{"version":3,"sources":["webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/node-libs-browser/node_modules/process/browser.js","webpack:///./node_modules/node-libs-browser/node_modules/url/util.js","webpack:///./node_modules/node-libs-browser/node_modules/os-browserify/browser.js","webpack:///./node_modules/node-libs-browser/node_modules/vm-browserify/index.js","webpack:///./node_modules/node-libs-browser/node_modules/https-browserify/index.js","webpack:///./node_modules/node-libs-browser/node_modules/buffer/index.js","webpack:///./node_modules/node-libs-browser/node_modules/events/events.js","webpack:///./node_modules/node-libs-browser/node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/node-libs-browser/node_modules/safe-buffer/index.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/node-libs-browser/node_modules/stream-browserify/index.js","webpack:///./node_modules/node-libs-browser/node_modules/timers-browserify/main.js","webpack:///./node_modules/node-libs-browser/node_modules/util/util.js","webpack:///./node_modules/node-libs-browser/node_modules/isarray/index.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/node-libs-browser/node_modules/url/url.js","webpack:///./node_modules/node-libs-browser/node_modules/string_decoder/node_modules/safe-buffer/index.js","webpack:///./node_modules/node-libs-browser/node_modules/base64-js/index.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/writable-browser.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/duplex-browser.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/transform.js","webpack:///./node_modules/node-libs-browser/node_modules/readable-stream/passthrough.js","webpack:///./node_modules/node-libs-browser/node_modules/util/support/isBufferBrowser.js","webpack:///./node_modules/node-libs-browser/node_modules/util/node_modules/inherits/inherits_browser.js"],"names":["pna","objectKeys","Object","keys","obj","key","push","module","exports","Duplex","util","create","inherits","Readable","Writable","prototype","v","length","method","options","this","call","readable","writable","allowHalfOpen","once","onend","_writableState","ended","nextTick","onEndNT","self","end","defineProperty","enumerable","get","highWaterMark","undefined","_readableState","destroyed","set","value","_destroy","err","cb","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","Error","defaultClearTimeout","runTimeout","fun","setTimeout","e","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","concat","drainQueue","timeout","len","run","runClearTimeout","marker","Item","array","noop","args","Array","arguments","i","apply","title","browser","env","argv","version","versions","on","addListener","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","name","binding","cwd","chdir","dir","umask","isString","arg","isObject","isNull","isNullOrUndefined","endianness","hostname","location","loadavg","uptime","freemem","Number","MAX_VALUE","totalmem","cpus","type","release","navigator","appVersion","networkInterfaces","getNetworkInterfaces","arch","platform","tmpdir","tmpDir","EOL","homedir","indexOf","xs","item","Object_keys","res","forEach","fn","defineProp","configurable","globals","Context","Script","NodeScript","code","runInContext","context","TypeError","iframe","document","createElement","style","display","body","appendChild","win","contentWindow","wEval","eval","wExecScript","execScript","winKeys","removeChild","runInThisContext","runInNewContext","ctx","createContext","s","slice","isContext","createScript","copy","http","url","https","hasOwnProperty","validateParams","params","parse","protocol","request","base64","ieee754","isArray","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","Uint8Array","__proto__","encodingOrOffset","allocUnsafe","from","ArrayBuffer","fromArrayBuffer","byteOffset","byteLength","fromArrayLike","fromString","string","encoding","isEncoding","actual","write","fromObject","isBuffer","checked","buffer","isnan","val","data","assertSize","size","toString","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","start","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","n","m","bidirectionalIndexOf","isNaN","arrayIndexOf","lastIndexOf","arr","indexSize","arrLength","valLength","String","read","buf","readUInt16BE","foundIndex","found","j","hexWrite","offset","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","str","byteArray","charCodeAt","latin1Write","base64Write","ucs2Write","utf16leToBytes","units","c","hi","lo","fromByteArray","Math","min","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","decodeCodePointsArray","codePoints","fromCharCode","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","typedArraySupport","foo","subarray","poolSize","_augment","Symbol","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","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","base64clean","stringtrim","trim","replace","src","dst","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","Function","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","EventEmitter","init","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","_addListener","prepend","events","existing","newListener","unshift","warned","w","emitter","count","ProcessEmitWarning","warning","console","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","getPrototypeOf","setMaxListeners","getMaxListeners","doError","error","er","message","handler","position","originalListener","shift","spliceOne","index","pop","rawListeners","eventNames","StringDecoder","nb","normalizeEncoding","enc","nenc","_normalizeEncoding","retried","text","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","p","r","utf8CheckExtraBytes","utf8End","utf8Text","total","utf8CheckIncomplete","Stream","Transform","PassThrough","copyProps","SafeBuffer","CorkedRequest","_this","next","entry","finish","onCorkedFinish","corkReq","callback","pendingcb","corkedRequestsFree","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","onwriteStateUpdate","writelen","onwriteError","finishMaybe","errorEmitted","needFinish","bufferedRequest","clearBuffer","afterWrite","lastBufferedRequest","prefinished","bufferedRequestCount","_write","writev","_writev","destroy","final","_final","doWrite","chunk","onwriteDrain","l","holder","allBuffers","isBuf","callFinal","need","prefinish","getBuffer","current","_","hasInstance","object","pipe","_isUint8Array","_uint8ArrayToBuffer","writeAfterEnd","validChunk","valid","writeOrBuffer","newChunk","decodeChunk","last","cork","uncork","setDefaultEncoding","endWritable","_undestroy","undestroy","EE","dest","source","ondata","pause","ondrain","resume","_isStdio","onclose","didOnEnd","onerror","cleanup","window","Timeout","id","clearFn","_id","_clearFn","scope","setInterval","clearInterval","close","unref","ref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","onTimeout","_onTimeout","clearImmediate","getOwnPropertyDescriptors","descriptors","getOwnPropertyDescriptor","formatRegExp","format","f","objects","JSON","stringify","msg","noDeprecation","deprecated","throwDeprecation","traceDeprecation","trace","debugEnviron","debugs","opts","seen","stylize","stylizeNoColor","depth","colors","isBoolean","showHidden","_extend","isUndefined","customInspect","stylizeWithColor","formatValue","styleType","styles","recurseTimes","isFunction","constructor","primitive","formatPrimitive","simple","isNumber","visibleKeys","arrayToHash","hash","idx","isError","formatError","isRegExp","RegExp","isDate","Date","output","base","braces","toUTCString","formatArray","formatProperty","map","reduceToSingleString","reduce","prev","cur","numLinesEst","desc","split","line","ar","re","objectToString","d","o","pad","debuglog","NODE_DEBUG","toUpperCase","test","pid","isSymbol","isPrimitive","months","timestamp","time","getHours","getMinutes","getSeconds","getDate","getMonth","prop","log","origin","add","kCustomPromisifiedSymbol","callbackifyOnRejected","reason","newReason","promisify","original","promiseResolve","promiseReject","promise","Promise","resolve","reject","setPrototypeOf","defineProperties","custom","callbackify","callbackified","maybeCb","then","rej","ReadableState","EElistenerCount","debugUtil","debug","BufferList","kProxyEvents","readableObjectMode","readableHwm","readableHighWaterMark","pipes","pipesCount","flowing","endEmitted","reading","needReadable","emittedReadable","readableListening","resumeScheduled","awaitDrain","readingMore","decoder","_read","readableAddChunk","addToFront","skipChunkCheck","onEofChunk","emitReadable","chunkInvalid","addChunk","maybeReadMore","needMoreData","isPaused","setEncoding","howMuchToRead","head","computeNewHighWaterMark","emitReadable_","flow","maybeReadMore_","nReadingNextTick","resume_","fromList","clear","fromListPartial","hasStrings","copyFromBufferString","tail","copyFromBuffer","endReadable","endReadableNT","nOrig","doRead","pipeOpts","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","onfinish","cleanedUp","pipeOnDrain","increasedAwaitDrain","event","dests","splice","ev","wrap","paused","_fromList","emitErrorNT","readableDestroyed","writableDestroyed","afterTransform","ts","_transformState","transforming","writechunk","rs","needTransform","writeencoding","transform","_transform","flush","_flush","done","_this2","err2","punycode","Url","slashes","auth","host","port","search","query","pathname","path","href","urlParse","urlResolve","relative","resolveObject","urlResolveObject","urlFormat","protocolPattern","portPattern","simplePathPattern","unwise","autoEscape","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","parseQueryString","slashesDenoteHost","u","queryIndex","splitter","uSplit","rest","simplePath","exec","proto","lowerProto","atSign","hostEnd","hec","decodeURIComponent","parseHost","ipv6Hostname","hostparts","part","newpart","k","validParts","notHost","bit","toASCII","h","ae","esc","encodeURIComponent","escape","qm","charAt","rel","result","tkeys","tk","tkey","rkeys","rk","rkey","relPath","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","authInHost","hasTrailingSlash","up","isAbsolute","b64","lens","getLens","validLen","placeHoldersLen","tmp","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","parts","len2","encodeChunk","lookup","num","_classCallCheck","instance","Constructor","ctor","superCtor","super_","TempCtor"],"mappings":"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","file":"npm.node-libs-browser-4d49372c444f4cae0b7c.js","sourcesContent":["// 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 = Object.create(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};","// 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","'use strict';\n\nmodule.exports = {\n  isString: function(arg) {\n    return typeof(arg) === 'string';\n  },\n  isObject: function(arg) {\n    return typeof(arg) === 'object' && arg !== null;\n  },\n  isNull: function(arg) {\n    return arg === null;\n  },\n  isNullOrUndefined: function(arg) {\n    return arg == null;\n  }\n};\n","exports.endianness = function () { return 'LE' };\n\nexports.hostname = function () {\n    if (typeof location !== 'undefined') {\n        return location.hostname\n    }\n    else return '';\n};\n\nexports.loadavg = function () { return [] };\n\nexports.uptime = function () { return 0 };\n\nexports.freemem = function () {\n    return Number.MAX_VALUE;\n};\n\nexports.totalmem = function () {\n    return Number.MAX_VALUE;\n};\n\nexports.cpus = function () { return [] };\n\nexports.type = function () { return 'Browser' };\n\nexports.release = function () {\n    if (typeof navigator !== 'undefined') {\n        return navigator.appVersion;\n    }\n    return '';\n};\n\nexports.networkInterfaces\n= exports.getNetworkInterfaces\n= function () { return {} };\n\nexports.arch = function () { return 'javascript' };\n\nexports.platform = function () { return 'browser' };\n\nexports.tmpdir = exports.tmpDir = function () {\n    return '/tmp';\n};\n\nexports.EOL = '\\n';\n\nexports.homedir = function () {\n\treturn '/'\n};\n","var indexOf = function (xs, item) {\n    if (xs.indexOf) return xs.indexOf(item);\n    else for (var i = 0; i < xs.length; i++) {\n        if (xs[i] === item) return i;\n    }\n    return -1;\n};\nvar Object_keys = function (obj) {\n    if (Object.keys) return Object.keys(obj)\n    else {\n        var res = [];\n        for (var key in obj) res.push(key)\n        return res;\n    }\n};\n\nvar forEach = function (xs, fn) {\n    if (xs.forEach) return xs.forEach(fn)\n    else for (var i = 0; i < xs.length; i++) {\n        fn(xs[i], i, xs);\n    }\n};\n\nvar defineProp = (function() {\n    try {\n        Object.defineProperty({}, '_', {});\n        return function(obj, name, value) {\n            Object.defineProperty(obj, name, {\n                writable: true,\n                enumerable: false,\n                configurable: true,\n                value: value\n            })\n        };\n    } catch(e) {\n        return function(obj, name, value) {\n            obj[name] = value;\n        };\n    }\n}());\n\nvar globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function',\n'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError',\n'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError',\n'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape',\n'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape'];\n\nfunction Context() {}\nContext.prototype = {};\n\nvar Script = exports.Script = function NodeScript (code) {\n    if (!(this instanceof Script)) return new Script(code);\n    this.code = code;\n};\n\nScript.prototype.runInContext = function (context) {\n    if (!(context instanceof Context)) {\n        throw new TypeError(\"needs a 'context' argument.\");\n    }\n    \n    var iframe = document.createElement('iframe');\n    if (!iframe.style) iframe.style = {};\n    iframe.style.display = 'none';\n    \n    document.body.appendChild(iframe);\n    \n    var win = iframe.contentWindow;\n    var wEval = win.eval, wExecScript = win.execScript;\n\n    if (!wEval && wExecScript) {\n        // win.eval() magically appears when this is called in IE:\n        wExecScript.call(win, 'null');\n        wEval = win.eval;\n    }\n    \n    forEach(Object_keys(context), function (key) {\n        win[key] = context[key];\n    });\n    forEach(globals, function (key) {\n        if (context[key]) {\n            win[key] = context[key];\n        }\n    });\n    \n    var winKeys = Object_keys(win);\n\n    var res = wEval.call(win, this.code);\n    \n    forEach(Object_keys(win), function (key) {\n        // Avoid copying circular objects like `top` and `window` by only\n        // updating existing context properties or new properties in the `win`\n        // that was only introduced after the eval.\n        if (key in context || indexOf(winKeys, key) === -1) {\n            context[key] = win[key];\n        }\n    });\n\n    forEach(globals, function (key) {\n        if (!(key in context)) {\n            defineProp(context, key, win[key]);\n        }\n    });\n    \n    document.body.removeChild(iframe);\n    \n    return res;\n};\n\nScript.prototype.runInThisContext = function () {\n    return eval(this.code); // maybe...\n};\n\nScript.prototype.runInNewContext = function (context) {\n    var ctx = Script.createContext(context);\n    var res = this.runInContext(ctx);\n\n    if (context) {\n        forEach(Object_keys(ctx), function (key) {\n            context[key] = ctx[key];\n        });\n    }\n\n    return res;\n};\n\nforEach(Object_keys(Script.prototype), function (name) {\n    exports[name] = Script[name] = function (code) {\n        var s = Script(code);\n        return s[name].apply(s, [].slice.call(arguments, 1));\n    };\n});\n\nexports.isContext = function (context) {\n    return context instanceof Context;\n};\n\nexports.createScript = function (code) {\n    return exports.Script(code);\n};\n\nexports.createContext = Script.createContext = function (context) {\n    var copy = new Context();\n    if(typeof context === 'object') {\n        forEach(Object_keys(context), function (key) {\n            copy[key] = context[key];\n        });\n    }\n    return copy;\n};\n","var http = require('http')\nvar url = require('url')\n\nvar https = module.exports\n\nfor (var key in http) {\n  if (http.hasOwnProperty(key)) https[key] = http[key]\n}\n\nhttps.request = function (params, cb) {\n  params = validateParams(params)\n  return http.request.call(this, params, cb)\n}\n\nhttps.get = function (params, cb) {\n  params = validateParams(params)\n  return http.get.call(this, params, cb)\n}\n\nfunction validateParams (params) {\n  if (typeof params === 'string') {\n    params = url.parse(params)\n  }\n  if (!params.protocol) {\n    params.protocol = 'https:'\n  }\n  if (params.protocol !== 'https:') {\n    throw new Error('Protocol \"' + params.protocol + '\" not supported. Expected \"https:\"')\n  }\n  return params\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","// 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\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\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  checkListener(listener);\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  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\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  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\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      checkListener(listener);\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","// 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}","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","/* 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// 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 = Object.create(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};","// 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","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","// 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","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 = Object.create(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 = Object.create(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}","// 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 punycode = require('punycode');\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n\nfunction Url() {\n  this.protocol = null;\n  this.slashes = null;\n  this.auth = null;\n  this.host = null;\n  this.port = null;\n  this.hostname = null;\n  this.hash = null;\n  this.search = null;\n  this.query = null;\n  this.pathname = null;\n  this.path = null;\n  this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n    portPattern = /:[0-9]*$/,\n\n    // Special case for a simple path URL\n    simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n    // RFC 2396: characters reserved for delimiting URLs.\n    // We actually just auto-escape these.\n    delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n\n    // RFC 2396: characters not allowed for various reasons.\n    unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n\n    // Allowed by RFCs, but cause of XSS attacks.  Always escape these.\n    autoEscape = ['\\''].concat(unwise),\n    // Characters that are never ever allowed in a hostname.\n    // Note that any invalid chars are also handled, but these\n    // are the ones that are *expected* to be seen, so we fast-path\n    // them.\n    nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n    hostEndingChars = ['/', '?', '#'],\n    hostnameMaxLen = 255,\n    hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n    hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n    // protocols that can allow \"unsafe\" and \"unwise\" chars.\n    unsafeProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that never have a hostname.\n    hostlessProtocol = {\n      'javascript': true,\n      'javascript:': true\n    },\n    // protocols that always contain a // bit.\n    slashedProtocol = {\n      'http': true,\n      'https': true,\n      'ftp': true,\n      'gopher': true,\n      'file': true,\n      'http:': true,\n      'https:': true,\n      'ftp:': true,\n      'gopher:': true,\n      'file:': true\n    },\n    querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n  if (url && util.isObject(url) && url instanceof Url) return url;\n\n  var u = new Url;\n  u.parse(url, parseQueryString, slashesDenoteHost);\n  return u;\n}\n\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n  if (!util.isString(url)) {\n    throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n  }\n\n  // Copy chrome, IE, opera backslash-handling behavior.\n  // Back slashes before the query string get converted to forward slashes\n  // See: https://code.google.com/p/chromium/issues/detail?id=25916\n  var queryIndex = url.indexOf('?'),\n      splitter =\n          (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\n      uSplit = url.split(splitter),\n      slashRegex = /\\\\/g;\n  uSplit[0] = uSplit[0].replace(slashRegex, '/');\n  url = uSplit.join(splitter);\n\n  var rest = url;\n\n  // trim before proceeding.\n  // This is to support parse stuff like \"  http://foo.com  \\n\"\n  rest = rest.trim();\n\n  if (!slashesDenoteHost && url.split('#').length === 1) {\n    // Try fast path regexp\n    var simplePath = simplePathPattern.exec(rest);\n    if (simplePath) {\n      this.path = rest;\n      this.href = rest;\n      this.pathname = simplePath[1];\n      if (simplePath[2]) {\n        this.search = simplePath[2];\n        if (parseQueryString) {\n          this.query = querystring.parse(this.search.substr(1));\n        } else {\n          this.query = this.search.substr(1);\n        }\n      } else if (parseQueryString) {\n        this.search = '';\n        this.query = {};\n      }\n      return this;\n    }\n  }\n\n  var proto = protocolPattern.exec(rest);\n  if (proto) {\n    proto = proto[0];\n    var lowerProto = proto.toLowerCase();\n    this.protocol = lowerProto;\n    rest = rest.substr(proto.length);\n  }\n\n  // figure out if it's got a host\n  // user@server is *always* interpreted as a hostname, and url\n  // resolution will treat //foo/bar as host=foo,path=bar because that's\n  // how the browser resolves relative URLs.\n  if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n    var slashes = rest.substr(0, 2) === '//';\n    if (slashes && !(proto && hostlessProtocol[proto])) {\n      rest = rest.substr(2);\n      this.slashes = true;\n    }\n  }\n\n  if (!hostlessProtocol[proto] &&\n      (slashes || (proto && !slashedProtocol[proto]))) {\n\n    // there's a hostname.\n    // the first instance of /, ?, ;, or # ends the host.\n    //\n    // If there is an @ in the hostname, then non-host chars *are* allowed\n    // to the left of the last @ sign, unless some host-ending character\n    // comes *before* the @-sign.\n    // URLs are obnoxious.\n    //\n    // ex:\n    // http://a@b@c/ => user:a@b host:c\n    // http://a@b?@c => user:a host:c path:/?@c\n\n    // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n    // Review our test case against browsers more comprehensively.\n\n    // find the first instance of any hostEndingChars\n    var hostEnd = -1;\n    for (var i = 0; i < hostEndingChars.length; i++) {\n      var hec = rest.indexOf(hostEndingChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n\n    // at this point, either we have an explicit point where the\n    // auth portion cannot go past, or the last @ char is the decider.\n    var auth, atSign;\n    if (hostEnd === -1) {\n      // atSign can be anywhere.\n      atSign = rest.lastIndexOf('@');\n    } else {\n      // atSign must be in auth portion.\n      // http://a@b/c@d => host:b auth:a path:/c@d\n      atSign = rest.lastIndexOf('@', hostEnd);\n    }\n\n    // Now we have a portion which is definitely the auth.\n    // Pull that off.\n    if (atSign !== -1) {\n      auth = rest.slice(0, atSign);\n      rest = rest.slice(atSign + 1);\n      this.auth = decodeURIComponent(auth);\n    }\n\n    // the host is the remaining to the left of the first non-host char\n    hostEnd = -1;\n    for (var i = 0; i < nonHostChars.length; i++) {\n      var hec = rest.indexOf(nonHostChars[i]);\n      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n        hostEnd = hec;\n    }\n    // if we still have not hit it, then the entire thing is a host.\n    if (hostEnd === -1)\n      hostEnd = rest.length;\n\n    this.host = rest.slice(0, hostEnd);\n    rest = rest.slice(hostEnd);\n\n    // pull out port.\n    this.parseHost();\n\n    // we've indicated that there is a hostname,\n    // so even if it's empty, it has to be present.\n    this.hostname = this.hostname || '';\n\n    // if hostname begins with [ and ends with ]\n    // assume that it's an IPv6 address.\n    var ipv6Hostname = this.hostname[0] === '[' &&\n        this.hostname[this.hostname.length - 1] === ']';\n\n    // validate a little.\n    if (!ipv6Hostname) {\n      var hostparts = this.hostname.split(/\\./);\n      for (var i = 0, l = hostparts.length; i < l; i++) {\n        var part = hostparts[i];\n        if (!part) continue;\n        if (!part.match(hostnamePartPattern)) {\n          var newpart = '';\n          for (var j = 0, k = part.length; j < k; j++) {\n            if (part.charCodeAt(j) > 127) {\n              // we replace non-ASCII char with a temporary placeholder\n              // we need this to make sure size of hostname is not\n              // broken by replacing non-ASCII by nothing\n              newpart += 'x';\n            } else {\n              newpart += part[j];\n            }\n          }\n          // we test again with ASCII char only\n          if (!newpart.match(hostnamePartPattern)) {\n            var validParts = hostparts.slice(0, i);\n            var notHost = hostparts.slice(i + 1);\n            var bit = part.match(hostnamePartStart);\n            if (bit) {\n              validParts.push(bit[1]);\n              notHost.unshift(bit[2]);\n            }\n            if (notHost.length) {\n              rest = '/' + notHost.join('.') + rest;\n            }\n            this.hostname = validParts.join('.');\n            break;\n          }\n        }\n      }\n    }\n\n    if (this.hostname.length > hostnameMaxLen) {\n      this.hostname = '';\n    } else {\n      // hostnames are always lower case.\n      this.hostname = this.hostname.toLowerCase();\n    }\n\n    if (!ipv6Hostname) {\n      // IDNA Support: Returns a punycoded representation of \"domain\".\n      // It only converts parts of the domain name that\n      // have non-ASCII characters, i.e. it doesn't matter if\n      // you call it with a domain that already is ASCII-only.\n      this.hostname = punycode.toASCII(this.hostname);\n    }\n\n    var p = this.port ? ':' + this.port : '';\n    var h = this.hostname || '';\n    this.host = h + p;\n    this.href += this.host;\n\n    // strip [ and ] from the hostname\n    // the host field still retains them, though\n    if (ipv6Hostname) {\n      this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n      if (rest[0] !== '/') {\n        rest = '/' + rest;\n      }\n    }\n  }\n\n  // now rest is set to the post-host stuff.\n  // chop off any delim chars.\n  if (!unsafeProtocol[lowerProto]) {\n\n    // First, make 100% sure that any \"autoEscape\" chars get\n    // escaped, even if encodeURIComponent doesn't think they\n    // need to be.\n    for (var i = 0, l = autoEscape.length; i < l; i++) {\n      var ae = autoEscape[i];\n      if (rest.indexOf(ae) === -1)\n        continue;\n      var esc = encodeURIComponent(ae);\n      if (esc === ae) {\n        esc = escape(ae);\n      }\n      rest = rest.split(ae).join(esc);\n    }\n  }\n\n\n  // chop off from the tail first.\n  var hash = rest.indexOf('#');\n  if (hash !== -1) {\n    // got a fragment string.\n    this.hash = rest.substr(hash);\n    rest = rest.slice(0, hash);\n  }\n  var qm = rest.indexOf('?');\n  if (qm !== -1) {\n    this.search = rest.substr(qm);\n    this.query = rest.substr(qm + 1);\n    if (parseQueryString) {\n      this.query = querystring.parse(this.query);\n    }\n    rest = rest.slice(0, qm);\n  } else if (parseQueryString) {\n    // no query string, but parseQueryString still requested\n    this.search = '';\n    this.query = {};\n  }\n  if (rest) this.pathname = rest;\n  if (slashedProtocol[lowerProto] &&\n      this.hostname && !this.pathname) {\n    this.pathname = '/';\n  }\n\n  //to support http.request\n  if (this.pathname || this.search) {\n    var p = this.pathname || '';\n    var s = this.search || '';\n    this.path = p + s;\n  }\n\n  // finally, reconstruct the href based on what has been validated.\n  this.href = this.format();\n  return this;\n};\n\n// format a parsed object into a url string\nfunction urlFormat(obj) {\n  // ensure it's an object, and not a string url.\n  // If it's an obj, this is a no-op.\n  // this way, you can call url_format() on strings\n  // to clean up potentially wonky urls.\n  if (util.isString(obj)) obj = urlParse(obj);\n  if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n  return obj.format();\n}\n\nUrl.prototype.format = function() {\n  var auth = this.auth || '';\n  if (auth) {\n    auth = encodeURIComponent(auth);\n    auth = auth.replace(/%3A/i, ':');\n    auth += '@';\n  }\n\n  var protocol = this.protocol || '',\n      pathname = this.pathname || '',\n      hash = this.hash || '',\n      host = false,\n      query = '';\n\n  if (this.host) {\n    host = auth + this.host;\n  } else if (this.hostname) {\n    host = auth + (this.hostname.indexOf(':') === -1 ?\n        this.hostname :\n        '[' + this.hostname + ']');\n    if (this.port) {\n      host += ':' + this.port;\n    }\n  }\n\n  if (this.query &&\n      util.isObject(this.query) &&\n      Object.keys(this.query).length) {\n    query = querystring.stringify(this.query);\n  }\n\n  var search = this.search || (query && ('?' + query)) || '';\n\n  if (protocol && protocol.substr(-1) !== ':') protocol += ':';\n\n  // only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.\n  // unless they had them to begin with.\n  if (this.slashes ||\n      (!protocol || slashedProtocol[protocol]) && host !== false) {\n    host = '//' + (host || '');\n    if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\n  } else if (!host) {\n    host = '';\n  }\n\n  if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\n  if (search && search.charAt(0) !== '?') search = '?' + search;\n\n  pathname = pathname.replace(/[?#]/g, function(match) {\n    return encodeURIComponent(match);\n  });\n  search = search.replace('#', '%23');\n\n  return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n  return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function(relative) {\n  return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n  if (!source) return relative;\n  return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function(relative) {\n  if (util.isString(relative)) {\n    var rel = new Url();\n    rel.parse(relative, false, true);\n    relative = rel;\n  }\n\n  var result = new Url();\n  var tkeys = Object.keys(this);\n  for (var tk = 0; tk < tkeys.length; tk++) {\n    var tkey = tkeys[tk];\n    result[tkey] = this[tkey];\n  }\n\n  // hash is always overridden, no matter what.\n  // even href=\"\" will remove it.\n  result.hash = relative.hash;\n\n  // if the relative url is empty, then there's nothing left to do here.\n  if (relative.href === '') {\n    result.href = result.format();\n    return result;\n  }\n\n  // hrefs like //foo/bar always cut to the protocol.\n  if (relative.slashes && !relative.protocol) {\n    // take everything except the protocol from relative\n    var rkeys = Object.keys(relative);\n    for (var rk = 0; rk < rkeys.length; rk++) {\n      var rkey = rkeys[rk];\n      if (rkey !== 'protocol')\n        result[rkey] = relative[rkey];\n    }\n\n    //urlParse appends trailing / to urls like http://www.example.com\n    if (slashedProtocol[result.protocol] &&\n        result.hostname && !result.pathname) {\n      result.path = result.pathname = '/';\n    }\n\n    result.href = result.format();\n    return result;\n  }\n\n  if (relative.protocol && relative.protocol !== result.protocol) {\n    // if it's a known url protocol, then changing\n    // the protocol does weird things\n    // first, if it's not file:, then we MUST have a host,\n    // and if there was a path\n    // to begin with, then we MUST have a path.\n    // if it is file:, then the host is dropped,\n    // because that's known to be hostless.\n    // anything else is assumed to be absolute.\n    if (!slashedProtocol[relative.protocol]) {\n      var keys = Object.keys(relative);\n      for (var v = 0; v < keys.length; v++) {\n        var k = keys[v];\n        result[k] = relative[k];\n      }\n      result.href = result.format();\n      return result;\n    }\n\n    result.protocol = relative.protocol;\n    if (!relative.host && !hostlessProtocol[relative.protocol]) {\n      var relPath = (relative.pathname || '').split('/');\n      while (relPath.length && !(relative.host = relPath.shift()));\n      if (!relative.host) relative.host = '';\n      if (!relative.hostname) relative.hostname = '';\n      if (relPath[0] !== '') relPath.unshift('');\n      if (relPath.length < 2) relPath.unshift('');\n      result.pathname = relPath.join('/');\n    } else {\n      result.pathname = relative.pathname;\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    result.host = relative.host || '';\n    result.auth = relative.auth;\n    result.hostname = relative.hostname || relative.host;\n    result.port = relative.port;\n    // to support http.request\n    if (result.pathname || result.search) {\n      var p = result.pathname || '';\n      var s = result.search || '';\n      result.path = p + s;\n    }\n    result.slashes = result.slashes || relative.slashes;\n    result.href = result.format();\n    return result;\n  }\n\n  var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\n      isRelAbs = (\n          relative.host ||\n          relative.pathname && relative.pathname.charAt(0) === '/'\n      ),\n      mustEndAbs = (isRelAbs || isSourceAbs ||\n                    (result.host && relative.pathname)),\n      removeAllDots = mustEndAbs,\n      srcPath = result.pathname && result.pathname.split('/') || [],\n      relPath = relative.pathname && relative.pathname.split('/') || [],\n      psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n  // if the url is a non-slashed url, then relative\n  // links like ../.. should be able\n  // to crawl up to the hostname, as well.  This is strange.\n  // result.protocol has already been set by now.\n  // Later on, put the first path part into the host field.\n  if (psychotic) {\n    result.hostname = '';\n    result.port = null;\n    if (result.host) {\n      if (srcPath[0] === '') srcPath[0] = result.host;\n      else srcPath.unshift(result.host);\n    }\n    result.host = '';\n    if (relative.protocol) {\n      relative.hostname = null;\n      relative.port = null;\n      if (relative.host) {\n        if (relPath[0] === '') relPath[0] = relative.host;\n        else relPath.unshift(relative.host);\n      }\n      relative.host = null;\n    }\n    mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n  }\n\n  if (isRelAbs) {\n    // it's absolute.\n    result.host = (relative.host || relative.host === '') ?\n                  relative.host : result.host;\n    result.hostname = (relative.hostname || relative.hostname === '') ?\n                      relative.hostname : result.hostname;\n    result.search = relative.search;\n    result.query = relative.query;\n    srcPath = relPath;\n    // fall through to the dot-handling below.\n  } else if (relPath.length) {\n    // it's relative\n    // throw away the existing file, and take the new path instead.\n    if (!srcPath) srcPath = [];\n    srcPath.pop();\n    srcPath = srcPath.concat(relPath);\n    result.search = relative.search;\n    result.query = relative.query;\n  } else if (!util.isNullOrUndefined(relative.search)) {\n    // just pull out the search.\n    // like href='?foo'.\n    // Put this after the other two cases because it simplifies the booleans\n    if (psychotic) {\n      result.hostname = result.host = srcPath.shift();\n      //occationaly the auth can get stuck only in host\n      //this especially happens in cases like\n      //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n      var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                       result.host.split('@') : false;\n      if (authInHost) {\n        result.auth = authInHost.shift();\n        result.host = result.hostname = authInHost.shift();\n      }\n    }\n    result.search = relative.search;\n    result.query = relative.query;\n    //to support http.request\n    if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n      result.path = (result.pathname ? result.pathname : '') +\n                    (result.search ? result.search : '');\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  if (!srcPath.length) {\n    // no path at all.  easy.\n    // we've already handled the other stuff above.\n    result.pathname = null;\n    //to support http.request\n    if (result.search) {\n      result.path = '/' + result.search;\n    } else {\n      result.path = null;\n    }\n    result.href = result.format();\n    return result;\n  }\n\n  // if a url ENDs in . or .., then it must get a trailing slash.\n  // however, if it ends in anything else non-slashy,\n  // then it must NOT get a trailing slash.\n  var last = srcPath.slice(-1)[0];\n  var hasTrailingSlash = (\n      (result.host || relative.host || srcPath.length > 1) &&\n      (last === '.' || last === '..') || last === '');\n\n  // strip single dots, resolve double dots to parent dir\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = srcPath.length; i >= 0; i--) {\n    last = srcPath[i];\n    if (last === '.') {\n      srcPath.splice(i, 1);\n    } else if (last === '..') {\n      srcPath.splice(i, 1);\n      up++;\n    } else if (up) {\n      srcPath.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (!mustEndAbs && !removeAllDots) {\n    for (; up--; up) {\n      srcPath.unshift('..');\n    }\n  }\n\n  if (mustEndAbs && srcPath[0] !== '' &&\n      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n    srcPath.unshift('');\n  }\n\n  if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n    srcPath.push('');\n  }\n\n  var isAbsolute = srcPath[0] === '' ||\n      (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n  // put the host back\n  if (psychotic) {\n    result.hostname = result.host = isAbsolute ? '' :\n                                    srcPath.length ? srcPath.shift() : '';\n    //occationaly the auth can get stuck only in host\n    //this especially happens in cases like\n    //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n    var authInHost = result.host && result.host.indexOf('@') > 0 ?\n                     result.host.split('@') : false;\n    if (authInHost) {\n      result.auth = authInHost.shift();\n      result.host = result.hostname = authInHost.shift();\n    }\n  }\n\n  mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n  if (mustEndAbs && !isAbsolute) {\n    srcPath.unshift('');\n  }\n\n  if (!srcPath.length) {\n    result.pathname = null;\n    result.path = null;\n  } else {\n    result.pathname = srcPath.join('/');\n  }\n\n  //to support request.http\n  if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n    result.path = (result.pathname ? result.pathname : '') +\n                  (result.search ? result.search : '');\n  }\n  result.auth = relative.auth || result.auth;\n  result.slashes = result.slashes || relative.slashes;\n  result.href = result.format();\n  return result;\n};\n\nUrl.prototype.parseHost = function() {\n  var host = this.host;\n  var port = portPattern.exec(host);\n  if (port) {\n    port = port[0];\n    if (port !== ':') {\n      this.port = port.substr(1);\n    }\n    host = host.substr(0, host.length - port.length);\n  }\n  if (host) this.hostname = host;\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\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","'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","'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}","// 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 = Object.create(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};","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","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"],"sourceRoot":""}