{"version":3,"sources":["webpack:///./node_modules/ripemd160/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack:///./node_modules/ripemd160/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/ripemd160/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/ripemd160/node_modules/readable-stream/lib/internal/streams/state.js","webpack:///./node_modules/ripemd160/node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/ripemd160/node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack:///./node_modules/ripemd160/node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack:///./node_modules/ripemd160/node_modules/readable-stream/lib/internal/streams/from-browser.js","webpack:///./node_modules/ripemd160/node_modules/readable-stream/lib/internal/streams/pipeline.js"],"names":["ERR_STREAM_PREMATURE_CLOSE","codes","noop","module","exports","eos","stream","opts","callback","called","_len","arguments","length","args","Array","_key","apply","this","once","readable","writable","onlegacyfinish","onfinish","writableEnded","_writableState","finished","call","readableEnded","_readableState","endEmitted","onend","onerror","err","onclose","ended","onrequest","req","on","setHeader","abort","isRequest","error","removeListener","EventEmitter","emitErrorAndCloseNT","self","emitErrorNT","emitCloseNT","emitClose","emit","destroy","cb","_this","readableDestroyed","destroyed","writableDestroyed","errorEmitted","process","nextTick","_destroy","undestroy","reading","ending","finalCalled","prefinished","errorOrDestroy","rState","wState","autoDestroy","ERR_INVALID_OPT_VALUE","getHighWaterMark","state","options","duplexKey","isDuplex","hwm","highWaterMark","highWaterMarkFrom","isFinite","Math","floor","objectMode","Stream","Readable","Writable","Duplex","Transform","PassThrough","pipeline","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","_objectSpread","target","i","source","forEach","key","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","obj","value","_toPropertyKey","configurable","_defineProperties","props","descriptor","arg","input","hint","prim","Symbol","toPrimitive","undefined","res","TypeError","String","Number","_toPrimitive","Buffer","inspect","custom","BufferList","instance","Constructor","_classCallCheck","head","tail","protoProps","staticProps","v","entry","data","next","ret","s","p","n","alloc","src","offset","allocUnsafe","prototype","copy","hasStrings","slice","shift","_getString","_getBuffer","c","str","nb","buf","_","depth","customInspect","_Object$setPrototypeO","kLastResolve","kLastReject","kError","kEnded","kLastPromise","kHandlePromise","kStream","createIterResult","done","readAndResolve","iter","resolve","read","onReadable","AsyncIteratorPrototype","getPrototypeOf","ReadableStreamAsyncIteratorPrototype","setPrototypeOf","Promise","reject","promise","lastPromise","then","wrapForNext","asyncIterator","_this2","_Object$create","iterator","create","code","bind","Error","_require$codes","ERR_MISSING_ARGS","ERR_STREAM_DESTROYED","fn","pipe","from","to","streams","pop","popCallback","isArray","destroys","map","writing","closed","destroyer","reduce"],"mappings":"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","file":"js/index~ee93f39d-2bc46f38673abf64e92d.chunk.js","sourcesContent":["// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    callback.apply(this, args);\n  };\n}\nfunction noop() {}\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\nfunction eos(stream, opts, callback) {\n  if (typeof opts === 'function') return eos(stream, null, opts);\n  if (!opts) opts = {};\n  callback = once(callback || noop);\n  var readable = opts.readable || opts.readable !== false && stream.readable;\n  var writable = opts.writable || opts.writable !== false && stream.writable;\n  var onlegacyfinish = function onlegacyfinish() {\n    if (!stream.writable) onfinish();\n  };\n  var writableEnded = stream._writableState && stream._writableState.finished;\n  var onfinish = function onfinish() {\n    writable = false;\n    writableEnded = true;\n    if (!readable) callback.call(stream);\n  };\n  var readableEnded = stream._readableState && stream._readableState.endEmitted;\n  var onend = function onend() {\n    readable = false;\n    readableEnded = true;\n    if (!writable) callback.call(stream);\n  };\n  var onerror = function onerror(err) {\n    callback.call(stream, err);\n  };\n  var onclose = function onclose() {\n    var err;\n    if (readable && !readableEnded) {\n      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n    if (writable && !writableEnded) {\n      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n  };\n  var onrequest = function onrequest() {\n    stream.req.on('finish', onfinish);\n  };\n  if (isRequest(stream)) {\n    stream.on('complete', onfinish);\n    stream.on('abort', onclose);\n    if (stream.req) onrequest();else stream.on('request', onrequest);\n  } else if (writable && !stream._writableState) {\n    // legacy streams\n    stream.on('end', onlegacyfinish);\n    stream.on('close', onlegacyfinish);\n  }\n  stream.on('end', onend);\n  stream.on('finish', onfinish);\n  if (opts.error !== false) stream.on('error', onerror);\n  stream.on('close', onclose);\n  return function () {\n    stream.removeListener('complete', onfinish);\n    stream.removeListener('abort', onclose);\n    stream.removeListener('request', onrequest);\n    if (stream.req) stream.req.removeListener('finish', onfinish);\n    stream.removeListener('end', onlegacyfinish);\n    stream.removeListener('close', onlegacyfinish);\n    stream.removeListener('finish', onfinish);\n    stream.removeListener('end', onend);\n    stream.removeListener('error', onerror);\n    stream.removeListener('close', onclose);\n  };\n}\nmodule.exports = eos;","module.exports = require('events').EventEmitter;","'use strict';\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err) {\n      if (!this._writableState) {\n        process.nextTick(emitErrorNT, this, err);\n      } else if (!this._writableState.errorEmitted) {\n        this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorNT, this, err);\n      }\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  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      if (!_this._writableState) {\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else if (!_this._writableState.errorEmitted) {\n        _this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else {\n        process.nextTick(emitCloseNT, _this);\n      }\n    } else if (cb) {\n      process.nextTick(emitCloseNT, _this);\n      cb(err);\n    } else {\n      process.nextTick(emitCloseNT, _this);\n    }\n  });\n  return this;\n}\nfunction emitErrorAndCloseNT(self, err) {\n  emitErrorNT(self, err);\n  emitCloseNT(self);\n}\nfunction emitCloseNT(self) {\n  if (self._writableState && !self._writableState.emitClose) return;\n  if (self._readableState && !self._readableState.emitClose) return;\n  self.emit('close');\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  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finalCalled = false;\n    this._writableState.prefinished = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\nfunction errorOrDestroy(stream, err) {\n  // We have tests that rely on errors being emitted\n  // in the same tick, so changing this is semver major.\n  // For now when you opt-in to autoDestroy we allow\n  // the error to be emitted nextTick. In a future\n  // semver major update we should change the default to this.\n\n  var rState = stream._readableState;\n  var wState = stream._writableState;\n  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);\n}\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy,\n  errorOrDestroy: errorOrDestroy\n};","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n  if (hwm != null) {\n    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n      var name = isDuplex ? duplexKey : 'highWaterMark';\n      throw new ERR_INVALID_OPT_VALUE(name, hwm);\n    }\n    return Math.floor(hwm);\n  }\n\n  // Default value\n  return state.objectMode ? 16 : 16 * 1024;\n}\nmodule.exports = {\n  getHighWaterMark: getHighWaterMark\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');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');","'use strict';\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n  return keys;\n}\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n  return target;\n}\nfunction _defineProperty(obj, key, value) {\n  key = _toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);\n  }\n}\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\nfunction _toPropertyKey(arg) {\n  var key = _toPrimitive(arg, \"string\");\n  return typeof key === \"symbol\" ? key : String(key);\n}\nfunction _toPrimitive(input, hint) {\n  if (typeof input !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (typeof res !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}\nvar _require = require('buffer'),\n  Buffer = _require.Buffer;\nvar _require2 = require('util'),\n  inspect = _require2.inspect;\nvar custom = inspect && inspect.custom || 'inspect';\nfunction copyBuffer(src, target, offset) {\n  Buffer.prototype.copy.call(src, target, offset);\n}\nmodule.exports = /*#__PURE__*/function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n  _createClass(BufferList, [{\n    key: \"push\",\n    value: function push(v) {\n      var entry = {\n        data: v,\n        next: null\n      };\n      if (this.length > 0) this.tail.next = entry;else this.head = entry;\n      this.tail = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"unshift\",\n    value: function unshift(v) {\n      var entry = {\n        data: v,\n        next: this.head\n      };\n      if (this.length === 0) this.tail = entry;\n      this.head = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"shift\",\n    value: 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    key: \"clear\",\n    value: function clear() {\n      this.head = this.tail = null;\n      this.length = 0;\n    }\n  }, {\n    key: \"join\",\n    value: function join(s) {\n      if (this.length === 0) return '';\n      var p = this.head;\n      var ret = '' + p.data;\n      while (p = p.next) ret += s + p.data;\n      return ret;\n    }\n  }, {\n    key: \"concat\",\n    value: function concat(n) {\n      if (this.length === 0) return Buffer.alloc(0);\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    // Consumes a specified amount of bytes or characters from the buffered data.\n  }, {\n    key: \"consume\",\n    value: function consume(n, hasStrings) {\n      var ret;\n      if (n < this.head.data.length) {\n        // `slice` is the same for buffers and strings.\n        ret = this.head.data.slice(0, n);\n        this.head.data = this.head.data.slice(n);\n      } else if (n === this.head.data.length) {\n        // First chunk is a perfect match.\n        ret = this.shift();\n      } else {\n        // Result spans more than one buffer.\n        ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n      }\n      return ret;\n    }\n  }, {\n    key: \"first\",\n    value: function first() {\n      return this.head.data;\n    }\n\n    // Consumes a specified amount of characters from the buffered data.\n  }, {\n    key: \"_getString\",\n    value: function _getString(n) {\n      var p = this.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) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = str.slice(nb);\n          }\n          break;\n        }\n        ++c;\n      }\n      this.length -= c;\n      return ret;\n    }\n\n    // Consumes a specified amount of bytes from the buffered data.\n  }, {\n    key: \"_getBuffer\",\n    value: function _getBuffer(n) {\n      var ret = Buffer.allocUnsafe(n);\n      var p = this.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) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = buf.slice(nb);\n          }\n          break;\n        }\n        ++c;\n      }\n      this.length -= c;\n      return ret;\n    }\n\n    // Make sure the linked list only shows the minimal necessary information.\n  }, {\n    key: custom,\n    value: function value(_, options) {\n      return inspect(this, _objectSpread(_objectSpread({}, options), {}, {\n        // Only inspect one level.\n        depth: 0,\n        // It should not recurse.\n        customInspect: false\n      }));\n    }\n  }]);\n  return BufferList;\n}();","'use strict';\n\nvar _Object$setPrototypeO;\nfunction _defineProperty(obj, key, value) {\n  key = _toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nfunction _toPropertyKey(arg) {\n  var key = _toPrimitive(arg, \"string\");\n  return typeof key === \"symbol\" ? key : String(key);\n}\nfunction _toPrimitive(input, hint) {\n  if (typeof input !== \"object\" || input === null) return input;\n  var prim = input[Symbol.toPrimitive];\n  if (prim !== undefined) {\n    var res = prim.call(input, hint || \"default\");\n    if (typeof res !== \"object\") return res;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (hint === \"string\" ? String : Number)(input);\n}\nvar finished = require('./end-of-stream');\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\nfunction createIterResult(value, done) {\n  return {\n    value: value,\n    done: done\n  };\n}\nfunction readAndResolve(iter) {\n  var resolve = iter[kLastResolve];\n  if (resolve !== null) {\n    var data = iter[kStream].read();\n    // we defer if data is null\n    // we can be expecting either 'end' or\n    // 'error'\n    if (data !== null) {\n      iter[kLastPromise] = null;\n      iter[kLastResolve] = null;\n      iter[kLastReject] = null;\n      resolve(createIterResult(data, false));\n    }\n  }\n}\nfunction onReadable(iter) {\n  // we wait for the next tick, because it might\n  // emit an error with process.nextTick\n  process.nextTick(readAndResolve, iter);\n}\nfunction wrapForNext(lastPromise, iter) {\n  return function (resolve, reject) {\n    lastPromise.then(function () {\n      if (iter[kEnded]) {\n        resolve(createIterResult(undefined, true));\n        return;\n      }\n      iter[kHandlePromise](resolve, reject);\n    }, reject);\n  };\n}\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n  get stream() {\n    return this[kStream];\n  },\n  next: function next() {\n    var _this = this;\n    // if we have detected an error in the meanwhile\n    // reject straight away\n    var error = this[kError];\n    if (error !== null) {\n      return Promise.reject(error);\n    }\n    if (this[kEnded]) {\n      return Promise.resolve(createIterResult(undefined, true));\n    }\n    if (this[kStream].destroyed) {\n      // We need to defer via nextTick because if .destroy(err) is\n      // called, the error will be emitted via nextTick, and\n      // we cannot guarantee that there is no error lingering around\n      // waiting to be emitted.\n      return new Promise(function (resolve, reject) {\n        process.nextTick(function () {\n          if (_this[kError]) {\n            reject(_this[kError]);\n          } else {\n            resolve(createIterResult(undefined, true));\n          }\n        });\n      });\n    }\n\n    // if we have multiple next() calls\n    // we will wait for the previous Promise to finish\n    // this logic is optimized to support for await loops,\n    // where next() is only called once at a time\n    var lastPromise = this[kLastPromise];\n    var promise;\n    if (lastPromise) {\n      promise = new Promise(wrapForNext(lastPromise, this));\n    } else {\n      // fast path needed to support multiple this.push()\n      // without triggering the next() queue\n      var data = this[kStream].read();\n      if (data !== null) {\n        return Promise.resolve(createIterResult(data, false));\n      }\n      promise = new Promise(this[kHandlePromise]);\n    }\n    this[kLastPromise] = promise;\n    return promise;\n  }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n  return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n  var _this2 = this;\n  // destroy(err, cb) is a private API\n  // we can guarantee we have that here, because we control the\n  // Readable class this is attached to\n  return new Promise(function (resolve, reject) {\n    _this2[kStream].destroy(null, function (err) {\n      if (err) {\n        reject(err);\n        return;\n      }\n      resolve(createIterResult(undefined, true));\n    });\n  });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n  var _Object$create;\n  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n    value: stream,\n    writable: true\n  }), _defineProperty(_Object$create, kLastResolve, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kLastReject, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kError, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kEnded, {\n    value: stream._readableState.endEmitted,\n    writable: true\n  }), _defineProperty(_Object$create, kHandlePromise, {\n    value: function value(resolve, reject) {\n      var data = iterator[kStream].read();\n      if (data) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        resolve(createIterResult(data, false));\n      } else {\n        iterator[kLastResolve] = resolve;\n        iterator[kLastReject] = reject;\n      }\n    },\n    writable: true\n  }), _Object$create));\n  iterator[kLastPromise] = null;\n  finished(stream, function (err) {\n    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n      var reject = iterator[kLastReject];\n      // reject if we are waiting for data in the Promise\n      // returned by next() and store the error\n      if (reject !== null) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        reject(err);\n      }\n      iterator[kError] = err;\n      return;\n    }\n    var resolve = iterator[kLastResolve];\n    if (resolve !== null) {\n      iterator[kLastPromise] = null;\n      iterator[kLastResolve] = null;\n      iterator[kLastReject] = null;\n      resolve(createIterResult(undefined, true));\n    }\n    iterator[kEnded] = true;\n  });\n  stream.on('readable', onReadable.bind(null, iterator));\n  return iterator;\n};\nmodule.exports = createReadableStreamAsyncIterator;","module.exports = function () {\n  throw new Error('Readable.from is not available in the browser');\n};","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n\n'use strict';\n\nvar eos;\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    callback.apply(void 0, arguments);\n  };\n}\nvar _require$codes = require('../../../errors').codes,\n  ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\nfunction noop(err) {\n  // Rethrow the error if it exists to avoid swallowing it\n  if (err) throw err;\n}\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\nfunction destroyer(stream, reading, writing, callback) {\n  callback = once(callback);\n  var closed = false;\n  stream.on('close', function () {\n    closed = true;\n  });\n  if (eos === undefined) eos = require('./end-of-stream');\n  eos(stream, {\n    readable: reading,\n    writable: writing\n  }, function (err) {\n    if (err) return callback(err);\n    closed = true;\n    callback();\n  });\n  var destroyed = false;\n  return function (err) {\n    if (closed) return;\n    if (destroyed) return;\n    destroyed = true;\n\n    // request.destroy just do .end - .abort is what we want\n    if (isRequest(stream)) return stream.abort();\n    if (typeof stream.destroy === 'function') return stream.destroy();\n    callback(err || new ERR_STREAM_DESTROYED('pipe'));\n  };\n}\nfunction call(fn) {\n  fn();\n}\nfunction pipe(from, to) {\n  return from.pipe(to);\n}\nfunction popCallback(streams) {\n  if (!streams.length) return noop;\n  if (typeof streams[streams.length - 1] !== 'function') return noop;\n  return streams.pop();\n}\nfunction pipeline() {\n  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n    streams[_key] = arguments[_key];\n  }\n  var callback = popCallback(streams);\n  if (Array.isArray(streams[0])) streams = streams[0];\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams');\n  }\n  var error;\n  var destroys = streams.map(function (stream, i) {\n    var reading = i < streams.length - 1;\n    var writing = i > 0;\n    return destroyer(stream, reading, writing, function (err) {\n      if (!error) error = err;\n      if (err) destroys.forEach(call);\n      if (reading) return;\n      destroys.forEach(call);\n      callback(error);\n    });\n  });\n  return streams.reduce(pipe);\n}\nmodule.exports = pipeline;"],"sourceRoot":""}