{"version":3,"sources":["webpack:///./node_modules/md5.js/node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/md5.js/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/md5.js/node_modules/readable-stream/lib/_stream_duplex.js"],"names":["Duplex","module","exports","Readable","ReadableState","EventEmitter","EElistenerCount","emitter","type","listeners","length","Stream","Buffer","OurUint8Array","global","window","self","Uint8Array","debug","debugUtil","debuglog","StringDecoder","createReadableStreamAsyncIterator","from","BufferList","destroyImpl","getHighWaterMark","_require$codes","codes","ERR_INVALID_ARG_TYPE","ERR_STREAM_PUSH_AFTER_EOF","ERR_METHOD_NOT_IMPLEMENTED","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","errorOrDestroy","kProxyEvents","options","stream","isDuplex","this","objectMode","readableObjectMode","highWaterMark","buffer","pipes","pipesCount","flowing","ended","endEmitted","reading","sync","needReadable","emittedReadable","readableListening","resumeScheduled","paused","emitClose","autoDestroy","destroyed","defaultEncoding","awaitDrain","readingMore","decoder","encoding","_readableState","readable","read","_read","destroy","_destroy","call","readableAddChunk","chunk","addToFront","skipChunkCheck","er","state","end","push","emitReadable","emitReadable_","onEofChunk","obj","isBuffer","undefined","chunkInvalid","Object","getPrototypeOf","prototype","_uint8ArrayToBuffer","addChunk","write","maybeReadMore","emit","unshift","defineProperty","enumerable","get","set","value","_undestroy","undestroy","err","cb","isPaused","setEncoding","enc","p","head","content","data","next","clear","MAX_HWM","howMuchToRead","n","computeNewHighWaterMark","process","nextTick","flow","maybeReadMore_","len","updateReadableListening","listenerCount","resume","nReadingNextTick","resume_","fromList","ret","shift","join","first","concat","consume","endReadable","endReadableNT","wState","_writableState","finished","indexOf","xs","x","i","l","parseInt","nOrig","doRead","pipe","dest","pipeOpts","src","endFn","stdout","stderr","onend","unpipe","onunpipe","unpipeInfo","hasUnpiped","removeListener","onclose","onfinish","ondrain","onerror","ondata","cleanedUp","needDrain","once","on","pipeOnDrain","pause","event","fn","prependListener","_events","Array","isArray","dests","index","splice","ev","res","addListener","removeAllListeners","apply","arguments","wrap","_this","method","bind","Symbol","asyncIterator","_fromList","iterable","opts","PassThrough","Transform","_transform","objectKeys","keys","key","Writable","v","allowHalfOpen","writable","onEndNT","getBuffer"],"mappings":"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","file":"js/index~78d5a372-99001e30f9b565b1056d.chunk.js","sourcesContent":["// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\nvar Buffer = require('buffer').Buffer;\nvar OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).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>*/\nvar debugUtil = require('util');\nvar debug;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/buffer_list');\nvar destroyImpl = require('./internal/streams/destroy');\nvar _require = require('./internal/streams/state'),\n  getHighWaterMark = _require.getHighWaterMark;\nvar _require$codes = require('../errors').codes,\n  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n  ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;\n\n// Lazy loaded to improve the startup performance.\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\nrequire('inherits')(Readable, Stream);\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\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 (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\nfunction ReadableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\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  if (typeof isDuplex !== 'boolean') 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  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  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex);\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  this.paused = true;\n\n  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = options.emitClose !== false;\n\n  // Should .destroy() be called after 'end' (and potentially 'finish')\n  this.autoDestroy = !!options.autoDestroy;\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  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}\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5\n  var isDuplex = this instanceof Duplex;\n  this._readableState = new ReadableState(options, this, isDuplex);\n\n  // legacy\n  this.readable = true;\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n  Stream.call(this);\n}\nObject.defineProperty(Readable.prototype, 'destroyed', {\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 get() {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function set(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});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\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  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  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};\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  debug('readableAddChunk', chunk);\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      errorOrDestroy(stream, 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      if (addToFront) {\n        if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n      } else if (state.destroyed) {\n        return false;\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      maybeReadMore(stream, state);\n    }\n  }\n\n  // We can push more data if we are below the highWaterMark.\n  // Also, if we have no data yet, we can stand some more bytes.\n  // This is to work around cases where hwm=0, such as the repl.\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    state.awaitDrain = 0;\n    stream.emit('data', chunk);\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    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n  }\n  return er;\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  var decoder = new StringDecoder(enc);\n  this._readableState.decoder = decoder;\n  // If setEncoding(null), decoder.encoding equals utf8\n  this._readableState.encoding = this._readableState.decoder.encoding;\n\n  // Iterate over current buffer to convert already stored Buffers:\n  var p = this._readableState.buffer.head;\n  var content = '';\n  while (p !== null) {\n    content += decoder.write(p.data);\n    p = p.next;\n  }\n  this._readableState.buffer.clear();\n  if (content !== '') this._readableState.buffer.push(content);\n  this._readableState.length = content.length;\n  return this;\n};\n\n// Don't raise the hwm > 1GB\nvar MAX_HWM = 0x40000000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.\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  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.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || 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 = 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  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n  if (ret === null) {\n    state.needReadable = state.length <= state.highWaterMark;\n    n = 0;\n  } else {\n    state.length -= n;\n    state.awaitDrain = 0;\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  if (ret !== null) this.emit('data', ret);\n  return ret;\n};\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk');\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  if (state.sync) {\n    // if we are sync, wait until next tick to emit the data.\n    // Otherwise we risk emitting data in the flow()\n    // the readable code triggers during a read() call\n    emitReadable(stream);\n  } else {\n    // emit 'readable' now to make sure it gets picked up.\n    state.needReadable = false;\n    if (!state.emittedReadable) {\n      state.emittedReadable = true;\n      emitReadable_(stream);\n    }\n  }\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  debug('emitReadable', state.needReadable, state.emittedReadable);\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    process.nextTick(emitReadable_, stream);\n  }\n}\nfunction emitReadable_(stream) {\n  var state = stream._readableState;\n  debug('emitReadable_', state.destroyed, state.length, state.ended);\n  if (!state.destroyed && (state.length || state.ended)) {\n    stream.emit('readable');\n    state.emittedReadable = false;\n  }\n\n  // The stream needs another readable event if\n  // 1. It is not flowing, as the flow mechanism will take\n  //    care of it.\n  // 2. It is not ended.\n  // 3. It is below the highWaterMark, so we can schedule\n  //    another readable later.\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\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    process.nextTick(maybeReadMore_, stream, state);\n  }\n}\nfunction maybeReadMore_(stream, state) {\n  // Attempt to read more data if we should.\n  //\n  // The conditions for reading more data are (one of):\n  // - Not enough data buffered (state.length < state.highWaterMark). The loop\n  //   is responsible for filling the buffer with enough data if such data\n  //   is available. If highWaterMark is 0 and we are not in the flowing mode\n  //   we should _not_ attempt to buffer any extra data. We'll get more data\n  //   when the stream consumer calls read() instead.\n  // - No data in the buffer, and the stream is in flowing mode. In this mode\n  //   the loop below is responsible for ensuring read() is called. Failing to\n  //   call read here would abort the flow and there's no other mechanism for\n  //   continuing the flow if the stream consumer has just subscribed to the\n  //   'data' event.\n  //\n  // In addition to the above conditions to keep reading data, the following\n  // conditions prevent the data from being read:\n  // - The stream has ended (state.ended).\n  // - There is already a pending 'read' operation (state.reading). This is a\n  //   case where the the stream has called the implementation defined _read()\n  //   method, but they are processing the call asynchronously and have _not_\n  //   called push() with new data. In this case we skip performing more\n  //   read()s. The execution ends in this method again after the _read() ends\n  //   up calling push() with more data.\n  while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n    var len = state.length;\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;\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  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\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  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\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  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  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    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  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    debug('dest.write', ret);\n    if (ret === false) {\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', state.awaitDrain);\n        state.awaitDrain++;\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) errorOrDestroy(dest, 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  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  return dest;\n};\nfunction pipeOnDrain(src) {\n  return function pipeOnDrainFunctionResult() {\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}\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = {\n    hasUnpiped: false\n  };\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    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    for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, {\n      hasUnpiped: false\n    });\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  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n  dest.emit('unpipe', this, unpipeInfo);\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  var state = this._readableState;\n  if (ev === 'data') {\n    // update readableListening so that resume() may be a no-op\n    // a few lines down. This is needed to support once('readable').\n    state.readableListening = this.listenerCount('readable') > 0;\n\n    // Try start flowing on next tick if stream isn't explicitly paused\n    if (state.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.flowing = false;\n      state.emittedReadable = false;\n      debug('on readable', state.length, state.reading);\n      if (state.length) {\n        emitReadable(this);\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this);\n      }\n    }\n  }\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\nReadable.prototype.removeListener = function (ev, fn) {\n  var res = Stream.prototype.removeListener.call(this, ev, fn);\n  if (ev === 'readable') {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n  return res;\n};\nReadable.prototype.removeAllListeners = function (ev) {\n  var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n  if (ev === 'readable' || ev === undefined) {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n  return res;\n};\nfunction updateReadableListening(self) {\n  var state = self._readableState;\n  state.readableListening = self.listenerCount('readable') > 0;\n  if (state.resumeScheduled && !state.paused) {\n    // flowing needs to be set to true now, otherwise\n    // the upcoming resume will not flow.\n    state.flowing = true;\n\n    // crude way to check if we should resume\n  } else if (self.listenerCount('data') > 0) {\n    self.resume();\n  }\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    // we flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume()\n    state.flowing = !state.readableListening;\n    resume(this, state);\n  }\n  state.paused = false;\n  return this;\n};\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(resume_, stream, state);\n  }\n}\nfunction resume_(stream, state) {\n  debug('resume', state.reading);\n  if (!state.reading) {\n    stream.read(0);\n  }\n  state.resumeScheduled = false;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (this._readableState.flowing !== false) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  this._readableState.paused = true;\n  return this;\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  var state = this._readableState;\n  var paused = false;\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    _this.push(null);\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    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 methodWrap(method) {\n        return function methodWrapReturnFunction() {\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  return this;\n};\nif (typeof Symbol === 'function') {\n  Readable.prototype[Symbol.asyncIterator] = function () {\n    if (createReadableStreamAsyncIterator === undefined) {\n      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n    }\n    return createReadableStreamAsyncIterator(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 get() {\n    return this._readableState.highWaterMark;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\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 get() {\n    return this._readableState && this._readableState.buffer;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\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 get() {\n    return this._readableState.flowing;\n  },\n  set: function set(state) {\n    if (this._readableState) {\n      this._readableState.flowing = state;\n    }\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\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 get() {\n    return this._readableState.length;\n  }\n});\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  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.first();else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = state.buffer.consume(n, state.decoder);\n  }\n  return ret;\n}\nfunction endReadable(stream) {\n  var state = stream._readableState;\n  debug('endReadable', state.endEmitted);\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(endReadableNT, state, stream);\n  }\n}\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length);\n\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    if (state.autoDestroy) {\n      // In case of duplex streams we need a way to detect\n      // if the writable side is ready for autoDestroy as well\n      var wState = stream._writableState;\n      if (!wState || wState.autoDestroy && wState.finished) {\n        stream.destroy();\n      }\n    }\n  }\n}\nif (typeof Symbol === 'function') {\n  Readable.from = function (iterable, opts) {\n    if (from === undefined) {\n      from = require('./internal/streams/from');\n    }\n    return from(Readable, iterable, opts);\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 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;\nvar Transform = require('./_stream_transform');\nrequire('inherits')(PassThrough, Transform);\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n  Transform.call(this, options);\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// 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>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\nrequire('inherits')(Duplex, Readable);\n{\n  // Allow the keys array to be GC'ed.\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}\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n  Readable.call(this, options);\n  Writable.call(this, options);\n  this.allowHalfOpen = true;\n  if (options) {\n    if (options.readable === false) this.readable = false;\n    if (options.writable === false) this.writable = false;\n    if (options.allowHalfOpen === false) {\n      this.allowHalfOpen = false;\n      this.once('end', onend);\n    }\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 get() {\n    return this._writableState.highWaterMark;\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\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 get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\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 get() {\n    return this._writableState.length;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // If the writable side ended, then we're ok.\n  if (this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  process.nextTick(onEndNT, this);\n}\nfunction onEndNT(self) {\n  self.end();\n}\nObject.defineProperty(Duplex.prototype, 'destroyed', {\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 get() {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function set(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});"],"sourceRoot":""}