{"version":3,"sources":["webpack:///./node_modules/readable-stream/duplex-browser.js","webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/readable-stream/writable-browser.js","webpack:///./node_modules/core-util-is/lib/util.js","webpack:///./node_modules/inherits/inherits_browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:///./node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/ieee754/index.js","webpack:///./node_modules/process-nextick-args/index.js","webpack:///./node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/buffer/index.js","webpack:///./node_modules/util-deprecate/browser.js","webpack:///./node_modules/readable-stream/passthrough.js","webpack:///./node_modules/readable-stream/transform.js","webpack:///./node_modules/stream-browserify/index.js","webpack:///./node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/isarray/index.js","webpack:///./node_modules/events/events.js"],"names":["module","exports","require","byteLength","toByteArray","fromByteArray","lookup","revLookup","Arr","Uint8Array","Array","code","i","len","length","charCodeAt","getLens","b64","Error","validLen","indexOf","placeHoldersLen","lens","_byteLength","tmp","arr","curByte","tripletToBase64","num","encodeChunk","uint8","start","end","output","push","join","extraBytes","parts","maxChunkLength","len2","Transform","Duplex","util","afterTransform","er","data","ts","this","_transformState","transforming","cb","writecb","emit","writechunk","rs","_readableState","reading","needReadable","highWaterMark","_read","options","call","bind","needTransform","writeencoding","sync","transform","_transform","flush","_flush","on","prefinish","_this","done","stream","_writableState","inherits","prototype","chunk","encoding","_write","n","_destroy","err","_this2","err2","isArray","arg","objectToString","isBoolean","isNull","isNullOrUndefined","isNumber","isString","isSymbol","_typeof","isUndefined","isRegExp","re","isObject","isDate","d","isError","e","isFunction","isPrimitive","o","Object","toString","isBuffer","Buffer","create","ctor","superCtor","super_","constructor","value","enumerable","writable","configurable","TempCtor","EventEmitter","pna","destroy","readableDestroyed","destroyed","writableDestroyed","errorEmitted","nextTick","emitErrorNT","undestroy","ended","endEmitted","ending","finished","self","_classCallCheck","instance","Constructor","TypeError","copyBuffer","src","target","offset","copy","BufferList","head","tail","v","entry","next","unshift","shift","ret","clear","s","p","concat","alloc","allocUnsafe","inspect","custom","obj","name","PassThrough","isEncoding","toLowerCase","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","StringDecoder","nb","text","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","write","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckIncomplete","buf","j","utf8CheckExtraBytes","r","undefined","utf8Text","total","utf8End","c","slice","buffer","copyProps","dst","key","SafeBuffer","encodingOrOffset","from","allocUnsafeSlow","size","fill","SlowBuffer","read","isLE","mLen","nBytes","m","eLen","eMax","eBias","nBits","NaN","Infinity","Math","pow","rt","abs","isNaN","floor","log","LN2","process","fn","arg1","arg2","arg3","args","arguments","apply","version","global","Readable","ReadableState","EElistenerCount","emitter","type","listeners","Stream","OurUint8Array","_uint8ArrayToBuffer","_isUint8Array","debugUtil","debug","debuglog","destroyImpl","kProxyEvents","prependListener","event","_events","isDuplex","objectMode","readableObjectMode","hwm","readableHwm","readableHighWaterMark","defaultHwm","pipes","pipesCount","flowing","emittedReadable","readableListening","resumeScheduled","defaultEncoding","awaitDrain","readingMore","decoder","readable","readableAddChunk","addToFront","skipChunkCheck","state","onEofChunk","chunkInvalid","getPrototypeOf","addChunk","maybeReadMore","needMoreData","emitReadable","defineProperty","get","set","_undestroy","isPaused","setEncoding","MAX_HWM","computeNewHighWaterMark","howMuchToRead","emitReadable_","flow","maybeReadMore_","pipeOnDrain","nReadingNextTick","resume","resume_","fromList","fromListPartial","list","hasStrings","copyFromBufferString","copyFromBuffer","str","endReadable","endReadableNT","xs","x","l","parseInt","nOrig","doRead","pipe","dest","pipeOpts","doEnd","stdout","stderr","endFn","onend","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanup","once","ondrain","cleanedUp","removeListener","onclose","onfinish","onerror","ondata","needDrain","increasedAwaitDrain","pause","dests","index","splice","ev","res","addListener","wrap","paused","method","_fromList","objectKeys","keys","Writable","allowHalfOpen","onEndNT","base64","ieee754","typedArraySupport","__proto__","foo","subarray","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","ArrayBuffer","fromArrayBuffer","fromString","fromObject","assertSize","checked","string","actual","fromArrayLike","array","byteOffset","isnan","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","bidirectionalIndexOf","val","dir","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","String","readUInt16BE","foundIndex","found","hexWrite","Number","remaining","strLen","parsed","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","min","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","decodeCodePointsArray","INSPECT_MAX_BYTES","poolSize","_augment","Symbol","species","_isBuffer","compare","a","y","pos","swap16","swap32","swap64","equals","max","match","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","MAX_ARGUMENTS_LENGTH","codePoints","fromCharCode","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","INVALID_BASE64_RE","base64clean","stringtrim","replace","trim","units","leadSurrogate","byteArray","hi","lo","deprecate","msg","config","warned","deprecated","console","trace","warn","localStorage","_","EE","source","_isStdio","didOnEnd","listenerCount","CorkedRequest","finish","onCorkedFinish","asyncWrite","browser","setImmediate","WritableState","internalUtil","realHasInstance","nop","writableObjectMode","writableHwm","writableHighWaterMark","finalCalled","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","bufferedRequestCount","corkedRequestsFree","writev","_writev","final","_final","writeAfterEnd","validChunk","valid","decodeChunk","writeOrBuffer","isBuf","newChunk","last","callback","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","afterWrite","onwriteDrain","holder","count","allBuffers","callFinal","need","endWritable","corkReq","getBuffer","current","hasInstance","Function","object","cork","uncork","setDefaultEncoding","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","ProcessEmitWarning","warning","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","init","_eventsCount","_maxListeners","defaultMaxListeners","$getMaxListeners","_addListener","listener","prepend","events","existing","newListener","w","onceWrapper","fired","wrapFn","_onceWrap","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","spliceOne","pop","setMaxListeners","getMaxListeners","doError","error","message","context","handler","prependOnceListener","position","originalListener","off","removeAllListeners","rawListeners","eventNames"],"mappings":"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","file":"static/js/chunk-145086d2.1743057352700.js","sourcesContent":["module.exports = require('./lib/_stream_duplex.js');\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  for (var 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","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","module.exports = require('./lib/_stream_writable.js');\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","module.exports = 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};","'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 = 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};","// 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}","/* 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","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","'use strict';\n\nif (!process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\n","module.exports = require('./readable').PassThrough\n","module.exports = require('./readable').Transform\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","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = require('core-util-is');\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};","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","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\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction $getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return $getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = $getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  var args = [];\n  for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    ReflectApply(this.listener, this.target, args);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      if (typeof listener !== 'function') {\n        throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n      }\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      if (typeof listener !== 'function') {\n        throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n      }\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n"],"sourceRoot":""}