akasha-id-client.js.map

{"version":3,"sources":["webpack://AKASHAidClient/webpack/universalModuleDefinition","webpack://AKASHAidClient/webpack/bootstrap","webpack://AKASHAidClient/./node_modules/node-libs-browser/node_modules/process/browser.js","webpack://AKASHAidClient/./node_modules/inherits/inherits_browser.js","webpack://AKASHAidClient/./node_modules/core-util-is/lib/util.js","webpack://AKASHAidClient/./node_modules/buffer/index.js","webpack://AKASHAidClient/(webpack)/buildin/global.js","webpack://AKASHAidClient/./node_modules/readable-stream/lib/_stream_duplex.js","webpack://AKASHAidClient/./node_modules/events/events.js","webpack://AKASHAidClient/./node_modules/readable-stream/readable-browser.js","webpack://AKASHAidClient/./node_modules/process-nextick-args/index.js","webpack://AKASHAidClient/./node_modules/safe-buffer/index.js","webpack://AKASHAidClient/./node_modules/string_decoder/lib/string_decoder.js","webpack://AKASHAidClient/./node_modules/readable-stream/lib/_stream_writable.js","webpack://AKASHAidClient/./node_modules/function-bind/index.js","webpack://AKASHAidClient/./node_modules/is-callable/index.js","webpack://AKASHAidClient/./node_modules/isarray/index.js","webpack://AKASHAidClient/./node_modules/readable-stream/lib/_stream_readable.js","webpack://AKASHAidClient/./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack://AKASHAidClient/./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack://AKASHAidClient/./node_modules/readable-stream/lib/_stream_transform.js","webpack://AKASHAidClient/./node_modules/define-properties/index.js","webpack://AKASHAidClient/./node_modules/define-properties/node_modules/object-keys/isArguments.js","webpack://AKASHAidClient/./node_modules/string.prototype.trim/implementation.js","webpack://AKASHAidClient/./node_modules/es-abstract/GetIntrinsic.js","webpack://AKASHAidClient/./node_modules/has/src/index.js","webpack://AKASHAidClient/./node_modules/string.prototype.trim/polyfill.js","webpack://AKASHAidClient/./node_modules/once/once.js","webpack://AKASHAidClient/./node_modules/through2/node_modules/readable-stream/lib/_stream_duplex.js","webpack://AKASHAidClient/./node_modules/stream-browserify/index.js","webpack://AKASHAidClient/./src/index.js","webpack://AKASHAidClient/./node_modules/base64-js/index.js","webpack://AKASHAidClient/./node_modules/ieee754/index.js","webpack://AKASHAidClient/./node_modules/signalhub/index.js","webpack://AKASHAidClient/./node_modules/event-source-stream/browser.js","webpack://AKASHAidClient/./node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack://AKASHAidClient/./node_modules/timers-browserify/main.js","webpack://AKASHAidClient/./node_modules/setimmediate/setImmediate.js","webpack://AKASHAidClient/./node_modules/util-deprecate/browser.js","webpack://AKASHAidClient/./node_modules/readable-stream/lib/_stream_passthrough.js","webpack://AKASHAidClient/./node_modules/nets/index.js","webpack://AKASHAidClient/./node_modules/xhr/index.js","webpack://AKASHAidClient/./node_modules/global/window.js","webpack://AKASHAidClient/./node_modules/is-function/index.js","webpack://AKASHAidClient/./node_modules/parse-headers/parse-headers.js","webpack://AKASHAidClient/./node_modules/string.prototype.trim/index.js","webpack://AKASHAidClient/./node_modules/function-bind/implementation.js","webpack://AKASHAidClient/./node_modules/define-properties/node_modules/object-keys/index.js","webpack://AKASHAidClient/./node_modules/define-properties/node_modules/object-keys/implementation.js","webpack://AKASHAidClient/./node_modules/es-abstract/es5.js","webpack://AKASHAidClient/./node_modules/es-abstract/helpers/assertRecord.js","webpack://AKASHAidClient/./node_modules/es-abstract/helpers/isNaN.js","webpack://AKASHAidClient/./node_modules/es-abstract/helpers/isFinite.js","webpack://AKASHAidClient/./node_modules/es-abstract/helpers/sign.js","webpack://AKASHAidClient/./node_modules/es-abstract/helpers/mod.js","webpack://AKASHAidClient/./node_modules/es-to-primitive/es5.js","webpack://AKASHAidClient/./node_modules/es-to-primitive/helpers/isPrimitive.js","webpack://AKASHAidClient/./node_modules/string.prototype.trim/shim.js","webpack://AKASHAidClient/./node_modules/for-each/index.js","webpack://AKASHAidClient/./node_modules/xhr/node_modules/xtend/immutable.js","webpack://AKASHAidClient/./node_modules/pump/index.js","webpack://AKASHAidClient/./node_modules/wrappy/wrappy.js","webpack://AKASHAidClient/./node_modules/end-of-stream/index.js","webpack://AKASHAidClient/./node_modules/through2/through2.js","webpack://AKASHAidClient/./node_modules/through2/node_modules/readable-stream/transform.js","webpack://AKASHAidClient/./node_modules/through2/node_modules/readable-stream/lib/_stream_transform.js","webpack://AKASHAidClient/./node_modules/through2/node_modules/readable-stream/lib/_stream_readable.js","webpack://AKASHAidClient/./node_modules/through2/node_modules/isarray/index.js","webpack://AKASHAidClient/./node_modules/readable-stream/writable-browser.js","webpack://AKASHAidClient/./node_modules/readable-stream/duplex-browser.js","webpack://AKASHAidClient/./node_modules/readable-stream/transform.js","webpack://AKASHAidClient/./node_modules/readable-stream/passthrough.js","webpack://AKASHAidClient/./node_modules/through2/node_modules/readable-stream/lib/_stream_writable.js","webpack://AKASHAidClient/./node_modules/util/util.js","webpack://AKASHAidClient/./node_modules/util/support/isBufferBrowser.js","webpack://AKASHAidClient/./node_modules/util/node_modules/inherits/inherits_browser.js","webpack://AKASHAidClient/./node_modules/through2/node_modules/xtend/immutable.js","webpack://AKASHAidClient/./node_modules/easy-web-crypto/src/index.js"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","Error","defaultClearTimeout","runTimeout","fun","setTimeout","e","this","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","length","concat","drainQueue","timeout","len","run","marker","runClearTimeout","Item","array","noop","nextTick","args","Array","arguments","push","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","ctor","superCtor","super_","constructor","writable","configurable","TempCtor","objectToString","toString","isArray","arg","isBoolean","isNull","isNullOrUndefined","isNumber","isString","isSymbol","isUndefined","isRegExp","re","isObject","isDate","isError","isFunction","isPrimitive","isBuffer","Buffer","base64","ieee754","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","Uint8Array","__proto__","encodingOrOffset","allocUnsafe","from","TypeError","ArrayBuffer","byteOffset","byteLength","undefined","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","write","slice","fromString","obj","checked","copy","buffer","val","type","data","fromObject","assertSize","size","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","bidirectionalIndexOf","isNaN","arrayIndexOf","indexOf","lastIndexOf","arr","indexSize","arrLength","valLength","String","read","buf","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","str","byteArray","charCodeAt","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","fromByteArray","Math","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","foo","subarray","typedArraySupport","poolSize","_augment","species","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","list","pos","swap16","swap32","swap64","equals","inspect","max","match","join","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","ret","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","code","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","trim","replace","stringtrim","base64clean","src","dst","g","Function","pna","objectKeys","keys","Duplex","util","inherits","Readable","Writable","v","method","options","readable","allowHalfOpen","onend","_writableState","ended","onEndNT","self","highWaterMark","_readableState","destroyed","_destroy","err","cb","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","EventEmitter","init","_events","_eventsCount","_maxListeners","defaultMaxListeners","$getMaxListeners","_addListener","listener","prepend","events","existing","warning","newListener","unshift","warned","w","emitter","count","console","warn","_onceWrap","state","fired","wrapFn","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","getPrototypeOf","setMaxListeners","getMaxListeners","doError","error","er","message","context","handler","position","originalListener","shift","index","pop","spliceOne","rawListeners","eventNames","Stream","Transform","PassThrough","fn","arg1","arg2","arg3","copyProps","SafeBuffer","StringDecoder","nb","enc","nenc","retried","_normalizeEncoding","normalizeEncoding","text","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckExtraBytes","total","utf8CheckIncomplete","CorkedRequest","_this","next","entry","finish","corkReq","callback","pendingcb","corkedRequestsFree","onCorkedFinish","asyncWrite","setImmediate","WritableState","internalUtil","deprecate","OurUint8Array","realHasInstance","destroyImpl","nop","stream","isDuplex","objectMode","writableObjectMode","hwm","writableHwm","writableHighWaterMark","defaultHwm","finalCalled","needDrain","ending","finished","noDecode","decodeStrings","defaultEncoding","writing","corked","sync","bufferProcessing","onwrite","writecb","writelen","onwriteStateUpdate","finishMaybe","errorEmitted","onwriteError","needFinish","bufferedRequest","clearBuffer","afterWrite","lastBufferedRequest","prefinished","bufferedRequestCount","_write","writev","_writev","destroy","final","_final","doWrite","chunk","onwriteDrain","holder","allBuffers","isBuf","callFinal","need","prefinish","getBuffer","current","_","hasInstance","pipe","_uint8ArrayToBuffer","writeAfterEnd","valid","validChunk","newChunk","decodeChunk","last","writeOrBuffer","cork","uncork","setDefaultEncoding","endWritable","_undestroy","undestroy","implementation","fnToStr","constructorRegex","isES6ClassFn","fnStr","test","toStr","hasToStringTag","tryFunctionObject","strClass","ReadableState","EElistenerCount","debugUtil","debug","debuglog","BufferList","kProxyEvents","readableObjectMode","readableHwm","readableHighWaterMark","pipes","pipesCount","flowing","endEmitted","reading","needReadable","emittedReadable","readableListening","resumeScheduled","awaitDrain","readingMore","decoder","_read","readableAddChunk","addToFront","skipChunkCheck","emitReadable","onEofChunk","chunkInvalid","addChunk","maybeReadMore","needMoreData","isPaused","setEncoding","MAX_HWM","howMuchToRead","head","computeNewHighWaterMark","emitReadable_","flow","maybeReadMore_","nReadingNextTick","resume_","fromList","clear","hasStrings","tail","copyFromBufferString","copyFromBuffer","fromListPartial","endReadable","endReadableNT","xs","nOrig","doRead","dest","pipeOpts","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","onclose","onfinish","ondrain","onerror","ondata","cleanedUp","pipeOnDrain","increasedAwaitDrain","pause","event","resume","dests","splice","ev","wrap","paused","_fromList","emitErrorNT","readableDestroyed","writableDestroyed","afterTransform","ts","_transformState","transforming","writechunk","rs","needTransform","writeencoding","transform","_transform","flush","_flush","done","_this2","err2","hasSymbols","origDefineProperty","supportsDescriptors","arePropertyDescriptorsSupported","predicate","defineProperties","map","predicates","props","isArgs","callee","ES","leftWhitespace","rightWhitespace","S","ToString","CheckObjectCoercible","ThrowTypeError","getOwnPropertyDescriptor","iterator","getProto","asyncGenIterator","TypedArray","INTRINSICS","entries","forEach","values","asyncIterator","Atomics","Boolean","DataView","Date","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","eval","EvalError","Float32Array","Float64Array","Int8Array","Int16Array","Int32Array","JSON","parse","Map","valueOf","parseFloat","Promise","then","all","reject","resolve","Proxy","ReferenceError","RegExp","Set","SharedArrayBuffer","SyntaxError","Uint8ClampedArray","Uint16Array","Uint32Array","URIError","WeakMap","WeakSet","allowMissing","wrappy","f","called","onceStrict","onceError","strict","proto","EE","source","_isStdio","didOnEnd","cleanup","WebCrypto","DEBUGGING","log","initHub","hubUrls","hub","Signalhub","url","appInfo","config","walletUrl","loginChannel","genId","nonce","genNonce","bootstrapKey","genAESKey","extractedKey","exportKey","b64Key","hashParams","stringify","loginLink","ceil","random","attributes","registrationLink","subscribe","async","request","msg","decrypt","encKey","importKey","exportedKey","encryptedMsg","encrypt","token","broadcast","cleanUp","claim","did","refreshEncKey","channel","getChannelFromDID","updateChannel","updateHub","toSend","split","close","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","len2","encodeChunk","lookup","num","output","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","abs","LN2","ess","nets","pump","through","SignalHub","app","urls","subscribers","closed","subscriber","endpoint","streams","json","pending","errors","statusCode","opts","es","EventSource","onmessage","decode","onopen","instance","Constructor","_classCallCheck","custom","Timeout","id","clearFn","_id","_clearFn","scope","setInterval","clearInterval","unref","ref","enroll","item","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","clearImmediate","registerImmediate","html","messagePrefix","onGlobalMessage","nextHandle","tasksByHandle","currentlyRunningATask","doc","document","attachTo","handle","runIfPresent","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","canUsePostMessage","MessageChannel","port1","port2","createElement","documentElement","script","onreadystatechange","removeChild","appendChild","addEventListener","attachEvent","task","localStorage","trace","uri","responseType","originalCb","resp","body","req","parseHeaders","xtend","initParams","params","createXHR","_createXHR","response","getBody","xhr","responseText","responseXML","firefoxBugTakenEffect","nodeName","getXml","isJson","errorFunc","evt","timeoutTimer","failureResponse","loadFunc","aborted","status","useXDR","headers","rawRequest","getAllResponseHeaders","cors","XDomainRequest","XMLHttpRequest","readyState","onload","onprogress","onabort","ontimeout","open","username","password","withCredentials","abort","setRequestHeader","isEmpty","beforeSend","send","default","forEachArray","toUpperCase","win","alert","confirm","prompt","result","row","getPolyfill","shim","boundTrim","ERROR_MESSAGE","bound","binder","boundLength","boundArgs","Empty","origKeys","keysShim","originalKeys","has","isEnumerable","propertyIsEnumerable","hasDontEnumBug","hasProtoEnumBug","dontEnums","equalsConstructorPrototype","excludedKeys","$applicationCache","$console","$external","$frame","$frameElement","$frames","$innerHeight","$innerWidth","$onmozfullscreenchange","$onmozfullscreenerror","$outerHeight","$outerWidth","$pageXOffset","$pageYOffset","$parent","$scrollLeft","$scrollTop","$scrollX","$scrollY","$self","$webkitIndexedDB","$webkitStorageInfo","$window","hasAutomationEqualityBug","k","isArguments","theKeys","skipProto","skipConstructor","equalsConstructorPrototypeIfNotBuggy","GetIntrinsic","$Object","$TypeError","$String","assertRecord","$isNaN","$isFinite","sign","mod","IsCallable","toPrimitive","ES5","ToPrimitive","ToBoolean","ToNumber","ToInteger","number","ToInt32","ToUint32","ToUint16","posInt","ToObject","optMessage","SameValue","Type","IsPropertyDescriptor","Desc","allowed","isData","IsAccessor","IsAccessorDescriptor","IsDataDescriptor","IsGenericDescriptor","FromPropertyDescriptor","ToPropertyDescriptor","Obj","desc","setter","$SyntaxError","recordType","argumentName","modulo","remain","isCallable","ES5internalSlots","O","actualHint","methods","input","polyfill","forEachString","charAt","forEachObject","thisArg","eos","fs","isFn","destroyer","ReadStream","WriteStream","isFS","setHeader","isRequest","to","destroys","reduce","wrapper","ws","onlegacyfinish","onexit","exitCode","onrequest","stdio","isChildProcess","DestroyableTransform","_destroyed","through2","construct","t2","Through2","override","TransformState","calledRead","ranOut","roundUpToNextPowerOf2","emitDataEvents","pipeOnReadable","startPaused","stringMode","cpy","WriteReq","getOwnPropertyDescriptors","descriptors","formatRegExp","format","objects","noDeprecation","throwDeprecation","traceDeprecation","debugEnviron","debugs","ctx","seen","stylize","stylizeNoColor","depth","colors","showHidden","_extend","customInspect","stylizeWithColor","formatValue","styleType","style","styles","recurseTimes","primitive","simple","formatPrimitive","visibleKeys","hash","idx","arrayToHash","formatError","base","braces","toUTCString","formatProperty","formatArray","prev","cur","numLinesEst","reduceToSingleString","line","ar","pad","NODE_DEBUG","pid","months","timestamp","time","getHours","getMinutes","getSeconds","getDate","getMonth","prop","origin","add","kCustomPromisifiedSymbol","callbackifyOnRejected","reason","newReason","promisify","original","promiseResolve","promiseReject","promise","setPrototypeOf","callbackify","callbackified","maybeCb","rej","checkCryptokey","genRandomBuffer","crypto","getRandomValues","genRandomBufferAsStr","encodingFormat","checkEncodingFormat","parsedKey","subtle","encryptBuffer","cipherContext","encrypted","decryptBuffer","decrypted","iv","algorithm","plaintext","ciphertext","deriveBits","passPhrase","salt","iterations","hashAlgo","baseKey","derivedKey","deriveKeyFromPassphrase","checkPassphrase","derivationParams","decryptMasterKey","protectedMasterKey","encryptedMasterKey","_salt","keyEncryptionKey","decryptedMasterKeyHex","digest","genKeyPair","extractable","namedCurve","generateKey","importPublicKey","importPrivateKey","exportPublicKey","exported","exportPrivateKey","signature","verify","keySize","genEncryptedMasterKey","masterKey","updatePassphraseKey","currentPassPhrase","newPassPhrase","oldMasterKey","toBeEncryptedMasterKey","_genRandomBuffer","_genRandomBufferAsStr"],"mappings":"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","file":"akasha-id-client.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"AKASHAidClient\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"AKASHAidClient\"] = factory();\n\telse\n\t\troot[\"AKASHAidClient\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 28);\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <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","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction $getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return $getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = $getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  var args = [];\n  for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    ReflectApply(this.listener, this.target, args);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      if (typeof listener !== 'function') {\n        throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n      }\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      if (typeof listener !== 'function') {\n        throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n      }\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","'use strict';\n\nif (typeof process === 'undefined' ||\n    !process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = Function.prototype.bind || implementation;\n","'use strict';\n\nvar fnToStr = Function.prototype.toString;\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value) {\n\ttry {\n\t\tvar fnStr = fnToStr.call(value);\n\t\treturn constructorRegex.test(fnStr);\n\t} catch (e) {\n\t\treturn false; // not a function\n\t}\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value) {\n\ttry {\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tfnToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';\n\nmodule.exports = function isCallable(value) {\n\tif (!value) { return false; }\n\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\tif (typeof value === 'function' && !value.prototype) { return true; }\n\tif (hasToStringTag) { return tryFunctionObject(value); }\n\tif (isES6ClassFn(value)) { return false; }\n\tvar strClass = toStr.call(value);\n\treturn strClass === fnClass || strClass === genClass;\n};\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","module.exports = require('events').EventEmitter;\n","'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      pna.nextTick(emitErrorNT, this, err);\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      pna.nextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n\n  return this;\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","'use strict';\n\nvar keys = require('object-keys');\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';\n\nvar toStr = Object.prototype.toString;\nvar concat = Array.prototype.concat;\nvar origDefineProperty = Object.defineProperty;\n\nvar isFunction = function (fn) {\n\treturn typeof fn === 'function' && toStr.call(fn) === '[object Function]';\n};\n\nvar arePropertyDescriptorsSupported = function () {\n\tvar obj = {};\n\ttry {\n\t\torigDefineProperty(obj, 'x', { enumerable: false, value: obj });\n\t\t// eslint-disable-next-line no-unused-vars, no-restricted-syntax\n\t\tfor (var _ in obj) { // jscs:ignore disallowUnusedVariables\n\t\t\treturn false;\n\t\t}\n\t\treturn obj.x === obj;\n\t} catch (e) { /* this is IE 8. */\n\t\treturn false;\n\t}\n};\nvar supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();\n\nvar defineProperty = function (object, name, value, predicate) {\n\tif (name in object && (!isFunction(predicate) || !predicate())) {\n\t\treturn;\n\t}\n\tif (supportsDescriptors) {\n\t\torigDefineProperty(object, name, {\n\t\t\tconfigurable: true,\n\t\t\tenumerable: false,\n\t\t\tvalue: value,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\tobject[name] = value;\n\t}\n};\n\nvar defineProperties = function (object, map) {\n\tvar predicates = arguments.length > 2 ? arguments[2] : {};\n\tvar props = keys(map);\n\tif (hasSymbols) {\n\t\tprops = concat.call(props, Object.getOwnPropertySymbols(map));\n\t}\n\tfor (var i = 0; i < props.length; i += 1) {\n\t\tdefineProperty(object, props[i], map[props[i]], predicates[props[i]]);\n\t}\n};\n\ndefineProperties.supportsDescriptors = !!supportsDescriptors;\n\nmodule.exports = defineProperties;\n","'use strict';\n\nvar toStr = Object.prototype.toString;\n\nmodule.exports = function isArguments(value) {\n\tvar str = toStr.call(value);\n\tvar isArgs = str === '[object Arguments]';\n\tif (!isArgs) {\n\t\tisArgs = str !== '[object Array]' &&\n\t\t\tvalue !== null &&\n\t\t\ttypeof value === 'object' &&\n\t\t\ttypeof value.length === 'number' &&\n\t\t\tvalue.length >= 0 &&\n\t\t\ttoStr.call(value.callee) === '[object Function]';\n\t}\n\treturn isArgs;\n};\n","'use strict';\n\nvar bind = require('function-bind');\nvar ES = require('es-abstract/es5');\nvar replace = bind.call(Function.call, String.prototype.replace);\n\n/* eslint-disable no-control-regex */\nvar leftWhitespace = /^[\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF]+/;\nvar rightWhitespace = /[\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF]+$/;\n/* eslint-enable no-control-regex */\n\nmodule.exports = function trim() {\n\tvar S = ES.ToString(ES.CheckObjectCoercible(this));\n\treturn replace(replace(S, leftWhitespace, ''), rightWhitespace, '');\n};\n","'use strict';\n\n/* globals\n\tSet,\n\tMap,\n\tWeakSet,\n\tWeakMap,\n\n\tPromise,\n\n\tSymbol,\n\tProxy,\n\n\tAtomics,\n\tSharedArrayBuffer,\n\n\tArrayBuffer,\n\tDataView,\n\tUint8Array,\n\tFloat32Array,\n\tFloat64Array,\n\tInt8Array,\n\tInt16Array,\n\tInt32Array,\n\tUint8ClampedArray,\n\tUint16Array,\n\tUint32Array,\n*/\n\nvar undefined; // eslint-disable-line no-shadow-restricted-names\n\nvar ThrowTypeError = Object.getOwnPropertyDescriptor\n\t? (function () { return Object.getOwnPropertyDescriptor(arguments, 'callee').get; }())\n\t: function () { throw new TypeError(); };\n\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';\n\nvar getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto\n\nvar generator; // = function * () {};\nvar generatorFunction = generator ? getProto(generator) : undefined;\nvar asyncFn; // async function() {};\nvar asyncFunction = asyncFn ? asyncFn.constructor : undefined;\nvar asyncGen; // async function * () {};\nvar asyncGenFunction = asyncGen ? getProto(asyncGen) : undefined;\nvar asyncGenIterator = asyncGen ? asyncGen() : undefined;\n\nvar TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);\n\nvar INTRINSICS = {\n\t'$ %Array%': Array,\n\t'$ %ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,\n\t'$ %ArrayBufferPrototype%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer.prototype,\n\t'$ %ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,\n\t'$ %ArrayPrototype%': Array.prototype,\n\t'$ %ArrayProto_entries%': Array.prototype.entries,\n\t'$ %ArrayProto_forEach%': Array.prototype.forEach,\n\t'$ %ArrayProto_keys%': Array.prototype.keys,\n\t'$ %ArrayProto_values%': Array.prototype.values,\n\t'$ %AsyncFromSyncIteratorPrototype%': undefined,\n\t'$ %AsyncFunction%': asyncFunction,\n\t'$ %AsyncFunctionPrototype%': asyncFunction ? asyncFunction.prototype : undefined,\n\t'$ %AsyncGenerator%': asyncGen ? getProto(asyncGenIterator) : undefined,\n\t'$ %AsyncGeneratorFunction%': asyncGenFunction,\n\t'$ %AsyncGeneratorPrototype%': asyncGenFunction ? asyncGenFunction.prototype : undefined,\n\t'$ %AsyncIteratorPrototype%': asyncGenIterator && hasSymbols && Symbol.asyncIterator ? asyncGenIterator[Symbol.asyncIterator]() : undefined,\n\t'$ %Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,\n\t'$ %Boolean%': Boolean,\n\t'$ %BooleanPrototype%': Boolean.prototype,\n\t'$ %DataView%': typeof DataView === 'undefined' ? undefined : DataView,\n\t'$ %DataViewPrototype%': typeof DataView === 'undefined' ? undefined : DataView.prototype,\n\t'$ %Date%': Date,\n\t'$ %DatePrototype%': Date.prototype,\n\t'$ %decodeURI%': decodeURI,\n\t'$ %decodeURIComponent%': decodeURIComponent,\n\t'$ %encodeURI%': encodeURI,\n\t'$ %encodeURIComponent%': encodeURIComponent,\n\t'$ %Error%': Error,\n\t'$ %ErrorPrototype%': Error.prototype,\n\t'$ %eval%': eval, // eslint-disable-line no-eval\n\t'$ %EvalError%': EvalError,\n\t'$ %EvalErrorPrototype%': EvalError.prototype,\n\t'$ %Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,\n\t'$ %Float32ArrayPrototype%': typeof Float32Array === 'undefined' ? undefined : Float32Array.prototype,\n\t'$ %Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,\n\t'$ %Float64ArrayPrototype%': typeof Float64Array === 'undefined' ? undefined : Float64Array.prototype,\n\t'$ %Function%': Function,\n\t'$ %FunctionPrototype%': Function.prototype,\n\t'$ %Generator%': generator ? getProto(generator()) : undefined,\n\t'$ %GeneratorFunction%': generatorFunction,\n\t'$ %GeneratorPrototype%': generatorFunction ? generatorFunction.prototype : undefined,\n\t'$ %Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,\n\t'$ %Int8ArrayPrototype%': typeof Int8Array === 'undefined' ? undefined : Int8Array.prototype,\n\t'$ %Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,\n\t'$ %Int16ArrayPrototype%': typeof Int16Array === 'undefined' ? undefined : Int8Array.prototype,\n\t'$ %Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,\n\t'$ %Int32ArrayPrototype%': typeof Int32Array === 'undefined' ? undefined : Int32Array.prototype,\n\t'$ %isFinite%': isFinite,\n\t'$ %isNaN%': isNaN,\n\t'$ %IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,\n\t'$ %JSON%': JSON,\n\t'$ %JSONParse%': JSON.parse,\n\t'$ %Map%': typeof Map === 'undefined' ? undefined : Map,\n\t'$ %MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),\n\t'$ %MapPrototype%': typeof Map === 'undefined' ? undefined : Map.prototype,\n\t'$ %Math%': Math,\n\t'$ %Number%': Number,\n\t'$ %NumberPrototype%': Number.prototype,\n\t'$ %Object%': Object,\n\t'$ %ObjectPrototype%': Object.prototype,\n\t'$ %ObjProto_toString%': Object.prototype.toString,\n\t'$ %ObjProto_valueOf%': Object.prototype.valueOf,\n\t'$ %parseFloat%': parseFloat,\n\t'$ %parseInt%': parseInt,\n\t'$ %Promise%': typeof Promise === 'undefined' ? undefined : Promise,\n\t'$ %PromisePrototype%': typeof Promise === 'undefined' ? undefined : Promise.prototype,\n\t'$ %PromiseProto_then%': typeof Promise === 'undefined' ? undefined : Promise.prototype.then,\n\t'$ %Promise_all%': typeof Promise === 'undefined' ? undefined : Promise.all,\n\t'$ %Promise_reject%': typeof Promise === 'undefined' ? undefined : Promise.reject,\n\t'$ %Promise_resolve%': typeof Promise === 'undefined' ? undefined : Promise.resolve,\n\t'$ %Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,\n\t'$ %RangeError%': RangeError,\n\t'$ %RangeErrorPrototype%': RangeError.prototype,\n\t'$ %ReferenceError%': ReferenceError,\n\t'$ %ReferenceErrorPrototype%': ReferenceError.prototype,\n\t'$ %Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,\n\t'$ %RegExp%': RegExp,\n\t'$ %RegExpPrototype%': RegExp.prototype,\n\t'$ %Set%': typeof Set === 'undefined' ? undefined : Set,\n\t'$ %SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),\n\t'$ %SetPrototype%': typeof Set === 'undefined' ? undefined : Set.prototype,\n\t'$ %SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,\n\t'$ %SharedArrayBufferPrototype%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer.prototype,\n\t'$ %String%': String,\n\t'$ %StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,\n\t'$ %StringPrototype%': String.prototype,\n\t'$ %Symbol%': hasSymbols ? Symbol : undefined,\n\t'$ %SymbolPrototype%': hasSymbols ? Symbol.prototype : undefined,\n\t'$ %SyntaxError%': SyntaxError,\n\t'$ %SyntaxErrorPrototype%': SyntaxError.prototype,\n\t'$ %ThrowTypeError%': ThrowTypeError,\n\t'$ %TypedArray%': TypedArray,\n\t'$ %TypedArrayPrototype%': TypedArray ? TypedArray.prototype : undefined,\n\t'$ %TypeError%': TypeError,\n\t'$ %TypeErrorPrototype%': TypeError.prototype,\n\t'$ %Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,\n\t'$ %Uint8ArrayPrototype%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array.prototype,\n\t'$ %Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,\n\t'$ %Uint8ClampedArrayPrototype%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray.prototype,\n\t'$ %Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,\n\t'$ %Uint16ArrayPrototype%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array.prototype,\n\t'$ %Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,\n\t'$ %Uint32ArrayPrototype%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array.prototype,\n\t'$ %URIError%': URIError,\n\t'$ %URIErrorPrototype%': URIError.prototype,\n\t'$ %WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,\n\t'$ %WeakMapPrototype%': typeof WeakMap === 'undefined' ? undefined : WeakMap.prototype,\n\t'$ %WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet,\n\t'$ %WeakSetPrototype%': typeof WeakSet === 'undefined' ? undefined : WeakSet.prototype\n};\n\nmodule.exports = function GetIntrinsic(name, allowMissing) {\n\tif (arguments.length > 1 && typeof allowMissing !== 'boolean') {\n\t\tthrow new TypeError('\"allowMissing\" argument must be a boolean');\n\t}\n\n\tvar key = '$ ' + name;\n\tif (!(key in INTRINSICS)) {\n\t\tthrow new SyntaxError('intrinsic ' + name + ' does not exist!');\n\t}\n\n\t// istanbul ignore if // hopefully this is impossible to test :-)\n\tif (typeof INTRINSICS[key] === 'undefined' && !allowMissing) {\n\t\tthrow new TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');\n\t}\n\treturn INTRINSICS[key];\n};\n","'use strict';\n\nvar bind = require('function-bind');\n\nmodule.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);\n","'use strict';\n\nvar implementation = require('./implementation');\n\nvar zeroWidthSpace = '\\u200b';\n\nmodule.exports = function getPolyfill() {\n\tif (String.prototype.trim && zeroWidthSpace.trim() === zeroWidthSpace) {\n\t\treturn String.prototype.trim;\n\t}\n\treturn implementation;\n};\n","var wrappy = require('wrappy')\nmodule.exports = wrappy(once)\nmodule.exports.strict = wrappy(onceStrict)\n\nonce.proto = once(function () {\n  Object.defineProperty(Function.prototype, 'once', {\n    value: function () {\n      return once(this)\n    },\n    configurable: true\n  })\n\n  Object.defineProperty(Function.prototype, 'onceStrict', {\n    value: function () {\n      return onceStrict(this)\n    },\n    configurable: true\n  })\n})\n\nfunction once (fn) {\n  var f = function () {\n    if (f.called) return f.value\n    f.called = true\n    return f.value = fn.apply(this, arguments)\n  }\n  f.called = false\n  return f\n}\n\nfunction onceStrict (fn) {\n  var f = function () {\n    if (f.called)\n      throw new Error(f.onceError)\n    f.called = true\n    return f.value = fn.apply(this, arguments)\n  }\n  var name = fn.name || 'Function wrapped with `once`'\n  f.onceError = name + \" shouldn't be called more than once\"\n  f.called = false\n  return f\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  return keys;\n}\n/*</replacement>*/\n\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\nforEach(objectKeys(Writable.prototype), function(method) {\n  if (!Duplex.prototype[method])\n    Duplex.prototype[method] = Writable.prototype[method];\n});\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex))\n    return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false)\n    this.readable = false;\n\n  if (options && options.writable === false)\n    this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false)\n    this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended)\n    return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  process.nextTick(this.end.bind(this));\n}\n\nfunction forEach (xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","const Signalhub = require('signalhub') // might switch to SocketCluster later\nconst WebCrypto = require('easy-web-crypto')\n\nconst APP_NAME = 'AKASHA'\n\nlet DEBUGGING = false\n\n// enable/disable debug\nfunction debug () {\n  if (DEBUGGING) {\n    console.log.apply(this, arguments)\n  }\n}\n\n// Initialize the signalhub connection\nconst initHub = (hubUrls) => {\n  const hub = Signalhub(APP_NAME, hubUrls)\n  // catch errors\n  hub.on('error', ({ url, error }) => {\n    throw new Error('Connection error', url, error)\n  })\n  return hub\n}\n\nclass Client {\n  /**\n    * Class constructor\n    *\n    * @param {Object} appInfo - An object containing app info to be used in the\n    * registration process\n    * @param {Object} config - Configuration options\n    */\n  constructor (appInfo, config = {}) {\n    if (!appInfo) {\n      throw new Error('Missing app details')\n    }\n    this.appInfo = appInfo\n\n    // init config\n    if (!config || !config.hubUrls || !config.walletUrl) {\n      throw new Error('Missing config details')\n    }\n    this.config = config\n    // debug\n    DEBUGGING = config.debug ? config.debug : false\n  }\n\n  /**\n    * Generate a special link to request access to the user's DID\n    *\n    * @returns {string} - A formatted link containing the necessary info to register the app\n    */\n  async registrationLink () {\n    // generate a one time channel ID\n    this.loginChannel = WebCrypto.genId()\n    // generate NONCE\n    this.nonce = this.genNonce()\n    // generate a one time symmetric encryption key and reveal it to AKASHA.id\n    this.bootstrapKey = await WebCrypto.genAESKey(true, 'AES-GCM', 128)\n    const extractedKey = await WebCrypto.exportKey(this.bootstrapKey)\n    const b64Key = Buffer.from(extractedKey).toString('base64')\n\n    // use the wallet app URL for the link\n    const hashParams = JSON.stringify([this.loginChannel, b64Key, this.nonce])\n    this.loginLink = this.config.walletUrl + Buffer.from(hashParams).toString('base64')\n    return this.loginLink\n  }\n\n  // Generate a none\n  genNonce (min, max) {\n    min = Math.ceil(min || 100000)\n    max = Math.floor(max || 9999999)\n    return Math.floor(Math.random() * (max - min + 1)) + min\n  }\n\n  /**\n    * Bootstrap the login process by creating a listener that also handles\n    * message exchanges for app registration\n    *\n    * @param {Array} attributes - A list of profile attributes that are useful to the\n    * client application\n    * @returns {Promise<Object>} - The response from the IDP, may contain a claim if\n    * the app was allowed (i.e. if msg.allowed is true)\n    */\n  async requestProfile (attributes) {\n    if (!this.loginLink) {\n      await this.registrationLink()\n    }\n    return new Promise((resolve, reject) => {\n      try {\n        const hub = initHub(this.config.hubUrls)\n        hub.subscribe(this.loginChannel).on('data', async (data) => {\n          data = JSON.parse(data)\n          if (data.request === 'reqInfo') {\n            const msg = await WebCrypto.decrypt(this.bootstrapKey, data.msg, 'base64')\n            if (msg.nonce && msg.nonce === this.nonce) {\n              // the AKASHA.id app is requesting app details\n              const encKey = await WebCrypto.importKey(Buffer.from(msg.encKey, 'base64'))\n              // genereate new key\n              // generate a one time symmetric encryption key and reveal it to AKASHA.id\n              this.bootstrapKey = await WebCrypto.genAESKey(true, 'AES-GCM', 128)\n              const exportedKey = await WebCrypto.exportKey(this.bootstrapKey)\n              const b64Key = Buffer.from(exportedKey).toString('base64')\n              const encryptedMsg = await WebCrypto.encrypt(encKey, {\n                token: msg.token,\n                nonce: msg.nonce,\n                appInfo: this.appInfo,\n                attributes,\n                key: b64Key\n              }, 'base64')\n              hub.broadcast(this.loginChannel, JSON.stringify({ request: 'appInfo', msg: encryptedMsg }))\n            }\n          } else if (data.request === 'claim') {\n            const msg = await WebCrypto.decrypt(this.bootstrapKey, data.msg, 'base64')\n            if (msg.nonce && msg.nonce === this.nonce) {\n              resolve(msg)\n              debug('Got response:', msg)\n              this.cleanUp(hub)\n            }\n          }\n        })\n      } catch (e) {\n        reject(e)\n      }\n    })\n  }\n\n  /**\n    * Request an updated claim for the user\n    *\n    * @param {string} channel - The channel to be used for requests\n    * @param {string} token - The application token to send\n    * @param {string} rawKey - The encryption key to use for the request message\n    * @returns {Promise<Object>} - The refreshed profile claim\n    */\n  async refreshProfile (claim) {\n    if (!claim.did || !claim.token || !claim.refreshEncKey) {\n      debug('refreshProfile:', claim.did, claim.token, claim.refreshEncKey)\n      throw new Error('You need to provide each of channel ID, app token, and encryption key for the request.')\n    }\n    try {\n      // get refresh channel from the user's DID by stripping 'did:akasha:'\n      const channel = this.getChannelFromDID(claim.did)\n      debug('Refreshing profile using:', channel, claim.token, claim.refreshEncKey)\n      // prepare request\n      const key = await WebCrypto.importKey(Buffer.from(claim.refreshEncKey, 'base64'))\n      // encrypt message to be sent\n      const nonce = this.genNonce()\n      const updateChannel = WebCrypto.genId()\n      const encryptedMsg = await WebCrypto.encrypt(key, {\n        nonce: nonce,\n        channel: updateChannel\n      }, 'base64')\n      // set up listener\n      return new Promise((resolve, reject) => {\n        const updateHub = initHub(this.config.hubUrls)\n        try {\n          updateHub.subscribe(updateChannel).on('data', async (data) => {\n            data = JSON.parse(data)\n            if (data.request === 'claim') {\n              const msg = await WebCrypto.decrypt(key, data.msg, 'base64')\n              if (msg.nonce === nonce) {\n                resolve(msg)\n                this.cleanUp(updateHub)\n              }\n            }\n          })\n          // also broadcast request\n          const toSend = {\n            request: 'refresh',\n            token: claim.token,\n            msg: encryptedMsg\n          }\n          debug('Sending refresh req:', toSend)\n          updateHub.broadcast(channel, JSON.stringify(toSend))\n        } catch (e) {\n          reject(e)\n          this.cleanUp(updateHub)\n        }\n      })\n    } catch (e) {\n      debug(e)\n      throw new Error(e)\n    }\n  }\n\n  /**\n    * Return the channel ID from a DID\n    *\n    * @param {string} did - The user's DID\n    * @returns {string} - The channel ID\n    */\n  getChannelFromDID (did) {\n    return did.split(':')[2]\n  }\n\n  /**\n    * Clean up the current request state and close the hub connection\n    *\n    * @param {Object} hub - The hub object\n    */\n  cleanUp (hub) {\n    this.loginChannel = null\n    this.loginLink = null\n    this.nonce = null\n    hub.close()\n  }\n}\n\nmodule.exports = Client\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(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\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","exports.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","var events = require('events')\nvar ess = require('event-source-stream')\nvar nets = require('nets')\nvar pump = require('pump')\nvar through = require('through2')\nvar inherits = require('inherits')\n\nmodule.exports = SignalHub\n\nfunction SignalHub (app, urls) {\n  if (!(this instanceof SignalHub)) return new SignalHub(app, urls)\n  if (!app) throw new Error('app name required')\n  if (!urls || !urls.length) throw new Error('signalhub url(s) required')\n\n  events.EventEmitter.call(this)\n  this.setMaxListeners(0)\n\n  this.app = app\n  if (!Array.isArray(urls)) urls = [urls]\n  this.urls = urls.map(function (url) {\n    url = url.replace(/\\/$/, '')\n    return url.indexOf('://') === -1 ? 'http://' + url : url\n  })\n  this.subscribers = []\n  this.closed = false\n}\n\ninherits(SignalHub, events.EventEmitter)\n\nSignalHub.prototype.subscribe = function (channel) {\n  if (this.closed) throw new Error('Cannot subscribe after close')\n\n  var self = this\n  var endpoint = Array.isArray(channel) ? channel.join(',') : channel\n  var streams = this.urls.map(function (url) {\n    return ess(url + '/v1/' + self.app + '/' + endpoint, {json: true})\n  })\n\n  var subscriber\n  if (streams.length === 1) {\n    subscriber = streams[0]\n  } else {\n    subscriber = through.obj()\n    subscriber.setMaxListeners(0)\n    streams.forEach(function (stream) {\n      stream.on('open', function () {\n        subscriber.emit('open')\n      })\n      pump(stream, subscriber)\n    })\n  }\n\n  this.subscribers.push(subscriber)\n\n  subscriber.once('close', function () {\n    var i = self.subscribers.indexOf(subscriber)\n    if (i > -1) self.subscribers.splice(i, 1)\n  })\n\n  return subscriber\n}\n\nSignalHub.prototype.broadcast = function (channel, message, cb) {\n  if (this.closed) throw new Error('Cannot broadcast after close')\n  if (!message) message = {}\n  if (!cb) cb = noop\n\n  var pending = this.urls.length\n  var errors = 0\n\n  var self = this\n  this.urls.forEach(function (url) {\n    broadcast(self.app, url, channel, message, function (err) {\n      if (err) errors++\n      if (--pending) return\n      if (errors === self.urls.length) return cb(err)\n      cb()\n    })\n  })\n}\n\nSignalHub.prototype.close = function (cb) {\n  if (this.closed) return\n  this.closed = true\n\n  if (cb) this.once('close', cb)\n  var len = this.subscribers.length\n  if (len > 0) {\n    var self = this\n    var closed = 0\n    this.subscribers.forEach(function (subscriber) {\n      subscriber.once('close', function () {\n        if (++closed === len) {\n          self.emit('close')\n        }\n      })\n      process.nextTick(function () {\n        subscriber.destroy()\n      })\n    })\n  } else {\n    this.emit('close')\n  }\n}\n\nfunction broadcast (app, url, channel, message, cb) {\n  return nets({\n    method: 'POST',\n    json: message,\n    url: url + '/v1/' + app + '/' + channel\n  }, function (err, res) {\n    if (err) return cb(err)\n    if (res.statusCode !== 200) return cb(new Error('Bad status: ' + res.statusCode))\n    cb()\n  })\n}\n\nfunction noop () {}\n","var stream = require('readable-stream')\n\nmodule.exports = function(url, opts) {\n  if (!opts) opts = {}\n\n  var es = new EventSource(url)\n  var rs = new stream.Readable({objectMode:true})\n\n  var json = !!opts.json\n  var decode = function (data) {\n    try {\n      if (json) return JSON.parse(data)\n      return data\n    } catch (err) {\n      return undefined\n    }\n  }\n\n  rs._read = function() {}\n\n  es.onmessage = function(e) {\n    rs.push(decode(e.data))\n  }\n\n  es.onerror = function(err) {\n    if (rs.listeners('error').length) rs.emit('error', err)\n  }\n\n  es.onopen = function () {\n    rs.emit('open')\n  }\n\n  var destroyed = false\n  rs.destroy = function() {\n    if (destroyed) return\n    destroyed = true\n    es.close()\n    rs.emit('close')\n  }\n\n  return rs\n}\n","'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require('safe-buffer').Buffer;\nvar util = require('util');\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\nif (util && util.inspect && util.inspect.custom) {\n  module.exports.prototype[util.inspect.custom] = function () {\n    var obj = util.inspect({ length: this.length });\n    return this.constructor.name + ' ' + obj;\n  };\n}","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","var req = require('request')\n\nmodule.exports = Nets\n\nfunction Nets (opts, cb) {\n  if (typeof opts === 'string') opts = { uri: opts }\n\n  // in node, if encoding === null then response will be a Buffer. we want this to be the default\n  if (!opts.hasOwnProperty('encoding')) opts.encoding = null\n\n  // in browser, we should by default convert the arraybuffer into a Buffer\n  if (process.browser && !opts.hasOwnProperty('json') && opts.encoding === null) {\n    opts.responseType = 'arraybuffer'\n    var originalCb = cb\n    cb = bufferify\n  }\n\n  function bufferify (err, resp, body) {\n    if (body) body = new Buffer(new Uint8Array(body))\n    originalCb(err, resp, body)\n  }\n\n  return req(opts, cb)\n}\n","\"use strict\";\nvar window = require(\"global/window\")\nvar isFunction = require(\"is-function\")\nvar parseHeaders = require(\"parse-headers\")\nvar xtend = require(\"xtend\")\n\nmodule.exports = createXHR\n// Allow use of default import syntax in TypeScript\nmodule.exports.default = createXHR;\ncreateXHR.XMLHttpRequest = window.XMLHttpRequest || noop\ncreateXHR.XDomainRequest = \"withCredentials\" in (new createXHR.XMLHttpRequest()) ? createXHR.XMLHttpRequest : window.XDomainRequest\n\nforEachArray([\"get\", \"put\", \"post\", \"patch\", \"head\", \"delete\"], function(method) {\n    createXHR[method === \"delete\" ? \"del\" : method] = function(uri, options, callback) {\n        options = initParams(uri, options, callback)\n        options.method = method.toUpperCase()\n        return _createXHR(options)\n    }\n})\n\nfunction forEachArray(array, iterator) {\n    for (var i = 0; i < array.length; i++) {\n        iterator(array[i])\n    }\n}\n\nfunction isEmpty(obj){\n    for(var i in obj){\n        if(obj.hasOwnProperty(i)) return false\n    }\n    return true\n}\n\nfunction initParams(uri, options, callback) {\n    var params = uri\n\n    if (isFunction(options)) {\n        callback = options\n        if (typeof uri === \"string\") {\n            params = {uri:uri}\n        }\n    } else {\n        params = xtend(options, {uri: uri})\n    }\n\n    params.callback = callback\n    return params\n}\n\nfunction createXHR(uri, options, callback) {\n    options = initParams(uri, options, callback)\n    return _createXHR(options)\n}\n\nfunction _createXHR(options) {\n    if(typeof options.callback === \"undefined\"){\n        throw new Error(\"callback argument missing\")\n    }\n\n    var called = false\n    var callback = function cbOnce(err, response, body){\n        if(!called){\n            called = true\n            options.callback(err, response, body)\n        }\n    }\n\n    function readystatechange() {\n        if (xhr.readyState === 4) {\n            setTimeout(loadFunc, 0)\n        }\n    }\n\n    function getBody() {\n        // Chrome with requestType=blob throws errors arround when even testing access to responseText\n        var body = undefined\n\n        if (xhr.response) {\n            body = xhr.response\n        } else {\n            body = xhr.responseText || getXml(xhr)\n        }\n\n        if (isJson) {\n            try {\n                body = JSON.parse(body)\n            } catch (e) {}\n        }\n\n        return body\n    }\n\n    function errorFunc(evt) {\n        clearTimeout(timeoutTimer)\n        if(!(evt instanceof Error)){\n            evt = new Error(\"\" + (evt || \"Unknown XMLHttpRequest Error\") )\n        }\n        evt.statusCode = 0\n        return callback(evt, failureResponse)\n    }\n\n    // will load the data & process the response in a special response object\n    function loadFunc() {\n        if (aborted) return\n        var status\n        clearTimeout(timeoutTimer)\n        if(options.useXDR && xhr.status===undefined) {\n            //IE8 CORS GET successful response doesn't have a status field, but body is fine\n            status = 200\n        } else {\n            status = (xhr.status === 1223 ? 204 : xhr.status)\n        }\n        var response = failureResponse\n        var err = null\n\n        if (status !== 0){\n            response = {\n                body: getBody(),\n                statusCode: status,\n                method: method,\n                headers: {},\n                url: uri,\n                rawRequest: xhr\n            }\n            if(xhr.getAllResponseHeaders){ //remember xhr can in fact be XDR for CORS in IE\n                response.headers = parseHeaders(xhr.getAllResponseHeaders())\n            }\n        } else {\n            err = new Error(\"Internal XMLHttpRequest Error\")\n        }\n        return callback(err, response, response.body)\n    }\n\n    var xhr = options.xhr || null\n\n    if (!xhr) {\n        if (options.cors || options.useXDR) {\n            xhr = new createXHR.XDomainRequest()\n        }else{\n            xhr = new createXHR.XMLHttpRequest()\n        }\n    }\n\n    var key\n    var aborted\n    var uri = xhr.url = options.uri || options.url\n    var method = xhr.method = options.method || \"GET\"\n    var body = options.body || options.data\n    var headers = xhr.headers = options.headers || {}\n    var sync = !!options.sync\n    var isJson = false\n    var timeoutTimer\n    var failureResponse = {\n        body: undefined,\n        headers: {},\n        statusCode: 0,\n        method: method,\n        url: uri,\n        rawRequest: xhr\n    }\n\n    if (\"json\" in options && options.json !== false) {\n        isJson = true\n        headers[\"accept\"] || headers[\"Accept\"] || (headers[\"Accept\"] = \"application/json\") //Don't override existing accept header declared by user\n        if (method !== \"GET\" && method !== \"HEAD\") {\n            headers[\"content-type\"] || headers[\"Content-Type\"] || (headers[\"Content-Type\"] = \"application/json\") //Don't override existing accept header declared by user\n            body = JSON.stringify(options.json === true ? body : options.json)\n        }\n    }\n\n    xhr.onreadystatechange = readystatechange\n    xhr.onload = loadFunc\n    xhr.onerror = errorFunc\n    // IE9 must have onprogress be set to a unique function.\n    xhr.onprogress = function () {\n        // IE must die\n    }\n    xhr.onabort = function(){\n        aborted = true;\n    }\n    xhr.ontimeout = errorFunc\n    xhr.open(method, uri, !sync, options.username, options.password)\n    //has to be after open\n    if(!sync) {\n        xhr.withCredentials = !!options.withCredentials\n    }\n    // Cannot set timeout with sync request\n    // not setting timeout on the xhr object, because of old webkits etc. not handling that correctly\n    // both npm's request and jquery 1.x use this kind of timeout, so this is being consistent\n    if (!sync && options.timeout > 0 ) {\n        timeoutTimer = setTimeout(function(){\n            if (aborted) return\n            aborted = true//IE9 may still call readystatechange\n            xhr.abort(\"timeout\")\n            var e = new Error(\"XMLHttpRequest timeout\")\n            e.code = \"ETIMEDOUT\"\n            errorFunc(e)\n        }, options.timeout )\n    }\n\n    if (xhr.setRequestHeader) {\n        for(key in headers){\n            if(headers.hasOwnProperty(key)){\n                xhr.setRequestHeader(key, headers[key])\n            }\n        }\n    } else if (options.headers && !isEmpty(options.headers)) {\n        throw new Error(\"Headers cannot be set on an XDomainRequest object\")\n    }\n\n    if (\"responseType\" in options) {\n        xhr.responseType = options.responseType\n    }\n\n    if (\"beforeSend\" in options &&\n        typeof options.beforeSend === \"function\"\n    ) {\n        options.beforeSend(xhr)\n    }\n\n    // Microsoft Edge browser sends \"undefined\" when send is called with undefined value.\n    // XMLHttpRequest spec says to pass null as body to indicate no body\n    // See https://github.com/naugtur/xhr/issues/100.\n    xhr.send(body || null)\n\n    return xhr\n\n\n}\n\nfunction getXml(xhr) {\n    // xhr.responseXML will throw Exception \"InvalidStateError\" or \"DOMException\"\n    // See https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseXML.\n    try {\n        if (xhr.responseType === \"document\") {\n            return xhr.responseXML\n        }\n        var firefoxBugTakenEffect = xhr.responseXML && xhr.responseXML.documentElement.nodeName === \"parsererror\"\n        if (xhr.responseType === \"\" && !firefoxBugTakenEffect) {\n            return xhr.responseXML\n        }\n    } catch (e) {}\n\n    return null\n}\n\nfunction noop() {}\n","var win;\n\nif (typeof window !== \"undefined\") {\n    win = window;\n} else if (typeof global !== \"undefined\") {\n    win = global;\n} else if (typeof self !== \"undefined\"){\n    win = self;\n} else {\n    win = {};\n}\n\nmodule.exports = win;\n","module.exports = isFunction\n\nvar toString = Object.prototype.toString\n\nfunction isFunction (fn) {\n  var string = toString.call(fn)\n  return string === '[object Function]' ||\n    (typeof fn === 'function' && string !== '[object RegExp]') ||\n    (typeof window !== 'undefined' &&\n     // IE8 and below\n     (fn === window.setTimeout ||\n      fn === window.alert ||\n      fn === window.confirm ||\n      fn === window.prompt))\n};\n","var trim = require('string.prototype.trim')\n  , forEach = require('for-each')\n  , isArray = function(arg) {\n      return Object.prototype.toString.call(arg) === '[object Array]';\n    }\n\nmodule.exports = function (headers) {\n  if (!headers)\n    return {}\n\n  var result = {}\n\n  forEach(\n      trim(headers).split('\\n')\n    , function (row) {\n        var index = row.indexOf(':')\n          , key = trim(row.slice(0, index)).toLowerCase()\n          , value = trim(row.slice(index + 1))\n\n        if (typeof(result[key]) === 'undefined') {\n          result[key] = value\n        } else if (isArray(result[key])) {\n          result[key].push(value)\n        } else {\n          result[key] = [ result[key], value ]\n        }\n      }\n  )\n\n  return result\n}\n","'use strict';\n\nvar bind = require('function-bind');\nvar define = require('define-properties');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar boundTrim = bind.call(Function.call, getPolyfill());\n\ndefine(boundTrim, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = boundTrim;\n","'use strict';\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar slice = Array.prototype.slice;\nvar toStr = Object.prototype.toString;\nvar funcType = '[object Function]';\n\nmodule.exports = function bind(that) {\n    var target = this;\n    if (typeof target !== 'function' || toStr.call(target) !== funcType) {\n        throw new TypeError(ERROR_MESSAGE + target);\n    }\n    var args = slice.call(arguments, 1);\n\n    var bound;\n    var binder = function () {\n        if (this instanceof bound) {\n            var result = target.apply(\n                this,\n                args.concat(slice.call(arguments))\n            );\n            if (Object(result) === result) {\n                return result;\n            }\n            return this;\n        } else {\n            return target.apply(\n                that,\n                args.concat(slice.call(arguments))\n            );\n        }\n    };\n\n    var boundLength = Math.max(0, target.length - args.length);\n    var boundArgs = [];\n    for (var i = 0; i < boundLength; i++) {\n        boundArgs.push('$' + i);\n    }\n\n    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);\n\n    if (target.prototype) {\n        var Empty = function Empty() {};\n        Empty.prototype = target.prototype;\n        bound.prototype = new Empty();\n        Empty.prototype = null;\n    }\n\n    return bound;\n};\n","'use strict';\n\nvar slice = Array.prototype.slice;\nvar isArgs = require('./isArguments');\n\nvar origKeys = Object.keys;\nvar keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation');\n\nvar originalKeys = Object.keys;\n\nkeysShim.shim = function shimObjectKeys() {\n\tif (Object.keys) {\n\t\tvar keysWorksWithArguments = (function () {\n\t\t\t// Safari 5.0 bug\n\t\t\tvar args = Object.keys(arguments);\n\t\t\treturn args && args.length === arguments.length;\n\t\t}(1, 2));\n\t\tif (!keysWorksWithArguments) {\n\t\t\tObject.keys = function keys(object) { // eslint-disable-line func-name-matching\n\t\t\t\tif (isArgs(object)) {\n\t\t\t\t\treturn originalKeys(slice.call(object));\n\t\t\t\t}\n\t\t\t\treturn originalKeys(object);\n\t\t\t};\n\t\t}\n\t} else {\n\t\tObject.keys = keysShim;\n\t}\n\treturn Object.keys || keysShim;\n};\n\nmodule.exports = keysShim;\n","'use strict';\n\nvar keysShim;\nif (!Object.keys) {\n\t// modified from https://github.com/es-shims/es5-shim\n\tvar has = Object.prototype.hasOwnProperty;\n\tvar toStr = Object.prototype.toString;\n\tvar isArgs = require('./isArguments'); // eslint-disable-line global-require\n\tvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\tvar hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');\n\tvar hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');\n\tvar dontEnums = [\n\t\t'toString',\n\t\t'toLocaleString',\n\t\t'valueOf',\n\t\t'hasOwnProperty',\n\t\t'isPrototypeOf',\n\t\t'propertyIsEnumerable',\n\t\t'constructor'\n\t];\n\tvar equalsConstructorPrototype = function (o) {\n\t\tvar ctor = o.constructor;\n\t\treturn ctor && ctor.prototype === o;\n\t};\n\tvar excludedKeys = {\n\t\t$applicationCache: true,\n\t\t$console: true,\n\t\t$external: true,\n\t\t$frame: true,\n\t\t$frameElement: true,\n\t\t$frames: true,\n\t\t$innerHeight: true,\n\t\t$innerWidth: true,\n\t\t$onmozfullscreenchange: true,\n\t\t$onmozfullscreenerror: true,\n\t\t$outerHeight: true,\n\t\t$outerWidth: true,\n\t\t$pageXOffset: true,\n\t\t$pageYOffset: true,\n\t\t$parent: true,\n\t\t$scrollLeft: true,\n\t\t$scrollTop: true,\n\t\t$scrollX: true,\n\t\t$scrollY: true,\n\t\t$self: true,\n\t\t$webkitIndexedDB: true,\n\t\t$webkitStorageInfo: true,\n\t\t$window: true\n\t};\n\tvar hasAutomationEqualityBug = (function () {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined') { return false; }\n\t\tfor (var k in window) {\n\t\t\ttry {\n\t\t\t\tif (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tequalsConstructorPrototype(window[k]);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}());\n\tvar equalsConstructorPrototypeIfNotBuggy = function (o) {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined' || !hasAutomationEqualityBug) {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t}\n\t\ttry {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n\n\tkeysShim = function keys(object) {\n\t\tvar isObject = object !== null && typeof object === 'object';\n\t\tvar isFunction = toStr.call(object) === '[object Function]';\n\t\tvar isArguments = isArgs(object);\n\t\tvar isString = isObject && toStr.call(object) === '[object String]';\n\t\tvar theKeys = [];\n\n\t\tif (!isObject && !isFunction && !isArguments) {\n\t\t\tthrow new TypeError('Object.keys called on a non-object');\n\t\t}\n\n\t\tvar skipProto = hasProtoEnumBug && isFunction;\n\t\tif (isString && object.length > 0 && !has.call(object, 0)) {\n\t\t\tfor (var i = 0; i < object.length; ++i) {\n\t\t\t\ttheKeys.push(String(i));\n\t\t\t}\n\t\t}\n\n\t\tif (isArguments && object.length > 0) {\n\t\t\tfor (var j = 0; j < object.length; ++j) {\n\t\t\t\ttheKeys.push(String(j));\n\t\t\t}\n\t\t} else {\n\t\t\tfor (var name in object) {\n\t\t\t\tif (!(skipProto && name === 'prototype') && has.call(object, name)) {\n\t\t\t\t\ttheKeys.push(String(name));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (hasDontEnumBug) {\n\t\t\tvar skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);\n\n\t\t\tfor (var k = 0; k < dontEnums.length; ++k) {\n\t\t\t\tif (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {\n\t\t\t\t\ttheKeys.push(dontEnums[k]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn theKeys;\n\t};\n}\nmodule.exports = keysShim;\n","'use strict';\n\nvar GetIntrinsic = require('./GetIntrinsic');\n\nvar $Object = GetIntrinsic('%Object%');\nvar $TypeError = GetIntrinsic('%TypeError%');\nvar $String = GetIntrinsic('%String%');\n\nvar assertRecord = require('./helpers/assertRecord');\nvar $isNaN = require('./helpers/isNaN');\nvar $isFinite = require('./helpers/isFinite');\n\nvar sign = require('./helpers/sign');\nvar mod = require('./helpers/mod');\n\nvar IsCallable = require('is-callable');\nvar toPrimitive = require('es-to-primitive/es5');\n\nvar has = require('has');\n\n// https://es5.github.io/#x9\nvar ES5 = {\n\tToPrimitive: toPrimitive,\n\n\tToBoolean: function ToBoolean(value) {\n\t\treturn !!value;\n\t},\n\tToNumber: function ToNumber(value) {\n\t\treturn +value; // eslint-disable-line no-implicit-coercion\n\t},\n\tToInteger: function ToInteger(value) {\n\t\tvar number = this.ToNumber(value);\n\t\tif ($isNaN(number)) { return 0; }\n\t\tif (number === 0 || !$isFinite(number)) { return number; }\n\t\treturn sign(number) * Math.floor(Math.abs(number));\n\t},\n\tToInt32: function ToInt32(x) {\n\t\treturn this.ToNumber(x) >> 0;\n\t},\n\tToUint32: function ToUint32(x) {\n\t\treturn this.ToNumber(x) >>> 0;\n\t},\n\tToUint16: function ToUint16(value) {\n\t\tvar number = this.ToNumber(value);\n\t\tif ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }\n\t\tvar posInt = sign(number) * Math.floor(Math.abs(number));\n\t\treturn mod(posInt, 0x10000);\n\t},\n\tToString: function ToString(value) {\n\t\treturn $String(value);\n\t},\n\tToObject: function ToObject(value) {\n\t\tthis.CheckObjectCoercible(value);\n\t\treturn $Object(value);\n\t},\n\tCheckObjectCoercible: function CheckObjectCoercible(value, optMessage) {\n\t\t/* jshint eqnull:true */\n\t\tif (value == null) {\n\t\t\tthrow new $TypeError(optMessage || 'Cannot call method on ' + value);\n\t\t}\n\t\treturn value;\n\t},\n\tIsCallable: IsCallable,\n\tSameValue: function SameValue(x, y) {\n\t\tif (x === y) { // 0 === -0, but they are not identical.\n\t\t\tif (x === 0) { return 1 / x === 1 / y; }\n\t\t\treturn true;\n\t\t}\n\t\treturn $isNaN(x) && $isNaN(y);\n\t},\n\n\t// https://www.ecma-international.org/ecma-262/5.1/#sec-8\n\tType: function Type(x) {\n\t\tif (x === null) {\n\t\t\treturn 'Null';\n\t\t}\n\t\tif (typeof x === 'undefined') {\n\t\t\treturn 'Undefined';\n\t\t}\n\t\tif (typeof x === 'function' || typeof x === 'object') {\n\t\t\treturn 'Object';\n\t\t}\n\t\tif (typeof x === 'number') {\n\t\t\treturn 'Number';\n\t\t}\n\t\tif (typeof x === 'boolean') {\n\t\t\treturn 'Boolean';\n\t\t}\n\t\tif (typeof x === 'string') {\n\t\t\treturn 'String';\n\t\t}\n\t},\n\n\t// https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type\n\tIsPropertyDescriptor: function IsPropertyDescriptor(Desc) {\n\t\tif (this.Type(Desc) !== 'Object') {\n\t\t\treturn false;\n\t\t}\n\t\tvar allowed = {\n\t\t\t'[[Configurable]]': true,\n\t\t\t'[[Enumerable]]': true,\n\t\t\t'[[Get]]': true,\n\t\t\t'[[Set]]': true,\n\t\t\t'[[Value]]': true,\n\t\t\t'[[Writable]]': true\n\t\t};\n\n\t\tfor (var key in Desc) { // eslint-disable-line\n\t\t\tif (has(Desc, key) && !allowed[key]) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tvar isData = has(Desc, '[[Value]]');\n\t\tvar IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]');\n\t\tif (isData && IsAccessor) {\n\t\t\tthrow new $TypeError('Property Descriptors may not be both accessor and data descriptors');\n\t\t}\n\t\treturn true;\n\t},\n\n\t// https://ecma-international.org/ecma-262/5.1/#sec-8.10.1\n\tIsAccessorDescriptor: function IsAccessorDescriptor(Desc) {\n\t\tif (typeof Desc === 'undefined') {\n\t\t\treturn false;\n\t\t}\n\n\t\tassertRecord(this, 'Property Descriptor', 'Desc', Desc);\n\n\t\tif (!has(Desc, '[[Get]]') && !has(Desc, '[[Set]]')) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t},\n\n\t// https://ecma-international.org/ecma-262/5.1/#sec-8.10.2\n\tIsDataDescriptor: function IsDataDescriptor(Desc) {\n\t\tif (typeof Desc === 'undefined') {\n\t\t\treturn false;\n\t\t}\n\n\t\tassertRecord(this, 'Property Descriptor', 'Desc', Desc);\n\n\t\tif (!has(Desc, '[[Value]]') && !has(Desc, '[[Writable]]')) {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t},\n\n\t// https://ecma-international.org/ecma-262/5.1/#sec-8.10.3\n\tIsGenericDescriptor: function IsGenericDescriptor(Desc) {\n\t\tif (typeof Desc === 'undefined') {\n\t\t\treturn false;\n\t\t}\n\n\t\tassertRecord(this, 'Property Descriptor', 'Desc', Desc);\n\n\t\tif (!this.IsAccessorDescriptor(Desc) && !this.IsDataDescriptor(Desc)) {\n\t\t\treturn true;\n\t\t}\n\n\t\treturn false;\n\t},\n\n\t// https://ecma-international.org/ecma-262/5.1/#sec-8.10.4\n\tFromPropertyDescriptor: function FromPropertyDescriptor(Desc) {\n\t\tif (typeof Desc === 'undefined') {\n\t\t\treturn Desc;\n\t\t}\n\n\t\tassertRecord(this, 'Property Descriptor', 'Desc', Desc);\n\n\t\tif (this.IsDataDescriptor(Desc)) {\n\t\t\treturn {\n\t\t\t\tvalue: Desc['[[Value]]'],\n\t\t\t\twritable: !!Desc['[[Writable]]'],\n\t\t\t\tenumerable: !!Desc['[[Enumerable]]'],\n\t\t\t\tconfigurable: !!Desc['[[Configurable]]']\n\t\t\t};\n\t\t} else if (this.IsAccessorDescriptor(Desc)) {\n\t\t\treturn {\n\t\t\t\tget: Desc['[[Get]]'],\n\t\t\t\tset: Desc['[[Set]]'],\n\t\t\t\tenumerable: !!Desc['[[Enumerable]]'],\n\t\t\t\tconfigurable: !!Desc['[[Configurable]]']\n\t\t\t};\n\t\t} else {\n\t\t\tthrow new $TypeError('FromPropertyDescriptor must be called with a fully populated Property Descriptor');\n\t\t}\n\t},\n\n\t// https://ecma-international.org/ecma-262/5.1/#sec-8.10.5\n\tToPropertyDescriptor: function ToPropertyDescriptor(Obj) {\n\t\tif (this.Type(Obj) !== 'Object') {\n\t\t\tthrow new $TypeError('ToPropertyDescriptor requires an object');\n\t\t}\n\n\t\tvar desc = {};\n\t\tif (has(Obj, 'enumerable')) {\n\t\t\tdesc['[[Enumerable]]'] = this.ToBoolean(Obj.enumerable);\n\t\t}\n\t\tif (has(Obj, 'configurable')) {\n\t\t\tdesc['[[Configurable]]'] = this.ToBoolean(Obj.configurable);\n\t\t}\n\t\tif (has(Obj, 'value')) {\n\t\t\tdesc['[[Value]]'] = Obj.value;\n\t\t}\n\t\tif (has(Obj, 'writable')) {\n\t\t\tdesc['[[Writable]]'] = this.ToBoolean(Obj.writable);\n\t\t}\n\t\tif (has(Obj, 'get')) {\n\t\t\tvar getter = Obj.get;\n\t\t\tif (typeof getter !== 'undefined' && !this.IsCallable(getter)) {\n\t\t\t\tthrow new TypeError('getter must be a function');\n\t\t\t}\n\t\t\tdesc['[[Get]]'] = getter;\n\t\t}\n\t\tif (has(Obj, 'set')) {\n\t\t\tvar setter = Obj.set;\n\t\t\tif (typeof setter !== 'undefined' && !this.IsCallable(setter)) {\n\t\t\t\tthrow new $TypeError('setter must be a function');\n\t\t\t}\n\t\t\tdesc['[[Set]]'] = setter;\n\t\t}\n\n\t\tif ((has(desc, '[[Get]]') || has(desc, '[[Set]]')) && (has(desc, '[[Value]]') || has(desc, '[[Writable]]'))) {\n\t\t\tthrow new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');\n\t\t}\n\t\treturn desc;\n\t}\n};\n\nmodule.exports = ES5;\n","'use strict';\n\nvar GetIntrinsic = require('../GetIntrinsic');\n\nvar $TypeError = GetIntrinsic('%TypeError%');\nvar $SyntaxError = GetIntrinsic('%SyntaxError%');\n\nvar has = require('has');\n\nvar predicates = {\n  // https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type\n  'Property Descriptor': function isPropertyDescriptor(ES, Desc) {\n    if (ES.Type(Desc) !== 'Object') {\n      return false;\n    }\n    var allowed = {\n      '[[Configurable]]': true,\n      '[[Enumerable]]': true,\n      '[[Get]]': true,\n      '[[Set]]': true,\n      '[[Value]]': true,\n      '[[Writable]]': true\n    };\n\n    for (var key in Desc) { // eslint-disable-line\n      if (has(Desc, key) && !allowed[key]) {\n        return false;\n      }\n    }\n\n    var isData = has(Desc, '[[Value]]');\n    var IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]');\n    if (isData && IsAccessor) {\n      throw new $TypeError('Property Descriptors may not be both accessor and data descriptors');\n    }\n    return true;\n  }\n};\n\nmodule.exports = function assertRecord(ES, recordType, argumentName, value) {\n  var predicate = predicates[recordType];\n  if (typeof predicate !== 'function') {\n    throw new $SyntaxError('unknown record type: ' + recordType);\n  }\n  if (!predicate(ES, value)) {\n    throw new $TypeError(argumentName + ' must be a ' + recordType);\n  }\n  console.log(predicate(ES, value), value);\n};\n","module.exports = Number.isNaN || function isNaN(a) {\n\treturn a !== a;\n};\n","var $isNaN = Number.isNaN || function (a) { return a !== a; };\n\nmodule.exports = Number.isFinite || function (x) { return typeof x === 'number' && !$isNaN(x) && x !== Infinity && x !== -Infinity; };\n","module.exports = function sign(number) {\n\treturn number >= 0 ? 1 : -1;\n};\n","module.exports = function mod(number, modulo) {\n\tvar remain = number % modulo;\n\treturn Math.floor(remain >= 0 ? remain : remain + modulo);\n};\n","'use strict';\n\nvar toStr = Object.prototype.toString;\n\nvar isPrimitive = require('./helpers/isPrimitive');\n\nvar isCallable = require('is-callable');\n\n// http://ecma-international.org/ecma-262/5.1/#sec-8.12.8\nvar ES5internalSlots = {\n\t'[[DefaultValue]]': function (O) {\n\t\tvar actualHint;\n\t\tif (arguments.length > 1) {\n\t\t\tactualHint = arguments[1];\n\t\t} else {\n\t\t\tactualHint = toStr.call(O) === '[object Date]' ? String : Number;\n\t\t}\n\n\t\tif (actualHint === String || actualHint === Number) {\n\t\t\tvar methods = actualHint === String ? ['toString', 'valueOf'] : ['valueOf', 'toString'];\n\t\t\tvar value, i;\n\t\t\tfor (i = 0; i < methods.length; ++i) {\n\t\t\t\tif (isCallable(O[methods[i]])) {\n\t\t\t\t\tvalue = O[methods[i]]();\n\t\t\t\t\tif (isPrimitive(value)) {\n\t\t\t\t\t\treturn value;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tthrow new TypeError('No default value');\n\t\t}\n\t\tthrow new TypeError('invalid [[DefaultValue]] hint supplied');\n\t}\n};\n\n// http://ecma-international.org/ecma-262/5.1/#sec-9.1\nmodule.exports = function ToPrimitive(input) {\n\tif (isPrimitive(input)) {\n\t\treturn input;\n\t}\n\tif (arguments.length > 1) {\n\t\treturn ES5internalSlots['[[DefaultValue]]'](input, arguments[1]);\n\t}\n\treturn ES5internalSlots['[[DefaultValue]]'](input);\n};\n","module.exports = function isPrimitive(value) {\n\treturn value === null || (typeof value !== 'function' && typeof value !== 'object');\n};\n","'use strict';\n\nvar define = require('define-properties');\nvar getPolyfill = require('./polyfill');\n\nmodule.exports = function shimStringTrim() {\n\tvar polyfill = getPolyfill();\n\tdefine(String.prototype, { trim: polyfill }, {\n\t\ttrim: function testTrim() {\n\t\t\treturn String.prototype.trim !== polyfill;\n\t\t}\n\t});\n\treturn polyfill;\n};\n","'use strict';\n\nvar isCallable = require('is-callable');\n\nvar toStr = Object.prototype.toString;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar forEachArray = function forEachArray(array, iterator, receiver) {\n    for (var i = 0, len = array.length; i < len; i++) {\n        if (hasOwnProperty.call(array, i)) {\n            if (receiver == null) {\n                iterator(array[i], i, array);\n            } else {\n                iterator.call(receiver, array[i], i, array);\n            }\n        }\n    }\n};\n\nvar forEachString = function forEachString(string, iterator, receiver) {\n    for (var i = 0, len = string.length; i < len; i++) {\n        // no such thing as a sparse string.\n        if (receiver == null) {\n            iterator(string.charAt(i), i, string);\n        } else {\n            iterator.call(receiver, string.charAt(i), i, string);\n        }\n    }\n};\n\nvar forEachObject = function forEachObject(object, iterator, receiver) {\n    for (var k in object) {\n        if (hasOwnProperty.call(object, k)) {\n            if (receiver == null) {\n                iterator(object[k], k, object);\n            } else {\n                iterator.call(receiver, object[k], k, object);\n            }\n        }\n    }\n};\n\nvar forEach = function forEach(list, iterator, thisArg) {\n    if (!isCallable(iterator)) {\n        throw new TypeError('iterator must be a function');\n    }\n\n    var receiver;\n    if (arguments.length >= 3) {\n        receiver = thisArg;\n    }\n\n    if (toStr.call(list) === '[object Array]') {\n        forEachArray(list, iterator, receiver);\n    } else if (typeof list === 'string') {\n        forEachString(list, iterator, receiver);\n    } else {\n        forEachObject(list, iterator, receiver);\n    }\n};\n\nmodule.exports = forEach;\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n","var once = require('once')\nvar eos = require('end-of-stream')\nvar fs = require('fs') // we only need fs to get the ReadStream and WriteStream prototypes\n\nvar noop = function () {}\n\nvar isFn = function (fn) {\n  return typeof fn === 'function'\n}\n\nvar isFS = function (stream) {\n  if (!fs) return false // browser\n  return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)\n}\n\nvar isRequest = function (stream) {\n  return stream.setHeader && isFn(stream.abort)\n}\n\nvar destroyer = function (stream, reading, writing, callback) {\n  callback = once(callback)\n\n  var closed = false\n  stream.on('close', function () {\n    closed = true\n  })\n\n  eos(stream, {readable: reading, writable: writing}, function (err) {\n    if (err) return callback(err)\n    closed = true\n    callback()\n  })\n\n  var destroyed = false\n  return function (err) {\n    if (closed) return\n    if (destroyed) return\n    destroyed = true\n\n    if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks\n    if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want\n\n    if (isFn(stream.destroy)) return stream.destroy()\n\n    callback(err || new Error('stream was destroyed'))\n  }\n}\n\nvar call = function (fn) {\n  fn()\n}\n\nvar pipe = function (from, to) {\n  return from.pipe(to)\n}\n\nvar pump = function () {\n  var streams = Array.prototype.slice.call(arguments)\n  var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop\n\n  if (Array.isArray(streams[0])) streams = streams[0]\n  if (streams.length < 2) throw new Error('pump requires two streams per minimum')\n\n  var error\n  var destroys = streams.map(function (stream, i) {\n    var reading = i < streams.length - 1\n    var writing = i > 0\n    return destroyer(stream, reading, writing, function (err) {\n      if (!error) error = err\n      if (err) destroys.forEach(call)\n      if (reading) return\n      destroys.forEach(call)\n      callback(error)\n    })\n  })\n\n  return streams.reduce(pipe)\n}\n\nmodule.exports = pump\n","// Returns a wrapper function that returns a wrapped callback\n// The wrapper function should do some stuff, and return a\n// presumably different callback function.\n// This makes sure that own properties are retained, so that\n// decorations and such are not lost along the way.\nmodule.exports = wrappy\nfunction wrappy (fn, cb) {\n  if (fn && cb) return wrappy(fn)(cb)\n\n  if (typeof fn !== 'function')\n    throw new TypeError('need wrapper function')\n\n  Object.keys(fn).forEach(function (k) {\n    wrapper[k] = fn[k]\n  })\n\n  return wrapper\n\n  function wrapper() {\n    var args = new Array(arguments.length)\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i]\n    }\n    var ret = fn.apply(this, args)\n    var cb = args[args.length-1]\n    if (typeof ret === 'function' && ret !== cb) {\n      Object.keys(cb).forEach(function (k) {\n        ret[k] = cb[k]\n      })\n    }\n    return ret\n  }\n}\n","var once = require('once');\n\nvar noop = function() {};\n\nvar isRequest = function(stream) {\n\treturn stream.setHeader && typeof stream.abort === 'function';\n};\n\nvar isChildProcess = function(stream) {\n\treturn stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3\n};\n\nvar eos = function(stream, opts, callback) {\n\tif (typeof opts === 'function') return eos(stream, null, opts);\n\tif (!opts) opts = {};\n\n\tcallback = once(callback || noop);\n\n\tvar ws = stream._writableState;\n\tvar rs = stream._readableState;\n\tvar readable = opts.readable || (opts.readable !== false && stream.readable);\n\tvar writable = opts.writable || (opts.writable !== false && stream.writable);\n\n\tvar onlegacyfinish = function() {\n\t\tif (!stream.writable) onfinish();\n\t};\n\n\tvar onfinish = function() {\n\t\twritable = false;\n\t\tif (!readable) callback.call(stream);\n\t};\n\n\tvar onend = function() {\n\t\treadable = false;\n\t\tif (!writable) callback.call(stream);\n\t};\n\n\tvar onexit = function(exitCode) {\n\t\tcallback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);\n\t};\n\n\tvar onerror = function(err) {\n\t\tcallback.call(stream, err);\n\t};\n\n\tvar onclose = function() {\n\t\tif (readable && !(rs && rs.ended)) return callback.call(stream, new Error('premature close'));\n\t\tif (writable && !(ws && ws.ended)) return callback.call(stream, new Error('premature close'));\n\t};\n\n\tvar onrequest = function() {\n\t\tstream.req.on('finish', onfinish);\n\t};\n\n\tif (isRequest(stream)) {\n\t\tstream.on('complete', onfinish);\n\t\tstream.on('abort', onclose);\n\t\tif (stream.req) onrequest();\n\t\telse stream.on('request', onrequest);\n\t} else if (writable && !ws) { // legacy streams\n\t\tstream.on('end', onlegacyfinish);\n\t\tstream.on('close', onlegacyfinish);\n\t}\n\n\tif (isChildProcess(stream)) stream.on('exit', onexit);\n\n\tstream.on('end', onend);\n\tstream.on('finish', onfinish);\n\tif (opts.error !== false) stream.on('error', onerror);\n\tstream.on('close', onclose);\n\n\treturn function() {\n\t\tstream.removeListener('complete', onfinish);\n\t\tstream.removeListener('abort', onclose);\n\t\tstream.removeListener('request', onrequest);\n\t\tif (stream.req) stream.req.removeListener('finish', onfinish);\n\t\tstream.removeListener('end', onlegacyfinish);\n\t\tstream.removeListener('close', onlegacyfinish);\n\t\tstream.removeListener('finish', onfinish);\n\t\tstream.removeListener('exit', onexit);\n\t\tstream.removeListener('end', onend);\n\t\tstream.removeListener('error', onerror);\n\t\tstream.removeListener('close', onclose);\n\t};\n};\n\nmodule.exports = eos;\n","var Transform = require('readable-stream/transform')\n  , inherits  = require('util').inherits\n  , xtend     = require('xtend')\n\nfunction DestroyableTransform(opts) {\n  Transform.call(this, opts)\n  this._destroyed = false\n}\n\ninherits(DestroyableTransform, Transform)\n\nDestroyableTransform.prototype.destroy = function(err) {\n  if (this._destroyed) return\n  this._destroyed = true\n  \n  var self = this\n  process.nextTick(function() {\n    if (err)\n      self.emit('error', err)\n    self.emit('close')\n  })\n}\n\n// a noop _transform function\nfunction noop (chunk, enc, callback) {\n  callback(null, chunk)\n}\n\n\n// create a new export function, used by both the main export and\n// the .ctor export, contains common logic for dealing with arguments\nfunction through2 (construct) {\n  return function (options, transform, flush) {\n    if (typeof options == 'function') {\n      flush     = transform\n      transform = options\n      options   = {}\n    }\n\n    if (typeof transform != 'function')\n      transform = noop\n\n    if (typeof flush != 'function')\n      flush = null\n\n    return construct(options, transform, flush)\n  }\n}\n\n\n// main export, just make me a transform stream!\nmodule.exports = through2(function (options, transform, flush) {\n  var t2 = new DestroyableTransform(options)\n\n  t2._transform = transform\n\n  if (flush)\n    t2._flush = flush\n\n  return t2\n})\n\n\n// make me a reusable prototype that I can `new`, or implicitly `new`\n// with a constructor call\nmodule.exports.ctor = through2(function (options, transform, flush) {\n  function Through2 (override) {\n    if (!(this instanceof Through2))\n      return new Through2(override)\n\n    this.options = xtend(options, override)\n\n    DestroyableTransform.call(this, this.options)\n  }\n\n  inherits(Through2, DestroyableTransform)\n\n  Through2.prototype._transform = transform\n\n  if (flush)\n    Through2.prototype._flush = flush\n\n  return Through2\n})\n\n\nmodule.exports.obj = through2(function (options, transform, flush) {\n  var t2 = new DestroyableTransform(xtend({ objectMode: true, highWaterMark: 16 }, options))\n\n  t2._transform = transform\n\n  if (flush)\n    t2._flush = flush\n\n  return t2\n})\n","module.exports = require(\"./lib/_stream_transform.js\")\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\n\nfunction TransformState(options, stream) {\n  this.afterTransform = function(er, data) {\n    return afterTransform(stream, er, data);\n  };\n\n  this.needTransform = false;\n  this.transforming = false;\n  this.writecb = null;\n  this.writechunk = null;\n}\n\nfunction afterTransform(stream, er, data) {\n  var ts = stream._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb)\n    return stream.emit('error', new Error('no writecb in Transform class'));\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data !== null && data !== undefined)\n    stream.push(data);\n\n  if (cb)\n    cb(er);\n\n  var rs = stream._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    stream._read(rs.highWaterMark);\n  }\n}\n\n\nfunction Transform(options) {\n  if (!(this instanceof Transform))\n    return new Transform(options);\n\n  Duplex.call(this, options);\n\n  var ts = this._transformState = new TransformState(options, this);\n\n  // when the writable side finishes, then flush out anything remaining.\n  var stream = this;\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  this.once('finish', function() {\n    if ('function' === typeof this._flush)\n      this._flush(function(er) {\n        done(stream, er);\n      });\n    else\n      done(stream);\n  });\n}\n\nTransform.prototype.push = function(chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function(chunk, encoding, cb) {\n  throw new Error('not implemented');\n};\n\nTransform.prototype._write = function(chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform ||\n        rs.needReadable ||\n        rs.length < rs.highWaterMark)\n      this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function(n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\n\nfunction done(stream, er) {\n  if (er)\n    return stream.emit('error', er);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  var ws = stream._writableState;\n  var rs = stream._readableState;\n  var ts = stream._transformState;\n\n  if (ws.length)\n    throw new Error('calling transform done when ws.length != 0');\n\n  if (ts.transforming)\n    throw new Error('calling transform done when still transforming');\n\n  return stream.push(null);\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n\n/*<replacement>*/\nvar Buffer = require('buffer').Buffer;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\nvar EE = require('events').EventEmitter;\n\n/*<replacement>*/\nif (!EE.listenerCount) EE.listenerCount = function(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\nvar Stream = require('stream');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nfunction ReadableState(options, stream) {\n  options = options || {};\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;\n\n  // cast to ints.\n  this.highWaterMark = ~~this.highWaterMark;\n\n  this.buffer = [];\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = false;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // In streams that never have any data, and do push(null) right away,\n  // the consumer can miss the 'end' event if they do some I/O before\n  // consuming the stream.  So, we don't emit('end') until some reading\n  // happens.\n  this.calledRead = false;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, becuase any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // when piping, we only care about 'readable' events that happen\n  // after read()ing all the bytes and not getting any pushback.\n  this.ranOut = false;\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder)\n      StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  if (!(this instanceof Readable))\n    return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  Stream.call(this);\n}\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function(chunk, encoding) {\n  var state = this._readableState;\n\n  if (typeof chunk === 'string' && !state.objectMode) {\n    encoding = encoding || state.defaultEncoding;\n    if (encoding !== state.encoding) {\n      chunk = new Buffer(chunk, encoding);\n      encoding = '';\n    }\n  }\n\n  return readableAddChunk(this, state, chunk, encoding, false);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function(chunk) {\n  var state = this._readableState;\n  return readableAddChunk(this, state, chunk, '', true);\n};\n\nfunction readableAddChunk(stream, state, chunk, encoding, addToFront) {\n  var er = chunkInvalid(state, chunk);\n  if (er) {\n    stream.emit('error', er);\n  } else if (chunk === null || chunk === undefined) {\n    state.reading = false;\n    if (!state.ended)\n      onEofChunk(stream, state);\n  } else if (state.objectMode || chunk && chunk.length > 0) {\n    if (state.ended && !addToFront) {\n      var e = new Error('stream.push() after EOF');\n      stream.emit('error', e);\n    } else if (state.endEmitted && addToFront) {\n      var e = new Error('stream.unshift() after end event');\n      stream.emit('error', e);\n    } else {\n      if (state.decoder && !addToFront && !encoding)\n        chunk = state.decoder.write(chunk);\n\n      // update the buffer info.\n      state.length += state.objectMode ? 1 : chunk.length;\n      if (addToFront) {\n        state.buffer.unshift(chunk);\n      } else {\n        state.reading = false;\n        state.buffer.push(chunk);\n      }\n\n      if (state.needReadable)\n        emitReadable(stream);\n\n      maybeReadMore(stream, state);\n    }\n  } else if (!addToFront) {\n    state.reading = false;\n  }\n\n  return needMoreData(state);\n}\n\n\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended &&\n         (state.needReadable ||\n          state.length < state.highWaterMark ||\n          state.length === 0);\n}\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function(enc) {\n  if (!StringDecoder)\n    StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n};\n\n// Don't raise the hwm > 128MB\nvar MAX_HWM = 0x800000;\nfunction roundUpToNextPowerOf2(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2\n    n--;\n    for (var p = 1; p < 32; p <<= 1) n |= n >> p;\n    n++;\n  }\n  return n;\n}\n\nfunction howMuchToRead(n, state) {\n  if (state.length === 0 && state.ended)\n    return 0;\n\n  if (state.objectMode)\n    return n === 0 ? 0 : 1;\n\n  if (n === null || isNaN(n)) {\n    // only flow one buffer at a time\n    if (state.flowing && state.buffer.length)\n      return state.buffer[0].length;\n    else\n      return state.length;\n  }\n\n  if (n <= 0)\n    return 0;\n\n  // If we're asking for more than the target buffer level,\n  // then raise the water mark.  Bump up to the next highest\n  // power of 2, to prevent increasing it excessively in tiny\n  // amounts.\n  if (n > state.highWaterMark)\n    state.highWaterMark = roundUpToNextPowerOf2(n);\n\n  // don't have that much.  return null, unless we've ended.\n  if (n > state.length) {\n    if (!state.ended) {\n      state.needReadable = true;\n      return 0;\n    } else\n      return state.length;\n  }\n\n  return n;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function(n) {\n  var state = this._readableState;\n  state.calledRead = true;\n  var nOrig = n;\n  var ret;\n\n  if (typeof n !== 'number' || n > 0)\n    state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 &&\n      state.needReadable &&\n      (state.length >= state.highWaterMark || state.ended)) {\n    emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    ret = null;\n\n    // In cases where the decoder did not receive enough data\n    // to produce a full chunk, then immediately received an\n    // EOF, state.buffer will contain [<Buffer >, <Buffer 00 ...>].\n    // howMuchToRead will see this and coerce the amount to\n    // read to zero (because it's looking at the length of the\n    // first <Buffer > in state.buffer), and we'll end up here.\n    //\n    // This can only happen via state.decoder -- no other venue\n    // exists for pushing a zero-length chunk into state.buffer\n    // and triggering this behavior. In this case, we return our\n    // remaining data and end the stream, if appropriate.\n    if (state.length > 0 && state.decoder) {\n      ret = fromList(n, state);\n      state.length -= ret.length;\n    }\n\n    if (state.length === 0)\n      endReadable(this);\n\n    return ret;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length - n <= state.highWaterMark)\n    doRead = true;\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading)\n    doRead = false;\n\n  if (doRead) {\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0)\n      state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n  }\n\n  // If _read called its callback synchronously, then `reading`\n  // will be false, and we need to re-evaluate how much data we\n  // can return to the user.\n  if (doRead && !state.reading)\n    n = howMuchToRead(nOrig, state);\n\n  if (n > 0)\n    ret = fromList(n, state);\n  else\n    ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  }\n\n  state.length -= n;\n\n  // If we have nothing in the buffer, then we want to know\n  // as soon as we *do* get something into the buffer.\n  if (state.length === 0 && !state.ended)\n    state.needReadable = true;\n\n  // If we happened to read() exactly the remaining amount in the\n  // buffer, and the EOF has been seen at this point, then make sure\n  // that we emit 'end' on the very next tick.\n  if (state.ended && !state.endEmitted && state.length === 0)\n    endReadable(this);\n\n  return ret;\n};\n\nfunction chunkInvalid(state, chunk) {\n  var er = null;\n  if (!Buffer.isBuffer(chunk) &&\n      'string' !== typeof chunk &&\n      chunk !== null &&\n      chunk !== undefined &&\n      !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n\nfunction onEofChunk(stream, state) {\n  if (state.decoder && !state.ended) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // if we've ended and we have some data left, then emit\n  // 'readable' now to make sure it gets picked up.\n  if (state.length > 0)\n    emitReadable(stream);\n  else\n    endReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (state.emittedReadable)\n    return;\n\n  state.emittedReadable = true;\n  if (state.sync)\n    process.nextTick(function() {\n      emitReadable_(stream);\n    });\n  else\n    emitReadable_(stream);\n}\n\nfunction emitReadable_(stream) {\n  stream.emit('readable');\n}\n\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(function() {\n      maybeReadMore_(stream, state);\n    });\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended &&\n         state.length < state.highWaterMark) {\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;\n    else\n      len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function(n) {\n  this.emit('error', new Error('not implemented'));\n};\n\nReadable.prototype.pipe = function(dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) &&\n              dest !== process.stdout &&\n              dest !== process.stderr;\n\n  var endFn = doEnd ? onend : cleanup;\n  if (state.endEmitted)\n    process.nextTick(endFn);\n  else\n    src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable) {\n    if (readable !== src) return;\n    cleanup();\n  }\n\n  function onend() {\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  function cleanup() {\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', cleanup);\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (!dest._writableState || dest._writableState.needDrain)\n      ondrain();\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EE.listenerCount(dest, 'error') === 0)\n      dest.emit('error', er);\n  }\n  // This is a brutally ugly hack to make sure that our error handler\n  // is attached before any userland ones.  NEVER DO THIS.\n  if (!dest._events || !dest._events.error)\n    dest.on('error', onerror);\n  else if (isArray(dest._events.error))\n    dest._events.error.unshift(onerror);\n  else\n    dest._events.error = [onerror, dest._events.error];\n\n\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    // the handler that waits for readable events after all\n    // the data gets sucked out in flow.\n    // This would be easier to follow with a .once() handler\n    // in flow(), but that is too slow.\n    this.on('readable', pipeOnReadable);\n\n    state.flowing = true;\n    process.nextTick(function() {\n      flow(src);\n    });\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function() {\n    var dest = this;\n    var state = src._readableState;\n    state.awaitDrain--;\n    if (state.awaitDrain === 0)\n      flow(src);\n  };\n}\n\nfunction flow(src) {\n  var state = src._readableState;\n  var chunk;\n  state.awaitDrain = 0;\n\n  function write(dest, i, list) {\n    var written = dest.write(chunk);\n    if (false === written) {\n      state.awaitDrain++;\n    }\n  }\n\n  while (state.pipesCount && null !== (chunk = src.read())) {\n\n    if (state.pipesCount === 1)\n      write(state.pipes, 0, null);\n    else\n      forEach(state.pipes, write);\n\n    src.emit('data', chunk);\n\n    // if anyone needs a drain, then we have to wait for that.\n    if (state.awaitDrain > 0)\n      return;\n  }\n\n  // if every destination was unpiped, either before entering this\n  // function, or in the while loop, then stop flowing.\n  //\n  // NB: This is a pretty rare edge case.\n  if (state.pipesCount === 0) {\n    state.flowing = false;\n\n    // if there were data event listeners added, then switch to old mode.\n    if (EE.listenerCount(src, 'data') > 0)\n      emitDataEvents(src);\n    return;\n  }\n\n  // at this point, no one needed a drain, so we just ran out of data\n  // on the next readable event, start it over again.\n  state.ranOut = true;\n}\n\nfunction pipeOnReadable() {\n  if (this._readableState.ranOut) {\n    this._readableState.ranOut = false;\n    flow(this);\n  }\n}\n\n\nReadable.prototype.unpipe = function(dest) {\n  var state = this._readableState;\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0)\n    return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes)\n      return this;\n\n    if (!dest)\n      dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    this.removeListener('readable', pipeOnReadable);\n    state.flowing = false;\n    if (dest)\n      dest.emit('unpipe', this);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    this.removeListener('readable', pipeOnReadable);\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++)\n      dests[i].emit('unpipe', this);\n    return this;\n  }\n\n  // try to find the right one.\n  var i = indexOf(state.pipes, dest);\n  if (i === -1)\n    return this;\n\n  state.pipes.splice(i, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1)\n    state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function(ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data' && !this._readableState.flowing)\n    emitDataEvents(this);\n\n  if (ev === 'readable' && this.readable) {\n    var state = this._readableState;\n    if (!state.readableListening) {\n      state.readableListening = true;\n      state.emittedReadable = false;\n      state.needReadable = true;\n      if (!state.reading) {\n        this.read(0);\n      } else if (state.length) {\n        emitReadable(this, state);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function() {\n  emitDataEvents(this);\n  this.read(0);\n  this.emit('resume');\n};\n\nReadable.prototype.pause = function() {\n  emitDataEvents(this, true);\n  this.emit('pause');\n};\n\nfunction emitDataEvents(stream, startPaused) {\n  var state = stream._readableState;\n\n  if (state.flowing) {\n    // https://github.com/isaacs/readable-stream/issues/16\n    throw new Error('Cannot switch to old mode now.');\n  }\n\n  var paused = startPaused || false;\n  var readable = false;\n\n  // convert to an old-style stream.\n  stream.readable = true;\n  stream.pipe = Stream.prototype.pipe;\n  stream.on = stream.addListener = Stream.prototype.on;\n\n  stream.on('readable', function() {\n    readable = true;\n\n    var c;\n    while (!paused && (null !== (c = stream.read())))\n      stream.emit('data', c);\n\n    if (c === null) {\n      readable = false;\n      stream._readableState.needReadable = true;\n    }\n  });\n\n  stream.pause = function() {\n    paused = true;\n    this.emit('pause');\n  };\n\n  stream.resume = function() {\n    paused = false;\n    if (readable)\n      process.nextTick(function() {\n        stream.emit('readable');\n      });\n    else\n      this.read(0);\n    this.emit('resume');\n  };\n\n  // now make it start, just in case it hadn't already.\n  stream.emit('readable');\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function(stream) {\n  var state = this._readableState;\n  var paused = false;\n\n  var self = this;\n  stream.on('end', function() {\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length)\n        self.push(chunk);\n    }\n\n    self.push(null);\n  });\n\n  stream.on('data', function(chunk) {\n    if (state.decoder)\n      chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    //if (state.objectMode && util.isNullOrUndefined(chunk))\n    if (state.objectMode && (chunk === null || chunk === undefined))\n      return;\n    else if (!state.objectMode && (!chunk || !chunk.length))\n      return;\n\n    var ret = self.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (typeof stream[i] === 'function' &&\n        typeof this[i] === 'undefined') {\n      this[i] = function(method) { return function() {\n        return stream[method].apply(stream, arguments);\n      }}(i);\n    }\n  }\n\n  // proxy certain important events.\n  var events = ['error', 'close', 'destroy', 'pause', 'resume'];\n  forEach(events, function(ev) {\n    stream.on(ev, self.emit.bind(self, ev));\n  });\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  self._read = function(n) {\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return self;\n};\n\n\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\nfunction fromList(n, state) {\n  var list = state.buffer;\n  var length = state.length;\n  var stringMode = !!state.decoder;\n  var objectMode = !!state.objectMode;\n  var ret;\n\n  // nothing in the list, definitely empty.\n  if (list.length === 0)\n    return null;\n\n  if (length === 0)\n    ret = null;\n  else if (objectMode)\n    ret = list.shift();\n  else if (!n || n >= length) {\n    // read it all, truncate the array.\n    if (stringMode)\n      ret = list.join('');\n    else\n      ret = Buffer.concat(list, length);\n    list.length = 0;\n  } else {\n    // read just some of it.\n    if (n < list[0].length) {\n      // just take a part of the first list item.\n      // slice is the same for buffers and strings.\n      var buf = list[0];\n      ret = buf.slice(0, n);\n      list[0] = buf.slice(n);\n    } else if (n === list[0].length) {\n      // first list is a perfect match\n      ret = list.shift();\n    } else {\n      // complex case.\n      // we have enough to cover it, but it spans past the first buffer.\n      if (stringMode)\n        ret = '';\n      else\n        ret = new Buffer(n);\n\n      var c = 0;\n      for (var i = 0, l = list.length; i < l && c < n; i++) {\n        var buf = list[0];\n        var cpy = Math.min(n - c, buf.length);\n\n        if (stringMode)\n          ret += buf.slice(0, cpy);\n        else\n          buf.copy(ret, c, 0, cpy);\n\n        if (cpy < buf.length)\n          list[0] = buf.slice(cpy);\n        else\n          list.shift();\n\n        c += cpy;\n      }\n    }\n  }\n\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0)\n    throw new Error('endReadable called on non-empty stream');\n\n  if (!state.endEmitted && state.calledRead) {\n    state.ended = true;\n    process.nextTick(function() {\n      // Check that we didn't get one last unshift.\n      if (!state.endEmitted && state.length === 0) {\n        state.endEmitted = true;\n        stream.readable = false;\n        stream.emit('end');\n      }\n    });\n  }\n}\n\nfunction forEach (xs, f) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    f(xs[i], i);\n  }\n}\n\nfunction indexOf (xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}\n","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n","module.exports = require('./lib/_stream_writable.js');\n","module.exports = require('./lib/_stream_duplex.js');\n","module.exports = require('./readable').Transform\n","module.exports = require('./readable').PassThrough\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, cb), and it'll handle all\n// the drain event emission and buffering.\n\nmodule.exports = Writable;\n\n/*<replacement>*/\nvar Buffer = require('buffer').Buffer;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Stream = require('stream');\n\nutil.inherits(Writable, Stream);\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n}\n\nfunction WritableState(options, stream) {\n  options = options || {};\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  // cast to ints.\n  this.highWaterMark = ~~this.highWaterMark;\n\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, becuase any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function(er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.buffer = [];\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n}\n\nfunction Writable(options) {\n  var Duplex = require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, though they're not\n  // instanceof Writable, they're instanceof Readable.\n  if (!(this instanceof Writable) && !(this instanceof Duplex))\n    return new Writable(options);\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function() {\n  this.emit('error', new Error('Cannot pipe. Not readable.'));\n};\n\n\nfunction writeAfterEnd(stream, state, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  process.nextTick(function() {\n    cb(er);\n  });\n}\n\n// If we get something that is not a buffer, string, null, or undefined,\n// and we're not in objectMode, then that's an error.\n// Otherwise stream chunks are all considered to be of length=1, and the\n// watermarks determine how many objects to keep in the buffer, rather than\n// how many bytes or characters.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  if (!Buffer.isBuffer(chunk) &&\n      'string' !== typeof chunk &&\n      chunk !== null &&\n      chunk !== undefined &&\n      !state.objectMode) {\n    var er = new TypeError('Invalid non-string/buffer chunk');\n    stream.emit('error', er);\n    process.nextTick(function() {\n      cb(er);\n    });\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function(chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (Buffer.isBuffer(chunk))\n    encoding = 'buffer';\n  else if (!encoding)\n    encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function')\n    cb = function() {};\n\n  if (state.ended)\n    writeAfterEnd(this, state, cb);\n  else if (validChunk(this, state, chunk, cb))\n    ret = writeOrBuffer(this, state, chunk, encoding, cb);\n\n  return ret;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode &&\n      state.decodeStrings !== false &&\n      typeof chunk === 'string') {\n    chunk = new Buffer(chunk, encoding);\n  }\n  return chunk;\n}\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, chunk, encoding, cb) {\n  chunk = decodeChunk(state, chunk, encoding);\n  if (Buffer.isBuffer(chunk))\n    encoding = 'buffer';\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret)\n    state.needDrain = true;\n\n  if (state.writing)\n    state.buffer.push(new WriteReq(chunk, encoding, cb));\n  else\n    doWrite(stream, state, len, chunk, encoding, cb);\n\n  return ret;\n}\n\nfunction doWrite(stream, state, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  if (sync)\n    process.nextTick(function() {\n      cb(er);\n    });\n  else\n    cb(er);\n\n  stream._writableState.errorEmitted = true;\n  stream.emit('error', er);\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er)\n    onwriteError(stream, state, sync, er, cb);\n  else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(stream, state);\n\n    if (!finished && !state.bufferProcessing && state.buffer.length)\n      clearBuffer(stream, state);\n\n    if (sync) {\n      process.nextTick(function() {\n        afterWrite(stream, state, finished, cb);\n      });\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished)\n    onwriteDrain(stream, state);\n  cb();\n  if (finished)\n    finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n\n  for (var c = 0; c < state.buffer.length; c++) {\n    var entry = state.buffer[c];\n    var chunk = entry.chunk;\n    var encoding = entry.encoding;\n    var cb = entry.callback;\n    var len = state.objectMode ? 1 : chunk.length;\n\n    doWrite(stream, state, len, chunk, encoding, cb);\n\n    // if we didn't call the onwrite immediately, then\n    // it means that we need to wait until it does.\n    // also, that means that the chunk and cb are currently\n    // being processed, so move the buffer counter past them.\n    if (state.writing) {\n      c++;\n      break;\n    }\n  }\n\n  state.bufferProcessing = false;\n  if (c < state.buffer.length)\n    state.buffer = state.buffer.slice(c);\n  else\n    state.buffer.length = 0;\n}\n\nWritable.prototype._write = function(chunk, encoding, cb) {\n  cb(new Error('not implemented'));\n};\n\nWritable.prototype.end = function(chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (typeof chunk !== 'undefined' && chunk !== null)\n    this.write(chunk, encoding);\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished)\n    endWritable(this, state, cb);\n};\n\n\nfunction needFinish(stream, state) {\n  return (state.ending &&\n          state.length === 0 &&\n          !state.finished &&\n          !state.writing);\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(stream, state);\n  if (need) {\n    state.finished = true;\n    stream.emit('finish');\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished)\n      process.nextTick(cb);\n    else\n      stream.once('finish', cb);\n  }\n  state.ended = true;\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n  function getOwnPropertyDescriptors(obj) {\n    var keys = Object.keys(obj);\n    var descriptors = {};\n    for (var i = 0; i < keys.length; i++) {\n      descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n    }\n    return descriptors;\n  };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  if (typeof process !== 'undefined' && process.noDeprecation === true) {\n    return fn;\n  }\n\n  // Allow for deprecating things in the process of starting up.\n  if (typeof process === 'undefined') {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n  if (typeof original !== 'function')\n    throw new TypeError('The \"original\" argument must be of type Function');\n\n  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n    var fn = original[kCustomPromisifiedSymbol];\n    if (typeof fn !== 'function') {\n      throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n    }\n    Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n      value: fn, enumerable: false, writable: false, configurable: true\n    });\n    return fn;\n  }\n\n  function fn() {\n    var promiseResolve, promiseReject;\n    var promise = new Promise(function (resolve, reject) {\n      promiseResolve = resolve;\n      promiseReject = reject;\n    });\n\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n    args.push(function (err, value) {\n      if (err) {\n        promiseReject(err);\n      } else {\n        promiseResolve(value);\n      }\n    });\n\n    try {\n      original.apply(this, args);\n    } catch (err) {\n      promiseReject(err);\n    }\n\n    return promise;\n  }\n\n  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n  if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n    value: fn, enumerable: false, writable: false, configurable: true\n  });\n  return Object.defineProperties(\n    fn,\n    getOwnPropertyDescriptors(original)\n  );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n  // Because `null` is a special error value in callbacks which means \"no error\n  // occurred\", we error-wrap so the callback consumer can distinguish between\n  // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n  if (!reason) {\n    var newReason = new Error('Promise was rejected with a falsy value');\n    newReason.reason = reason;\n    reason = newReason;\n  }\n  return cb(reason);\n}\n\nfunction callbackify(original) {\n  if (typeof original !== 'function') {\n    throw new TypeError('The \"original\" argument must be of type Function');\n  }\n\n  // We DO NOT return the promise as it gives the user a false sense that\n  // the promise is actually somehow related to the callback's execution\n  // and that the callback throwing will reject the promise.\n  function callbackified() {\n    var args = [];\n    for (var i = 0; i < arguments.length; i++) {\n      args.push(arguments[i]);\n    }\n\n    var maybeCb = args.pop();\n    if (typeof maybeCb !== 'function') {\n      throw new TypeError('The last argument must be of type Function');\n    }\n    var self = this;\n    var cb = function() {\n      return maybeCb.apply(self, arguments);\n    };\n    // In true node style we process the callback on `nextTick` with all the\n    // implications (stack, `uncaughtException`, `async_hooks`)\n    original.apply(this, args)\n      .then(function(ret) { process.nextTick(cb, null, ret) },\n            function(rej) { process.nextTick(callbackifyOnRejected, rej, cb) });\n  }\n\n  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n  Object.defineProperties(callbackified,\n                          getOwnPropertyDescriptors(original));\n  return callbackified;\n}\nexports.callbackify = callbackify;\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n    var target = {}\n\n    for (var i = 0; i < arguments.length; i++) {\n        var source = arguments[i]\n\n        for (var key in source) {\n            if (hasOwnProperty.call(source, key)) {\n                target[key] = source[key]\n            }\n        }\n    }\n\n    return target\n}\n","/**\n * Originally from https://github.com/QwantResearch/masq-common/ with improvements\n * by Andrei Sambra\n */\n\nconst checkCryptokey = (key) => {\n  if (!key.type || key.type !== 'secret') {\n    throw new Error('Invalid key type')\n  }\n}\n\nconst genRandomBuffer = (len = 16) => {\n  const values = window.crypto.getRandomValues(new Uint8Array(len))\n  return Buffer.from(values)\n}\n\nconst genRandomBufferAsStr = (len = 16, encodingFormat = 'hex') => {\n  if (encodingFormat) {\n    checkEncodingFormat(encodingFormat)\n  }\n  const buf = genRandomBuffer(len)\n  return buf.toString(encodingFormat)\n}\n\nconst checkPassphrase = (str) => {\n  if (typeof str !== 'string' || str === '') {\n    throw new Error(`Not a valid value`)\n  }\n}\n\nconst checkEncodingFormat = (format) => {\n  if (format !== 'hex' && format !== 'base64') throw new Error('Invalid encoding')\n}\n\n/**\n * Generate a random hexadecimal ID of a given length\n *\n * @param {integer} [len] The string length of the new ID\n * @returns {string} The new ID\n */\nconst genId = (len = 32) => {\n  // 2 bytes for each char\n  return genRandomBufferAsStr(Math.floor(len / 2))\n}\n\n/**\n * Generate the hash of a string or ArrayBuffer\n *\n * @param {string | arrayBuffer} data The message\n * @param {string} [format] The encoding format ('hex' by default, can also be 'base64')\n * @param {string} [name] The hashing algorithm (SHA-256 by default)\n * @returns {Promise<String>}  A promise that contains the hash as a String encoded with encodingFormat\n */\nconst hash = async (data, format = 'hex', name = 'SHA-256') => {\n  const digest = await window.crypto.subtle.digest(\n    {\n      name\n    },\n    (typeof data === 'string') ? Buffer.from(data) : data\n  )\n  return Buffer.from(digest).toString(format)\n}\n\n/**\n   * Generate an ECDA key pair based on the provided curve name\n   *\n   * @param {boolean} extractable - Specify if the generated key is extractable\n   * @param {namedCurve} namedCurve - The curve name to use\n   * @returns {Promise<CryptoKey>} - A promise containing the key pair\n   */\nconst genKeyPair = (extractable = true, namedCurve = 'P-256') => {\n  return window.crypto.subtle.generateKey(\n    {\n      name: 'ECDSA',\n      namedCurve // can be \"P-256\", \"P-384\", or \"P-521\"\n    },\n    extractable,\n    ['sign', 'verify']\n  )\n}\n\n/**\n  * Import a public key\n  *\n  * @param {CryptoKey} key - The public CryptoKey\n  * @param {string} namedCurve - The curve name to use\n  * @returns {Promise<arrayBuffer>} - The raw key\n  */\nconst importPublicKey = (key, namedCurve = 'P-256', format = 'base64') => {\n  return window.crypto.subtle.importKey(\n    'spki',\n    Buffer.from(key, format),\n    {\n      name: 'ECDSA',\n      namedCurve // can be \"P-256\", \"P-384\", or \"P-521\"\n    },\n    true,\n    ['verify']\n  )\n}\n\n/**\n  * Import a private key\n  *\n  * @param {CryptoKey} key - The private CryptoKey\n  * @param {string} namedCurve - The curve name to use\n  * @returns {Promise<arrayBuffer>} - The raw key\n  */\nconst importPrivateKey = (key, namedCurve = 'P-256', format = 'base64') => {\n  return window.crypto.subtle.importKey(\n    'pkcs8',\n    Buffer.from(key, format),\n    {\n      name: 'ECDSA',\n      namedCurve // can be \"P-256\", \"P-384\", or \"P-521\"\n    },\n    true,\n    ['sign']\n  )\n}\n\n/**\n  * Export a public key\n  *\n  * @param {CryptoKey} key - The public CryptoKey\n  * @returns {Promise<arrayBuffer>} - The raw key\n  */\nconst exportPublicKey = async (key, format = 'base64') => {\n  const exported = await window.crypto.subtle.exportKey('spki', key)\n  return (format === 'raw') ? new Uint8Array(exported) : Buffer.from(exported).toString(format)\n}\n\n/**\n  * Export a private key\n  *\n  * @param {CryptoKey} key - The private CryptoKey\n  * @returns {Promise<arrayBuffer>} - The raw key\n  */\nconst exportPrivateKey = async (key, format = 'base64') => {\n  const exported = await window.crypto.subtle.exportKey('pkcs8', key)\n  return (format === 'raw') ? new Uint8Array(exported) : Buffer.from(exported).toString(format)\n}\n\n/**\n * Sign data using the private key\n *\n * @param {CryptoKey} key - The private key\n * @param {*} data - Data to sign\n * @param {*} hash - The hashing algorithm\n * @returns {Promise<arrayBuffer>} - The raw signature\n */\nconst sign = async (key, data, format = 'base64', hash = 'SHA-256') => {\n  const signature = await window.crypto.subtle.sign(\n    {\n      name: 'ECDSA',\n      hash: { name: 'SHA-256' } // can be \"SHA-1\", \"SHA-256\", \"SHA-384\", or \"SHA-512\"\n    },\n    key,\n    Buffer.from(JSON.stringify(data))\n  )\n  return (format === 'raw') ? new Uint8Array(signature) : Buffer.from(signature).toString(format)\n}\n\n/**\n * Verify data using the public key\n *\n * @param {CryptoKey} key - The public key\n * @param {*} data - Data to verify\n * @param {*} hash - The hashing algorithm\n * @returns {Promise<boolean>} - The verification outcome\n */\nconst verify = async (key, data, signature, format = 'base64', hash = 'SHA-256') => {\n  return window.crypto.subtle.verify(\n    {\n      name: 'ECDSA',\n      hash: { name: 'SHA-256' } // can be \"SHA-1\", \"SHA-256\", \"SHA-384\", or \"SHA-512\"\n    },\n    key,\n    Buffer.from(signature, format),\n    Buffer.from(JSON.stringify(data))\n  )\n}\n\n/**\n   * Generate an AES key based on the cipher mode and keysize\n   *\n   * @param {boolean} [extractable] - Specify if the generated key is extractable\n   * @param {string} [mode] - The aes mode of the generated key\n   * @param {Number} [keySize] - Specify if the generated key is extractable\n   * @returns {Promise<CryptoKey>} - The generated AES key.\n   */\nconst genAESKey = (extractable = true, mode = 'AES-GCM', keySize = 128) => {\n  return window.crypto.subtle.generateKey({\n    name: mode,\n    length: keySize\n  },\n  extractable,\n  ['decrypt', 'encrypt'])\n}\n\n/**\n    * Import a raw|jwk as a CryptoKey\n    *\n    * @param {arrayBuffer|Object} key - The key\n    * @param {string} [type] - The type of the key to import ('raw', 'jwk')\n    * @param {string} [mode] - The mode of the key to import (default 'AES-GCM')\n    * @returns {Promise<arrayBuffer>} - The cryptoKey\n    */\nconst importKey = (key, type = 'raw', mode = 'AES-GCM') => {\n  const parsedKey = (type === 'raw') ? Buffer.from(key, 'base64') : key\n  return window.crypto.subtle.importKey(type, parsedKey, { name: mode }\n    , true, ['encrypt', 'decrypt'])\n}\n\n/**\n  * Export a CryptoKey into a raw|jwk key\n  *\n  * @param {CryptoKey} key - The CryptoKey\n  * @param {string} [type] - The type of the exported key: raw|jwk\n  * @returns {Promise<arrayBuffer>} - The raw key or the key as a jwk format\n  */\nconst exportKey = async (key, type = 'raw') => {\n  const exportedKey = await window.crypto.subtle.exportKey(type, key)\n  return (type === 'raw') ? new Uint8Array(exportedKey) : exportedKey\n}\n\n/**\n   * Encrypt buffer\n   *\n   * @param {ArrayBuffer} key - The AES CryptoKey\n   * @param {ArrayBuffer} data - Data to encrypt\n   * @param {Object} cipherContext - The AES cipher parameters\n   * @returns {ArrayBuffer} - The encrypted buffer\n   */\nconst encryptBuffer = async (key, data, cipherContext) => {\n  const encrypted = await window.crypto.subtle.encrypt(cipherContext, key, data)\n  return new Uint8Array(encrypted)\n}\n\n/**\n * Decrypt buffer\n * @param {ArrayBuffer} key - The AES CryptoKey\n * @param {ArrayBuffer} data - Data to decrypt\n * @param {Object} cipherContext - The AES cipher parameters\n * @returns {Promise<ArrayBuffer>} - The decrypted buffer\n */\nconst decryptBuffer = async (key, data, cipherContext) => {\n  // TODO: test input params\n  try {\n    const decrypted = await window.crypto.subtle.decrypt(cipherContext, key, data)\n    return new Uint8Array(decrypted)\n  } catch (e) {\n    if (e.message === 'Unsupported state or unable to authenticate data') {\n      throw new Error('Unable to decrypt data')\n    }\n  }\n}\n\n/**\n * Encrypt data\n *\n * @param {CryptoKey} key - The AES CryptoKey\n * @param {string | Object} - The data to encrypt\n * @param {string} [format] - The ciphertext and iv encoding format\n * @returns {Object} - The stringified ciphertext object (ciphertext and iv)\n */\nconst encrypt = async (key, data, format = 'hex') => {\n  checkCryptokey(key)\n  const context = {\n    iv: genRandomBuffer(key.algorithm.name === 'AES-GCM' ? 12 : 16),\n    plaintext: Buffer.from(JSON.stringify(data))\n  }\n\n  // Prepare cipher context, depends on cipher mode\n  const cipherContext = {\n    name: key.algorithm.name,\n    iv: context.iv\n  }\n\n  const encrypted = await encryptBuffer(key, context.plaintext, cipherContext)\n  return {\n    ciphertext: Buffer.from(encrypted).toString(format),\n    iv: Buffer.from(context.iv).toString(format)\n  }\n}\n\n/**\n   * Decrypt data\n   *\n   * @param {CryptoKey} key - The AES CryptoKey\n   * @param {string | Object} - The data to encrypt\n   * @param {string} [format] - The ciphertext and iv encoding format\n   */\nconst decrypt = async (key, ciphertext, format = 'hex') => {\n  checkCryptokey(key)\n\n  const context = {\n    ciphertext: Object.prototype.hasOwnProperty.call(ciphertext, 'ciphertext') ? Buffer.from(ciphertext.ciphertext, (format)) : '',\n    // IV is 128 bits long === 16 bytes\n    iv: Object.prototype.hasOwnProperty.call(ciphertext, 'iv') ? Buffer.from(ciphertext.iv, (format)) : ''\n  }\n\n  // Prepare cipher context, depends on cipher mode\n  const cipherContext = {\n    name: key.algorithm.name,\n    iv: context.iv\n  }\n  try {\n    const decrypted = await decryptBuffer(key, context.ciphertext, cipherContext)\n    return JSON.parse(Buffer.from(decrypted).toString())\n  } catch (error) {\n    throw new Error('Unable to decrypt data')\n  }\n}\n\n/**\n * Generate a PBKDF2 derived key (bits) based on user given passPhrase\n *\n * @param {string | arrayBuffer} passPhrase The passphrase that is used to derive the key\n * @param {arrayBuffer} [salt] The salt\n * @param {Number} [iterations] The iterations number\n * @param {string} [hashAlgo] The hash function used for derivation\n * @returns {Promise<Uint8Array>} A promise that contains the derived key\n */\nconst deriveBits = async (passPhrase, salt, iterations, hashAlgo) => {\n  // Always specify a strong salt\n  if (iterations < 10000) { console.warn('Less than 10000 :(') }\n\n  const baseKey = await window.crypto.subtle.importKey(\n    'raw',\n    (typeof passPhrase === 'string') ? Buffer.from(passPhrase) : passPhrase,\n    'PBKDF2',\n    false,\n    ['deriveBits', 'deriveKey']\n  )\n  const derivedKey = await window.crypto.subtle.deriveBits({\n    name: 'PBKDF2',\n    salt: salt || new Uint8Array([]),\n    iterations: iterations || 100000,\n    hash: hashAlgo || 'SHA-256'\n  }, baseKey, 128)\n\n  return new Uint8Array(derivedKey)\n}\n\n/**\n * Derive a key based on a given passphrase\n *\n * @param {string | arrayBuffer} passPhrase The passphrase that is used to derive the key\n * @param {arrayBuffer} [salt] The salt\n * @param {Number} [iterations] The iterations number\n * @param {string} [hashAlgo] The hash function used for derivation and final hash computing\n * @returns {Promise<keyEncryptionKey>} A promise that contains the derived key and derivation\n * parameters\n */\nconst deriveKeyFromPassphrase = async (passPhrase, salt = genRandomBuffer(16), iterations = 100000, hashAlgo = 'SHA-256') => {\n  checkPassphrase(passPhrase)\n\n  const derivedKey = await deriveBits(passPhrase, salt, iterations, hashAlgo)\n  const key = await importKey(derivedKey)\n  return {\n    derivationParams: {\n      salt: Buffer.from(salt).toString('hex'),\n      iterations,\n      hashAlgo\n    },\n    key\n  }\n}\n\n/**\n * Derive the passphrase with PBKDF2 to obtain a KEK\n * Generate a AES key (masterKey)\n * Encrypt the masterKey with the KEK\n *\n * @param {string | arrayBuffer} passPhrase The passphrase that is used to derive the key\n * @param {arrayBuffer} [salt] The salt\n * @param {Number} [iterations] The iterations number\n * @param {string} [hashAlgo] The hash function used for derivation and final hash computing\n * @returns {Promise<protectedMasterKey>} A promise that contains the encrypted derived key\n */\nconst genEncryptedMasterKey = async (passPhrase, salt, iterations, hashAlgo) => {\n  // derive key encryption key from passphrase\n  const keyEncryptionKey = await deriveKeyFromPassphrase(passPhrase, salt, iterations, hashAlgo)\n\n  // Generate the masterKey\n  const masterKey = await genRandomBufferAsStr(32, 'hex')\n\n  const encryptedMasterKey = await encrypt(keyEncryptionKey.key, masterKey)\n\n  return {\n    derivationParams: keyEncryptionKey.derivationParams,\n    encryptedMasterKey\n  }\n}\n\n/**\n * Update the derived encryption key (KEK) based on the new passphrase from user, while retaining\n * the symmetric key that encrypts data at rest\n *\n * @param {string | arrayBuffer} currentPassPhrase The current (old) passphrase that is used to derive the key\n * @param {string | arrayBuffer} newPassPhrase The new passphrase that will be used to derive the key\n * @param {oldMasterKey} oldMasterKey - The old object returned by genEncryptedMasterKey for the old passphrase\n * @param {arrayBuffer} [salt] The salt\n * @param {Number} [iterations] The iterations number\n * @param {string} [hashAlgo] The hash function used for derivation and final hash computing\n * @returns {Promise<protectedMasterKey>}\n */\nconst updatePassphraseKey = async (currentPassPhrase, newPassPhrase, oldMasterKey, salt, iterations, hashAlgo) => {\n  const masterKey = await decryptMasterKey(currentPassPhrase, oldMasterKey)\n  // derive a new key encryption key from newPassPhrase\n  const keyEncryptionKey = await deriveKeyFromPassphrase(newPassPhrase, salt, iterations, hashAlgo)\n\n  // enconde existing masterKey as a hex string since it's a buffer\n  const toBeEncryptedMasterKey = Buffer.from(await exportKey(masterKey)).toString('hex')\n\n  const encryptedMasterKey = await encrypt(keyEncryptionKey.key, toBeEncryptedMasterKey)\n\n  return {\n    derivationParams: keyEncryptionKey.derivationParams,\n    encryptedMasterKey\n  }\n}\n\n/**\n * Decrypt a master key by deriving the encryption key from the\n * provided passphrase and encrypted master key.\n *\n * @param {string | arrayBuffer} passPhrase The passphrase that is used to derive the key\n * @param {protectedMasterKey} protectedMasterKey - The same object returned\n * by genEncryptedMasterKey\n * @returns {Promise<masterKey>} A promise that contains the masterKey\n */\nconst decryptMasterKey = async (passPhrase, protectedMasterKey) => {\n  if (!protectedMasterKey.encryptedMasterKey ||\n    !protectedMasterKey.derivationParams) {\n    throw new Error('Missing properties from master key')\n  }\n  const { derivationParams, encryptedMasterKey } = protectedMasterKey\n  const { salt, iterations, hashAlgo } = derivationParams\n  const _salt = typeof (salt) === 'string' ? Buffer.from(salt, ('hex')) : salt\n  const derivedKey = await deriveBits(passPhrase, _salt, iterations, hashAlgo)\n  const keyEncryptionKey = await importKey(derivedKey)\n  try {\n    const decryptedMasterKeyHex = await decrypt(keyEncryptionKey, encryptedMasterKey)\n    // return decryptedMasterKeyHex\n    const parsedKey = Buffer.from(decryptedMasterKeyHex, 'hex')\n    return window.crypto.subtle.importKey('raw', parsedKey, { name: 'AES-GCM' }\n      , true, ['encrypt', 'decrypt'])\n  } catch (error) {\n    throw new Error('Wrong passphrase')\n  }\n}\n\nmodule.exports = {\n  genId,\n  hash,\n  genKeyPair,\n  importPublicKey,\n  importPrivateKey,\n  exportPublicKey,\n  exportPrivateKey,\n  sign,\n  verify,\n  genAESKey,\n  importKey,\n  exportKey,\n  encrypt,\n  decrypt,\n  encryptBuffer,\n  decryptBuffer,\n  genEncryptedMasterKey,\n  decryptMasterKey,\n  updatePassphraseKey,\n  _genRandomBuffer: genRandomBuffer,\n  _genRandomBufferAsStr: genRandomBufferAsStr\n}\n"],"sourceRoot":""}