{"version":3,"sources":["webpack:///./node_modules/inherits/inherits_browser.js","webpack:///./node_modules/events/events.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/debug/src/browser.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/util-deprecate/browser.js","webpack:///./node_modules/queue-microtask/index.js","webpack:///./node_modules/once/once.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/errors-browser.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/errors-browser.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/run-parallel/index.js","webpack:///./node_modules/randombytes/browser.js","webpack:///./node_modules/simple-peer/index.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/internal/streams/state.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/bittorrent-tracker/client.js","webpack:///./node_modules/bittorrent-tracker/lib/common.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/internal/streams/state.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/wrappy/wrappy.js","webpack:///./node_modules/debug/src/common.js","webpack:///./node_modules/debug/node_modules/ms/index.js","webpack:///./node_modules/get-browser-rtc/index.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/internal/streams/from-browser.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/simple-peer/node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack:///./node_modules/err-code/index.js","webpack:///./node_modules/bittorrent-tracker/lib/client/websocket-tracker.js","webpack:///./node_modules/simple-websocket/index.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/internal/streams/from-browser.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/simple-websocket/node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack:///./node_modules/bittorrent-tracker/lib/client/tracker.js"],"names":["Object","create","module","exports","ctor","superCtor","super_","prototype","constructor","value","enumerable","writable","configurable","TempCtor","ReflectOwnKeys","R","Reflect","ReflectApply","apply","target","receiver","args","Function","call","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","concat","NumberIsNaN","Number","isNaN","EventEmitter","init","this","once","emitter","name","Promise","resolve","reject","errorListener","err","removeListener","resolver","slice","arguments","eventTargetAgnosticAddListener","handler","flags","on","addErrorHandlerIfEventEmitter","_events","undefined","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","TypeError","_getMaxListeners","that","_addListener","type","prepend","m","events","existing","warning","newListener","emit","unshift","push","length","warned","w","Error","String","count","console","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","arr","ret","Array","i","unwrapListeners","arrayClone","listenerCount","n","copy","addEventListener","wrapListener","arg","removeEventListener","defineProperty","get","set","RangeError","getPrototypeOf","setMaxListeners","getMaxListeners","doError","error","er","message","context","len","listeners","addListener","prependListener","prependOnceListener","list","position","originalListener","shift","index","pop","spliceOne","off","removeAllListeners","key","keys","rawListeners","eventNames","Buffer","isEncoding","encoding","toLowerCase","StringDecoder","nb","enc","nenc","retried","_normalizeEncoding","normalizeEncoding","text","utf16Text","end","utf16End","fillLast","utf8FillLast","base64Text","base64End","write","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","allocUnsafe","utf8CheckByte","byte","buf","p","r","self","utf8CheckExtraBytes","toString","c","charCodeAt","total","j","utf8CheckIncomplete","formatArgs","useColors","namespace","humanize","diff","color","splice","lastC","replace","match","save","namespaces","storage","setItem","removeItem","load","getItem","process","env","DEBUG","window","__nwjs","navigator","userAgent","document","documentElement","style","WebkitAppearance","firebug","exception","table","parseInt","RegExp","$1","localStorage","localstorage","destroy","colors","log","debug","formatters","v","JSON","stringify","buffer","copyProps","src","dst","SafeBuffer","encodingOrOffset","from","alloc","allocUnsafeSlow","size","fill","SlowBuffer","config","global","_","val","fn","msg","trace","promise","queueMicrotask","cb","then","catch","setTimeout","wrappy","f","called","onceStrict","onceError","strict","proto","codes","createErrorType","code","Base","NodeError","_Base","subClass","superClass","arg1","arg2","arg3","getMessage","__proto__","oneOf","expected","thing","isArray","map","join","actual","determiner","search","pos","substr","str","this_len","substring","endsWith","start","indexOf","includes","objectKeys","obj","Duplex","Readable","Writable","method","options","allowHalfOpen","readable","onend","_writableState","ended","nextTick","onEndNT","highWaterMark","getBuffer","_readableState","destroyed","tasks","results","pending","isSync","done","each","result","forEach","task","MAX_BYTES","MAX_UINT32","crypto","msCrypto","getRandomValues","bytes","generated","getBrowserRTC","randombytes","stream","errCode","MAX_BUFFERED_AMOUNT","filterTrickle","sdp","Peer","opts","super","assign","_id","_debug","channelName","initiator","channelConfig","channelNegotiated","negotiated","offerOptions","answerOptions","sdpTransform","streams","trickle","allowHalfTrickle","iceCompleteTimeout","destroying","_connected","remoteAddress","remoteFamily","remotePort","localAddress","localFamily","localPort","_wrtc","wrtc","_pcReady","_channelReady","_iceComplete","_iceCompleteTimer","_channel","_pendingCandidates","_isNegotiating","_firstNegotiation","_batchedNegotiation","_queuedNegotiation","_sendersAwaitingStable","_senderMap","Map","_closingInterval","_remoteTracks","_remoteStreams","_chunk","_cb","_interval","_pc","_isReactNativeWebrtc","_peerConnectionId","oniceconnectionstatechange","_onIceStateChange","onicegatheringstatechange","onconnectionstatechange","_onConnectionStateChange","onsignalingstatechange","_onSignalingStateChange","onicecandidate","event","_onIceCandidate","peerIdentity","_setupData","channel","createDataChannel","ondatachannel","addStream","ontrack","_onTrack","_needsNegotiation","_onFinishBound","_onFinish","bufferedAmount","readyState","port","family","address","data","parse","renegotiate","transceiverRequest","addTransceiver","kind","candidate","remoteDescription","_addIceCandidate","setRemoteDescription","_createAnswer","iceCandidateObj","RTCIceCandidate","addIceCandidate","chunk","send","getTracks","track","addTrack","submap","sender","removed","oldTrack","newTrack","replaceTrack","removeTrack","negotiate","_createOffer","_destroy","finished","clearInterval","close","onmessage","onopen","onclose","onerror","binaryType","bufferedAmountLowThreshold","label","_onChannelMessage","onbufferedamountlow","_onChannelBufferedAmountLow","_onChannelOpen","_onChannelClose","isClosing","setInterval","destroySoon","createOffer","offer","sendOffer","signal","localDescription","setLocalDescription","getTransceivers","transceiver","mid","requested","createAnswer","answer","sendAnswer","_requestMissingTransceivers","connectionState","iceConnectionState","iceGatheringState","_maybeReady","flattenValues","report","values","getStats","res","reports","names","stat","id","timestamp","_connecting","findCandidatePair","items","remoteCandidates","localCandidates","candidatePairs","foundSelectedCandidatePair","item","setSelectedCandidatePair","selectedCandidatePair","local","localCandidateId","ip","ipAddress","portNumber","googLocalAddress","split","remote","remoteCandidateId","googRemoteAddress","selectedCandidatePairId","googActiveConnection","selected","_onInterval","unref","signalingState","sdpMLineIndex","sdpMid","_startIceCompleteTimeout","ArrayBuffer","eventStream","some","remoteStream","WEBRTC_SUPPORT","iceServers","urls","sdpSemantics","ERR_STREAM_PREMATURE_CLOSE","noop","eos","callback","_len","_key","onlegacyfinish","onfinish","writableEnded","readableEnded","endEmitted","onrequest","req","setHeader","abort","isRequest","ReadableState","EElistenerCount","Stream","OurUint8Array","Uint8Array","debugUtil","debuglog","createReadableStreamAsyncIterator","BufferList","destroyImpl","getHighWaterMark","_require$codes","ERR_INVALID_ARG_TYPE","ERR_STREAM_PUSH_AFTER_EOF","ERR_METHOD_NOT_IMPLEMENTED","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","errorOrDestroy","kProxyEvents","isDuplex","objectMode","readableObjectMode","pipes","pipesCount","flowing","reading","sync","needReadable","emittedReadable","readableListening","resumeScheduled","paused","emitClose","autoDestroy","defaultEncoding","awaitDrain","readingMore","decoder","read","_read","readableAddChunk","addToFront","skipChunkCheck","emitReadable","emitReadable_","onEofChunk","isBuffer","chunkInvalid","_uint8ArrayToBuffer","addChunk","maybeReadMore","_undestroy","undestroy","isPaused","setEncoding","head","content","next","clear","MAX_HWM","howMuchToRead","computeNewHighWaterMark","flow","maybeReadMore_","updateReadableListening","resume","nReadingNextTick","resume_","fromList","first","consume","endReadable","endReadableNT","wState","xs","x","l","nOrig","doRead","pipe","dest","pipeOpts","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","ondrain","ondata","cleanedUp","needDrain","pipeOnDrain","pause","dests","ev","wrap","_this","Symbol","asyncIterator","_fromList","iterable","emitErrorAndCloseNT","emitErrorNT","emitCloseNT","readableDestroyed","writableDestroyed","errorEmitted","ending","finalCalled","prefinished","rState","ERR_INVALID_OPT_VALUE","duplexKey","hwm","highWaterMarkFrom","isFinite","Math","floor","CorkedRequest","entry","finish","corkReq","pendingcb","corkedRequestsFree","onCorkedFinish","WritableState","internalUtil","deprecate","realHasInstance","ERR_MULTIPLE_CALLBACK","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_DESTROYED","ERR_STREAM_NULL_VALUES","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","nop","writableObjectMode","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writecb","writelen","onwriteStateUpdate","finishMaybe","onwriteError","needFinish","bufferedRequest","clearBuffer","afterWrite","lastBufferedRequest","bufferedRequestCount","_write","writev","_writev","final","_final","doWrite","onwriteDrain","holder","allBuffers","isBuf","callFinal","need","prefinish","current","out","hasInstance","object","writeAfterEnd","validChunk","newChunk","decodeChunk","last","writeOrBuffer","cork","uncork","setDefaultEncoding","endWritable","Transform","ERR_TRANSFORM_ALREADY_TRANSFORMING","ERR_TRANSFORM_WITH_LENGTH_0","afterTransform","ts","_transformState","transforming","writechunk","rs","needTransform","writeencoding","transform","_transform","flush","_flush","err2","parallel","common","HTTPTracker","UDPTracker","WebSocketTracker","Client","peerId","infoHash","announce","browser","_peerIdBuffer","_peerIdBinary","_infoHashBuffer","_infoHashBinary","_port","_getAnnounceOpts","getAnnounceOpts","_rtcConfig","rtcConfig","_userAgent","announceUrl","Set","webrtcSupport","nextTickWarn","_trackers","parsedUrl","URL","protocol","location","filter","Boolean","_defaultAnnounceOpts","_announce","tracker","scrape","intervalMs","numwant","DEFAULT_ANNOUNCE_PEERS","uploaded","downloaded","clientOpts","client","MAX_ANNOUNCE_PEERS","binaryToHex","hexToBinary","k","wrapper","createDebug","prevTime","enableOverride","enabled","curr","Date","ms","prev","coerce","format","formatter","selectColor","extend","delimiter","newDebug","toNamespace","regexp","default","stack","disable","skips","enable","test","hash","abs","s","h","d","y","plural","msAbs","isPlural","round","exec","parseFloat","long","fmtLong","fmtShort","globalThis","RTCPeerConnection","mozRTCPeerConnection","webkitRTCPeerConnection","RTCSessionDescription","mozRTCSessionDescription","webkitRTCSessionDescription","mozRTCIceCandidate","webkitRTCIceCandidate","PassThrough","pipeline","enumerableOnly","symbols","sym","getOwnPropertyDescriptor","_defineProperty","_defineProperties","props","descriptor","inspect","custom","instance","Constructor","_classCallCheck","tail","protoProps","staticProps","offset","hasStrings","_getString","_getBuffer","source","getOwnPropertyDescriptors","defineProperties","_objectSpread","depth","customInspect","_Object$setPrototypeO","kLastResolve","kLastReject","kError","kEnded","kLastPromise","kHandlePromise","kStream","createIterResult","readAndResolve","iter","onReadable","AsyncIteratorPrototype","ReadableStreamAsyncIteratorPrototype","setPrototypeOf","lastPromise","wrapForNext","_this2","_Object$create","iterator","ERR_MISSING_ARGS","destroyer","closed","to","popCallback","destroys","reduce","ErrClass","Socket","Tracker","socketPool","peers","socket","reconnecting","retries","reconnectTimer","expectingResponse","_openSocket","connected","params","action","info_hash","peer_id","_trackerId","trackerid","_send","min","_generateOffers","offers","interval","clearTimeout","peer","trackerTimeout","_onSocketConnectBound","_onSocketDataBound","_onSocketCloseBound","_onSocketErrorBound","consumers","timeout","destroyCleanup","DESTROY_TIMEOUT","_onSocketConnect","_onSocketError","_onSocketData","_onSocketClose","_onAnnounceResponse","_onScrapeResponse","failure","trackerId","complete","response","_createPeer","to_peer_id","offer_id","offerId","files","_startReconnectTimer","random","pow","generateOffer","checkDone","onError","onConnect","DEFAULT_ANNOUNCE_INTERVAL","_socketPool","ws","_WebSocket","WebSocket","url","_ws","OPEN","_handleOpen","_handleMessage","_handleClose","_handleError","_handleFinishBound","_handleFinish","onClose","CLOSED","WEBSOCKET_SUPPORT"],"mappings":"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","file":"0.chunk.js?v=2600","sourcesContent":["if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'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;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\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 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-env browser */\n\n/**\n * This is the web browser implementation of `debug()`.\n */\n\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = localstorage();\nexports.destroy = (() => {\n\tlet warned = false;\n\n\treturn () => {\n\t\tif (!warned) {\n\t\t\twarned = true;\n\t\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t\t}\n\t};\n})();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n\t'#0000CC',\n\t'#0000FF',\n\t'#0033CC',\n\t'#0033FF',\n\t'#0066CC',\n\t'#0066FF',\n\t'#0099CC',\n\t'#0099FF',\n\t'#00CC00',\n\t'#00CC33',\n\t'#00CC66',\n\t'#00CC99',\n\t'#00CCCC',\n\t'#00CCFF',\n\t'#3300CC',\n\t'#3300FF',\n\t'#3333CC',\n\t'#3333FF',\n\t'#3366CC',\n\t'#3366FF',\n\t'#3399CC',\n\t'#3399FF',\n\t'#33CC00',\n\t'#33CC33',\n\t'#33CC66',\n\t'#33CC99',\n\t'#33CCCC',\n\t'#33CCFF',\n\t'#6600CC',\n\t'#6600FF',\n\t'#6633CC',\n\t'#6633FF',\n\t'#66CC00',\n\t'#66CC33',\n\t'#9900CC',\n\t'#9900FF',\n\t'#9933CC',\n\t'#9933FF',\n\t'#99CC00',\n\t'#99CC33',\n\t'#CC0000',\n\t'#CC0033',\n\t'#CC0066',\n\t'#CC0099',\n\t'#CC00CC',\n\t'#CC00FF',\n\t'#CC3300',\n\t'#CC3333',\n\t'#CC3366',\n\t'#CC3399',\n\t'#CC33CC',\n\t'#CC33FF',\n\t'#CC6600',\n\t'#CC6633',\n\t'#CC9900',\n\t'#CC9933',\n\t'#CCCC00',\n\t'#CCCC33',\n\t'#FF0000',\n\t'#FF0033',\n\t'#FF0066',\n\t'#FF0099',\n\t'#FF00CC',\n\t'#FF00FF',\n\t'#FF3300',\n\t'#FF3333',\n\t'#FF3366',\n\t'#FF3399',\n\t'#FF33CC',\n\t'#FF33FF',\n\t'#FF6600',\n\t'#FF6633',\n\t'#FF9900',\n\t'#FF9933',\n\t'#FFCC00',\n\t'#FFCC33'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\n// eslint-disable-next-line complexity\nfunction useColors() {\n\t// NB: In an Electron preload script, document will be defined but not fully\n\t// initialized. Since we know we're in Chrome, we'll just detect this case\n\t// explicitly\n\tif (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {\n\t\treturn true;\n\t}\n\n\t// Internet Explorer and Edge do not support colors.\n\tif (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n\t\treturn false;\n\t}\n\n\t// Is webkit? http://stackoverflow.com/a/16459606/376773\n\t// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n\treturn (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n\t\t// Is firebug? http://stackoverflow.com/a/398120/376773\n\t\t(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n\t\t// Is firefox >= v31?\n\t\t// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n\t\t// Double check webkit in userAgent just in case we are in a worker\n\t\t(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n\targs[0] = (this.useColors ? '%c' : '') +\n\t\tthis.namespace +\n\t\t(this.useColors ? ' %c' : ' ') +\n\t\targs[0] +\n\t\t(this.useColors ? '%c ' : ' ') +\n\t\t'+' + module.exports.humanize(this.diff);\n\n\tif (!this.useColors) {\n\t\treturn;\n\t}\n\n\tconst c = 'color: ' + this.color;\n\targs.splice(1, 0, c, 'color: inherit');\n\n\t// The final \"%c\" is somewhat tricky, because there could be other\n\t// arguments passed either before or after the %c, so we need to\n\t// figure out the correct index to insert the CSS into\n\tlet index = 0;\n\tlet lastC = 0;\n\targs[0].replace(/%[a-zA-Z%]/g, match => {\n\t\tif (match === '%%') {\n\t\t\treturn;\n\t\t}\n\t\tindex++;\n\t\tif (match === '%c') {\n\t\t\t// We only are interested in the *last* %c\n\t\t\t// (the user may have provided their own)\n\t\t\tlastC = index;\n\t\t}\n\t});\n\n\targs.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.debug()` when available.\n * No-op when `console.debug` is not a \"function\".\n * If `console.debug` is not available, falls back\n * to `console.log`.\n *\n * @api public\n */\nexports.log = console.debug || console.log || (() => {});\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\nfunction save(namespaces) {\n\ttry {\n\t\tif (namespaces) {\n\t\t\texports.storage.setItem('debug', namespaces);\n\t\t} else {\n\t\t\texports.storage.removeItem('debug');\n\t\t}\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\nfunction load() {\n\tlet r;\n\ttry {\n\t\tr = exports.storage.getItem('debug');\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n\n\t// If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n\tif (!r && typeof process !== 'undefined' && 'env' in process) {\n\t\tr = process.env.DEBUG;\n\t}\n\n\treturn r;\n}\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n\ttry {\n\t\t// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context\n\t\t// The Browser also has localStorage in the global context.\n\t\treturn localStorage;\n\t} catch (error) {\n\t\t// Swallow\n\t\t// XXX (@Qix-) should we be logging these?\n\t}\n}\n\nmodule.exports = require('./common')(exports);\n\nconst {formatters} = module.exports;\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nformatters.j = function (v) {\n\ttry {\n\t\treturn JSON.stringify(v);\n\t} catch (error) {\n\t\treturn '[UnexpectedJSONParseError]: ' + error.message;\n\t}\n};\n","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","\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","/*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\nlet promise\n\nmodule.exports = typeof queueMicrotask === 'function'\n  ? queueMicrotask.bind(typeof window !== 'undefined' ? window : global)\n  // reuse resolved promise, and allocate it lazily\n  : cb => (promise || (promise = Promise.resolve()))\n    .then(cb)\n    .catch(err => setTimeout(() => { throw err }, 0))\n","var wrappy = require('wrappy')\nmodule.exports = wrappy(once)\nmodule.exports.strict = wrappy(onceStrict)\n\nonce.proto = once(function () {\n  Object.defineProperty(Function.prototype, 'once', {\n    value: function () {\n      return once(this)\n    },\n    configurable: true\n  })\n\n  Object.defineProperty(Function.prototype, 'onceStrict', {\n    value: function () {\n      return onceStrict(this)\n    },\n    configurable: true\n  })\n})\n\nfunction once (fn) {\n  var f = function () {\n    if (f.called) return f.value\n    f.called = true\n    return f.value = fn.apply(this, arguments)\n  }\n  f.called = false\n  return f\n}\n\nfunction onceStrict (fn) {\n  var f = function () {\n    if (f.called)\n      throw new Error(f.onceError)\n    f.called = true\n    return f.value = fn.apply(this, arguments)\n  }\n  var name = fn.name || 'Function wrapped with `once`'\n  f.onceError = name + \" shouldn't be called more than once\"\n  f.called = false\n  return f\n}\n","'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\n\nfunction createErrorType(code, message, Base) {\n  if (!Base) {\n    Base = Error;\n  }\n\n  function getMessage(arg1, arg2, arg3) {\n    if (typeof message === 'string') {\n      return message;\n    } else {\n      return message(arg1, arg2, arg3);\n    }\n  }\n\n  var NodeError =\n  /*#__PURE__*/\n  function (_Base) {\n    _inheritsLoose(NodeError, _Base);\n\n    function NodeError(arg1, arg2, arg3) {\n      return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n    }\n\n    return NodeError;\n  }(Base);\n\n  NodeError.prototype.name = Base.name;\n  NodeError.prototype.code = code;\n  codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n  if (Array.isArray(expected)) {\n    var len = expected.length;\n    expected = expected.map(function (i) {\n      return String(i);\n    });\n\n    if (len > 2) {\n      return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n    } else if (len === 2) {\n      return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n    } else {\n      return \"of \".concat(thing, \" \").concat(expected[0]);\n    }\n  } else {\n    return \"of \".concat(thing, \" \").concat(String(expected));\n  }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n  return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n  if (this_len === undefined || this_len > str.length) {\n    this_len = str.length;\n  }\n\n  return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n  if (typeof start !== 'number') {\n    start = 0;\n  }\n\n  if (start + search.length > str.length) {\n    return false;\n  } else {\n    return str.indexOf(search, start) !== -1;\n  }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n  return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n  // determiner: 'must be' or 'must not be'\n  var determiner;\n\n  if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n    determiner = 'must not be';\n    expected = expected.replace(/^not /, '');\n  } else {\n    determiner = 'must be';\n  }\n\n  var msg;\n\n  if (endsWith(name, ' argument')) {\n    // For cases like 'first argument'\n    msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  } else {\n    var type = includes(name, '.') ? 'property' : 'argument';\n    msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  }\n\n  msg += \". Received type \".concat(typeof actual);\n  return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n  return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n  return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n  return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\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// 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'use strict';\n/*<replacement>*/\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n\n  for (var key in obj) {\n    keys.push(key);\n  }\n\n  return keys;\n};\n/*</replacement>*/\n\n\nmodule.exports = Duplex;\n\nvar Readable = require('./_stream_readable');\n\nvar Writable = require('./_stream_writable');\n\nrequire('inherits')(Duplex, Readable);\n\n{\n  // Allow the keys array to be GC'ed.\n  var keys = objectKeys(Writable.prototype);\n\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  Readable.call(this, options);\n  Writable.call(this, options);\n  this.allowHalfOpen = true;\n\n  if (options) {\n    if (options.readable === false) this.readable = false;\n    if (options.writable === false) this.writable = false;\n\n    if (options.allowHalfOpen === false) {\n      this.allowHalfOpen = false;\n      this.once('end', onend);\n    }\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}); // the no-half-open enforcer\n\nfunction onend() {\n  // If the writable side ended, then we're ok.\n  if (this._writableState.ended) return; // no more data can be written.\n  // But allow more writes to happen in this tick.\n\n  process.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\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\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    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});","'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\n\nfunction createErrorType(code, message, Base) {\n  if (!Base) {\n    Base = Error;\n  }\n\n  function getMessage(arg1, arg2, arg3) {\n    if (typeof message === 'string') {\n      return message;\n    } else {\n      return message(arg1, arg2, arg3);\n    }\n  }\n\n  var NodeError =\n  /*#__PURE__*/\n  function (_Base) {\n    _inheritsLoose(NodeError, _Base);\n\n    function NodeError(arg1, arg2, arg3) {\n      return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n    }\n\n    return NodeError;\n  }(Base);\n\n  NodeError.prototype.name = Base.name;\n  NodeError.prototype.code = code;\n  codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n  if (Array.isArray(expected)) {\n    var len = expected.length;\n    expected = expected.map(function (i) {\n      return String(i);\n    });\n\n    if (len > 2) {\n      return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n    } else if (len === 2) {\n      return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n    } else {\n      return \"of \".concat(thing, \" \").concat(expected[0]);\n    }\n  } else {\n    return \"of \".concat(thing, \" \").concat(String(expected));\n  }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n  return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n  if (this_len === undefined || this_len > str.length) {\n    this_len = str.length;\n  }\n\n  return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n  if (typeof start !== 'number') {\n    start = 0;\n  }\n\n  if (start + search.length > str.length) {\n    return false;\n  } else {\n    return str.indexOf(search, start) !== -1;\n  }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n  return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n  // determiner: 'must be' or 'must not be'\n  var determiner;\n\n  if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n    determiner = 'must not be';\n    expected = expected.replace(/^not /, '');\n  } else {\n    determiner = 'must be';\n  }\n\n  var msg;\n\n  if (endsWith(name, ' argument')) {\n    // For cases like 'first argument'\n    msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  } else {\n    var type = includes(name, '.') ? 'property' : 'argument';\n    msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  }\n\n  msg += \". Received type \".concat(typeof actual);\n  return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n  return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n  return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n  return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\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// 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'use strict';\n/*<replacement>*/\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n\n  for (var key in obj) {\n    keys.push(key);\n  }\n\n  return keys;\n};\n/*</replacement>*/\n\n\nmodule.exports = Duplex;\n\nvar Readable = require('./_stream_readable');\n\nvar Writable = require('./_stream_writable');\n\nrequire('inherits')(Duplex, Readable);\n\n{\n  // Allow the keys array to be GC'ed.\n  var keys = objectKeys(Writable.prototype);\n\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  Readable.call(this, options);\n  Writable.call(this, options);\n  this.allowHalfOpen = true;\n\n  if (options) {\n    if (options.readable === false) this.readable = false;\n    if (options.writable === false) this.writable = false;\n\n    if (options.allowHalfOpen === false) {\n      this.allowHalfOpen = false;\n      this.once('end', onend);\n    }\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}); // the no-half-open enforcer\n\nfunction onend() {\n  // If the writable side ended, then we're ok.\n  if (this._writableState.ended) return; // no more data can be written.\n  // But allow more writes to happen in this tick.\n\n  process.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\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\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    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});","/*! run-parallel. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\nmodule.exports = runParallel\n\nconst queueMicrotask = require('queue-microtask')\n\nfunction runParallel (tasks, cb) {\n  let results, pending, keys\n  let isSync = true\n\n  if (Array.isArray(tasks)) {\n    results = []\n    pending = tasks.length\n  } else {\n    keys = Object.keys(tasks)\n    results = {}\n    pending = keys.length\n  }\n\n  function done (err) {\n    function end () {\n      if (cb) cb(err, results)\n      cb = null\n    }\n    if (isSync) queueMicrotask(end)\n    else end()\n  }\n\n  function each (i, err, result) {\n    results[i] = result\n    if (--pending === 0 || err) {\n      done(err)\n    }\n  }\n\n  if (!pending) {\n    // empty\n    done(null)\n  } else if (keys) {\n    // object\n    keys.forEach(function (key) {\n      tasks[key](function (err, result) { each(key, err, result) })\n    })\n  } else {\n    // array\n    tasks.forEach(function (task, i) {\n      task(function (err, result) { each(i, err, result) })\n    })\n  }\n\n  isSync = false\n}\n","'use strict'\n\n// limit of Crypto.getRandomValues()\n// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues\nvar MAX_BYTES = 65536\n\n// Node supports requesting up to this number of bytes\n// https://github.com/nodejs/node/blob/master/lib/internal/crypto/random.js#L48\nvar MAX_UINT32 = 4294967295\n\nfunction oldBrowser () {\n  throw new Error('Secure random number generation is not supported by this browser.\\nUse Chrome, Firefox or Internet Explorer 11')\n}\n\nvar Buffer = require('safe-buffer').Buffer\nvar crypto = global.crypto || global.msCrypto\n\nif (crypto && crypto.getRandomValues) {\n  module.exports = randomBytes\n} else {\n  module.exports = oldBrowser\n}\n\nfunction randomBytes (size, cb) {\n  // phantomjs needs to throw\n  if (size > MAX_UINT32) throw new RangeError('requested too many random bytes')\n\n  var bytes = Buffer.allocUnsafe(size)\n\n  if (size > 0) {  // getRandomValues fails on IE if size == 0\n    if (size > MAX_BYTES) { // this is the max bytes crypto.getRandomValues\n      // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues\n      for (var generated = 0; generated < size; generated += MAX_BYTES) {\n        // buffer.slice automatically checks if the end is past the end of\n        // the buffer so we don't have to here\n        crypto.getRandomValues(bytes.slice(generated, generated + MAX_BYTES))\n      }\n    } else {\n      crypto.getRandomValues(bytes)\n    }\n  }\n\n  if (typeof cb === 'function') {\n    return process.nextTick(function () {\n      cb(null, bytes)\n    })\n  }\n\n  return bytes\n}\n","/*! simple-peer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\nconst debug = require('debug')('simple-peer')\nconst getBrowserRTC = require('get-browser-rtc')\nconst randombytes = require('randombytes')\nconst stream = require('readable-stream')\nconst queueMicrotask = require('queue-microtask') // TODO: remove when Node 10 is not supported\nconst errCode = require('err-code')\nconst { Buffer } = require('buffer')\n\nconst MAX_BUFFERED_AMOUNT = 64 * 1024\nconst ICECOMPLETE_TIMEOUT = 5 * 1000\nconst CHANNEL_CLOSING_TIMEOUT = 5 * 1000\n\n// HACK: Filter trickle lines when trickle is disabled #354\nfunction filterTrickle (sdp) {\n  return sdp.replace(/a=ice-options:trickle\\s\\n/g, '')\n}\n\nfunction warn (message) {\n  console.warn(message)\n}\n\n/**\n * WebRTC peer connection. Same API as node core `net.Socket`, plus a few extra methods.\n * Duplex stream.\n * @param {Object} opts\n */\nclass Peer extends stream.Duplex {\n  constructor (opts) {\n    opts = Object.assign({\n      allowHalfOpen: false\n    }, opts)\n\n    super(opts)\n\n    this._id = randombytes(4).toString('hex').slice(0, 7)\n    this._debug('new peer %o', opts)\n\n    this.channelName = opts.initiator\n      ? opts.channelName || randombytes(20).toString('hex')\n      : null\n\n    this.initiator = opts.initiator || false\n    this.channelConfig = opts.channelConfig || Peer.channelConfig\n    this.channelNegotiated = this.channelConfig.negotiated\n    this.config = Object.assign({}, Peer.config, opts.config)\n    this.offerOptions = opts.offerOptions || {}\n    this.answerOptions = opts.answerOptions || {}\n    this.sdpTransform = opts.sdpTransform || (sdp => sdp)\n    this.streams = opts.streams || (opts.stream ? [opts.stream] : []) // support old \"stream\" option\n    this.trickle = opts.trickle !== undefined ? opts.trickle : true\n    this.allowHalfTrickle = opts.allowHalfTrickle !== undefined ? opts.allowHalfTrickle : false\n    this.iceCompleteTimeout = opts.iceCompleteTimeout || ICECOMPLETE_TIMEOUT\n\n    this.destroyed = false\n    this.destroying = false\n    this._connected = false\n\n    this.remoteAddress = undefined\n    this.remoteFamily = undefined\n    this.remotePort = undefined\n    this.localAddress = undefined\n    this.localFamily = undefined\n    this.localPort = undefined\n\n    this._wrtc = (opts.wrtc && typeof opts.wrtc === 'object')\n      ? opts.wrtc\n      : getBrowserRTC()\n\n    if (!this._wrtc) {\n      if (typeof window === 'undefined') {\n        throw errCode(new Error('No WebRTC support: Specify `opts.wrtc` option in this environment'), 'ERR_WEBRTC_SUPPORT')\n      } else {\n        throw errCode(new Error('No WebRTC support: Not a supported browser'), 'ERR_WEBRTC_SUPPORT')\n      }\n    }\n\n    this._pcReady = false\n    this._channelReady = false\n    this._iceComplete = false // ice candidate trickle done (got null candidate)\n    this._iceCompleteTimer = null // send an offer/answer anyway after some timeout\n    this._channel = null\n    this._pendingCandidates = []\n\n    this._isNegotiating = false // is this peer waiting for negotiation to complete?\n    this._firstNegotiation = true\n    this._batchedNegotiation = false // batch synchronous negotiations\n    this._queuedNegotiation = false // is there a queued negotiation request?\n    this._sendersAwaitingStable = []\n    this._senderMap = new Map()\n    this._closingInterval = null\n\n    this._remoteTracks = []\n    this._remoteStreams = []\n\n    this._chunk = null\n    this._cb = null\n    this._interval = null\n\n    try {\n      this._pc = new (this._wrtc.RTCPeerConnection)(this.config)\n    } catch (err) {\n      this.destroy(errCode(err, 'ERR_PC_CONSTRUCTOR'))\n      return\n    }\n\n    // We prefer feature detection whenever possible, but sometimes that's not\n    // possible for certain implementations.\n    this._isReactNativeWebrtc = typeof this._pc._peerConnectionId === 'number'\n\n    this._pc.oniceconnectionstatechange = () => {\n      this._onIceStateChange()\n    }\n    this._pc.onicegatheringstatechange = () => {\n      this._onIceStateChange()\n    }\n    this._pc.onconnectionstatechange = () => {\n      this._onConnectionStateChange()\n    }\n    this._pc.onsignalingstatechange = () => {\n      this._onSignalingStateChange()\n    }\n    this._pc.onicecandidate = event => {\n      this._onIceCandidate(event)\n    }\n\n    // HACK: Fix for odd Firefox behavior, see: https://github.com/feross/simple-peer/pull/783\n    if (typeof this._pc.peerIdentity === 'object') {\n      this._pc.peerIdentity.catch(err => {\n        this.destroy(errCode(err, 'ERR_PC_PEER_IDENTITY'))\n      })\n    }\n\n    // Other spec events, unused by this implementation:\n    // - onconnectionstatechange\n    // - onicecandidateerror\n    // - onfingerprintfailure\n    // - onnegotiationneeded\n\n    if (this.initiator || this.channelNegotiated) {\n      this._setupData({\n        channel: this._pc.createDataChannel(this.channelName, this.channelConfig)\n      })\n    } else {\n      this._pc.ondatachannel = event => {\n        this._setupData(event)\n      }\n    }\n\n    if (this.streams) {\n      this.streams.forEach(stream => {\n        this.addStream(stream)\n      })\n    }\n    this._pc.ontrack = event => {\n      this._onTrack(event)\n    }\n\n    this._debug('initial negotiation')\n    this._needsNegotiation()\n\n    this._onFinishBound = () => {\n      this._onFinish()\n    }\n    this.once('finish', this._onFinishBound)\n  }\n\n  get bufferSize () {\n    return (this._channel && this._channel.bufferedAmount) || 0\n  }\n\n  // HACK: it's possible channel.readyState is \"closing\" before peer.destroy() fires\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=882743\n  get connected () {\n    return (this._connected && this._channel.readyState === 'open')\n  }\n\n  address () {\n    return { port: this.localPort, family: this.localFamily, address: this.localAddress }\n  }\n\n  signal (data) {\n    if (this.destroying) return\n    if (this.destroyed) throw errCode(new Error('cannot signal after peer is destroyed'), 'ERR_DESTROYED')\n    if (typeof data === 'string') {\n      try {\n        data = JSON.parse(data)\n      } catch (err) {\n        data = {}\n      }\n    }\n    this._debug('signal()')\n\n    if (data.renegotiate && this.initiator) {\n      this._debug('got request to renegotiate')\n      this._needsNegotiation()\n    }\n    if (data.transceiverRequest && this.initiator) {\n      this._debug('got request for transceiver')\n      this.addTransceiver(data.transceiverRequest.kind, data.transceiverRequest.init)\n    }\n    if (data.candidate) {\n      if (this._pc.remoteDescription && this._pc.remoteDescription.type) {\n        this._addIceCandidate(data.candidate)\n      } else {\n        this._pendingCandidates.push(data.candidate)\n      }\n    }\n    if (data.sdp) {\n      this._pc.setRemoteDescription(new (this._wrtc.RTCSessionDescription)(data))\n        .then(() => {\n          if (this.destroyed) return\n\n          this._pendingCandidates.forEach(candidate => {\n            this._addIceCandidate(candidate)\n          })\n          this._pendingCandidates = []\n\n          if (this._pc.remoteDescription.type === 'offer') this._createAnswer()\n        })\n        .catch(err => {\n          this.destroy(errCode(err, 'ERR_SET_REMOTE_DESCRIPTION'))\n        })\n    }\n    if (!data.sdp && !data.candidate && !data.renegotiate && !data.transceiverRequest) {\n      this.destroy(errCode(new Error('signal() called with invalid signal data'), 'ERR_SIGNALING'))\n    }\n  }\n\n  _addIceCandidate (candidate) {\n    const iceCandidateObj = new this._wrtc.RTCIceCandidate(candidate)\n    this._pc.addIceCandidate(iceCandidateObj)\n      .catch(err => {\n        if (!iceCandidateObj.address || iceCandidateObj.address.endsWith('.local')) {\n          warn('Ignoring unsupported ICE candidate.')\n        } else {\n          this.destroy(errCode(err, 'ERR_ADD_ICE_CANDIDATE'))\n        }\n      })\n  }\n\n  /**\n   * Send text/binary data to the remote peer.\n   * @param {ArrayBufferView|ArrayBuffer|Buffer|string|Blob} chunk\n   */\n  send (chunk) {\n    if (this.destroying) return\n    if (this.destroyed) throw errCode(new Error('cannot send after peer is destroyed'), 'ERR_DESTROYED')\n    this._channel.send(chunk)\n  }\n\n  /**\n   * Add a Transceiver to the connection.\n   * @param {String} kind\n   * @param {Object} init\n   */\n  addTransceiver (kind, init) {\n    if (this.destroying) return\n    if (this.destroyed) throw errCode(new Error('cannot addTransceiver after peer is destroyed'), 'ERR_DESTROYED')\n    this._debug('addTransceiver()')\n\n    if (this.initiator) {\n      try {\n        this._pc.addTransceiver(kind, init)\n        this._needsNegotiation()\n      } catch (err) {\n        this.destroy(errCode(err, 'ERR_ADD_TRANSCEIVER'))\n      }\n    } else {\n      this.emit('signal', { // request initiator to renegotiate\n        type: 'transceiverRequest',\n        transceiverRequest: { kind, init }\n      })\n    }\n  }\n\n  /**\n   * Add a MediaStream to the connection.\n   * @param {MediaStream} stream\n   */\n  addStream (stream) {\n    if (this.destroying) return\n    if (this.destroyed) throw errCode(new Error('cannot addStream after peer is destroyed'), 'ERR_DESTROYED')\n    this._debug('addStream()')\n\n    stream.getTracks().forEach(track => {\n      this.addTrack(track, stream)\n    })\n  }\n\n  /**\n   * Add a MediaStreamTrack to the connection.\n   * @param {MediaStreamTrack} track\n   * @param {MediaStream} stream\n   */\n  addTrack (track, stream) {\n    if (this.destroying) return\n    if (this.destroyed) throw errCode(new Error('cannot addTrack after peer is destroyed'), 'ERR_DESTROYED')\n    this._debug('addTrack()')\n\n    const submap = this._senderMap.get(track) || new Map() // nested Maps map [track, stream] to sender\n    let sender = submap.get(stream)\n    if (!sender) {\n      sender = this._pc.addTrack(track, stream)\n      submap.set(stream, sender)\n      this._senderMap.set(track, submap)\n      this._needsNegotiation()\n    } else if (sender.removed) {\n      throw errCode(new Error('Track has been removed. You should enable/disable tracks that you want to re-add.'), 'ERR_SENDER_REMOVED')\n    } else {\n      throw errCode(new Error('Track has already been added to that stream.'), 'ERR_SENDER_ALREADY_ADDED')\n    }\n  }\n\n  /**\n   * Replace a MediaStreamTrack by another in the connection.\n   * @param {MediaStreamTrack} oldTrack\n   * @param {MediaStreamTrack} newTrack\n   * @param {MediaStream} stream\n   */\n  replaceTrack (oldTrack, newTrack, stream) {\n    if (this.destroying) return\n    if (this.destroyed) throw errCode(new Error('cannot replaceTrack after peer is destroyed'), 'ERR_DESTROYED')\n    this._debug('replaceTrack()')\n\n    const submap = this._senderMap.get(oldTrack)\n    const sender = submap ? submap.get(stream) : null\n    if (!sender) {\n      throw errCode(new Error('Cannot replace track that was never added.'), 'ERR_TRACK_NOT_ADDED')\n    }\n    if (newTrack) this._senderMap.set(newTrack, submap)\n\n    if (sender.replaceTrack != null) {\n      sender.replaceTrack(newTrack)\n    } else {\n      this.destroy(errCode(new Error('replaceTrack is not supported in this browser'), 'ERR_UNSUPPORTED_REPLACETRACK'))\n    }\n  }\n\n  /**\n   * Remove a MediaStreamTrack from the connection.\n   * @param {MediaStreamTrack} track\n   * @param {MediaStream} stream\n   */\n  removeTrack (track, stream) {\n    if (this.destroying) return\n    if (this.destroyed) throw errCode(new Error('cannot removeTrack after peer is destroyed'), 'ERR_DESTROYED')\n    this._debug('removeSender()')\n\n    const submap = this._senderMap.get(track)\n    const sender = submap ? submap.get(stream) : null\n    if (!sender) {\n      throw errCode(new Error('Cannot remove track that was never added.'), 'ERR_TRACK_NOT_ADDED')\n    }\n    try {\n      sender.removed = true\n      this._pc.removeTrack(sender)\n    } catch (err) {\n      if (err.name === 'NS_ERROR_UNEXPECTED') {\n        this._sendersAwaitingStable.push(sender) // HACK: Firefox must wait until (signalingState === stable) https://bugzilla.mozilla.org/show_bug.cgi?id=1133874\n      } else {\n        this.destroy(errCode(err, 'ERR_REMOVE_TRACK'))\n      }\n    }\n    this._needsNegotiation()\n  }\n\n  /**\n   * Remove a MediaStream from the connection.\n   * @param {MediaStream} stream\n   */\n  removeStream (stream) {\n    if (this.destroying) return\n    if (this.destroyed) throw errCode(new Error('cannot removeStream after peer is destroyed'), 'ERR_DESTROYED')\n    this._debug('removeSenders()')\n\n    stream.getTracks().forEach(track => {\n      this.removeTrack(track, stream)\n    })\n  }\n\n  _needsNegotiation () {\n    this._debug('_needsNegotiation')\n    if (this._batchedNegotiation) return // batch synchronous renegotiations\n    this._batchedNegotiation = true\n    queueMicrotask(() => {\n      this._batchedNegotiation = false\n      if (this.initiator || !this._firstNegotiation) {\n        this._debug('starting batched negotiation')\n        this.negotiate()\n      } else {\n        this._debug('non-initiator initial negotiation request discarded')\n      }\n      this._firstNegotiation = false\n    })\n  }\n\n  negotiate () {\n    if (this.destroying) return\n    if (this.destroyed) throw errCode(new Error('cannot negotiate after peer is destroyed'), 'ERR_DESTROYED')\n\n    if (this.initiator) {\n      if (this._isNegotiating) {\n        this._queuedNegotiation = true\n        this._debug('already negotiating, queueing')\n      } else {\n        this._debug('start negotiation')\n        setTimeout(() => { // HACK: Chrome crashes if we immediately call createOffer\n          this._createOffer()\n        }, 0)\n      }\n    } else {\n      if (this._isNegotiating) {\n        this._queuedNegotiation = true\n        this._debug('already negotiating, queueing')\n      } else {\n        this._debug('requesting negotiation from initiator')\n        this.emit('signal', { // request initiator to renegotiate\n          type: 'renegotiate',\n          renegotiate: true\n        })\n      }\n    }\n    this._isNegotiating = true\n  }\n\n  // TODO: Delete this method once readable-stream is updated to contain a default\n  // implementation of destroy() that automatically calls _destroy()\n  // See: https://github.com/nodejs/readable-stream/issues/283\n  destroy (err) {\n    this._destroy(err, () => {})\n  }\n\n  _destroy (err, cb) {\n    if (this.destroyed || this.destroying) return\n    this.destroying = true\n\n    this._debug('destroying (error: %s)', err && (err.message || err))\n\n    queueMicrotask(() => { // allow events concurrent with the call to _destroy() to fire (see #692)\n      this.destroyed = true\n      this.destroying = false\n\n      this._debug('destroy (error: %s)', err && (err.message || err))\n\n      this.readable = this.writable = false\n\n      if (!this._readableState.ended) this.push(null)\n      if (!this._writableState.finished) this.end()\n\n      this._connected = false\n      this._pcReady = false\n      this._channelReady = false\n      this._remoteTracks = null\n      this._remoteStreams = null\n      this._senderMap = null\n\n      clearInterval(this._closingInterval)\n      this._closingInterval = null\n\n      clearInterval(this._interval)\n      this._interval = null\n      this._chunk = null\n      this._cb = null\n\n      if (this._onFinishBound) this.removeListener('finish', this._onFinishBound)\n      this._onFinishBound = null\n\n      if (this._channel) {\n        try {\n          this._channel.close()\n        } catch (err) {}\n\n        // allow events concurrent with destruction to be handled\n        this._channel.onmessage = null\n        this._channel.onopen = null\n        this._channel.onclose = null\n        this._channel.onerror = null\n      }\n      if (this._pc) {\n        try {\n          this._pc.close()\n        } catch (err) {}\n\n        // allow events concurrent with destruction to be handled\n        this._pc.oniceconnectionstatechange = null\n        this._pc.onicegatheringstatechange = null\n        this._pc.onsignalingstatechange = null\n        this._pc.onicecandidate = null\n        this._pc.ontrack = null\n        this._pc.ondatachannel = null\n      }\n      this._pc = null\n      this._channel = null\n\n      if (err) this.emit('error', err)\n      this.emit('close')\n      cb()\n    })\n  }\n\n  _setupData (event) {\n    if (!event.channel) {\n      // In some situations `pc.createDataChannel()` returns `undefined` (in wrtc),\n      // which is invalid behavior. Handle it gracefully.\n      // See: https://github.com/feross/simple-peer/issues/163\n      return this.destroy(errCode(new Error('Data channel event is missing `channel` property'), 'ERR_DATA_CHANNEL'))\n    }\n\n    this._channel = event.channel\n    this._channel.binaryType = 'arraybuffer'\n\n    if (typeof this._channel.bufferedAmountLowThreshold === 'number') {\n      this._channel.bufferedAmountLowThreshold = MAX_BUFFERED_AMOUNT\n    }\n\n    this.channelName = this._channel.label\n\n    this._channel.onmessage = event => {\n      this._onChannelMessage(event)\n    }\n    this._channel.onbufferedamountlow = () => {\n      this._onChannelBufferedAmountLow()\n    }\n    this._channel.onopen = () => {\n      this._onChannelOpen()\n    }\n    this._channel.onclose = () => {\n      this._onChannelClose()\n    }\n    this._channel.onerror = err => {\n      this.destroy(errCode(err, 'ERR_DATA_CHANNEL'))\n    }\n\n    // HACK: Chrome will sometimes get stuck in readyState \"closing\", let's check for this condition\n    // https://bugs.chromium.org/p/chromium/issues/detail?id=882743\n    let isClosing = false\n    this._closingInterval = setInterval(() => { // No \"onclosing\" event\n      if (this._channel && this._channel.readyState === 'closing') {\n        if (isClosing) this._onChannelClose() // closing timed out: equivalent to onclose firing\n        isClosing = true\n      } else {\n        isClosing = false\n      }\n    }, CHANNEL_CLOSING_TIMEOUT)\n  }\n\n  _read () {}\n\n  _write (chunk, encoding, cb) {\n    if (this.destroyed) return cb(errCode(new Error('cannot write after peer is destroyed'), 'ERR_DATA_CHANNEL'))\n\n    if (this._connected) {\n      try {\n        this.send(chunk)\n      } catch (err) {\n        return this.destroy(errCode(err, 'ERR_DATA_CHANNEL'))\n      }\n      if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {\n        this._debug('start backpressure: bufferedAmount %d', this._channel.bufferedAmount)\n        this._cb = cb\n      } else {\n        cb(null)\n      }\n    } else {\n      this._debug('write before connect')\n      this._chunk = chunk\n      this._cb = cb\n    }\n  }\n\n  // When stream finishes writing, close socket. Half open connections are not\n  // supported.\n  _onFinish () {\n    if (this.destroyed) return\n\n    // Wait a bit before destroying so the socket flushes.\n    // TODO: is there a more reliable way to accomplish this?\n    const destroySoon = () => {\n      setTimeout(() => this.destroy(), 1000)\n    }\n\n    if (this._connected) {\n      destroySoon()\n    } else {\n      this.once('connect', destroySoon)\n    }\n  }\n\n  _startIceCompleteTimeout () {\n    if (this.destroyed) return\n    if (this._iceCompleteTimer) return\n    this._debug('started iceComplete timeout')\n    this._iceCompleteTimer = setTimeout(() => {\n      if (!this._iceComplete) {\n        this._iceComplete = true\n        this._debug('iceComplete timeout completed')\n        this.emit('iceTimeout')\n        this.emit('_iceComplete')\n      }\n    }, this.iceCompleteTimeout)\n  }\n\n  _createOffer () {\n    if (this.destroyed) return\n\n    this._pc.createOffer(this.offerOptions)\n      .then(offer => {\n        if (this.destroyed) return\n        if (!this.trickle && !this.allowHalfTrickle) offer.sdp = filterTrickle(offer.sdp)\n        offer.sdp = this.sdpTransform(offer.sdp)\n\n        const sendOffer = () => {\n          if (this.destroyed) return\n          const signal = this._pc.localDescription || offer\n          this._debug('signal')\n          this.emit('signal', {\n            type: signal.type,\n            sdp: signal.sdp\n          })\n        }\n\n        const onSuccess = () => {\n          this._debug('createOffer success')\n          if (this.destroyed) return\n          if (this.trickle || this._iceComplete) sendOffer()\n          else this.once('_iceComplete', sendOffer) // wait for candidates\n        }\n\n        const onError = err => {\n          this.destroy(errCode(err, 'ERR_SET_LOCAL_DESCRIPTION'))\n        }\n\n        this._pc.setLocalDescription(offer)\n          .then(onSuccess)\n          .catch(onError)\n      })\n      .catch(err => {\n        this.destroy(errCode(err, 'ERR_CREATE_OFFER'))\n      })\n  }\n\n  _requestMissingTransceivers () {\n    if (this._pc.getTransceivers) {\n      this._pc.getTransceivers().forEach(transceiver => {\n        if (!transceiver.mid && transceiver.sender.track && !transceiver.requested) {\n          transceiver.requested = true // HACK: Safari returns negotiated transceivers with a null mid\n          this.addTransceiver(transceiver.sender.track.kind)\n        }\n      })\n    }\n  }\n\n  _createAnswer () {\n    if (this.destroyed) return\n\n    this._pc.createAnswer(this.answerOptions)\n      .then(answer => {\n        if (this.destroyed) return\n        if (!this.trickle && !this.allowHalfTrickle) answer.sdp = filterTrickle(answer.sdp)\n        answer.sdp = this.sdpTransform(answer.sdp)\n\n        const sendAnswer = () => {\n          if (this.destroyed) return\n          const signal = this._pc.localDescription || answer\n          this._debug('signal')\n          this.emit('signal', {\n            type: signal.type,\n            sdp: signal.sdp\n          })\n          if (!this.initiator) this._requestMissingTransceivers()\n        }\n\n        const onSuccess = () => {\n          if (this.destroyed) return\n          if (this.trickle || this._iceComplete) sendAnswer()\n          else this.once('_iceComplete', sendAnswer)\n        }\n\n        const onError = err => {\n          this.destroy(errCode(err, 'ERR_SET_LOCAL_DESCRIPTION'))\n        }\n\n        this._pc.setLocalDescription(answer)\n          .then(onSuccess)\n          .catch(onError)\n      })\n      .catch(err => {\n        this.destroy(errCode(err, 'ERR_CREATE_ANSWER'))\n      })\n  }\n\n  _onConnectionStateChange () {\n    if (this.destroyed) return\n    if (this._pc.connectionState === 'failed') {\n      this.destroy(errCode(new Error('Connection failed.'), 'ERR_CONNECTION_FAILURE'))\n    }\n  }\n\n  _onIceStateChange () {\n    if (this.destroyed) return\n    const iceConnectionState = this._pc.iceConnectionState\n    const iceGatheringState = this._pc.iceGatheringState\n\n    this._debug(\n      'iceStateChange (connection: %s) (gathering: %s)',\n      iceConnectionState,\n      iceGatheringState\n    )\n    this.emit('iceStateChange', iceConnectionState, iceGatheringState)\n\n    if (iceConnectionState === 'connected' || iceConnectionState === 'completed') {\n      this._pcReady = true\n      this._maybeReady()\n    }\n    if (iceConnectionState === 'failed') {\n      this.destroy(errCode(new Error('Ice connection failed.'), 'ERR_ICE_CONNECTION_FAILURE'))\n    }\n    if (iceConnectionState === 'closed') {\n      this.destroy(errCode(new Error('Ice connection closed.'), 'ERR_ICE_CONNECTION_CLOSED'))\n    }\n  }\n\n  getStats (cb) {\n    // statreports can come with a value array instead of properties\n    const flattenValues = report => {\n      if (Object.prototype.toString.call(report.values) === '[object Array]') {\n        report.values.forEach(value => {\n          Object.assign(report, value)\n        })\n      }\n      return report\n    }\n\n    // Promise-based getStats() (standard)\n    if (this._pc.getStats.length === 0 || this._isReactNativeWebrtc) {\n      this._pc.getStats()\n        .then(res => {\n          const reports = []\n          res.forEach(report => {\n            reports.push(flattenValues(report))\n          })\n          cb(null, reports)\n        }, err => cb(err))\n\n    // Single-parameter callback-based getStats() (non-standard)\n    } else if (this._pc.getStats.length > 0) {\n      this._pc.getStats(res => {\n        // If we destroy connection in `connect` callback this code might happen to run when actual connection is already closed\n        if (this.destroyed) return\n\n        const reports = []\n        res.result().forEach(result => {\n          const report = {}\n          result.names().forEach(name => {\n            report[name] = result.stat(name)\n          })\n          report.id = result.id\n          report.type = result.type\n          report.timestamp = result.timestamp\n          reports.push(flattenValues(report))\n        })\n        cb(null, reports)\n      }, err => cb(err))\n\n    // Unknown browser, skip getStats() since it's anyone's guess which style of\n    // getStats() they implement.\n    } else {\n      cb(null, [])\n    }\n  }\n\n  _maybeReady () {\n    this._debug('maybeReady pc %s channel %s', this._pcReady, this._channelReady)\n    if (this._connected || this._connecting || !this._pcReady || !this._channelReady) return\n\n    this._connecting = true\n\n    // HACK: We can't rely on order here, for details see https://github.com/js-platform/node-webrtc/issues/339\n    const findCandidatePair = () => {\n      if (this.destroyed) return\n\n      this.getStats((err, items) => {\n        if (this.destroyed) return\n\n        // Treat getStats error as non-fatal. It's not essential.\n        if (err) items = []\n\n        const remoteCandidates = {}\n        const localCandidates = {}\n        const candidatePairs = {}\n        let foundSelectedCandidatePair = false\n\n        items.forEach(item => {\n          // TODO: Once all browsers support the hyphenated stats report types, remove\n          // the non-hypenated ones\n          if (item.type === 'remotecandidate' || item.type === 'remote-candidate') {\n            remoteCandidates[item.id] = item\n          }\n          if (item.type === 'localcandidate' || item.type === 'local-candidate') {\n            localCandidates[item.id] = item\n          }\n          if (item.type === 'candidatepair' || item.type === 'candidate-pair') {\n            candidatePairs[item.id] = item\n          }\n        })\n\n        const setSelectedCandidatePair = selectedCandidatePair => {\n          foundSelectedCandidatePair = true\n\n          let local = localCandidates[selectedCandidatePair.localCandidateId]\n\n          if (local && (local.ip || local.address)) {\n            // Spec\n            this.localAddress = local.ip || local.address\n            this.localPort = Number(local.port)\n          } else if (local && local.ipAddress) {\n            // Firefox\n            this.localAddress = local.ipAddress\n            this.localPort = Number(local.portNumber)\n          } else if (typeof selectedCandidatePair.googLocalAddress === 'string') {\n            // TODO: remove this once Chrome 58 is released\n            local = selectedCandidatePair.googLocalAddress.split(':')\n            this.localAddress = local[0]\n            this.localPort = Number(local[1])\n          }\n          if (this.localAddress) {\n            this.localFamily = this.localAddress.includes(':') ? 'IPv6' : 'IPv4'\n          }\n\n          let remote = remoteCandidates[selectedCandidatePair.remoteCandidateId]\n\n          if (remote && (remote.ip || remote.address)) {\n            // Spec\n            this.remoteAddress = remote.ip || remote.address\n            this.remotePort = Number(remote.port)\n          } else if (remote && remote.ipAddress) {\n            // Firefox\n            this.remoteAddress = remote.ipAddress\n            this.remotePort = Number(remote.portNumber)\n          } else if (typeof selectedCandidatePair.googRemoteAddress === 'string') {\n            // TODO: remove this once Chrome 58 is released\n            remote = selectedCandidatePair.googRemoteAddress.split(':')\n            this.remoteAddress = remote[0]\n            this.remotePort = Number(remote[1])\n          }\n          if (this.remoteAddress) {\n            this.remoteFamily = this.remoteAddress.includes(':') ? 'IPv6' : 'IPv4'\n          }\n\n          this._debug(\n            'connect local: %s:%s remote: %s:%s',\n            this.localAddress,\n            this.localPort,\n            this.remoteAddress,\n            this.remotePort\n          )\n        }\n\n        items.forEach(item => {\n          // Spec-compliant\n          if (item.type === 'transport' && item.selectedCandidatePairId) {\n            setSelectedCandidatePair(candidatePairs[item.selectedCandidatePairId])\n          }\n\n          // Old implementations\n          if (\n            (item.type === 'googCandidatePair' && item.googActiveConnection === 'true') ||\n            ((item.type === 'candidatepair' || item.type === 'candidate-pair') && item.selected)\n          ) {\n            setSelectedCandidatePair(item)\n          }\n        })\n\n        // Ignore candidate pair selection in browsers like Safari 11 that do not have any local or remote candidates\n        // But wait until at least 1 candidate pair is available\n        if (!foundSelectedCandidatePair && (!Object.keys(candidatePairs).length || Object.keys(localCandidates).length)) {\n          setTimeout(findCandidatePair, 100)\n          return\n        } else {\n          this._connecting = false\n          this._connected = true\n        }\n\n        if (this._chunk) {\n          try {\n            this.send(this._chunk)\n          } catch (err) {\n            return this.destroy(errCode(err, 'ERR_DATA_CHANNEL'))\n          }\n          this._chunk = null\n          this._debug('sent chunk from \"write before connect\"')\n\n          const cb = this._cb\n          this._cb = null\n          cb(null)\n        }\n\n        // If `bufferedAmountLowThreshold` and 'onbufferedamountlow' are unsupported,\n        // fallback to using setInterval to implement backpressure.\n        if (typeof this._channel.bufferedAmountLowThreshold !== 'number') {\n          this._interval = setInterval(() => this._onInterval(), 150)\n          if (this._interval.unref) this._interval.unref()\n        }\n\n        this._debug('connect')\n        this.emit('connect')\n      })\n    }\n    findCandidatePair()\n  }\n\n  _onInterval () {\n    if (!this._cb || !this._channel || this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {\n      return\n    }\n    this._onChannelBufferedAmountLow()\n  }\n\n  _onSignalingStateChange () {\n    if (this.destroyed) return\n\n    if (this._pc.signalingState === 'stable') {\n      this._isNegotiating = false\n\n      // HACK: Firefox doesn't yet support removing tracks when signalingState !== 'stable'\n      this._debug('flushing sender queue', this._sendersAwaitingStable)\n      this._sendersAwaitingStable.forEach(sender => {\n        this._pc.removeTrack(sender)\n        this._queuedNegotiation = true\n      })\n      this._sendersAwaitingStable = []\n\n      if (this._queuedNegotiation) {\n        this._debug('flushing negotiation queue')\n        this._queuedNegotiation = false\n        this._needsNegotiation() // negotiate again\n      } else {\n        this._debug('negotiated')\n        this.emit('negotiated')\n      }\n    }\n\n    this._debug('signalingStateChange %s', this._pc.signalingState)\n    this.emit('signalingStateChange', this._pc.signalingState)\n  }\n\n  _onIceCandidate (event) {\n    if (this.destroyed) return\n    if (event.candidate && this.trickle) {\n      this.emit('signal', {\n        type: 'candidate',\n        candidate: {\n          candidate: event.candidate.candidate,\n          sdpMLineIndex: event.candidate.sdpMLineIndex,\n          sdpMid: event.candidate.sdpMid\n        }\n      })\n    } else if (!event.candidate && !this._iceComplete) {\n      this._iceComplete = true\n      this.emit('_iceComplete')\n    }\n    // as soon as we've received one valid candidate start timeout\n    if (event.candidate) {\n      this._startIceCompleteTimeout()\n    }\n  }\n\n  _onChannelMessage (event) {\n    if (this.destroyed) return\n    let data = event.data\n    if (data instanceof ArrayBuffer) data = Buffer.from(data)\n    this.push(data)\n  }\n\n  _onChannelBufferedAmountLow () {\n    if (this.destroyed || !this._cb) return\n    this._debug('ending backpressure: bufferedAmount %d', this._channel.bufferedAmount)\n    const cb = this._cb\n    this._cb = null\n    cb(null)\n  }\n\n  _onChannelOpen () {\n    if (this._connected || this.destroyed) return\n    this._debug('on channel open')\n    this._channelReady = true\n    this._maybeReady()\n  }\n\n  _onChannelClose () {\n    if (this.destroyed) return\n    this._debug('on channel close')\n    this.destroy()\n  }\n\n  _onTrack (event) {\n    if (this.destroyed) return\n\n    event.streams.forEach(eventStream => {\n      this._debug('on track')\n      this.emit('track', event.track, eventStream)\n\n      this._remoteTracks.push({\n        track: event.track,\n        stream: eventStream\n      })\n\n      if (this._remoteStreams.some(remoteStream => {\n        return remoteStream.id === eventStream.id\n      })) return // Only fire one 'stream' event, even though there may be multiple tracks per stream\n\n      this._remoteStreams.push(eventStream)\n      queueMicrotask(() => {\n        this._debug('on stream')\n        this.emit('stream', eventStream) // ensure all tracks have been added\n      })\n    })\n  }\n\n  _debug () {\n    const args = [].slice.call(arguments)\n    args[0] = '[' + this._id + '] ' + args[0]\n    debug.apply(null, args)\n  }\n}\n\nPeer.WEBRTC_SUPPORT = !!getBrowserRTC()\n\n/**\n * Expose peer and data channel config for overriding all Peer\n * instances. Otherwise, just set opts.config or opts.channelConfig\n * when constructing a Peer.\n */\nPeer.config = {\n  iceServers: [\n    {\n      urls: [\n        'stun:stun.l.google.com:19302',\n        'stun:global.stun.twilio.com:3478'\n      ]\n    }\n  ],\n  sdpSemantics: 'unified-plan'\n}\n\nPeer.channelConfig = {}\n\nmodule.exports = Peer\n","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\n\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    callback.apply(this, args);\n  };\n}\n\nfunction noop() {}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\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\n  var onlegacyfinish = function onlegacyfinish() {\n    if (!stream.writable) onfinish();\n  };\n\n  var writableEnded = stream._writableState && stream._writableState.finished;\n\n  var onfinish = function onfinish() {\n    writable = false;\n    writableEnded = true;\n    if (!readable) callback.call(stream);\n  };\n\n  var readableEnded = stream._readableState && stream._readableState.endEmitted;\n\n  var onend = function onend() {\n    readable = false;\n    readableEnded = true;\n    if (!writable) callback.call(stream);\n  };\n\n  var onerror = function onerror(err) {\n    callback.call(stream, err);\n  };\n\n  var onclose = function onclose() {\n    var err;\n\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\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\n  var onrequest = function onrequest() {\n    stream.req.on('finish', onfinish);\n  };\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\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}\n\nmodule.exports = eos;","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\n\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    callback.apply(this, args);\n  };\n}\n\nfunction noop() {}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\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\n  var onlegacyfinish = function onlegacyfinish() {\n    if (!stream.writable) onfinish();\n  };\n\n  var writableEnded = stream._writableState && stream._writableState.finished;\n\n  var onfinish = function onfinish() {\n    writable = false;\n    writableEnded = true;\n    if (!readable) callback.call(stream);\n  };\n\n  var readableEnded = stream._readableState && stream._readableState.endEmitted;\n\n  var onend = function onend() {\n    readable = false;\n    readableEnded = true;\n    if (!writable) callback.call(stream);\n  };\n\n  var onerror = function onerror(err) {\n    callback.call(stream, err);\n  };\n\n  var onclose = function onclose() {\n    var err;\n\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\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\n  var onrequest = function onrequest() {\n    stream.req.on('finish', onfinish);\n  };\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\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}\n\nmodule.exports = eos;","// 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'use strict';\n\nmodule.exports = Readable;\n/*<replacement>*/\n\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n/*<replacement>*/\n\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*<replacement>*/\n\n\nvar debugUtil = require('util');\n\nvar debug;\n\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\n\nvar BufferList = require('./internal/streams/buffer_list');\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\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; // Lazy loaded to improve the startup performance.\n\n\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\n\nrequire('inherits')(Readable, Stream);\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\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); // 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\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}\n\nfunction ReadableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // 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\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // 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\n  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // 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\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; // 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\n  this.sync = true; // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n  this.paused = true; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')\n\n  this.autoDestroy = !!options.autoDestroy; // has it been destroyed\n\n  this.destroyed = false; // 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\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s\n\n  this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled\n\n  this.readingMore = false;\n  this.decoder = null;\n  this.encoding = null;\n\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  if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  this._readableState = new ReadableState(options, this, isDuplex); // legacy\n\n  this.readable = true;\n\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\n  Stream.call(this);\n}\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\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    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n  }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\n\nReadable.prototype._destroy = function (err, cb) {\n  cb(err);\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.\n\n\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\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n}; // Unshift should *always* be something directly out of read()\n\n\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  debug('readableAddChunk', chunk);\n  var state = stream._readableState;\n\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\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\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\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  } // 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\n\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\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\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n\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\n  return er;\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n}; // backwards compatibility.\n\n\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  var decoder = new StringDecoder(enc);\n  this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8\n\n  this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:\n\n  var p = this._readableState.buffer.head;\n  var content = '';\n\n  while (p !== null) {\n    content += decoder.write(p.data);\n    p = p.next;\n  }\n\n  this._readableState.buffer.clear();\n\n  if (content !== '') this._readableState.buffer.push(content);\n  this._readableState.length = content.length;\n  return this;\n}; // Don't raise the hwm > 1GB\n\n\nvar MAX_HWM = 0x40000000;\n\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\n  return n;\n} // This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\n\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n\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  } // If we're asking for more than the current hwm, then raise the hwm.\n\n\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n; // Don't have enough\n\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n\n  return state.length;\n} // you can override either this method, or the async _read(n) below.\n\n\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; // 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\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  n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.\n\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\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  // if we need a readable event, then we need to do some reading.\n\n\n  var doRead = state.needReadable;\n  debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some\n\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  } // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n\n\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; // if the length is currently zero, then we *need* a readable event.\n\n    if (state.length === 0) state.needReadable = true; // call internal read method\n\n    this._read(state.highWaterMark);\n\n    state.sync = false; // 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\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 = state.length <= state.highWaterMark;\n    n = 0;\n  } else {\n    state.length -= n;\n    state.awaitDrain = 0;\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; // If we tried to read() past the EOF, then emit end on the next tick.\n\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk');\n  if (state.ended) return;\n\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n\n  state.ended = true;\n\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\n    if (!state.emittedReadable) {\n      state.emittedReadable = true;\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.\n\n\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  debug('emitReadable', state.needReadable, state.emittedReadable);\n  state.needReadable = false;\n\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    process.nextTick(emitReadable_, stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  var state = stream._readableState;\n  debug('emitReadable_', state.destroyed, state.length, state.ended);\n\n  if (!state.destroyed && (state.length || state.ended)) {\n    stream.emit('readable');\n    state.emittedReadable = false;\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\n\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n  flow(stream);\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.\n\n\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(maybeReadMore_, stream, state);\n  }\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) // didn't get any data, stop spinning.\n      break;\n  }\n\n  state.readingMore = false;\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.\n\n\nReadable.prototype._read = function (n) {\n  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\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\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n\n    default:\n      state.pipes.push(dest);\n      break;\n  }\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\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n\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  } // 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\n\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n  var cleanedUp = false;\n\n  function cleanup() {\n    debug('cleanup'); // cleanup event handlers once the pipe is broken\n\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; // 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\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  src.on('data', ondata);\n\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    debug('dest.write', ret);\n\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\n      src.pause();\n    }\n  } // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n\n\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  } // Make sure our error handler is attached before userland ones.\n\n\n  prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.\n\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n\n  dest.once('close', onclose);\n\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  } // tell the dest that it's being piped to\n\n\n  dest.emit('pipe', src); // start the flow if it hasn't been started already.\n\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\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\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 = {\n    hasUnpiped: false\n  }; // if we're not piping anywhere, then do nothing.\n\n  if (state.pipesCount === 0) return this; // just one destination.  most common case.\n\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; // got a match.\n\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  } // slow case. multiple pipe destinations.\n\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, {\n        hasUnpiped: false\n      });\n    }\n\n    return this;\n  } // try to find the right one.\n\n\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}; // set up data events if they are asked for\n// Ensure readable listeners eventually get something\n\n\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n  var state = this._readableState;\n\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; // Try start flowing on next tick if stream isn't explicitly paused\n\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\n      if (state.length) {\n        emitReadable(this);\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this);\n      }\n    }\n  }\n\n  return res;\n};\n\nReadable.prototype.addListener = Readable.prototype.on;\n\nReadable.prototype.removeListener = function (ev, fn) {\n  var res = Stream.prototype.removeListener.call(this, ev, fn);\n\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\n  return res;\n};\n\nReadable.prototype.removeAllListeners = function (ev) {\n  var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n\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\n  return res;\n};\n\nfunction updateReadableListening(self) {\n  var state = self._readableState;\n  state.readableListening = self.listenerCount('readable') > 0;\n\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; // crude way to check if we should resume\n  } else if (self.listenerCount('data') > 0) {\n    self.resume();\n  }\n}\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n} // pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\n\n\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n\n  if (!state.flowing) {\n    debug('resume'); // we flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume()\n\n    state.flowing = !state.readableListening;\n    resume(this, state);\n  }\n\n  state.paused = false;\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  debug('resume', state.reading);\n\n  if (!state.reading) {\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\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\n  if (this._readableState.flowing !== false) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n\n  this._readableState.paused = true;\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n\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.\n\n\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n  stream.on('end', function () {\n    debug('wrapped end');\n\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  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode\n\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\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  }); // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n\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  } // proxy certain important events.\n\n\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  } // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n\n\n  this._read = function (n) {\n    debug('wrapped _read', n);\n\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nif (typeof Symbol === 'function') {\n  Readable.prototype[Symbol.asyncIterator] = function () {\n    if (createReadableStreamAsyncIterator === undefined) {\n      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n    }\n\n    return createReadableStreamAsyncIterator(this);\n  };\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}); // exposed for testing purposes only.\n\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}); // 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.\n\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}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n  debug('endReadable', state.endEmitted);\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.\n\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n\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\n      if (!wState || wState.autoDestroy && wState.finished) {\n        stream.destroy();\n      }\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\n    return from(Readable, iterable, opts);\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\n  return -1;\n}","module.exports = require('events').EventEmitter;\n","'use strict'; // undocumented cb() API, needed for core, not for public API\n\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) {\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\n    return this;\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\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  } // if this is a duplex stream mark the writable part as destroyed as well\n\n\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\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\n  return this;\n}\n\nfunction emitErrorAndCloseNT(self, err) {\n  emitErrorNT(self, err);\n  emitCloseNT(self);\n}\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}\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.finalCalled = false;\n    this._writableState.prefinished = 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\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  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}\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;\n\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\n\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n\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\n    return Math.floor(hwm);\n  } // Default value\n\n\n  return state.objectMode ? 16 : 16 * 1024;\n}\n\nmodule.exports = {\n  getHighWaterMark: getHighWaterMark\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// 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'use strict';\n\nmodule.exports = Writable;\n/* <replacement> */\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\n\n\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n/*<replacement>*/\n\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // 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  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // 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\n  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n  this.finalCalled = false; // drain event flag.\n\n  this.needDrain = false; // at the start of calling end()\n\n  this.ending = false; // when end() has been called, and returned\n\n  this.ended = false; // when 'finish' is emitted\n\n  this.finished = false; // has it been destroyed\n\n  this.destroyed = false; // 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\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode; // 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\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // 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\n  this.length = 0; // a flag to see when we're in the middle of a write.\n\n  this.writing = false; // when true all writes will be buffered until .uncork() call\n\n  this.corked = 0; // 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\n  this.sync = true; // 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\n  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n  this.writecb = null; // the amount that is being written when _write is called.\n\n  this.writelen = 0;\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n\n  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n\n  this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')\n\n  this.autoDestroy = !!options.autoDestroy; // count buffered requests\n\n  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function writableStateBufferGetter() {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\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 value(object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex'); // 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  // 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  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n  this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n    if (typeof options.writev === 'function') this._writev = options.writev;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n  errorOrDestroy(stream, er);\n  process.nextTick(cb, er);\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.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n  var er;\n\n  if (chunk === null) {\n    er = new ERR_STREAM_NULL_VALUES();\n  } else if (typeof chunk !== 'string' && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n  }\n\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n\n  return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\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  if (typeof cb !== 'function') cb = nop;\n  if (state.ending) 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  return ret;\n};\n\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !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 ERR_UNKNOWN_ENCODING(encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nObject.defineProperty(Writable.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});\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\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 get() {\n    return this._writableState.highWaterMark;\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.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n\n  var len = state.objectMode ? 1 : chunk.length;\n  state.length += len;\n  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\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\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\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 (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else 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    process.nextTick(cb, er); // this can emit finish, and it will always happen\n    // after error\n\n    process.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, 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    errorOrDestroy(stream, er); // this can emit finish, but finish must\n    // always follow error\n\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  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n  onwriteStateUpdate(state);\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) || stream.destroyed;\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\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} // 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.\n\n\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n} // if there's something in the buffer waiting, then process it\n\n\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    var count = 0;\n    var allBuffers = true;\n\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n\n    buffer.allBuffers = allBuffers;\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\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      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--; // 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\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 ERR_METHOD_NOT_IMPLEMENTED('_write()'));\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); // .end() fully uncorks\n\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  } // ignore unnecessary end() calls.\n\n\n  if (!state.ending) endWritable(this, state, cb);\n  return this;\n};\n\nObject.defineProperty(Writable.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\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n\n    if (err) {\n      errorOrDestroy(stream, err);\n    }\n\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\n\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.pendingcb++;\n      state.finalCalled = true;\n      process.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\n  if (need) {\n    prefinish(stream, state);\n\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n\n      if (state.autoDestroy) {\n        // In case of duplex streams we need a way to detect\n        // if the readable side is ready for autoDestroy as well\n        var rState = stream._readableState;\n\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\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\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  } // reuse the free corkReq.\n\n\n  state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.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._writableState === undefined) {\n      return false;\n    }\n\n    return 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._writableState) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// 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'use strict';\n\nmodule.exports = Transform;\n\nvar _require$codes = require('../errors').codes,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n    ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\n\nvar Duplex = require('./_stream_duplex');\n\nrequire('inherits')(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n  var cb = ts.writecb;\n\n  if (cb === null) {\n    return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n  cb(er);\n  var rs = this._readableState;\n  rs.reading = false;\n\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  Duplex.call(this, options);\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  }; // start out asking for a readable event once data is transformed.\n\n  this._readableState.needReadable = true; // 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\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  } // When the writable side finishes, then flush out anything remaining.\n\n\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function' && !this._readableState.destroyed) {\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}; // 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.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\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\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}; // 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.\n\n\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && !ts.transforming) {\n    ts.transforming = true;\n\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  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data); // TODO(BridgeAR): Write a test for these two error cases\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n\n  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n  return stream.push(null);\n}","const debug = require('debug')('bittorrent-tracker:client')\nconst EventEmitter = require('events')\nconst once = require('once')\nconst parallel = require('run-parallel')\nconst Peer = require('simple-peer')\nconst queueMicrotask = require('queue-microtask')\n\nconst common = require('./lib/common')\nconst HTTPTracker = require('./lib/client/http-tracker') // empty object in browser\nconst UDPTracker = require('./lib/client/udp-tracker') // empty object in browser\nconst WebSocketTracker = require('./lib/client/websocket-tracker')\n\n/**\n * BitTorrent tracker client.\n *\n * Find torrent peers, to help a torrent client participate in a torrent swarm.\n *\n * @param {Object} opts                          options object\n * @param {string|Buffer} opts.infoHash          torrent info hash\n * @param {string|Buffer} opts.peerId            peer id\n * @param {string|Array.<string>} opts.announce  announce\n * @param {number} opts.port                     torrent client listening port\n * @param {function} opts.getAnnounceOpts        callback to provide data to tracker\n * @param {number} opts.rtcConfig                RTCPeerConnection configuration object\n * @param {number} opts.userAgent                User-Agent header for http requests\n * @param {number} opts.wrtc                     custom webrtc impl (useful in node.js)\n */\nclass Client extends EventEmitter {\n  constructor (opts = {}) {\n    super()\n\n    if (!opts.peerId) throw new Error('Option `peerId` is required')\n    if (!opts.infoHash) throw new Error('Option `infoHash` is required')\n    if (!opts.announce) throw new Error('Option `announce` is required')\n    if (!process.browser && !opts.port) throw new Error('Option `port` is required')\n\n    this.peerId = typeof opts.peerId === 'string'\n      ? opts.peerId\n      : opts.peerId.toString('hex')\n    this._peerIdBuffer = Buffer.from(this.peerId, 'hex')\n    this._peerIdBinary = this._peerIdBuffer.toString('binary')\n\n    this.infoHash = typeof opts.infoHash === 'string'\n      ? opts.infoHash.toLowerCase()\n      : opts.infoHash.toString('hex')\n    this._infoHashBuffer = Buffer.from(this.infoHash, 'hex')\n    this._infoHashBinary = this._infoHashBuffer.toString('binary')\n\n    debug('new client %s', this.infoHash)\n\n    this.destroyed = false\n\n    this._port = opts.port\n    this._getAnnounceOpts = opts.getAnnounceOpts\n    this._rtcConfig = opts.rtcConfig\n    this._userAgent = opts.userAgent\n\n    // Support lazy 'wrtc' module initialization\n    // See: https://github.com/webtorrent/webtorrent-hybrid/issues/46\n    this._wrtc = typeof opts.wrtc === 'function' ? opts.wrtc() : opts.wrtc\n\n    let announce = typeof opts.announce === 'string'\n      ? [opts.announce]\n      : opts.announce == null ? [] : opts.announce\n\n    // Remove trailing slash from trackers to catch duplicates\n    announce = announce.map(announceUrl => {\n      announceUrl = announceUrl.toString()\n      if (announceUrl[announceUrl.length - 1] === '/') {\n        announceUrl = announceUrl.substring(0, announceUrl.length - 1)\n      }\n      return announceUrl\n    })\n    // remove duplicates by converting to Set and back\n    announce = Array.from(new Set(announce))\n\n    const webrtcSupport = this._wrtc !== false && (!!this._wrtc || Peer.WEBRTC_SUPPORT)\n\n    const nextTickWarn = err => {\n      queueMicrotask(() => {\n        this.emit('warning', err)\n      })\n    }\n\n    this._trackers = announce\n      .map(announceUrl => {\n        let parsedUrl\n        try {\n          parsedUrl = new URL(announceUrl)\n        } catch (err) {\n          nextTickWarn(new Error(`Invalid tracker URL: ${announceUrl}`))\n          return null\n        }\n\n        const port = parsedUrl.port\n        if (port < 0 || port > 65535) {\n          nextTickWarn(new Error(`Invalid tracker port: ${announceUrl}`))\n          return null\n        }\n\n        const protocol = parsedUrl.protocol\n        if ((protocol === 'http:' || protocol === 'https:') &&\n            typeof HTTPTracker === 'function') {\n          return new HTTPTracker(this, announceUrl)\n        } else if (protocol === 'udp:' && typeof UDPTracker === 'function') {\n          return new UDPTracker(this, announceUrl)\n        } else if ((protocol === 'ws:' || protocol === 'wss:') && webrtcSupport) {\n          // Skip ws:// trackers on https:// sites because they throw SecurityError\n          if (protocol === 'ws:' && typeof window !== 'undefined' &&\n              window.location.protocol === 'https:') {\n            nextTickWarn(new Error(`Unsupported tracker protocol: ${announceUrl}`))\n            return null\n          }\n          return new WebSocketTracker(this, announceUrl)\n        } else {\n          nextTickWarn(new Error(`Unsupported tracker protocol: ${announceUrl}`))\n          return null\n        }\n      })\n      .filter(Boolean)\n  }\n\n  /**\n   * Send a `start` announce to the trackers.\n   * @param {Object} opts\n   * @param {number=} opts.uploaded\n   * @param {number=} opts.downloaded\n   * @param {number=} opts.left (if not set, calculated automatically)\n   */\n  start (opts) {\n    opts = this._defaultAnnounceOpts(opts)\n    opts.event = 'started'\n    debug('send `start` %o', opts)\n    this._announce(opts)\n\n    // start announcing on intervals\n    this._trackers.forEach(tracker => {\n      tracker.setInterval()\n    })\n  }\n\n  /**\n   * Send a `stop` announce to the trackers.\n   * @param {Object} opts\n   * @param {number=} opts.uploaded\n   * @param {number=} opts.downloaded\n   * @param {number=} opts.numwant\n   * @param {number=} opts.left (if not set, calculated automatically)\n   */\n  stop (opts) {\n    opts = this._defaultAnnounceOpts(opts)\n    opts.event = 'stopped'\n    debug('send `stop` %o', opts)\n    this._announce(opts)\n  }\n\n  /**\n   * Send a `complete` announce to the trackers.\n   * @param {Object} opts\n   * @param {number=} opts.uploaded\n   * @param {number=} opts.downloaded\n   * @param {number=} opts.numwant\n   * @param {number=} opts.left (if not set, calculated automatically)\n   */\n  complete (opts) {\n    if (!opts) opts = {}\n    opts = this._defaultAnnounceOpts(opts)\n    opts.event = 'completed'\n    debug('send `complete` %o', opts)\n    this._announce(opts)\n  }\n\n  /**\n   * Send a `update` announce to the trackers.\n   * @param {Object} opts\n   * @param {number=} opts.uploaded\n   * @param {number=} opts.downloaded\n   * @param {number=} opts.numwant\n   * @param {number=} opts.left (if not set, calculated automatically)\n   */\n  update (opts) {\n    opts = this._defaultAnnounceOpts(opts)\n    if (opts.event) delete opts.event\n    debug('send `update` %o', opts)\n    this._announce(opts)\n  }\n\n  _announce (opts) {\n    this._trackers.forEach(tracker => {\n      // tracker should not modify `opts` object, it's passed to all trackers\n      tracker.announce(opts)\n    })\n  }\n\n  /**\n   * Send a scrape request to the trackers.\n   * @param {Object} opts\n   */\n  scrape (opts) {\n    debug('send `scrape`')\n    if (!opts) opts = {}\n    this._trackers.forEach(tracker => {\n      // tracker should not modify `opts` object, it's passed to all trackers\n      tracker.scrape(opts)\n    })\n  }\n\n  setInterval (intervalMs) {\n    debug('setInterval %d', intervalMs)\n    this._trackers.forEach(tracker => {\n      tracker.setInterval(intervalMs)\n    })\n  }\n\n  destroy (cb) {\n    if (this.destroyed) return\n    this.destroyed = true\n    debug('destroy')\n\n    const tasks = this._trackers.map(tracker => cb => {\n      tracker.destroy(cb)\n    })\n\n    parallel(tasks, cb)\n\n    this._trackers = []\n    this._getAnnounceOpts = null\n  }\n\n  _defaultAnnounceOpts (opts = {}) {\n    if (opts.numwant == null) opts.numwant = common.DEFAULT_ANNOUNCE_PEERS\n\n    if (opts.uploaded == null) opts.uploaded = 0\n    if (opts.downloaded == null) opts.downloaded = 0\n\n    if (this._getAnnounceOpts) opts = Object.assign({}, opts, this._getAnnounceOpts())\n\n    return opts\n  }\n}\n\n/**\n * Simple convenience function to scrape a tracker for an info hash without needing to\n * create a Client, pass it a parsed torrent, etc. Support scraping a tracker for multiple\n * torrents at the same time.\n * @params {Object} opts\n * @param  {string|Array.<string>} opts.infoHash\n * @param  {string} opts.announce\n * @param  {function} cb\n */\nClient.scrape = (opts, cb) => {\n  cb = once(cb)\n\n  if (!opts.infoHash) throw new Error('Option `infoHash` is required')\n  if (!opts.announce) throw new Error('Option `announce` is required')\n\n  const clientOpts = Object.assign({}, opts, {\n    infoHash: Array.isArray(opts.infoHash) ? opts.infoHash[0] : opts.infoHash,\n    peerId: Buffer.from('01234567890123456789'), // dummy value\n    port: 6881 // dummy value\n  })\n\n  const client = new Client(clientOpts)\n  client.once('error', cb)\n  client.once('warning', cb)\n\n  let len = Array.isArray(opts.infoHash) ? opts.infoHash.length : 1\n  const results = {}\n  client.on('scrape', data => {\n    len -= 1\n    results[data.infoHash] = data\n    if (len === 0) {\n      client.destroy()\n      const keys = Object.keys(results)\n      if (keys.length === 1) {\n        cb(null, results[keys[0]])\n      } else {\n        cb(null, results)\n      }\n    }\n  })\n\n  opts.infoHash = Array.isArray(opts.infoHash)\n    ? opts.infoHash.map(infoHash => {\n        return Buffer.from(infoHash, 'hex')\n      })\n    : Buffer.from(opts.infoHash, 'hex')\n  client.scrape({ infoHash: opts.infoHash })\n  return client\n}\n\nmodule.exports = Client\n","/**\n * Functions/constants needed by both the client and server.\n */\n\nexports.DEFAULT_ANNOUNCE_PEERS = 50\nexports.MAX_ANNOUNCE_PEERS = 82\n\nexports.binaryToHex = function (str) {\n  if (typeof str !== 'string') {\n    str = String(str)\n  }\n  return Buffer.from(str, 'binary').toString('hex')\n}\n\nexports.hexToBinary = function (str) {\n  if (typeof str !== 'string') {\n    str = String(str)\n  }\n  return Buffer.from(str, 'hex').toString('binary')\n}\n\nconst config = require('./common-node')\nObject.assign(exports, config)\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'use strict';\n\nmodule.exports = Readable;\n/*<replacement>*/\n\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n/*<replacement>*/\n\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*<replacement>*/\n\n\nvar debugUtil = require('util');\n\nvar debug;\n\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\n\nvar BufferList = require('./internal/streams/buffer_list');\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\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; // Lazy loaded to improve the startup performance.\n\n\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\n\nrequire('inherits')(Readable, Stream);\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\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); // 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\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}\n\nfunction ReadableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // 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\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // 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\n  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // 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\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; // 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\n  this.sync = true; // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n  this.paused = true; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')\n\n  this.autoDestroy = !!options.autoDestroy; // has it been destroyed\n\n  this.destroyed = false; // 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\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s\n\n  this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled\n\n  this.readingMore = false;\n  this.decoder = null;\n  this.encoding = null;\n\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  if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  this._readableState = new ReadableState(options, this, isDuplex); // legacy\n\n  this.readable = true;\n\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\n  Stream.call(this);\n}\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\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    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._readableState.destroyed = value;\n  }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\n\nReadable.prototype._destroy = function (err, cb) {\n  cb(err);\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.\n\n\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\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n}; // Unshift should *always* be something directly out of read()\n\n\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  debug('readableAddChunk', chunk);\n  var state = stream._readableState;\n\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\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\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\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  } // 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\n\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\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\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n\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\n  return er;\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n}; // backwards compatibility.\n\n\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  var decoder = new StringDecoder(enc);\n  this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8\n\n  this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:\n\n  var p = this._readableState.buffer.head;\n  var content = '';\n\n  while (p !== null) {\n    content += decoder.write(p.data);\n    p = p.next;\n  }\n\n  this._readableState.buffer.clear();\n\n  if (content !== '') this._readableState.buffer.push(content);\n  this._readableState.length = content.length;\n  return this;\n}; // Don't raise the hwm > 1GB\n\n\nvar MAX_HWM = 0x40000000;\n\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\n  return n;\n} // This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\n\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n\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  } // If we're asking for more than the current hwm, then raise the hwm.\n\n\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n; // Don't have enough\n\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n\n  return state.length;\n} // you can override either this method, or the async _read(n) below.\n\n\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; // 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\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  n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.\n\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\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  // if we need a readable event, then we need to do some reading.\n\n\n  var doRead = state.needReadable;\n  debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some\n\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  } // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n\n\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; // if the length is currently zero, then we *need* a readable event.\n\n    if (state.length === 0) state.needReadable = true; // call internal read method\n\n    this._read(state.highWaterMark);\n\n    state.sync = false; // 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\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 = state.length <= state.highWaterMark;\n    n = 0;\n  } else {\n    state.length -= n;\n    state.awaitDrain = 0;\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; // If we tried to read() past the EOF, then emit end on the next tick.\n\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk');\n  if (state.ended) return;\n\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n\n  state.ended = true;\n\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\n    if (!state.emittedReadable) {\n      state.emittedReadable = true;\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.\n\n\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  debug('emitReadable', state.needReadable, state.emittedReadable);\n  state.needReadable = false;\n\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    process.nextTick(emitReadable_, stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  var state = stream._readableState;\n  debug('emitReadable_', state.destroyed, state.length, state.ended);\n\n  if (!state.destroyed && (state.length || state.ended)) {\n    stream.emit('readable');\n    state.emittedReadable = false;\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\n\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n  flow(stream);\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.\n\n\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(maybeReadMore_, stream, state);\n  }\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) // didn't get any data, stop spinning.\n      break;\n  }\n\n  state.readingMore = false;\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.\n\n\nReadable.prototype._read = function (n) {\n  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\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\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n\n    default:\n      state.pipes.push(dest);\n      break;\n  }\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\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n\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  } // 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\n\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n  var cleanedUp = false;\n\n  function cleanup() {\n    debug('cleanup'); // cleanup event handlers once the pipe is broken\n\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; // 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\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  src.on('data', ondata);\n\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    debug('dest.write', ret);\n\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\n      src.pause();\n    }\n  } // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n\n\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  } // Make sure our error handler is attached before userland ones.\n\n\n  prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.\n\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n\n  dest.once('close', onclose);\n\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  } // tell the dest that it's being piped to\n\n\n  dest.emit('pipe', src); // start the flow if it hasn't been started already.\n\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\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\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 = {\n    hasUnpiped: false\n  }; // if we're not piping anywhere, then do nothing.\n\n  if (state.pipesCount === 0) return this; // just one destination.  most common case.\n\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; // got a match.\n\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  } // slow case. multiple pipe destinations.\n\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, {\n        hasUnpiped: false\n      });\n    }\n\n    return this;\n  } // try to find the right one.\n\n\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}; // set up data events if they are asked for\n// Ensure readable listeners eventually get something\n\n\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n  var state = this._readableState;\n\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; // Try start flowing on next tick if stream isn't explicitly paused\n\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\n      if (state.length) {\n        emitReadable(this);\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this);\n      }\n    }\n  }\n\n  return res;\n};\n\nReadable.prototype.addListener = Readable.prototype.on;\n\nReadable.prototype.removeListener = function (ev, fn) {\n  var res = Stream.prototype.removeListener.call(this, ev, fn);\n\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\n  return res;\n};\n\nReadable.prototype.removeAllListeners = function (ev) {\n  var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n\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\n  return res;\n};\n\nfunction updateReadableListening(self) {\n  var state = self._readableState;\n  state.readableListening = self.listenerCount('readable') > 0;\n\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; // crude way to check if we should resume\n  } else if (self.listenerCount('data') > 0) {\n    self.resume();\n  }\n}\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n} // pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\n\n\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n\n  if (!state.flowing) {\n    debug('resume'); // we flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume()\n\n    state.flowing = !state.readableListening;\n    resume(this, state);\n  }\n\n  state.paused = false;\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  debug('resume', state.reading);\n\n  if (!state.reading) {\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\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\n  if (this._readableState.flowing !== false) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n\n  this._readableState.paused = true;\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n\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.\n\n\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n  stream.on('end', function () {\n    debug('wrapped end');\n\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  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode\n\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\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  }); // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n\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  } // proxy certain important events.\n\n\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  } // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n\n\n  this._read = function (n) {\n    debug('wrapped _read', n);\n\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nif (typeof Symbol === 'function') {\n  Readable.prototype[Symbol.asyncIterator] = function () {\n    if (createReadableStreamAsyncIterator === undefined) {\n      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n    }\n\n    return createReadableStreamAsyncIterator(this);\n  };\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}); // exposed for testing purposes only.\n\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}); // 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.\n\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}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n  debug('endReadable', state.endEmitted);\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.\n\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n\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\n      if (!wState || wState.autoDestroy && wState.finished) {\n        stream.destroy();\n      }\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\n    return from(Readable, iterable, opts);\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\n  return -1;\n}","module.exports = require('events').EventEmitter;\n","'use strict'; // undocumented cb() API, needed for core, not for public API\n\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) {\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\n    return this;\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\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  } // if this is a duplex stream mark the writable part as destroyed as well\n\n\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\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\n  return this;\n}\n\nfunction emitErrorAndCloseNT(self, err) {\n  emitErrorNT(self, err);\n  emitCloseNT(self);\n}\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}\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.finalCalled = false;\n    this._writableState.prefinished = 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\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  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}\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;\n\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\n\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n\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\n    return Math.floor(hwm);\n  } // Default value\n\n\n  return state.objectMode ? 16 : 16 * 1024;\n}\n\nmodule.exports = {\n  getHighWaterMark: getHighWaterMark\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// 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'use strict';\n\nmodule.exports = Writable;\n/* <replacement> */\n\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\n\n\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n/*<replacement>*/\n\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n    getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {}; // 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  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // 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\n  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n  this.finalCalled = false; // drain event flag.\n\n  this.needDrain = false; // at the start of calling end()\n\n  this.ending = false; // when end() has been called, and returned\n\n  this.ended = false; // when 'finish' is emitted\n\n  this.finished = false; // has it been destroyed\n\n  this.destroyed = false; // 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\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode; // 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\n  this.defaultEncoding = options.defaultEncoding || 'utf8'; // 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\n  this.length = 0; // a flag to see when we're in the middle of a write.\n\n  this.writing = false; // when true all writes will be buffered until .uncork() call\n\n  this.corked = 0; // 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\n  this.sync = true; // 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\n  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n  this.writecb = null; // the amount that is being written when _write is called.\n\n  this.writelen = 0;\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n\n  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n\n  this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')\n\n  this.autoDestroy = !!options.autoDestroy; // count buffered requests\n\n  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function writableStateBufferGetter() {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\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 value(object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex'); // 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  // 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  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n\n  var isDuplex = this instanceof Duplex;\n  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n  this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n    if (typeof options.writev === 'function') this._writev = options.writev;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n  errorOrDestroy(stream, er);\n  process.nextTick(cb, er);\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.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n  var er;\n\n  if (chunk === null) {\n    er = new ERR_STREAM_NULL_VALUES();\n  } else if (typeof chunk !== 'string' && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n  }\n\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n\n  return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n\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  if (typeof cb !== 'function') cb = nop;\n  if (state.ending) 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  return ret;\n};\n\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !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 ERR_UNKNOWN_ENCODING(encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nObject.defineProperty(Writable.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});\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\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 get() {\n    return this._writableState.highWaterMark;\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.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n\n  var len = state.objectMode ? 1 : chunk.length;\n  state.length += len;\n  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\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\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\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 (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else 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    process.nextTick(cb, er); // this can emit finish, and it will always happen\n    // after error\n\n    process.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, 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    errorOrDestroy(stream, er); // this can emit finish, but finish must\n    // always follow error\n\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  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n  onwriteStateUpdate(state);\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) || stream.destroyed;\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\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} // 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.\n\n\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n} // if there's something in the buffer waiting, then process it\n\n\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    var count = 0;\n    var allBuffers = true;\n\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n\n    buffer.allBuffers = allBuffers;\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\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      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--; // 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\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 ERR_METHOD_NOT_IMPLEMENTED('_write()'));\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); // .end() fully uncorks\n\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  } // ignore unnecessary end() calls.\n\n\n  if (!state.ending) endWritable(this, state, cb);\n  return this;\n};\n\nObject.defineProperty(Writable.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\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n\n    if (err) {\n      errorOrDestroy(stream, err);\n    }\n\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\n\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.pendingcb++;\n      state.finalCalled = true;\n      process.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\n  if (need) {\n    prefinish(stream, state);\n\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n\n      if (state.autoDestroy) {\n        // In case of duplex streams we need a way to detect\n        // if the readable side is ready for autoDestroy as well\n        var rState = stream._readableState;\n\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\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\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  } // reuse the free corkReq.\n\n\n  state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.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._writableState === undefined) {\n      return false;\n    }\n\n    return 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._writableState) {\n      return;\n    } // backward compatibility, the user is explicitly\n    // managing destroyed\n\n\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// 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'use strict';\n\nmodule.exports = Transform;\n\nvar _require$codes = require('../errors').codes,\n    ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n    ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n    ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\n\nvar Duplex = require('./_stream_duplex');\n\nrequire('inherits')(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n  var cb = ts.writecb;\n\n  if (cb === null) {\n    return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n  cb(er);\n  var rs = this._readableState;\n  rs.reading = false;\n\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  Duplex.call(this, options);\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  }; // start out asking for a readable event once data is transformed.\n\n  this._readableState.needReadable = true; // 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\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  } // When the writable side finishes, then flush out anything remaining.\n\n\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function' && !this._readableState.destroyed) {\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}; // 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.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\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\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}; // 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.\n\n\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && !ts.transforming) {\n    ts.transforming = true;\n\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  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data); // TODO(BridgeAR): Write a test for these two error cases\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n\n  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n  return stream.push(null);\n}","// Returns a wrapper function that returns a wrapped callback\n// The wrapper function should do some stuff, and return a\n// presumably different callback function.\n// This makes sure that own properties are retained, so that\n// decorations and such are not lost along the way.\nmodule.exports = wrappy\nfunction wrappy (fn, cb) {\n  if (fn && cb) return wrappy(fn)(cb)\n\n  if (typeof fn !== 'function')\n    throw new TypeError('need wrapper function')\n\n  Object.keys(fn).forEach(function (k) {\n    wrapper[k] = fn[k]\n  })\n\n  return wrapper\n\n  function wrapper() {\n    var args = new Array(arguments.length)\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i]\n    }\n    var ret = fn.apply(this, args)\n    var cb = args[args.length-1]\n    if (typeof ret === 'function' && ret !== cb) {\n      Object.keys(cb).forEach(function (k) {\n        ret[k] = cb[k]\n      })\n    }\n    return ret\n  }\n}\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n */\n\nfunction setup(env) {\n\tcreateDebug.debug = createDebug;\n\tcreateDebug.default = createDebug;\n\tcreateDebug.coerce = coerce;\n\tcreateDebug.disable = disable;\n\tcreateDebug.enable = enable;\n\tcreateDebug.enabled = enabled;\n\tcreateDebug.humanize = require('ms');\n\tcreateDebug.destroy = destroy;\n\n\tObject.keys(env).forEach(key => {\n\t\tcreateDebug[key] = env[key];\n\t});\n\n\t/**\n\t* The currently active debug mode names, and names to skip.\n\t*/\n\n\tcreateDebug.names = [];\n\tcreateDebug.skips = [];\n\n\t/**\n\t* Map of special \"%n\" handling functions, for the debug \"format\" argument.\n\t*\n\t* Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n\t*/\n\tcreateDebug.formatters = {};\n\n\t/**\n\t* Selects a color for a debug namespace\n\t* @param {String} namespace The namespace string for the for the debug instance to be colored\n\t* @return {Number|String} An ANSI color code for the given namespace\n\t* @api private\n\t*/\n\tfunction selectColor(namespace) {\n\t\tlet hash = 0;\n\n\t\tfor (let i = 0; i < namespace.length; i++) {\n\t\t\thash = ((hash << 5) - hash) + namespace.charCodeAt(i);\n\t\t\thash |= 0; // Convert to 32bit integer\n\t\t}\n\n\t\treturn createDebug.colors[Math.abs(hash) % createDebug.colors.length];\n\t}\n\tcreateDebug.selectColor = selectColor;\n\n\t/**\n\t* Create a debugger with the given `namespace`.\n\t*\n\t* @param {String} namespace\n\t* @return {Function}\n\t* @api public\n\t*/\n\tfunction createDebug(namespace) {\n\t\tlet prevTime;\n\t\tlet enableOverride = null;\n\n\t\tfunction debug(...args) {\n\t\t\t// Disabled?\n\t\t\tif (!debug.enabled) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst self = debug;\n\n\t\t\t// Set `diff` timestamp\n\t\t\tconst curr = Number(new Date());\n\t\t\tconst ms = curr - (prevTime || curr);\n\t\t\tself.diff = ms;\n\t\t\tself.prev = prevTime;\n\t\t\tself.curr = curr;\n\t\t\tprevTime = curr;\n\n\t\t\targs[0] = createDebug.coerce(args[0]);\n\n\t\t\tif (typeof args[0] !== 'string') {\n\t\t\t\t// Anything else let's inspect with %O\n\t\t\t\targs.unshift('%O');\n\t\t\t}\n\n\t\t\t// Apply any `formatters` transformations\n\t\t\tlet index = 0;\n\t\t\targs[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {\n\t\t\t\t// If we encounter an escaped % then don't increase the array index\n\t\t\t\tif (match === '%%') {\n\t\t\t\t\treturn '%';\n\t\t\t\t}\n\t\t\t\tindex++;\n\t\t\t\tconst formatter = createDebug.formatters[format];\n\t\t\t\tif (typeof formatter === 'function') {\n\t\t\t\t\tconst val = args[index];\n\t\t\t\t\tmatch = formatter.call(self, val);\n\n\t\t\t\t\t// Now we need to remove `args[index]` since it's inlined in the `format`\n\t\t\t\t\targs.splice(index, 1);\n\t\t\t\t\tindex--;\n\t\t\t\t}\n\t\t\t\treturn match;\n\t\t\t});\n\n\t\t\t// Apply env-specific formatting (colors, etc.)\n\t\t\tcreateDebug.formatArgs.call(self, args);\n\n\t\t\tconst logFn = self.log || createDebug.log;\n\t\t\tlogFn.apply(self, args);\n\t\t}\n\n\t\tdebug.namespace = namespace;\n\t\tdebug.useColors = createDebug.useColors();\n\t\tdebug.color = createDebug.selectColor(namespace);\n\t\tdebug.extend = extend;\n\t\tdebug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.\n\n\t\tObject.defineProperty(debug, 'enabled', {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: false,\n\t\t\tget: () => enableOverride === null ? createDebug.enabled(namespace) : enableOverride,\n\t\t\tset: v => {\n\t\t\t\tenableOverride = v;\n\t\t\t}\n\t\t});\n\n\t\t// Env-specific initialization logic for debug instances\n\t\tif (typeof createDebug.init === 'function') {\n\t\t\tcreateDebug.init(debug);\n\t\t}\n\n\t\treturn debug;\n\t}\n\n\tfunction extend(namespace, delimiter) {\n\t\tconst newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);\n\t\tnewDebug.log = this.log;\n\t\treturn newDebug;\n\t}\n\n\t/**\n\t* Enables a debug mode by namespaces. This can include modes\n\t* separated by a colon and wildcards.\n\t*\n\t* @param {String} namespaces\n\t* @api public\n\t*/\n\tfunction enable(namespaces) {\n\t\tcreateDebug.save(namespaces);\n\n\t\tcreateDebug.names = [];\n\t\tcreateDebug.skips = [];\n\n\t\tlet i;\n\t\tconst split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n\t\tconst len = split.length;\n\n\t\tfor (i = 0; i < len; i++) {\n\t\t\tif (!split[i]) {\n\t\t\t\t// ignore empty strings\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tnamespaces = split[i].replace(/\\*/g, '.*?');\n\n\t\t\tif (namespaces[0] === '-') {\n\t\t\t\tcreateDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n\t\t\t} else {\n\t\t\t\tcreateDebug.names.push(new RegExp('^' + namespaces + '$'));\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t* Disable debug output.\n\t*\n\t* @return {String} namespaces\n\t* @api public\n\t*/\n\tfunction disable() {\n\t\tconst namespaces = [\n\t\t\t...createDebug.names.map(toNamespace),\n\t\t\t...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)\n\t\t].join(',');\n\t\tcreateDebug.enable('');\n\t\treturn namespaces;\n\t}\n\n\t/**\n\t* Returns true if the given mode name is enabled, false otherwise.\n\t*\n\t* @param {String} name\n\t* @return {Boolean}\n\t* @api public\n\t*/\n\tfunction enabled(name) {\n\t\tif (name[name.length - 1] === '*') {\n\t\t\treturn true;\n\t\t}\n\n\t\tlet i;\n\t\tlet len;\n\n\t\tfor (i = 0, len = createDebug.skips.length; i < len; i++) {\n\t\t\tif (createDebug.skips[i].test(name)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tfor (i = 0, len = createDebug.names.length; i < len; i++) {\n\t\t\tif (createDebug.names[i].test(name)) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\t/**\n\t* Convert regexp to namespace\n\t*\n\t* @param {RegExp} regxep\n\t* @return {String} namespace\n\t* @api private\n\t*/\n\tfunction toNamespace(regexp) {\n\t\treturn regexp.toString()\n\t\t\t.substring(2, regexp.toString().length - 2)\n\t\t\t.replace(/\\.\\*\\?$/, '*');\n\t}\n\n\t/**\n\t* Coerce `val`.\n\t*\n\t* @param {Mixed} val\n\t* @return {Mixed}\n\t* @api private\n\t*/\n\tfunction coerce(val) {\n\t\tif (val instanceof Error) {\n\t\t\treturn val.stack || val.message;\n\t\t}\n\t\treturn val;\n\t}\n\n\t/**\n\t* XXX DO NOT USE. This is a temporary stub function.\n\t* XXX It WILL be removed in the next major release.\n\t*/\n\tfunction destroy() {\n\t\tconsole.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');\n\t}\n\n\tcreateDebug.enable(createDebug.load());\n\n\treturn createDebug;\n}\n\nmodule.exports = setup;\n","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar w = d * 7;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isFinite(val)) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^(-?(?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'weeks':\n    case 'week':\n    case 'w':\n      return n * w;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (msAbs >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (msAbs >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (msAbs >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  var msAbs = Math.abs(ms);\n  if (msAbs >= d) {\n    return plural(ms, msAbs, d, 'day');\n  }\n  if (msAbs >= h) {\n    return plural(ms, msAbs, h, 'hour');\n  }\n  if (msAbs >= m) {\n    return plural(ms, msAbs, m, 'minute');\n  }\n  if (msAbs >= s) {\n    return plural(ms, msAbs, s, 'second');\n  }\n  return ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, msAbs, n, name) {\n  var isPlural = msAbs >= n * 1.5;\n  return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');\n}\n","// originally pulled out of simple-peer\n\nmodule.exports = function getBrowserRTC () {\n  if (typeof globalThis === 'undefined') return null\n  var wrtc = {\n    RTCPeerConnection: globalThis.RTCPeerConnection || globalThis.mozRTCPeerConnection ||\n      globalThis.webkitRTCPeerConnection,\n    RTCSessionDescription: globalThis.RTCSessionDescription ||\n      globalThis.mozRTCSessionDescription || globalThis.webkitRTCSessionDescription,\n    RTCIceCandidate: globalThis.RTCIceCandidate || globalThis.mozRTCIceCandidate ||\n      globalThis.webkitRTCIceCandidate\n  }\n  if (!wrtc.RTCPeerConnection) return null\n  return wrtc\n}\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');\n","'use strict';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar _require = require('buffer'),\n    Buffer = _require.Buffer;\n\nvar _require2 = require('util'),\n    inspect = _require2.inspect;\n\nvar custom = inspect && inspect.custom || 'inspect';\n\nfunction copyBuffer(src, target, offset) {\n  Buffer.prototype.copy.call(src, target, offset);\n}\n\nmodule.exports =\n/*#__PURE__*/\nfunction () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\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\n      while (p = p.next) {\n        ret += s + p.data;\n      }\n\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\n      while (p) {\n        copyBuffer(p.data, ret, i);\n        i += p.data.length;\n        p = p.next;\n      }\n\n      return ret;\n    } // Consumes a specified amount of bytes or characters from the buffered data.\n\n  }, {\n    key: \"consume\",\n    value: function consume(n, hasStrings) {\n      var ret;\n\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\n      return ret;\n    }\n  }, {\n    key: \"first\",\n    value: function first() {\n      return this.head.data;\n    } // Consumes a specified amount of characters from the buffered data.\n\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\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\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\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Consumes a specified amount of bytes from the buffered data.\n\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\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\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\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Make sure the linked list only shows the minimal necessary information.\n\n  }, {\n    key: custom,\n    value: function value(_, options) {\n      return inspect(this, _objectSpread({}, options, {\n        // Only inspect one level.\n        depth: 0,\n        // It should not recurse.\n        customInspect: false\n      }));\n    }\n  }]);\n\n  return BufferList;\n}();","'use strict';\n\nvar _Object$setPrototypeO;\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar finished = require('./end-of-stream');\n\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');\n\nfunction createIterResult(value, done) {\n  return {\n    value: value,\n    done: done\n  };\n}\n\nfunction readAndResolve(iter) {\n  var resolve = iter[kLastResolve];\n\n  if (resolve !== null) {\n    var data = iter[kStream].read(); // we defer if data is null\n    // we can be expecting either 'end' or\n    // 'error'\n\n    if (data !== null) {\n      iter[kLastPromise] = null;\n      iter[kLastResolve] = null;\n      iter[kLastReject] = null;\n      resolve(createIterResult(data, false));\n    }\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}\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\n      iter[kHandlePromise](resolve, reject);\n    }, reject);\n  };\n}\n\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n  get stream() {\n    return this[kStream];\n  },\n\n  next: function next() {\n    var _this = this;\n\n    // if we have detected an error in the meanwhile\n    // reject straight away\n    var error = this[kError];\n\n    if (error !== null) {\n      return Promise.reject(error);\n    }\n\n    if (this[kEnded]) {\n      return Promise.resolve(createIterResult(undefined, true));\n    }\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    } // 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\n\n    var lastPromise = this[kLastPromise];\n    var promise;\n\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\n      if (data !== null) {\n        return Promise.resolve(createIterResult(data, false));\n      }\n\n      promise = new Promise(this[kHandlePromise]);\n    }\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\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\n      resolve(createIterResult(undefined, true));\n    });\n  });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\n\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n  var _Object$create;\n\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\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]; // reject if we are waiting for data in the Promise\n      // returned by next() and store the error\n\n      if (reject !== null) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        reject(err);\n      }\n\n      iterator[kError] = err;\n      return;\n    }\n\n    var resolve = iterator[kLastResolve];\n\n    if (resolve !== null) {\n      iterator[kLastPromise] = null;\n      iterator[kLastResolve] = null;\n      iterator[kLastReject] = null;\n      resolve(createIterResult(undefined, true));\n    }\n\n    iterator[kEnded] = true;\n  });\n  stream.on('readable', onReadable.bind(null, iterator));\n  return iterator;\n};\n\nmodule.exports = createReadableStreamAsyncIterator;","module.exports = function () {\n  throw new Error('Readable.from is not available in the browser')\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// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\nrequire('inherits')(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar eos;\n\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}\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;\n\nfunction noop(err) {\n  // Rethrow the error if it exists to avoid swallowing it\n  if (err) throw err;\n}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\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; // request.destroy just do .end - .abort is what we want\n\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}\n\nfunction call(fn) {\n  fn();\n}\n\nfunction pipe(from, to) {\n  return from.pipe(to);\n}\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}\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\n  var callback = popCallback(streams);\n  if (Array.isArray(streams[0])) streams = streams[0];\n\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams');\n  }\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}\n\nmodule.exports = pipeline;","'use strict';\n\nfunction assign(obj, props) {\n    for (const key in props) {\n        Object.defineProperty(obj, key, {\n            value: props[key],\n            enumerable: true,\n            configurable: true,\n        });\n    }\n\n    return obj;\n}\n\nfunction createError(err, code, props) {\n    if (!err || typeof err === 'string') {\n        throw new TypeError('Please pass an Error to err-code');\n    }\n\n    if (!props) {\n        props = {};\n    }\n\n    if (typeof code === 'object') {\n        props = code;\n        code = undefined;\n    }\n\n    if (code != null) {\n        props.code = code;\n    }\n\n    try {\n        return assign(err, props);\n    } catch (_) {\n        props.message = err.message;\n        props.stack = err.stack;\n\n        const ErrClass = function () {};\n\n        ErrClass.prototype = Object.create(Object.getPrototypeOf(err));\n\n        return assign(new ErrClass(), props);\n    }\n}\n\nmodule.exports = createError;\n","const debug = require('debug')('bittorrent-tracker:websocket-tracker')\nconst Peer = require('simple-peer')\nconst randombytes = require('randombytes')\nconst Socket = require('simple-websocket')\n\nconst common = require('../common')\nconst Tracker = require('./tracker')\n\n// Use a socket pool, so tracker clients share WebSocket objects for the same server.\n// In practice, WebSockets are pretty slow to establish, so this gives a nice performance\n// boost, and saves browser resources.\nconst socketPool = {}\n\nconst RECONNECT_MINIMUM = 10 * 1000\nconst RECONNECT_MAXIMUM = 60 * 60 * 1000\nconst RECONNECT_VARIANCE = 5 * 60 * 1000\nconst OFFER_TIMEOUT = 50 * 1000\n\nclass WebSocketTracker extends Tracker {\n  constructor (client, announceUrl, opts) {\n    super(client, announceUrl)\n    debug('new websocket tracker %s', announceUrl)\n\n    this.peers = {} // peers (offer id -> peer)\n    this.socket = null\n\n    this.reconnecting = false\n    this.retries = 0\n    this.reconnectTimer = null\n\n    // Simple boolean flag to track whether the socket has received data from\n    // the websocket server since the last time socket.send() was called.\n    this.expectingResponse = false\n\n    this._openSocket()\n  }\n\n  announce (opts) {\n    if (this.destroyed || this.reconnecting) return\n    if (!this.socket.connected) {\n      this.socket.once('connect', () => {\n        this.announce(opts)\n      })\n      return\n    }\n\n    const params = Object.assign({}, opts, {\n      action: 'announce',\n      info_hash: this.client._infoHashBinary,\n      peer_id: this.client._peerIdBinary\n    })\n    if (this._trackerId) params.trackerid = this._trackerId\n\n    if (opts.event === 'stopped' || opts.event === 'completed') {\n      // Don't include offers with 'stopped' or 'completed' event\n      this._send(params)\n    } else {\n      // Limit the number of offers that are generated, since it can be slow\n      const numwant = Math.min(opts.numwant, 10)\n\n      this._generateOffers(numwant, offers => {\n        params.numwant = numwant\n        params.offers = offers\n        this._send(params)\n      })\n    }\n  }\n\n  scrape (opts) {\n    if (this.destroyed || this.reconnecting) return\n    if (!this.socket.connected) {\n      this.socket.once('connect', () => {\n        this.scrape(opts)\n      })\n      return\n    }\n\n    const infoHashes = (Array.isArray(opts.infoHash) && opts.infoHash.length > 0)\n      ? opts.infoHash.map(infoHash => {\n          return infoHash.toString('binary')\n        })\n      : (opts.infoHash && opts.infoHash.toString('binary')) || this.client._infoHashBinary\n    const params = {\n      action: 'scrape',\n      info_hash: infoHashes\n    }\n\n    this._send(params)\n  }\n\n  destroy (cb = noop) {\n    if (this.destroyed) return cb(null)\n\n    this.destroyed = true\n\n    clearInterval(this.interval)\n    clearTimeout(this.reconnectTimer)\n\n    // Destroy peers\n    for (const peerId in this.peers) {\n      const peer = this.peers[peerId]\n      clearTimeout(peer.trackerTimeout)\n      peer.destroy()\n    }\n    this.peers = null\n\n    if (this.socket) {\n      this.socket.removeListener('connect', this._onSocketConnectBound)\n      this.socket.removeListener('data', this._onSocketDataBound)\n      this.socket.removeListener('close', this._onSocketCloseBound)\n      this.socket.removeListener('error', this._onSocketErrorBound)\n      this.socket = null\n    }\n\n    this._onSocketConnectBound = null\n    this._onSocketErrorBound = null\n    this._onSocketDataBound = null\n    this._onSocketCloseBound = null\n\n    if (socketPool[this.announceUrl]) {\n      socketPool[this.announceUrl].consumers -= 1\n    }\n\n    // Other instances are using the socket, so there's nothing left to do here\n    if (socketPool[this.announceUrl].consumers > 0) return cb()\n\n    let socket = socketPool[this.announceUrl]\n    delete socketPool[this.announceUrl]\n    socket.on('error', noop) // ignore all future errors\n    socket.once('close', cb)\n\n    let timeout\n\n    // If there is no data response expected, destroy immediately.\n    if (!this.expectingResponse) return destroyCleanup()\n\n    // Otherwise, wait a short time for potential responses to come in from the\n    // server, then force close the socket.\n    timeout = setTimeout(destroyCleanup, common.DESTROY_TIMEOUT)\n\n    // But, if a response comes from the server before the timeout fires, do cleanup\n    // right away.\n    socket.once('data', destroyCleanup)\n\n    function destroyCleanup () {\n      if (timeout) {\n        clearTimeout(timeout)\n        timeout = null\n      }\n      socket.removeListener('data', destroyCleanup)\n      socket.destroy()\n      socket = null\n    }\n  }\n\n  _openSocket () {\n    this.destroyed = false\n\n    if (!this.peers) this.peers = {}\n\n    this._onSocketConnectBound = () => {\n      this._onSocketConnect()\n    }\n    this._onSocketErrorBound = err => {\n      this._onSocketError(err)\n    }\n    this._onSocketDataBound = data => {\n      this._onSocketData(data)\n    }\n    this._onSocketCloseBound = () => {\n      this._onSocketClose()\n    }\n\n    this.socket = socketPool[this.announceUrl]\n    if (this.socket) {\n      socketPool[this.announceUrl].consumers += 1\n      if (this.socket.connected) {\n        this._onSocketConnectBound()\n      }\n    } else {\n      this.socket = socketPool[this.announceUrl] = new Socket(this.announceUrl)\n      this.socket.consumers = 1\n      this.socket.once('connect', this._onSocketConnectBound)\n    }\n\n    this.socket.on('data', this._onSocketDataBound)\n    this.socket.once('close', this._onSocketCloseBound)\n    this.socket.once('error', this._onSocketErrorBound)\n  }\n\n  _onSocketConnect () {\n    if (this.destroyed) return\n\n    if (this.reconnecting) {\n      this.reconnecting = false\n      this.retries = 0\n      this.announce(this.client._defaultAnnounceOpts())\n    }\n  }\n\n  _onSocketData (data) {\n    if (this.destroyed) return\n\n    this.expectingResponse = false\n\n    try {\n      data = JSON.parse(data)\n    } catch (err) {\n      this.client.emit('warning', new Error('Invalid tracker response'))\n      return\n    }\n\n    if (data.action === 'announce') {\n      this._onAnnounceResponse(data)\n    } else if (data.action === 'scrape') {\n      this._onScrapeResponse(data)\n    } else {\n      this._onSocketError(new Error(`invalid action in WS response: ${data.action}`))\n    }\n  }\n\n  _onAnnounceResponse (data) {\n    if (data.info_hash !== this.client._infoHashBinary) {\n      debug(\n        'ignoring websocket data from %s for %s (looking for %s: reused socket)',\n        this.announceUrl, common.binaryToHex(data.info_hash), this.client.infoHash\n      )\n      return\n    }\n\n    if (data.peer_id && data.peer_id === this.client._peerIdBinary) {\n      // ignore offers/answers from this client\n      return\n    }\n\n    debug(\n      'received %s from %s for %s',\n      JSON.stringify(data), this.announceUrl, this.client.infoHash\n    )\n\n    const failure = data['failure reason']\n    if (failure) return this.client.emit('warning', new Error(failure))\n\n    const warning = data['warning message']\n    if (warning) this.client.emit('warning', new Error(warning))\n\n    const interval = data.interval || data['min interval']\n    if (interval) this.setInterval(interval * 1000)\n\n    const trackerId = data['tracker id']\n    if (trackerId) {\n      // If absent, do not discard previous trackerId value\n      this._trackerId = trackerId\n    }\n\n    if (data.complete != null) {\n      const response = Object.assign({}, data, {\n        announce: this.announceUrl,\n        infoHash: common.binaryToHex(data.info_hash)\n      })\n      this.client.emit('update', response)\n    }\n\n    let peer\n    if (data.offer && data.peer_id) {\n      debug('creating peer (from remote offer)')\n      peer = this._createPeer()\n      peer.id = common.binaryToHex(data.peer_id)\n      peer.once('signal', answer => {\n        const params = {\n          action: 'announce',\n          info_hash: this.client._infoHashBinary,\n          peer_id: this.client._peerIdBinary,\n          to_peer_id: data.peer_id,\n          answer,\n          offer_id: data.offer_id\n        }\n        if (this._trackerId) params.trackerid = this._trackerId\n        this._send(params)\n      })\n      peer.signal(data.offer)\n      this.client.emit('peer', peer)\n    }\n\n    if (data.answer && data.peer_id) {\n      const offerId = common.binaryToHex(data.offer_id)\n      peer = this.peers[offerId]\n      if (peer) {\n        peer.id = common.binaryToHex(data.peer_id)\n        peer.signal(data.answer)\n        this.client.emit('peer', peer)\n\n        clearTimeout(peer.trackerTimeout)\n        peer.trackerTimeout = null\n        delete this.peers[offerId]\n      } else {\n        debug(`got unexpected answer: ${JSON.stringify(data.answer)}`)\n      }\n    }\n  }\n\n  _onScrapeResponse (data) {\n    data = data.files || {}\n\n    const keys = Object.keys(data)\n    if (keys.length === 0) {\n      this.client.emit('warning', new Error('invalid scrape response'))\n      return\n    }\n\n    keys.forEach(infoHash => {\n      // TODO: optionally handle data.flags.min_request_interval\n      // (separate from announce interval)\n      const response = Object.assign(data[infoHash], {\n        announce: this.announceUrl,\n        infoHash: common.binaryToHex(infoHash)\n      })\n      this.client.emit('scrape', response)\n    })\n  }\n\n  _onSocketClose () {\n    if (this.destroyed) return\n    this.destroy()\n    this._startReconnectTimer()\n  }\n\n  _onSocketError (err) {\n    if (this.destroyed) return\n    this.destroy()\n    // errors will often happen if a tracker is offline, so don't treat it as fatal\n    this.client.emit('warning', err)\n    this._startReconnectTimer()\n  }\n\n  _startReconnectTimer () {\n    const ms = Math.floor(Math.random() * RECONNECT_VARIANCE) + Math.min(Math.pow(2, this.retries) * RECONNECT_MINIMUM, RECONNECT_MAXIMUM)\n\n    this.reconnecting = true\n    clearTimeout(this.reconnectTimer)\n    this.reconnectTimer = setTimeout(() => {\n      this.retries++\n      this._openSocket()\n    }, ms)\n    if (this.reconnectTimer.unref) this.reconnectTimer.unref()\n\n    debug('reconnecting socket in %s ms', ms)\n  }\n\n  _send (params) {\n    if (this.destroyed) return\n    this.expectingResponse = true\n    const message = JSON.stringify(params)\n    debug('send %s', message)\n    this.socket.send(message)\n  }\n\n  _generateOffers (numwant, cb) {\n    const self = this\n    const offers = []\n    debug('generating %s offers', numwant)\n\n    for (let i = 0; i < numwant; ++i) {\n      generateOffer()\n    }\n    checkDone()\n\n    function generateOffer () {\n      const offerId = randombytes(20).toString('hex')\n      debug('creating peer (from _generateOffers)')\n      const peer = self.peers[offerId] = self._createPeer({ initiator: true })\n      peer.once('signal', offer => {\n        offers.push({\n          offer,\n          offer_id: common.hexToBinary(offerId)\n        })\n        checkDone()\n      })\n      peer.trackerTimeout = setTimeout(() => {\n        debug('tracker timeout: destroying peer')\n        peer.trackerTimeout = null\n        delete self.peers[offerId]\n        peer.destroy()\n      }, OFFER_TIMEOUT)\n      if (peer.trackerTimeout.unref) peer.trackerTimeout.unref()\n    }\n\n    function checkDone () {\n      if (offers.length === numwant) {\n        debug('generated %s offers', numwant)\n        cb(offers)\n      }\n    }\n  }\n\n  _createPeer (opts) {\n    const self = this\n\n    opts = Object.assign({\n      trickle: false,\n      config: self.client._rtcConfig,\n      wrtc: self.client._wrtc\n    }, opts)\n\n    const peer = new Peer(opts)\n\n    peer.once('error', onError)\n    peer.once('connect', onConnect)\n\n    return peer\n\n    // Handle peer 'error' events that are fired *before* the peer is emitted in\n    // a 'peer' event.\n    function onError (err) {\n      self.client.emit('warning', new Error(`Connection error: ${err.message}`))\n      peer.destroy()\n    }\n\n    // Once the peer is emitted in a 'peer' event, then it's the consumer's\n    // responsibility to listen for errors, so the listeners are removed here.\n    function onConnect () {\n      peer.removeListener('error', onError)\n      peer.removeListener('connect', onConnect)\n    }\n  }\n}\n\nWebSocketTracker.prototype.DEFAULT_ANNOUNCE_INTERVAL = 30 * 1000 // 30 seconds\n// Normally this shouldn't be accessed but is occasionally useful\nWebSocketTracker._socketPool = socketPool\n\nfunction noop () {}\n\nmodule.exports = WebSocketTracker\n","/*! simple-websocket. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* global WebSocket */\n\nconst debug = require('debug')('simple-websocket')\nconst randombytes = require('randombytes')\nconst stream = require('readable-stream')\nconst queueMicrotask = require('queue-microtask') // TODO: remove when Node 10 is not supported\nconst ws = require('ws') // websockets in node - will be empty object in browser\n\nconst _WebSocket = typeof ws !== 'function' ? WebSocket : ws\n\nconst MAX_BUFFERED_AMOUNT = 64 * 1024\n\n/**\n * WebSocket. Same API as node core `net.Socket`. Duplex stream.\n * @param {Object} opts\n * @param {string=} opts.url websocket server url\n * @param {string=} opts.socket raw websocket instance to wrap\n */\nclass Socket extends stream.Duplex {\n  constructor (opts = {}) {\n    // Support simple usage: `new Socket(url)`\n    if (typeof opts === 'string') {\n      opts = { url: opts }\n    }\n\n    opts = Object.assign({\n      allowHalfOpen: false\n    }, opts)\n\n    super(opts)\n\n    if (opts.url == null && opts.socket == null) {\n      throw new Error('Missing required `url` or `socket` option')\n    }\n    if (opts.url != null && opts.socket != null) {\n      throw new Error('Must specify either `url` or `socket` option, not both')\n    }\n\n    this._id = randombytes(4).toString('hex').slice(0, 7)\n    this._debug('new websocket: %o', opts)\n\n    this.connected = false\n    this.destroyed = false\n\n    this._chunk = null\n    this._cb = null\n    this._interval = null\n\n    if (opts.socket) {\n      this.url = opts.socket.url\n      this._ws = opts.socket\n      this.connected = opts.socket.readyState === _WebSocket.OPEN\n    } else {\n      this.url = opts.url\n      try {\n        if (typeof ws === 'function') {\n          // `ws` package accepts options\n          this._ws = new _WebSocket(opts.url, null, {\n            ...opts,\n            encoding: undefined // encoding option breaks ws internals\n          })\n        } else {\n          this._ws = new _WebSocket(opts.url)\n        }\n      } catch (err) {\n        queueMicrotask(() => this.destroy(err))\n        return\n      }\n    }\n\n    this._ws.binaryType = 'arraybuffer'\n\n    if (opts.socket && this.connected) {\n      queueMicrotask(() => this._handleOpen())\n    } else {\n      this._ws.onopen = () => this._handleOpen()\n    }\n\n    this._ws.onmessage = event => this._handleMessage(event)\n    this._ws.onclose = () => this._handleClose()\n    this._ws.onerror = err => this._handleError(err)\n\n    this._handleFinishBound = () => this._handleFinish()\n    this.once('finish', this._handleFinishBound)\n  }\n\n  /**\n   * Send text/binary data to the WebSocket server.\n   * @param {TypedArrayView|ArrayBuffer|Buffer|string|Blob|Object} chunk\n   */\n  send (chunk) {\n    this._ws.send(chunk)\n  }\n\n  // TODO: Delete this method once readable-stream is updated to contain a default\n  // implementation of destroy() that automatically calls _destroy()\n  // See: https://github.com/nodejs/readable-stream/issues/283\n  destroy (err) {\n    this._destroy(err, () => {})\n  }\n\n  _destroy (err, cb) {\n    if (this.destroyed) return\n\n    this._debug('destroy (error: %s)', err && (err.message || err))\n\n    this.readable = this.writable = false\n    if (!this._readableState.ended) this.push(null)\n    if (!this._writableState.finished) this.end()\n\n    this.connected = false\n    this.destroyed = true\n\n    clearInterval(this._interval)\n    this._interval = null\n    this._chunk = null\n    this._cb = null\n\n    if (this._handleFinishBound) {\n      this.removeListener('finish', this._handleFinishBound)\n    }\n    this._handleFinishBound = null\n\n    if (this._ws) {\n      const ws = this._ws\n      const onClose = () => {\n        ws.onclose = null\n      }\n      if (ws.readyState === _WebSocket.CLOSED) {\n        onClose()\n      } else {\n        try {\n          ws.onclose = onClose\n          ws.close()\n        } catch (err) {\n          onClose()\n        }\n      }\n\n      ws.onopen = null\n      ws.onmessage = null\n      ws.onerror = () => {}\n    }\n    this._ws = null\n\n    if (err) this.emit('error', err)\n    this.emit('close')\n    cb()\n  }\n\n  _read () {}\n\n  _write (chunk, encoding, cb) {\n    if (this.destroyed) return cb(new Error('cannot write after socket is destroyed'))\n\n    if (this.connected) {\n      try {\n        this.send(chunk)\n      } catch (err) {\n        return this.destroy(err)\n      }\n      if (typeof ws !== 'function' && this._ws.bufferedAmount > MAX_BUFFERED_AMOUNT) {\n        this._debug('start backpressure: bufferedAmount %d', this._ws.bufferedAmount)\n        this._cb = cb\n      } else {\n        cb(null)\n      }\n    } else {\n      this._debug('write before connect')\n      this._chunk = chunk\n      this._cb = cb\n    }\n  }\n\n  _handleOpen () {\n    if (this.connected || this.destroyed) return\n    this.connected = true\n\n    if (this._chunk) {\n      try {\n        this.send(this._chunk)\n      } catch (err) {\n        return this.destroy(err)\n      }\n      this._chunk = null\n      this._debug('sent chunk from \"write before connect\"')\n\n      const cb = this._cb\n      this._cb = null\n      cb(null)\n    }\n\n    // Backpressure is not implemented in Node.js. The `ws` module has a buggy\n    // `bufferedAmount` property. See: https://github.com/websockets/ws/issues/492\n    if (typeof ws !== 'function') {\n      this._interval = setInterval(() => this._onInterval(), 150)\n      if (this._interval.unref) this._interval.unref()\n    }\n\n    this._debug('connect')\n    this.emit('connect')\n  }\n\n  _handleMessage (event) {\n    if (this.destroyed) return\n    let data = event.data\n    if (data instanceof ArrayBuffer) data = Buffer.from(data)\n    this.push(data)\n  }\n\n  _handleClose () {\n    if (this.destroyed) return\n    this._debug('on close')\n    this.destroy()\n  }\n\n  _handleError (_) {\n    this.destroy(new Error(`Error connecting to ${this.url}`))\n  }\n\n  // When stream finishes writing, close socket. Half open connections are not\n  // supported.\n  _handleFinish () {\n    if (this.destroyed) return\n\n    // Wait a bit before destroying so the socket flushes.\n    // TODO: is there a more reliable way to accomplish this?\n    const destroySoon = () => {\n      setTimeout(() => this.destroy(), 1000)\n    }\n\n    if (this.connected) {\n      destroySoon()\n    } else {\n      this.once('connect', destroySoon)\n    }\n  }\n\n  _onInterval () {\n    if (!this._cb || !this._ws || this._ws.bufferedAmount > MAX_BUFFERED_AMOUNT) {\n      return\n    }\n    this._debug('ending backpressure: bufferedAmount %d', this._ws.bufferedAmount)\n    const cb = this._cb\n    this._cb = null\n    cb(null)\n  }\n\n  _debug () {\n    const args = [].slice.call(arguments)\n    args[0] = '[' + this._id + '] ' + args[0]\n    debug.apply(null, args)\n  }\n}\n\nSocket.WEBSOCKET_SUPPORT = !!_WebSocket\n\nmodule.exports = Socket\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');\n","'use strict';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar _require = require('buffer'),\n    Buffer = _require.Buffer;\n\nvar _require2 = require('util'),\n    inspect = _require2.inspect;\n\nvar custom = inspect && inspect.custom || 'inspect';\n\nfunction copyBuffer(src, target, offset) {\n  Buffer.prototype.copy.call(src, target, offset);\n}\n\nmodule.exports =\n/*#__PURE__*/\nfunction () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\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\n      while (p = p.next) {\n        ret += s + p.data;\n      }\n\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\n      while (p) {\n        copyBuffer(p.data, ret, i);\n        i += p.data.length;\n        p = p.next;\n      }\n\n      return ret;\n    } // Consumes a specified amount of bytes or characters from the buffered data.\n\n  }, {\n    key: \"consume\",\n    value: function consume(n, hasStrings) {\n      var ret;\n\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\n      return ret;\n    }\n  }, {\n    key: \"first\",\n    value: function first() {\n      return this.head.data;\n    } // Consumes a specified amount of characters from the buffered data.\n\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\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\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\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Consumes a specified amount of bytes from the buffered data.\n\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\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\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\n          break;\n        }\n\n        ++c;\n      }\n\n      this.length -= c;\n      return ret;\n    } // Make sure the linked list only shows the minimal necessary information.\n\n  }, {\n    key: custom,\n    value: function value(_, options) {\n      return inspect(this, _objectSpread({}, options, {\n        // Only inspect one level.\n        depth: 0,\n        // It should not recurse.\n        customInspect: false\n      }));\n    }\n  }]);\n\n  return BufferList;\n}();","'use strict';\n\nvar _Object$setPrototypeO;\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar finished = require('./end-of-stream');\n\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');\n\nfunction createIterResult(value, done) {\n  return {\n    value: value,\n    done: done\n  };\n}\n\nfunction readAndResolve(iter) {\n  var resolve = iter[kLastResolve];\n\n  if (resolve !== null) {\n    var data = iter[kStream].read(); // we defer if data is null\n    // we can be expecting either 'end' or\n    // 'error'\n\n    if (data !== null) {\n      iter[kLastPromise] = null;\n      iter[kLastResolve] = null;\n      iter[kLastReject] = null;\n      resolve(createIterResult(data, false));\n    }\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}\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\n      iter[kHandlePromise](resolve, reject);\n    }, reject);\n  };\n}\n\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n  get stream() {\n    return this[kStream];\n  },\n\n  next: function next() {\n    var _this = this;\n\n    // if we have detected an error in the meanwhile\n    // reject straight away\n    var error = this[kError];\n\n    if (error !== null) {\n      return Promise.reject(error);\n    }\n\n    if (this[kEnded]) {\n      return Promise.resolve(createIterResult(undefined, true));\n    }\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    } // 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\n\n    var lastPromise = this[kLastPromise];\n    var promise;\n\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\n      if (data !== null) {\n        return Promise.resolve(createIterResult(data, false));\n      }\n\n      promise = new Promise(this[kHandlePromise]);\n    }\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\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\n      resolve(createIterResult(undefined, true));\n    });\n  });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\n\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n  var _Object$create;\n\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\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]; // reject if we are waiting for data in the Promise\n      // returned by next() and store the error\n\n      if (reject !== null) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        reject(err);\n      }\n\n      iterator[kError] = err;\n      return;\n    }\n\n    var resolve = iterator[kLastResolve];\n\n    if (resolve !== null) {\n      iterator[kLastPromise] = null;\n      iterator[kLastResolve] = null;\n      iterator[kLastReject] = null;\n      resolve(createIterResult(undefined, true));\n    }\n\n    iterator[kEnded] = true;\n  });\n  stream.on('readable', onReadable.bind(null, iterator));\n  return iterator;\n};\n\nmodule.exports = createReadableStreamAsyncIterator;","module.exports = function () {\n  throw new Error('Readable.from is not available in the browser')\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// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\nrequire('inherits')(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar eos;\n\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}\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;\n\nfunction noop(err) {\n  // Rethrow the error if it exists to avoid swallowing it\n  if (err) throw err;\n}\n\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\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; // request.destroy just do .end - .abort is what we want\n\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}\n\nfunction call(fn) {\n  fn();\n}\n\nfunction pipe(from, to) {\n  return from.pipe(to);\n}\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}\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\n  var callback = popCallback(streams);\n  if (Array.isArray(streams[0])) streams = streams[0];\n\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams');\n  }\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}\n\nmodule.exports = pipeline;","const EventEmitter = require('events')\n\nclass Tracker extends EventEmitter {\n  constructor (client, announceUrl) {\n    super()\n\n    this.client = client\n    this.announceUrl = announceUrl\n\n    this.interval = null\n    this.destroyed = false\n  }\n\n  setInterval (intervalMs) {\n    if (intervalMs == null) intervalMs = this.DEFAULT_ANNOUNCE_INTERVAL\n\n    clearInterval(this.interval)\n\n    if (intervalMs) {\n      this.interval = setInterval(() => {\n        this.announce(this.client._defaultAnnounceOpts())\n      }, intervalMs)\n      if (this.interval.unref) this.interval.unref()\n    }\n  }\n}\n\nmodule.exports = Tracker\n"],"sourceRoot":""}