{"version":3,"sources":["webpack:////workdir/node_modules/readable-stream/lib/_stream_transform.js","webpack:////workdir/node_modules/node-libs-browser/mock/process.js","webpack:////workdir/node_modules/public-encrypt/publicEncrypt.js","webpack:////workdir/node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:////workdir/node_modules/readable-stream/readable-browser.js","webpack:////workdir/node_modules/register-service-worker/index.js","webpack:////workdir/node_modules/public-encrypt/withPublic.js","webpack:////workdir/node_modules/pbkdf2/lib/to-buffer.js","webpack:////workdir/node_modules/sha.js/sha256.js","webpack:////workdir/node_modules/safe-buffer/index.js","webpack:////workdir/node_modules/sha.js/sha.js","webpack:////workdir/node_modules/public-encrypt/privateDecrypt.js","webpack:////workdir/node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js","webpack:////workdir/node_modules/randomstring/node_modules/randombytes/browser.js","webpack:////workdir/node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:////workdir/node_modules/randomfill/browser.js","webpack:////workdir/node_modules/public-encrypt/mgf.js","webpack:////workdir/node_modules/pbkdf2/lib/async.js","webpack:////workdir/node_modules/pbkdf2/lib/sync-browser.js","webpack:////workdir/node_modules/parseuri/index.js","webpack:////workdir/node_modules/readable-stream/passthrough.js","webpack:////workdir/node_modules/sha.js/sha224.js","webpack:////workdir/node_modules/process-nextick-args/index.js","webpack:////workdir/node_modules/minimalistic-assert/index.js","webpack:////workdir/node_modules/sha.js/sha512.js","webpack:////workdir/node_modules/safer-buffer/safer.js","webpack:////workdir/node_modules/parse-asn1/index.js","webpack:////workdir/node_modules/readable-stream/duplex-browser.js","webpack:////workdir/node_modules/public-encrypt/xor.js","webpack:////workdir/node_modules/randomstring/node_modules/array-uniq/index.js","webpack:////workdir/node_modules/minimalistic-crypto-utils/lib/utils.js","webpack:////workdir/node_modules/sha.js/index.js","webpack:////workdir/node_modules/readable-stream/node_modules/safe-buffer/index.js","webpack:////workdir/node_modules/pbkdf2/browser.js","webpack:////workdir/node_modules/randombytes/browser.js","webpack:////workdir/node_modules/nosleep.js/src/media.js","webpack:////workdir/node_modules/randomstring/index.js","webpack:////workdir/node_modules/sha.js/sha384.js","webpack:////workdir/node_modules/path-browserify/index.js","webpack:////workdir/node_modules/readable-stream/transform.js","webpack:////workdir/node_modules/randomstring/lib/randomstring.js","webpack:////workdir/node_modules/readable-stream/lib/_stream_readable.js","webpack:////workdir/node_modules/readable-stream/lib/_stream_passthrough.js","webpack:////workdir/node_modules/pbkdf2/lib/precondition.js","webpack:////workdir/node_modules/parse-asn1/fixProc.js","webpack:////workdir/node_modules/readable-stream/lib/_stream_duplex.js","webpack:////workdir/node_modules/randomstring/lib/charset.js","webpack:////workdir/node_modules/readable-stream/lib/_stream_writable.js","webpack:////workdir/node_modules/pbkdf2/lib/default-encoding.js","webpack:////workdir/node_modules/screenfull/index.js","webpack:////workdir/node_modules/miller-rabin/lib/mr.js","webpack:////workdir/node_modules/public-encrypt/browser.js","webpack:////workdir/node_modules/readable-stream/writable-browser.js","webpack:////workdir/node_modules/sha.js/hash.js","webpack:////workdir/node_modules/parseqs/index.js","webpack:////workdir/node_modules/md5.js/index.js","webpack:////workdir/node_modules/nosleep.js/src/index.js","webpack:////workdir/node_modules/parse-asn1/asn1.js","webpack:////workdir/node_modules/sha.js/sha1.js","webpack:////workdir/node_modules/parse-asn1/certificate.js","webpack:////workdir/node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:////workdir/node_modules/ripemd160/index.js"],"names":["module","exports","Transform","Duplex","util","Object","create","afterTransform","er","data","ts","this","_transformState","transforming","cb","writecb","emit","Error","writechunk","push","rs","_readableState","reading","needReadable","length","highWaterMark","_read","options","call","bind","needTransform","writeencoding","sync","transform","_transform","flush","_flush","on","prefinish","_this","done","stream","_writableState","inherits","prototype","chunk","encoding","_write","n","_destroy","err","_this2","err2","nextTick","fn","args","Array","slice","arguments","shift","setTimeout","apply","platform","arch","execPath","title","pid","browser","env","argv","binding","name","path","cwd","chdir","dir","resolve","exit","kill","umask","dlopen","uptime","memoryUsage","uvCounters","features","parseKeys","randomBytes","createHash","mgf","xor","BN","withPublic","crt","Buffer","oaep","key","msg","k","modulus","byteLength","mLen","iHash","update","alloc","digest","hLen","hLen2","ps","dblen","seed","maskedDb","concat","maskedSeed","pkcs1","reverse","nonZero","from","len","num","out","allocUnsafe","i","cache","cur","publicKey","padding","paddedMsg","cmp","_classCallCheck","instance","Constructor","TypeError","copyBuffer","src","target","offset","copy","BufferList","head","tail","v","entry","next","unshift","ret","clear","join","s","p","inspect","custom","obj","constructor","Stream","Readable","Writable","PassThrough","waitWindowLoad","isLocalhost","Boolean","window","location","hostname","match","register","swUrl","hooks","registrationOptions","hook","navigator","then","checkValidServiceWorker","serviceWorker","ready","registration","catch","error","handleError","registerValidSW","onLine","waiting","onupdatefound","installingWorker","installing","onstatechange","state","controller","fetch","response","status","unregister","headers","get","indexOf","Promise","addEventListener","toRed","mont","redPow","publicExponent","fromRed","toArray","thing","isBuffer","ArrayBuffer","isView","buffer","Hash","K","W","Sha256","init","_w","ch","x","y","z","maj","sigma0","sigma1","gamma0","gamma1","_a","_b","_c","_d","_e","_f","_g","_h","_update","M","a","b","c","d","e","f","g","h","readInt32BE","j","T1","T2","_hash","H","writeInt32BE","copyProps","dst","SafeBuffer","arg","encodingOrOffset","allocUnsafeSlow","size","fill","buf","undefined","SlowBuffer","Sha","rotl5","rotl30","ft","t","db","compare","p1","toString","dif","Math","min","privateKey","enc","zBuffer","MapShim","Map","getIndex","arr","result","some","index","class_1","__entries__","defineProperty","enumerable","configurable","set","value","delete","entries","splice","has","forEach","callback","ctx","_i","isBrowser","document","global$1","global","self","Function","requestAnimationFrame$1","requestAnimationFrame","Date","now","trailingTimeout","throttle","delay","leadingCall","trailingCall","lastCallTime","resolvePending","proxy","timeoutCallback","timeStamp","REFRESH_DELAY","transitionKeys","mutationObserverSupported","MutationObserver","ResizeObserverController","connected_","mutationEventsAdded_","mutationsObserver_","observers_","onTransitionEnd_","refresh","addObserver","observer","connect_","removeObserver","observers","disconnect_","changesDetected","updateObservers_","activeObservers","filter","gatherActive","hasActive","broadcastActive","observe","attributes","childList","characterData","subtree","removeEventListener","disconnect","propertyName","isReflowProperty","getInstance","instance_","defineConfigurable","props","keys","writable","getWindowOf","ownerGlobal","ownerDocument","defaultView","emptyRect","createRectInit","toFloat","parseFloat","getBordersSize","styles","positions","reduce","position","getPaddings","paddings","positions_1","getSVGContentRect","bbox","getBBox","width","height","getHTMLElementContentRect","clientWidth","clientHeight","getComputedStyle","horizPad","left","right","vertPad","top","bottom","boxSizing","round","isDocumentElement","vertScrollbar","horizScrollbar","abs","isSVGGraphicsElement","SVGGraphicsElement","SVGElement","documentElement","getContentRect","createReadOnlyRect","Constr","DOMRectReadOnly","rect","ResizeObservation","broadcastWidth","broadcastHeight","contentRect_","isActive","broadcastRect","ResizeObserverEntry","rectInit","contentRect","ResizeObserverSPI","callbackCtx","activeObservations_","observations_","callback_","controller_","callbackCtx_","Element","observations","unobserve","clearActive","observation","map","WeakMap","ResizeObserver","method","oldBrowser","crypto","msCrypto","rawBytes","Uint8Array","getRandomValues","bytes","process","pna","destroy","readableDestroyed","destroyed","writableDestroyed","errorEmitted","emitErrorNT","undestroy","ended","endEmitted","ending","finished","safeBuffer","randombytes","kBufferMaxLength","kMaxLength","kMaxUint32","pow","assertOffset","RangeError","assertSize","randomFill","actualFill","ourBuf","uint","randomFillSync","i2ops","writeUInt32BE","ZERO_BUF","checkParameters","defaultEncoding","toBuffer","subtle","toBrowser","sha","sha1","sha256","sha384","sha512","checks","checkNative","algo","importKey","deriveBits","prom","browserPbkdf2","getNextTick","queueMicrotask","setImmediate","password","salt","iterations","hash","res","resolvePromise","promise","keylen","toLowerCase","resp","md5","RIPEMD160","ZEROS","sizes","sha224","rmd160","ripemd160","Hmac","alg","saltLen","getDigest","blocksize","ipad","opad","ipad1","ipad2","shaFunc","rmd160Func","pbkdf2","hmac","DK","block1","destPos","l","ceil","T","run","U","re","parts","pathNames","regx","names","replace","split","substr","queryKey","uri","query","$0","$1","$2","str","substring","m","exec","source","host","authority","ipv6uri","Sha224","arg1","arg2","arg3","version","assert","val","equal","r","Sha512","Ch","xl","Gamma0","Gamma0l","Gamma1","Gamma1l","getCarry","_ah","_bh","_ch","_dh","_eh","_fh","_gh","_hh","_al","_bl","_cl","_dl","_el","_fl","_gl","_hl","ah","bh","dh","eh","fh","gh","hh","al","bl","cl","dl","el","fl","gl","hl","xh","gamma0l","gamma1l","Wi7h","Wi7l","Wi16h","Wi16l","Wil","Wih","majh","majl","sigma0h","sigma0l","sigma1h","sigma1l","Kih","Kil","chh","chl","t1l","t1h","t2l","t2h","writeInt64BE","safer","hasOwnProperty","Safer","kStringMaxLength","constants","MAX_LENGTH","MAX_STRING_LENGTH","asn1","aesid","fixProc","ciphers","compat","passphrase","subtype","ndata","stripped","type","tag","certificate","decode","tbsCertificate","subjectPublicKeyInfo","PublicKey","algorithm","RSAPublicKey","subjectPublicKey","subjectPrivateKey","params","pub_key","DSAparam","EncryptedPrivateKey","decrypt","PrivateKey","RSAPrivateKey","curve","ECPrivateKey","priv_key","DSAPrivateKey","parameters","kde","kdeparams","iters","parseInt","cipher","iv","cipherText","pbkdf2Sync","createDecipheriv","final","signature","uniqNoSet","uniqSet","seen","Set","add","uniqSetWithForEach","doesForEachActuallyWork","utils","isArray","charCodeAt","hi","lo","zero2","word","toHex","encode","Algorithm","MAX_BYTES","MAX_UINT32","generated","webm","mp4","SHA512","Sha384","normalizeArray","allowAboveRoot","up","last","basename","start","end","matchedSlash","xs","resolvedPath","resolvedAbsolute","charAt","normalize","isAbsolute","trailingSlash","paths","relative","to","trim","fromParts","toParts","samePartsLength","outputParts","sep","delimiter","dirname","code","hasRoot","ext","extname","startDot","startPart","preDotState","Charset","safeRandomBytes","processString","initialString","chars","reqLen","maxByte","string","randomByte","readUInt8","getAsyncString","generatedString","generate","charset","setType","capitalization","setcapitalization","readable","removeUnreadable","removeDuplicates","charsLen","ReadableState","EventEmitter","EElistenerCount","emitter","listeners","OurUint8Array","_uint8ArrayToBuffer","_isUint8Array","debugUtil","debug","debuglog","StringDecoder","destroyImpl","kProxyEvents","prependListener","event","_events","isDuplex","objectMode","readableObjectMode","hwm","readableHwm","readableHighWaterMark","defaultHwm","floor","pipes","pipesCount","flowing","emittedReadable","readableListening","resumeScheduled","awaitDrain","readingMore","decoder","read","readableAddChunk","addToFront","skipChunkCheck","onEofChunk","chunkInvalid","getPrototypeOf","addChunk","write","maybeReadMore","needMoreData","emitReadable","_undestroy","isPaused","setEncoding","MAX_HWM","computeNewHighWaterMark","howMuchToRead","emitReadable_","flow","maybeReadMore_","pipeOnDrain","nReadingNextTick","resume","resume_","fromList","fromListPartial","list","hasStrings","copyFromBufferString","copyFromBuffer","nb","endReadable","endReadableNT","nOrig","doRead","pipe","dest","pipeOpts","doEnd","stdout","stderr","endFn","onend","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanup","once","ondrain","cleanedUp","removeListener","onclose","onfinish","onerror","ondata","needDrain","increasedAwaitDrain","pause","dests","ev","addListener","wrap","paused","_fromList","MAX_ALLOC","findProc","startRegex","fullRegex","evp","okey","decrypted","suite","cipherKey","match2","objectKeys","allowHalfOpen","onEndNT","arrayUniq","numbers","charsLower","charsUpper","toUpperCase","hexChars","binaryChars","octalChars","unreadableChars","charMap","CorkedRequest","finish","onCorkedFinish","asyncWrite","WritableState","internalUtil","deprecate","realHasInstance","nop","writableObjectMode","writableHwm","writableHighWaterMark","finalCalled","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","bufferedRequestCount","corkedRequestsFree","writev","_writev","_final","writeAfterEnd","validChunk","valid","decodeChunk","writeOrBuffer","isBuf","newChunk","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","afterWrite","onwriteDrain","holder","count","allBuffers","callFinal","need","endWritable","corkReq","getBuffer","current","_","Symbol","hasInstance","object","cork","uncork","setDefaultEncoding","pVersionMajor","methodMap","nativeAPI","unprefixedMethods","returnValue","methodList","exitFullscreenMethod","eventNameMap","change","fullscreenchange","fullscreenerror","screenfull","request","element","reject","onFullScreenEntered","off","returnPromise","requestFullscreen","isFullscreen","onFullScreenExit","exitFullscreen","toggle","onchange","eventName","raw","defineProperties","fullscreenElement","isEnabled","fullscreenEnabled","bn","brorand","MillerRabin","rand","Rand","_randbelow","bitLength","min_bytes","_randrange","stop","sub","test","red","rone","max","n1","subn","testn","shrn","rn1","prime","redSqr","getDivisor","gcd","cmpn","publicEncrypt","privateDecrypt","privateEncrypt","publicDecrypt","blockSize","finalSize","_block","_finalSize","_blockSize","_len","block","accum","assigned","remainder","rem","bits","lowBits","highBits","encodeURIComponent","qs","qry","pairs","pair","decodeURIComponent","HashBase","ARRAY16","MD5","rotl","fnF","fnG","fnH","fnI","readInt32LE","_digest","_blockOffset","writeUInt32LE","_length","writeInt32LE","oldIOS","userAgent","MSStream","nativeWakeLock","NoSleep","enabled","_wakeLock","handleVisibilityChange","visibilityState","enable","noSleepTimer","noSleepVideo","createElement","setAttribute","_addSourceToVideo","duration","currentTime","random","dataURI","appendChild","wakeLock","console","log","message","disable","warn","setInterval","hidden","href","playPromise","play","release","clearInterval","define","seq","int","use","AlgorithmIdentifier","bitstr","objid","null_","optional","PrivateKeyInfo","octstr","EncryptedPrivateKeyInfo","explicit","ECParameters","choice","namedCurve","Sha1","rotl1","asn","Time","utcTime","utctime","generalTime","gentime","AttributeTypeValue","any","SubjectPublicKeyInfo","RelativeDistinguishedName","setof","RDNSequence","seqof","Name","rdnSequence","Validity","Extension","bool","def","TBSCertificate","implicit","X509Certificate","zl","zr","sl","sr","hr","fn1","fn2","fn3","fn4","fn5","words","ar","br","cr","dr","tl","tr"],"mappings":"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","file":"static/js/app-402f6fec.js","sourcesContent":["// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","exports.nextTick = function nextTick(fn) {\n    var args = Array.prototype.slice.call(arguments);\n    args.shift();\n    setTimeout(function () {\n        fn.apply(null, args);\n    }, 0);\n};\n\nexports.platform = exports.arch = \nexports.execPath = exports.title = 'browser';\nexports.pid = 1;\nexports.browser = true;\nexports.env = {};\nexports.argv = [];\n\nexports.binding = function (name) {\n\tthrow new Error('No such module. (Possibly not yet loaded)')\n};\n\n(function () {\n    var cwd = '/';\n    var path;\n    exports.cwd = function () { return cwd };\n    exports.chdir = function (dir) {\n        if (!path) path = require('path');\n        cwd = path.resolve(dir, cwd);\n    };\n})();\n\nexports.exit = exports.kill = \nexports.umask = exports.dlopen = \nexports.uptime = exports.memoryUsage = \nexports.uvCounters = function() {};\nexports.features = {};\n","var parseKeys = require('parse-asn1')\nvar randomBytes = require('randombytes')\nvar createHash = require('create-hash')\nvar mgf = require('./mgf')\nvar xor = require('./xor')\nvar BN = require('bn.js')\nvar withPublic = require('./withPublic')\nvar crt = require('browserify-rsa')\nvar Buffer = require('safe-buffer').Buffer\n\nmodule.exports = function publicEncrypt (publicKey, msg, reverse) {\n  var padding\n  if (publicKey.padding) {\n    padding = publicKey.padding\n  } else if (reverse) {\n    padding = 1\n  } else {\n    padding = 4\n  }\n  var key = parseKeys(publicKey)\n  var paddedMsg\n  if (padding === 4) {\n    paddedMsg = oaep(key, msg)\n  } else if (padding === 1) {\n    paddedMsg = pkcs1(key, msg, reverse)\n  } else if (padding === 3) {\n    paddedMsg = new BN(msg)\n    if (paddedMsg.cmp(key.modulus) >= 0) {\n      throw new Error('data too long for modulus')\n    }\n  } else {\n    throw new Error('unknown padding')\n  }\n  if (reverse) {\n    return crt(paddedMsg, key)\n  } else {\n    return withPublic(paddedMsg, key)\n  }\n}\n\nfunction oaep (key, msg) {\n  var k = key.modulus.byteLength()\n  var mLen = msg.length\n  var iHash = createHash('sha1').update(Buffer.alloc(0)).digest()\n  var hLen = iHash.length\n  var hLen2 = 2 * hLen\n  if (mLen > k - hLen2 - 2) {\n    throw new Error('message too long')\n  }\n  var ps = Buffer.alloc(k - mLen - hLen2 - 2)\n  var dblen = k - hLen - 1\n  var seed = randomBytes(hLen)\n  var maskedDb = xor(Buffer.concat([iHash, ps, Buffer.alloc(1, 1), msg], dblen), mgf(seed, dblen))\n  var maskedSeed = xor(seed, mgf(maskedDb, hLen))\n  return new BN(Buffer.concat([Buffer.alloc(1), maskedSeed, maskedDb], k))\n}\nfunction pkcs1 (key, msg, reverse) {\n  var mLen = msg.length\n  var k = key.modulus.byteLength()\n  if (mLen > k - 11) {\n    throw new Error('message too long')\n  }\n  var ps\n  if (reverse) {\n    ps = Buffer.alloc(k - mLen - 3, 0xff)\n  } else {\n    ps = nonZero(k - mLen - 3)\n  }\n  return new BN(Buffer.concat([Buffer.from([0, reverse ? 1 : 2]), ps, Buffer.alloc(1), msg], k))\n}\nfunction nonZero (len) {\n  var out = Buffer.allocUnsafe(len)\n  var i = 0\n  var cache = randomBytes(len * 2)\n  var cur = 0\n  var num\n  while (i < len) {\n    if (cur === cache.length) {\n      cache = randomBytes(len * 2)\n      cur = 0\n    }\n    num = cache[cur++]\n    if (num) {\n      out[i++] = num\n    }\n  }\n  return out\n}\n","'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require('safe-buffer').Buffer;\nvar util = require('util');\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\nif (util && util.inspect && util.inspect.custom) {\n  module.exports.prototype[util.inspect.custom] = function () {\n    var obj = util.inspect({ length: this.length });\n    return this.constructor.name + ' ' + obj;\n  };\n}","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","// Register a service worker to serve assets from local cache.\n\n// This lets the app load faster on subsequent visits in production, and gives\n// it offline capabilities. However, it also means that developers (and users)\n// will only see deployed updates on the \"N+1\" visit to a page, since previously\n// cached resources are updated in the background.\n\nvar isLocalhost = function () { return Boolean(\n  window.location.hostname === 'localhost' ||\n    // [::1] is the IPv6 localhost address.\n    window.location.hostname === '[::1]' ||\n    // 127.0.0.1/8 is considered localhost for IPv4.\n    window.location.hostname.match(\n      /^127(?:\\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/\n    )\n); }\n\nvar waitWindowLoad\n// https://github.com/yyx990803/register-service-worker/pull/33#discussion_r394181861\nif (typeof window !== 'undefined') {\n  // Typically, a browser that supports `serviceWorker` should also have supported\n  // `Promise`. But as this package can be used in environments without service\n  // worker support (in that case it would do nothing), there's a chance that\n  // `Promise` does not exist. So we must check for its existence first.\n  if (typeof Promise !== 'undefined') {\n    waitWindowLoad = new Promise(function (resolve) { return window.addEventListener('load', resolve); })\n  } else {\n    waitWindowLoad = { then: function (cb) { return window.addEventListener('load', cb); } }\n  }\n}\n\nexport function register (swUrl, hooks) {\n  if ( hooks === void 0 ) hooks = {};\n\n  var registrationOptions = hooks.registrationOptions; if ( registrationOptions === void 0 ) registrationOptions = {};\n  delete hooks.registrationOptions\n\n  var emit = function (hook) {\n    var args = [], len = arguments.length - 1;\n    while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];\n\n    if (hooks && hooks[hook]) {\n      hooks[hook].apply(hooks, args)\n    }\n  }\n\n  if ('serviceWorker' in navigator) {\n    waitWindowLoad.then(function () {\n      if (isLocalhost()) {\n        // This is running on localhost. Lets check if a service worker still exists or not.\n        checkValidServiceWorker(swUrl, emit, registrationOptions)\n        navigator.serviceWorker.ready.then(function (registration) {\n          emit('ready', registration)\n        }).catch(function (error) { return handleError(emit, error); })\n      } else {\n        // Is not local host. Just register service worker\n        registerValidSW(swUrl, emit, registrationOptions)\n        navigator.serviceWorker.ready.then(function (registration) {\n          emit('ready', registration)\n        }).catch(function (error) { return handleError(emit, error); })\n      }\n    })\n  }\n}\n\nfunction handleError (emit, error) {\n  if (!navigator.onLine) {\n    emit('offline')\n  }\n  emit('error', error)\n}\n\nfunction registerValidSW (swUrl, emit, registrationOptions) {\n  navigator.serviceWorker\n    .register(swUrl, registrationOptions)\n    .then(function (registration) {\n      emit('registered', registration)\n      if (registration.waiting) {\n        emit('updated', registration)\n        return\n      }\n      registration.onupdatefound = function () {\n        emit('updatefound', registration)\n        var installingWorker = registration.installing\n        installingWorker.onstatechange = function () {\n          if (installingWorker.state === 'installed') {\n            if (navigator.serviceWorker.controller) {\n              // At this point, the old content will have been purged and\n              // the fresh content will have been added to the cache.\n              // It's the perfect time to display a \"New content is\n              // available; please refresh.\" message in your web app.\n              emit('updated', registration)\n            } else {\n              // At this point, everything has been precached.\n              // It's the perfect time to display a\n              // \"Content is cached for offline use.\" message.\n              emit('cached', registration)\n            }\n          }\n        }\n      }\n    })\n    .catch(function (error) { return handleError(emit, error); })\n}\n\nfunction checkValidServiceWorker (swUrl, emit, registrationOptions) {\n  // Check if the service worker can be found.\n  fetch(swUrl)\n    .then(function (response) {\n      // Ensure service worker exists, and that we really are getting a JS file.\n      if (response.status === 404) {\n        // No service worker found.\n        emit('error', new Error((\"Service worker not found at \" + swUrl)))\n        unregister()\n      } else if (response.headers.get('content-type').indexOf('javascript') === -1) {\n        emit('error', new Error(\n          \"Expected \" + swUrl + \" to have javascript content-type, \" +\n          \"but received \" + (response.headers.get('content-type'))))\n        unregister()\n      } else {\n        // Service worker found. Proceed as normal.\n        registerValidSW(swUrl, emit, registrationOptions)\n      }\n    })\n    .catch(function (error) { return handleError(emit, error); })\n}\n\nexport function unregister () {\n  if ('serviceWorker' in navigator) {\n    navigator.serviceWorker.ready.then(function (registration) {\n      registration.unregister()\n    }).catch(function (error) { return handleError(emit, error); })\n  }\n}\n","var BN = require('bn.js')\nvar Buffer = require('safe-buffer').Buffer\n\nfunction withPublic (paddedMsg, key) {\n  return Buffer.from(paddedMsg\n    .toRed(BN.mont(key.modulus))\n    .redPow(new BN(key.publicExponent))\n    .fromRed()\n    .toArray())\n}\n\nmodule.exports = withPublic\n","var Buffer = require('safe-buffer').Buffer\n\nmodule.exports = function (thing, encoding, name) {\n  if (Buffer.isBuffer(thing)) {\n    return thing\n  } else if (typeof thing === 'string') {\n    return Buffer.from(thing, encoding)\n  } else if (ArrayBuffer.isView(thing)) {\n    return Buffer.from(thing.buffer)\n  } else {\n    throw new TypeError(name + ' must be a string, a Buffer, a typed array or a DataView')\n  }\n}\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,\n  0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,\n  0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,\n  0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,\n  0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,\n  0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,\n  0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,\n  0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,\n  0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,\n  0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,\n  0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,\n  0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,\n  0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,\n  0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,\n  0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,\n  0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2\n]\n\nvar W = new Array(64)\n\nfunction Sha256 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha256, Hash)\n\nSha256.prototype.init = function () {\n  this._a = 0x6a09e667\n  this._b = 0xbb67ae85\n  this._c = 0x3c6ef372\n  this._d = 0xa54ff53a\n  this._e = 0x510e527f\n  this._f = 0x9b05688c\n  this._g = 0x1f83d9ab\n  this._h = 0x5be0cd19\n\n  return this\n}\n\nfunction ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x) {\n  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)\n}\n\nfunction sigma1 (x) {\n  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)\n}\n\nfunction gamma0 (x) {\n  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)\n}\n\nfunction gamma1 (x) {\n  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)\n}\n\nSha256.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n  var f = this._f | 0\n  var g = this._g | 0\n  var h = this._h | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0\n\n  for (var j = 0; j < 64; ++j) {\n    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0\n    var T2 = (sigma0(a) + maj(a, b, c)) | 0\n\n    h = g\n    g = f\n    f = e\n    e = (d + T1) | 0\n    d = c\n    c = b\n    b = a\n    a = (T1 + T2) | 0\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n  this._f = (f + this._f) | 0\n  this._g = (g + this._g) | 0\n  this._h = (h + this._h) | 0\n}\n\nSha256.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(32)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n  H.writeInt32BE(this._h, 28)\n\n  return H\n}\n\nmodule.exports = Sha256\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 * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined\n * in FIPS PUB 180-1\n * This source code is derived from sha1.js of the same repository.\n * The difference between SHA-0 and SHA-1 is just a bitwise rotate left\n * operation was added.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha, Hash)\n\nSha.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha\n","var parseKeys = require('parse-asn1')\nvar mgf = require('./mgf')\nvar xor = require('./xor')\nvar BN = require('bn.js')\nvar crt = require('browserify-rsa')\nvar createHash = require('create-hash')\nvar withPublic = require('./withPublic')\nvar Buffer = require('safe-buffer').Buffer\n\nmodule.exports = function privateDecrypt (privateKey, enc, reverse) {\n  var padding\n  if (privateKey.padding) {\n    padding = privateKey.padding\n  } else if (reverse) {\n    padding = 1\n  } else {\n    padding = 4\n  }\n\n  var key = parseKeys(privateKey)\n  var k = key.modulus.byteLength()\n  if (enc.length > k || new BN(enc).cmp(key.modulus) >= 0) {\n    throw new Error('decryption error')\n  }\n  var msg\n  if (reverse) {\n    msg = withPublic(new BN(enc), key)\n  } else {\n    msg = crt(enc, key)\n  }\n  var zBuffer = Buffer.alloc(k - msg.length)\n  msg = Buffer.concat([zBuffer, msg], k)\n  if (padding === 4) {\n    return oaep(key, msg)\n  } else if (padding === 1) {\n    return pkcs1(key, msg, reverse)\n  } else if (padding === 3) {\n    return msg\n  } else {\n    throw new Error('unknown padding')\n  }\n}\n\nfunction oaep (key, msg) {\n  var k = key.modulus.byteLength()\n  var iHash = createHash('sha1').update(Buffer.alloc(0)).digest()\n  var hLen = iHash.length\n  if (msg[0] !== 0) {\n    throw new Error('decryption error')\n  }\n  var maskedSeed = msg.slice(1, hLen + 1)\n  var maskedDb = msg.slice(hLen + 1)\n  var seed = xor(maskedSeed, mgf(maskedDb, hLen))\n  var db = xor(maskedDb, mgf(seed, k - hLen - 1))\n  if (compare(iHash, db.slice(0, hLen))) {\n    throw new Error('decryption error')\n  }\n  var i = hLen\n  while (db[i] === 0) {\n    i++\n  }\n  if (db[i++] !== 1) {\n    throw new Error('decryption error')\n  }\n  return db.slice(i)\n}\n\nfunction pkcs1 (key, msg, reverse) {\n  var p1 = msg.slice(0, 2)\n  var i = 2\n  var status = 0\n  while (msg[i++] !== 0) {\n    if (i >= msg.length) {\n      status++\n      break\n    }\n  }\n  var ps = msg.slice(2, i - 1)\n\n  if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !== '0001' && reverse)) {\n    status++\n  }\n  if (ps.length < 8) {\n    status++\n  }\n  if (status) {\n    throw new Error('decryption error')\n  }\n  return msg.slice(i)\n}\nfunction compare (a, b) {\n  a = Buffer.from(a)\n  b = Buffer.from(b)\n  var dif = 0\n  var len = a.length\n  if (a.length !== b.length) {\n    dif++\n    len = Math.min(a.length, b.length)\n  }\n  var i = -1\n  while (++i < len) {\n    dif += (a[i] ^ b[i])\n  }\n  return dif\n}\n","/**\r\n * A collection of shims that provide minimal functionality of the ES6 collections.\r\n *\r\n * These implementations are not meant to be used outside of the ResizeObserver\r\n * modules as they cover only a limited range of use cases.\r\n */\r\n/* eslint-disable require-jsdoc, valid-jsdoc */\r\nvar MapShim = (function () {\r\n    if (typeof Map !== 'undefined') {\r\n        return Map;\r\n    }\r\n    /**\r\n     * Returns index in provided array that matches the specified key.\r\n     *\r\n     * @param {Array<Array>} arr\r\n     * @param {*} key\r\n     * @returns {number}\r\n     */\r\n    function getIndex(arr, key) {\r\n        var result = -1;\r\n        arr.some(function (entry, index) {\r\n            if (entry[0] === key) {\r\n                result = index;\r\n                return true;\r\n            }\r\n            return false;\r\n        });\r\n        return result;\r\n    }\r\n    return /** @class */ (function () {\r\n        function class_1() {\r\n            this.__entries__ = [];\r\n        }\r\n        Object.defineProperty(class_1.prototype, \"size\", {\r\n            /**\r\n             * @returns {boolean}\r\n             */\r\n            get: function () {\r\n                return this.__entries__.length;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        /**\r\n         * @param {*} key\r\n         * @returns {*}\r\n         */\r\n        class_1.prototype.get = function (key) {\r\n            var index = getIndex(this.__entries__, key);\r\n            var entry = this.__entries__[index];\r\n            return entry && entry[1];\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @param {*} value\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.set = function (key, value) {\r\n            var index = getIndex(this.__entries__, key);\r\n            if (~index) {\r\n                this.__entries__[index][1] = value;\r\n            }\r\n            else {\r\n                this.__entries__.push([key, value]);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.delete = function (key) {\r\n            var entries = this.__entries__;\r\n            var index = getIndex(entries, key);\r\n            if (~index) {\r\n                entries.splice(index, 1);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.has = function (key) {\r\n            return !!~getIndex(this.__entries__, key);\r\n        };\r\n        /**\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.clear = function () {\r\n            this.__entries__.splice(0);\r\n        };\r\n        /**\r\n         * @param {Function} callback\r\n         * @param {*} [ctx=null]\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.forEach = function (callback, ctx) {\r\n            if (ctx === void 0) { ctx = null; }\r\n            for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {\r\n                var entry = _a[_i];\r\n                callback.call(ctx, entry[1], entry[0]);\r\n            }\r\n        };\r\n        return class_1;\r\n    }());\r\n})();\n\n/**\r\n * Detects whether window and document objects are available in current environment.\r\n */\r\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;\n\n// Returns global object of a current environment.\r\nvar global$1 = (function () {\r\n    if (typeof global !== 'undefined' && global.Math === Math) {\r\n        return global;\r\n    }\r\n    if (typeof self !== 'undefined' && self.Math === Math) {\r\n        return self;\r\n    }\r\n    if (typeof window !== 'undefined' && window.Math === Math) {\r\n        return window;\r\n    }\r\n    // eslint-disable-next-line no-new-func\r\n    return Function('return this')();\r\n})();\n\n/**\r\n * A shim for the requestAnimationFrame which falls back to the setTimeout if\r\n * first one is not supported.\r\n *\r\n * @returns {number} Requests' identifier.\r\n */\r\nvar requestAnimationFrame$1 = (function () {\r\n    if (typeof requestAnimationFrame === 'function') {\r\n        // It's required to use a bounded function because IE sometimes throws\r\n        // an \"Invalid calling object\" error if rAF is invoked without the global\r\n        // object on the left hand side.\r\n        return requestAnimationFrame.bind(global$1);\r\n    }\r\n    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };\r\n})();\n\n// Defines minimum timeout before adding a trailing call.\r\nvar trailingTimeout = 2;\r\n/**\r\n * Creates a wrapper function which ensures that provided callback will be\r\n * invoked only once during the specified delay period.\r\n *\r\n * @param {Function} callback - Function to be invoked after the delay period.\r\n * @param {number} delay - Delay after which to invoke callback.\r\n * @returns {Function}\r\n */\r\nfunction throttle (callback, delay) {\r\n    var leadingCall = false, trailingCall = false, lastCallTime = 0;\r\n    /**\r\n     * Invokes the original callback function and schedules new invocation if\r\n     * the \"proxy\" was called during current request.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function resolvePending() {\r\n        if (leadingCall) {\r\n            leadingCall = false;\r\n            callback();\r\n        }\r\n        if (trailingCall) {\r\n            proxy();\r\n        }\r\n    }\r\n    /**\r\n     * Callback invoked after the specified delay. It will further postpone\r\n     * invocation of the original function delegating it to the\r\n     * requestAnimationFrame.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function timeoutCallback() {\r\n        requestAnimationFrame$1(resolvePending);\r\n    }\r\n    /**\r\n     * Schedules invocation of the original function.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function proxy() {\r\n        var timeStamp = Date.now();\r\n        if (leadingCall) {\r\n            // Reject immediately following calls.\r\n            if (timeStamp - lastCallTime < trailingTimeout) {\r\n                return;\r\n            }\r\n            // Schedule new call to be in invoked when the pending one is resolved.\r\n            // This is important for \"transitions\" which never actually start\r\n            // immediately so there is a chance that we might miss one if change\r\n            // happens amids the pending invocation.\r\n            trailingCall = true;\r\n        }\r\n        else {\r\n            leadingCall = true;\r\n            trailingCall = false;\r\n            setTimeout(timeoutCallback, delay);\r\n        }\r\n        lastCallTime = timeStamp;\r\n    }\r\n    return proxy;\r\n}\n\n// Minimum delay before invoking the update of observers.\r\nvar REFRESH_DELAY = 20;\r\n// A list of substrings of CSS properties used to find transition events that\r\n// might affect dimensions of observed elements.\r\nvar transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];\r\n// Check if MutationObserver is available.\r\nvar mutationObserverSupported = typeof MutationObserver !== 'undefined';\r\n/**\r\n * Singleton controller class which handles updates of ResizeObserver instances.\r\n */\r\nvar ResizeObserverController = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserverController.\r\n     *\r\n     * @private\r\n     */\r\n    function ResizeObserverController() {\r\n        /**\r\n         * Indicates whether DOM listeners have been added.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.connected_ = false;\r\n        /**\r\n         * Tells that controller has subscribed for Mutation Events.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.mutationEventsAdded_ = false;\r\n        /**\r\n         * Keeps reference to the instance of MutationObserver.\r\n         *\r\n         * @private {MutationObserver}\r\n         */\r\n        this.mutationsObserver_ = null;\r\n        /**\r\n         * A list of connected observers.\r\n         *\r\n         * @private {Array<ResizeObserverSPI>}\r\n         */\r\n        this.observers_ = [];\r\n        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);\r\n        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);\r\n    }\r\n    /**\r\n     * Adds observer to observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be added.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.addObserver = function (observer) {\r\n        if (!~this.observers_.indexOf(observer)) {\r\n            this.observers_.push(observer);\r\n        }\r\n        // Add listeners if they haven't been added yet.\r\n        if (!this.connected_) {\r\n            this.connect_();\r\n        }\r\n    };\r\n    /**\r\n     * Removes observer from observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be removed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.removeObserver = function (observer) {\r\n        var observers = this.observers_;\r\n        var index = observers.indexOf(observer);\r\n        // Remove observer if it's present in registry.\r\n        if (~index) {\r\n            observers.splice(index, 1);\r\n        }\r\n        // Remove listeners if controller has no connected observers.\r\n        if (!observers.length && this.connected_) {\r\n            this.disconnect_();\r\n        }\r\n    };\r\n    /**\r\n     * Invokes the update of observers. It will continue running updates insofar\r\n     * it detects changes.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.refresh = function () {\r\n        var changesDetected = this.updateObservers_();\r\n        // Continue running updates if changes have been detected as there might\r\n        // be future ones caused by CSS transitions.\r\n        if (changesDetected) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Updates every observer from observers list and notifies them of queued\r\n     * entries.\r\n     *\r\n     * @private\r\n     * @returns {boolean} Returns \"true\" if any observer has detected changes in\r\n     *      dimensions of it's elements.\r\n     */\r\n    ResizeObserverController.prototype.updateObservers_ = function () {\r\n        // Collect observers that have active observations.\r\n        var activeObservers = this.observers_.filter(function (observer) {\r\n            return observer.gatherActive(), observer.hasActive();\r\n        });\r\n        // Deliver notifications in a separate cycle in order to avoid any\r\n        // collisions between observers, e.g. when multiple instances of\r\n        // ResizeObserver are tracking the same element and the callback of one\r\n        // of them changes content dimensions of the observed target. Sometimes\r\n        // this may result in notifications being blocked for the rest of observers.\r\n        activeObservers.forEach(function (observer) { return observer.broadcastActive(); });\r\n        return activeObservers.length > 0;\r\n    };\r\n    /**\r\n     * Initializes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.connect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already added.\r\n        if (!isBrowser || this.connected_) {\r\n            return;\r\n        }\r\n        // Subscription to the \"Transitionend\" event is used as a workaround for\r\n        // delayed transitions. This way it's possible to capture at least the\r\n        // final state of an element.\r\n        document.addEventListener('transitionend', this.onTransitionEnd_);\r\n        window.addEventListener('resize', this.refresh);\r\n        if (mutationObserverSupported) {\r\n            this.mutationsObserver_ = new MutationObserver(this.refresh);\r\n            this.mutationsObserver_.observe(document, {\r\n                attributes: true,\r\n                childList: true,\r\n                characterData: true,\r\n                subtree: true\r\n            });\r\n        }\r\n        else {\r\n            document.addEventListener('DOMSubtreeModified', this.refresh);\r\n            this.mutationEventsAdded_ = true;\r\n        }\r\n        this.connected_ = true;\r\n    };\r\n    /**\r\n     * Removes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.disconnect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already removed.\r\n        if (!isBrowser || !this.connected_) {\r\n            return;\r\n        }\r\n        document.removeEventListener('transitionend', this.onTransitionEnd_);\r\n        window.removeEventListener('resize', this.refresh);\r\n        if (this.mutationsObserver_) {\r\n            this.mutationsObserver_.disconnect();\r\n        }\r\n        if (this.mutationEventsAdded_) {\r\n            document.removeEventListener('DOMSubtreeModified', this.refresh);\r\n        }\r\n        this.mutationsObserver_ = null;\r\n        this.mutationEventsAdded_ = false;\r\n        this.connected_ = false;\r\n    };\r\n    /**\r\n     * \"Transitionend\" event handler.\r\n     *\r\n     * @private\r\n     * @param {TransitionEvent} event\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {\r\n        var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;\r\n        // Detect whether transition may affect dimensions of an element.\r\n        var isReflowProperty = transitionKeys.some(function (key) {\r\n            return !!~propertyName.indexOf(key);\r\n        });\r\n        if (isReflowProperty) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Returns instance of the ResizeObserverController.\r\n     *\r\n     * @returns {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.getInstance = function () {\r\n        if (!this.instance_) {\r\n            this.instance_ = new ResizeObserverController();\r\n        }\r\n        return this.instance_;\r\n    };\r\n    /**\r\n     * Holds reference to the controller's instance.\r\n     *\r\n     * @private {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.instance_ = null;\r\n    return ResizeObserverController;\r\n}());\n\n/**\r\n * Defines non-writable/enumerable properties of the provided target object.\r\n *\r\n * @param {Object} target - Object for which to define properties.\r\n * @param {Object} props - Properties to be defined.\r\n * @returns {Object} Target object.\r\n */\r\nvar defineConfigurable = (function (target, props) {\r\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\r\n        var key = _a[_i];\r\n        Object.defineProperty(target, key, {\r\n            value: props[key],\r\n            enumerable: false,\r\n            writable: false,\r\n            configurable: true\r\n        });\r\n    }\r\n    return target;\r\n});\n\n/**\r\n * Returns the global object associated with provided element.\r\n *\r\n * @param {Object} target\r\n * @returns {Object}\r\n */\r\nvar getWindowOf = (function (target) {\r\n    // Assume that the element is an instance of Node, which means that it\r\n    // has the \"ownerDocument\" property from which we can retrieve a\r\n    // corresponding global object.\r\n    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;\r\n    // Return the local global object if it's not possible extract one from\r\n    // provided element.\r\n    return ownerGlobal || global$1;\r\n});\n\n// Placeholder of an empty content rectangle.\r\nvar emptyRect = createRectInit(0, 0, 0, 0);\r\n/**\r\n * Converts provided string to a number.\r\n *\r\n * @param {number|string} value\r\n * @returns {number}\r\n */\r\nfunction toFloat(value) {\r\n    return parseFloat(value) || 0;\r\n}\r\n/**\r\n * Extracts borders size from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @param {...string} positions - Borders positions (top, right, ...)\r\n * @returns {number}\r\n */\r\nfunction getBordersSize(styles) {\r\n    var positions = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        positions[_i - 1] = arguments[_i];\r\n    }\r\n    return positions.reduce(function (size, position) {\r\n        var value = styles['border-' + position + '-width'];\r\n        return size + toFloat(value);\r\n    }, 0);\r\n}\r\n/**\r\n * Extracts paddings sizes from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @returns {Object} Paddings box.\r\n */\r\nfunction getPaddings(styles) {\r\n    var positions = ['top', 'right', 'bottom', 'left'];\r\n    var paddings = {};\r\n    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {\r\n        var position = positions_1[_i];\r\n        var value = styles['padding-' + position];\r\n        paddings[position] = toFloat(value);\r\n    }\r\n    return paddings;\r\n}\r\n/**\r\n * Calculates content rectangle of provided SVG element.\r\n *\r\n * @param {SVGGraphicsElement} target - Element content rectangle of which needs\r\n *      to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getSVGContentRect(target) {\r\n    var bbox = target.getBBox();\r\n    return createRectInit(0, 0, bbox.width, bbox.height);\r\n}\r\n/**\r\n * Calculates content rectangle of provided HTMLElement.\r\n *\r\n * @param {HTMLElement} target - Element for which to calculate the content rectangle.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getHTMLElementContentRect(target) {\r\n    // Client width & height properties can't be\r\n    // used exclusively as they provide rounded values.\r\n    var clientWidth = target.clientWidth, clientHeight = target.clientHeight;\r\n    // By this condition we can catch all non-replaced inline, hidden and\r\n    // detached elements. Though elements with width & height properties less\r\n    // than 0.5 will be discarded as well.\r\n    //\r\n    // Without it we would need to implement separate methods for each of\r\n    // those cases and it's not possible to perform a precise and performance\r\n    // effective test for hidden elements. E.g. even jQuery's ':visible' filter\r\n    // gives wrong results for elements with width & height less than 0.5.\r\n    if (!clientWidth && !clientHeight) {\r\n        return emptyRect;\r\n    }\r\n    var styles = getWindowOf(target).getComputedStyle(target);\r\n    var paddings = getPaddings(styles);\r\n    var horizPad = paddings.left + paddings.right;\r\n    var vertPad = paddings.top + paddings.bottom;\r\n    // Computed styles of width & height are being used because they are the\r\n    // only dimensions available to JS that contain non-rounded values. It could\r\n    // be possible to utilize the getBoundingClientRect if only it's data wasn't\r\n    // affected by CSS transformations let alone paddings, borders and scroll bars.\r\n    var width = toFloat(styles.width), height = toFloat(styles.height);\r\n    // Width & height include paddings and borders when the 'border-box' box\r\n    // model is applied (except for IE).\r\n    if (styles.boxSizing === 'border-box') {\r\n        // Following conditions are required to handle Internet Explorer which\r\n        // doesn't include paddings and borders to computed CSS dimensions.\r\n        //\r\n        // We can say that if CSS dimensions + paddings are equal to the \"client\"\r\n        // properties then it's either IE, and thus we don't need to subtract\r\n        // anything, or an element merely doesn't have paddings/borders styles.\r\n        if (Math.round(width + horizPad) !== clientWidth) {\r\n            width -= getBordersSize(styles, 'left', 'right') + horizPad;\r\n        }\r\n        if (Math.round(height + vertPad) !== clientHeight) {\r\n            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;\r\n        }\r\n    }\r\n    // Following steps can't be applied to the document's root element as its\r\n    // client[Width/Height] properties represent viewport area of the window.\r\n    // Besides, it's as well not necessary as the <html> itself neither has\r\n    // rendered scroll bars nor it can be clipped.\r\n    if (!isDocumentElement(target)) {\r\n        // In some browsers (only in Firefox, actually) CSS width & height\r\n        // include scroll bars size which can be removed at this step as scroll\r\n        // bars are the only difference between rounded dimensions + paddings\r\n        // and \"client\" properties, though that is not always true in Chrome.\r\n        var vertScrollbar = Math.round(width + horizPad) - clientWidth;\r\n        var horizScrollbar = Math.round(height + vertPad) - clientHeight;\r\n        // Chrome has a rather weird rounding of \"client\" properties.\r\n        // E.g. for an element with content width of 314.2px it sometimes gives\r\n        // the client width of 315px and for the width of 314.7px it may give\r\n        // 314px. And it doesn't happen all the time. So just ignore this delta\r\n        // as a non-relevant.\r\n        if (Math.abs(vertScrollbar) !== 1) {\r\n            width -= vertScrollbar;\r\n        }\r\n        if (Math.abs(horizScrollbar) !== 1) {\r\n            height -= horizScrollbar;\r\n        }\r\n    }\r\n    return createRectInit(paddings.left, paddings.top, width, height);\r\n}\r\n/**\r\n * Checks whether provided element is an instance of the SVGGraphicsElement.\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nvar isSVGGraphicsElement = (function () {\r\n    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement\r\n    // interface.\r\n    if (typeof SVGGraphicsElement !== 'undefined') {\r\n        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };\r\n    }\r\n    // If it's so, then check that element is at least an instance of the\r\n    // SVGElement and that it has the \"getBBox\" method.\r\n    // eslint-disable-next-line no-extra-parens\r\n    return function (target) { return (target instanceof getWindowOf(target).SVGElement &&\r\n        typeof target.getBBox === 'function'); };\r\n})();\r\n/**\r\n * Checks whether provided element is a document element (<html>).\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nfunction isDocumentElement(target) {\r\n    return target === getWindowOf(target).document.documentElement;\r\n}\r\n/**\r\n * Calculates an appropriate content rectangle for provided html or svg element.\r\n *\r\n * @param {Element} target - Element content rectangle of which needs to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getContentRect(target) {\r\n    if (!isBrowser) {\r\n        return emptyRect;\r\n    }\r\n    if (isSVGGraphicsElement(target)) {\r\n        return getSVGContentRect(target);\r\n    }\r\n    return getHTMLElementContentRect(target);\r\n}\r\n/**\r\n * Creates rectangle with an interface of the DOMRectReadOnly.\r\n * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly\r\n *\r\n * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.\r\n * @returns {DOMRectReadOnly}\r\n */\r\nfunction createReadOnlyRect(_a) {\r\n    var x = _a.x, y = _a.y, width = _a.width, height = _a.height;\r\n    // If DOMRectReadOnly is available use it as a prototype for the rectangle.\r\n    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;\r\n    var rect = Object.create(Constr.prototype);\r\n    // Rectangle's properties are not writable and non-enumerable.\r\n    defineConfigurable(rect, {\r\n        x: x, y: y, width: width, height: height,\r\n        top: y,\r\n        right: x + width,\r\n        bottom: height + y,\r\n        left: x\r\n    });\r\n    return rect;\r\n}\r\n/**\r\n * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.\r\n * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit\r\n *\r\n * @param {number} x - X coordinate.\r\n * @param {number} y - Y coordinate.\r\n * @param {number} width - Rectangle's width.\r\n * @param {number} height - Rectangle's height.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction createRectInit(x, y, width, height) {\r\n    return { x: x, y: y, width: width, height: height };\r\n}\n\n/**\r\n * Class that is responsible for computations of the content rectangle of\r\n * provided DOM element and for keeping track of it's changes.\r\n */\r\nvar ResizeObservation = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObservation.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     */\r\n    function ResizeObservation(target) {\r\n        /**\r\n         * Broadcasted width of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastWidth = 0;\r\n        /**\r\n         * Broadcasted height of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastHeight = 0;\r\n        /**\r\n         * Reference to the last observed content rectangle.\r\n         *\r\n         * @private {DOMRectInit}\r\n         */\r\n        this.contentRect_ = createRectInit(0, 0, 0, 0);\r\n        this.target = target;\r\n    }\r\n    /**\r\n     * Updates content rectangle and tells whether it's width or height properties\r\n     * have changed since the last broadcast.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObservation.prototype.isActive = function () {\r\n        var rect = getContentRect(this.target);\r\n        this.contentRect_ = rect;\r\n        return (rect.width !== this.broadcastWidth ||\r\n            rect.height !== this.broadcastHeight);\r\n    };\r\n    /**\r\n     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data\r\n     * from the corresponding properties of the last observed content rectangle.\r\n     *\r\n     * @returns {DOMRectInit} Last observed content rectangle.\r\n     */\r\n    ResizeObservation.prototype.broadcastRect = function () {\r\n        var rect = this.contentRect_;\r\n        this.broadcastWidth = rect.width;\r\n        this.broadcastHeight = rect.height;\r\n        return rect;\r\n    };\r\n    return ResizeObservation;\r\n}());\n\nvar ResizeObserverEntry = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObserverEntry.\r\n     *\r\n     * @param {Element} target - Element that is being observed.\r\n     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.\r\n     */\r\n    function ResizeObserverEntry(target, rectInit) {\r\n        var contentRect = createReadOnlyRect(rectInit);\r\n        // According to the specification following properties are not writable\r\n        // and are also not enumerable in the native implementation.\r\n        //\r\n        // Property accessors are not being used as they'd require to define a\r\n        // private WeakMap storage which may cause memory leaks in browsers that\r\n        // don't support this type of collections.\r\n        defineConfigurable(this, { target: target, contentRect: contentRect });\r\n    }\r\n    return ResizeObserverEntry;\r\n}());\n\nvar ResizeObserverSPI = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback function that is invoked\r\n     *      when one of the observed elements changes it's content dimensions.\r\n     * @param {ResizeObserverController} controller - Controller instance which\r\n     *      is responsible for the updates of observer.\r\n     * @param {ResizeObserver} callbackCtx - Reference to the public\r\n     *      ResizeObserver instance which will be passed to callback function.\r\n     */\r\n    function ResizeObserverSPI(callback, controller, callbackCtx) {\r\n        /**\r\n         * Collection of resize observations that have detected changes in dimensions\r\n         * of elements.\r\n         *\r\n         * @private {Array<ResizeObservation>}\r\n         */\r\n        this.activeObservations_ = [];\r\n        /**\r\n         * Registry of the ResizeObservation instances.\r\n         *\r\n         * @private {Map<Element, ResizeObservation>}\r\n         */\r\n        this.observations_ = new MapShim();\r\n        if (typeof callback !== 'function') {\r\n            throw new TypeError('The callback provided as parameter 1 is not a function.');\r\n        }\r\n        this.callback_ = callback;\r\n        this.controller_ = controller;\r\n        this.callbackCtx_ = callbackCtx;\r\n    }\r\n    /**\r\n     * Starts observing provided element.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.observe = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is already being observed.\r\n        if (observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.set(target, new ResizeObservation(target));\r\n        this.controller_.addObserver(this);\r\n        // Force the update of observations.\r\n        this.controller_.refresh();\r\n    };\r\n    /**\r\n     * Stops observing provided element.\r\n     *\r\n     * @param {Element} target - Element to stop observing.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.unobserve = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is not being observed.\r\n        if (!observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.delete(target);\r\n        if (!observations.size) {\r\n            this.controller_.removeObserver(this);\r\n        }\r\n    };\r\n    /**\r\n     * Stops observing all elements.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.disconnect = function () {\r\n        this.clearActive();\r\n        this.observations_.clear();\r\n        this.controller_.removeObserver(this);\r\n    };\r\n    /**\r\n     * Collects observation instances the associated element of which has changed\r\n     * it's content rectangle.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.gatherActive = function () {\r\n        var _this = this;\r\n        this.clearActive();\r\n        this.observations_.forEach(function (observation) {\r\n            if (observation.isActive()) {\r\n                _this.activeObservations_.push(observation);\r\n            }\r\n        });\r\n    };\r\n    /**\r\n     * Invokes initial callback function with a list of ResizeObserverEntry\r\n     * instances collected from active resize observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.broadcastActive = function () {\r\n        // Do nothing if observer doesn't have active observations.\r\n        if (!this.hasActive()) {\r\n            return;\r\n        }\r\n        var ctx = this.callbackCtx_;\r\n        // Create ResizeObserverEntry instance for every active observation.\r\n        var entries = this.activeObservations_.map(function (observation) {\r\n            return new ResizeObserverEntry(observation.target, observation.broadcastRect());\r\n        });\r\n        this.callback_.call(ctx, entries, ctx);\r\n        this.clearActive();\r\n    };\r\n    /**\r\n     * Clears the collection of active observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.clearActive = function () {\r\n        this.activeObservations_.splice(0);\r\n    };\r\n    /**\r\n     * Tells whether observer has active observations.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObserverSPI.prototype.hasActive = function () {\r\n        return this.activeObservations_.length > 0;\r\n    };\r\n    return ResizeObserverSPI;\r\n}());\n\n// Registry of internal observers. If WeakMap is not available use current shim\r\n// for the Map collection as it has all required methods and because WeakMap\r\n// can't be fully polyfilled anyway.\r\nvar observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();\r\n/**\r\n * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation\r\n * exposing only those methods and properties that are defined in the spec.\r\n */\r\nvar ResizeObserver = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback that is invoked when\r\n     *      dimensions of the observed elements change.\r\n     */\r\n    function ResizeObserver(callback) {\r\n        if (!(this instanceof ResizeObserver)) {\r\n            throw new TypeError('Cannot call a class as a function.');\r\n        }\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        var controller = ResizeObserverController.getInstance();\r\n        var observer = new ResizeObserverSPI(callback, controller, this);\r\n        observers.set(this, observer);\r\n    }\r\n    return ResizeObserver;\r\n}());\r\n// Expose public methods of ResizeObserver.\r\n[\r\n    'observe',\r\n    'unobserve',\r\n    'disconnect'\r\n].forEach(function (method) {\r\n    ResizeObserver.prototype[method] = function () {\r\n        var _a;\r\n        return (_a = observers.get(this))[method].apply(_a, arguments);\r\n    };\r\n});\n\nvar index = (function () {\r\n    // Export existing implementation if available.\r\n    if (typeof global$1.ResizeObserver !== 'undefined') {\r\n        return global$1.ResizeObserver;\r\n    }\r\n    return ResizeObserver;\r\n})();\n\nexport default index;\n","'use strict'\n\nfunction oldBrowser () {\n  throw new Error('secure random number generation not supported by this browser\\nuse chrome, FireFox or Internet Explorer 11')\n}\n\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 > 65536) throw new Error('requested too many random bytes')\n  // in case browserify  isn't using the Uint8Array version\n  var rawBytes = new global.Uint8Array(size)\n\n  // This will not work in older browsers.\n  // See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues\n  if (size > 0) {  // getRandomValues fails on IE if size == 0\n    crypto.getRandomValues(rawBytes)\n  }\n  // phantomjs doesn't like a buffer being passed here\n  var bytes = new Buffer(rawBytes.buffer)\n\n  if (typeof cb === 'function') {\n    return process.nextTick(function () {\n      cb(null, bytes)\n    })\n  }\n\n  return bytes\n}\n","'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      pna.nextTick(emitErrorNT, this, err);\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      pna.nextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n\n  return this;\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};","'use strict'\n\nfunction oldBrowser () {\n  throw new Error('secure random number generation not supported by this browser\\nuse chrome, FireFox or Internet Explorer 11')\n}\nvar safeBuffer = require('safe-buffer')\nvar randombytes = require('randombytes')\nvar Buffer = safeBuffer.Buffer\nvar kBufferMaxLength = safeBuffer.kMaxLength\nvar crypto = global.crypto || global.msCrypto\nvar kMaxUint32 = Math.pow(2, 32) - 1\nfunction assertOffset (offset, length) {\n  if (typeof offset !== 'number' || offset !== offset) { // eslint-disable-line no-self-compare\n    throw new TypeError('offset must be a number')\n  }\n\n  if (offset > kMaxUint32 || offset < 0) {\n    throw new TypeError('offset must be a uint32')\n  }\n\n  if (offset > kBufferMaxLength || offset > length) {\n    throw new RangeError('offset out of range')\n  }\n}\n\nfunction assertSize (size, offset, length) {\n  if (typeof size !== 'number' || size !== size) { // eslint-disable-line no-self-compare\n    throw new TypeError('size must be a number')\n  }\n\n  if (size > kMaxUint32 || size < 0) {\n    throw new TypeError('size must be a uint32')\n  }\n\n  if (size + offset > length || size > kBufferMaxLength) {\n    throw new RangeError('buffer too small')\n  }\n}\nif ((crypto && crypto.getRandomValues) || !process.browser) {\n  exports.randomFill = randomFill\n  exports.randomFillSync = randomFillSync\n} else {\n  exports.randomFill = oldBrowser\n  exports.randomFillSync = oldBrowser\n}\nfunction randomFill (buf, offset, size, cb) {\n  if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {\n    throw new TypeError('\"buf\" argument must be a Buffer or Uint8Array')\n  }\n\n  if (typeof offset === 'function') {\n    cb = offset\n    offset = 0\n    size = buf.length\n  } else if (typeof size === 'function') {\n    cb = size\n    size = buf.length - offset\n  } else if (typeof cb !== 'function') {\n    throw new TypeError('\"cb\" argument must be a function')\n  }\n  assertOffset(offset, buf.length)\n  assertSize(size, offset, buf.length)\n  return actualFill(buf, offset, size, cb)\n}\n\nfunction actualFill (buf, offset, size, cb) {\n  if (process.browser) {\n    var ourBuf = buf.buffer\n    var uint = new Uint8Array(ourBuf, offset, size)\n    crypto.getRandomValues(uint)\n    if (cb) {\n      process.nextTick(function () {\n        cb(null, buf)\n      })\n      return\n    }\n    return buf\n  }\n  if (cb) {\n    randombytes(size, function (err, bytes) {\n      if (err) {\n        return cb(err)\n      }\n      bytes.copy(buf, offset)\n      cb(null, buf)\n    })\n    return\n  }\n  var bytes = randombytes(size)\n  bytes.copy(buf, offset)\n  return buf\n}\nfunction randomFillSync (buf, offset, size) {\n  if (typeof offset === 'undefined') {\n    offset = 0\n  }\n  if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {\n    throw new TypeError('\"buf\" argument must be a Buffer or Uint8Array')\n  }\n\n  assertOffset(offset, buf.length)\n\n  if (size === undefined) size = buf.length - offset\n\n  assertSize(size, offset, buf.length)\n\n  return actualFill(buf, offset, size)\n}\n","var createHash = require('create-hash')\nvar Buffer = require('safe-buffer').Buffer\n\nmodule.exports = function (seed, len) {\n  var t = Buffer.alloc(0)\n  var i = 0\n  var c\n  while (t.length < len) {\n    c = i2ops(i++)\n    t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()])\n  }\n  return t.slice(0, len)\n}\n\nfunction i2ops (c) {\n  var out = Buffer.allocUnsafe(4)\n  out.writeUInt32BE(c, 0)\n  return out\n}\n","var Buffer = require('safe-buffer').Buffer\n\nvar checkParameters = require('./precondition')\nvar defaultEncoding = require('./default-encoding')\nvar sync = require('./sync')\nvar toBuffer = require('./to-buffer')\n\nvar ZERO_BUF\nvar subtle = global.crypto && global.crypto.subtle\nvar toBrowser = {\n  sha: 'SHA-1',\n  'sha-1': 'SHA-1',\n  sha1: 'SHA-1',\n  sha256: 'SHA-256',\n  'sha-256': 'SHA-256',\n  sha384: 'SHA-384',\n  'sha-384': 'SHA-384',\n  'sha-512': 'SHA-512',\n  sha512: 'SHA-512'\n}\nvar checks = []\nfunction checkNative (algo) {\n  if (global.process && !global.process.browser) {\n    return Promise.resolve(false)\n  }\n  if (!subtle || !subtle.importKey || !subtle.deriveBits) {\n    return Promise.resolve(false)\n  }\n  if (checks[algo] !== undefined) {\n    return checks[algo]\n  }\n  ZERO_BUF = ZERO_BUF || Buffer.alloc(8)\n  var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo)\n    .then(function () {\n      return true\n    }).catch(function () {\n      return false\n    })\n  checks[algo] = prom\n  return prom\n}\nvar nextTick\nfunction getNextTick () {\n  if (nextTick) {\n    return nextTick\n  }\n  if (global.process && global.process.nextTick) {\n    nextTick = global.process.nextTick\n  } else if (global.queueMicrotask) {\n    nextTick = global.queueMicrotask\n  } else if (global.setImmediate) {\n    nextTick = global.setImmediate\n  } else {\n    nextTick = global.setTimeout\n  }\n  return nextTick\n}\nfunction browserPbkdf2 (password, salt, iterations, length, algo) {\n  return subtle.importKey(\n    'raw', password, { name: 'PBKDF2' }, false, ['deriveBits']\n  ).then(function (key) {\n    return subtle.deriveBits({\n      name: 'PBKDF2',\n      salt: salt,\n      iterations: iterations,\n      hash: {\n        name: algo\n      }\n    }, key, length << 3)\n  }).then(function (res) {\n    return Buffer.from(res)\n  })\n}\n\nfunction resolvePromise (promise, callback) {\n  promise.then(function (out) {\n    getNextTick()(function () {\n      callback(null, out)\n    })\n  }, function (e) {\n    getNextTick()(function () {\n      callback(e)\n    })\n  })\n}\nmodule.exports = function (password, salt, iterations, keylen, digest, callback) {\n  if (typeof digest === 'function') {\n    callback = digest\n    digest = undefined\n  }\n\n  digest = digest || 'sha1'\n  var algo = toBrowser[digest.toLowerCase()]\n\n  if (!algo || typeof global.Promise !== 'function') {\n    getNextTick()(function () {\n      var out\n      try {\n        out = sync(password, salt, iterations, keylen, digest)\n      } catch (e) {\n        return callback(e)\n      }\n      callback(null, out)\n    })\n    return\n  }\n\n  checkParameters(iterations, keylen)\n  password = toBuffer(password, defaultEncoding, 'Password')\n  salt = toBuffer(salt, defaultEncoding, 'Salt')\n  if (typeof callback !== 'function') throw new Error('No callback provided to pbkdf2')\n\n  resolvePromise(checkNative(algo).then(function (resp) {\n    if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo)\n\n    return sync(password, salt, iterations, keylen, digest)\n  }), callback)\n}\n","var md5 = require('create-hash/md5')\nvar RIPEMD160 = require('ripemd160')\nvar sha = require('sha.js')\nvar Buffer = require('safe-buffer').Buffer\n\nvar checkParameters = require('./precondition')\nvar defaultEncoding = require('./default-encoding')\nvar toBuffer = require('./to-buffer')\n\nvar ZEROS = Buffer.alloc(128)\nvar sizes = {\n  md5: 16,\n  sha1: 20,\n  sha224: 28,\n  sha256: 32,\n  sha384: 48,\n  sha512: 64,\n  rmd160: 20,\n  ripemd160: 20\n}\n\nfunction Hmac (alg, key, saltLen) {\n  var hash = getDigest(alg)\n  var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64\n\n  if (key.length > blocksize) {\n    key = hash(key)\n  } else if (key.length < blocksize) {\n    key = Buffer.concat([key, ZEROS], blocksize)\n  }\n\n  var ipad = Buffer.allocUnsafe(blocksize + sizes[alg])\n  var opad = Buffer.allocUnsafe(blocksize + sizes[alg])\n  for (var i = 0; i < blocksize; i++) {\n    ipad[i] = key[i] ^ 0x36\n    opad[i] = key[i] ^ 0x5C\n  }\n\n  var ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4)\n  ipad.copy(ipad1, 0, 0, blocksize)\n  this.ipad1 = ipad1\n  this.ipad2 = ipad\n  this.opad = opad\n  this.alg = alg\n  this.blocksize = blocksize\n  this.hash = hash\n  this.size = sizes[alg]\n}\n\nHmac.prototype.run = function (data, ipad) {\n  data.copy(ipad, this.blocksize)\n  var h = this.hash(ipad)\n  h.copy(this.opad, this.blocksize)\n  return this.hash(this.opad)\n}\n\nfunction getDigest (alg) {\n  function shaFunc (data) {\n    return sha(alg).update(data).digest()\n  }\n  function rmd160Func (data) {\n    return new RIPEMD160().update(data).digest()\n  }\n\n  if (alg === 'rmd160' || alg === 'ripemd160') return rmd160Func\n  if (alg === 'md5') return md5\n  return shaFunc\n}\n\nfunction pbkdf2 (password, salt, iterations, keylen, digest) {\n  checkParameters(iterations, keylen)\n  password = toBuffer(password, defaultEncoding, 'Password')\n  salt = toBuffer(salt, defaultEncoding, 'Salt')\n\n  digest = digest || 'sha1'\n\n  var hmac = new Hmac(digest, password, salt.length)\n\n  var DK = Buffer.allocUnsafe(keylen)\n  var block1 = Buffer.allocUnsafe(salt.length + 4)\n  salt.copy(block1, 0, 0, salt.length)\n\n  var destPos = 0\n  var hLen = sizes[digest]\n  var l = Math.ceil(keylen / hLen)\n\n  for (var i = 1; i <= l; i++) {\n    block1.writeUInt32BE(i, salt.length)\n\n    var T = hmac.run(block1, hmac.ipad1)\n    var U = T\n\n    for (var j = 1; j < iterations; j++) {\n      U = hmac.run(U, hmac.ipad2)\n      for (var k = 0; k < hLen; k++) T[k] ^= U[k]\n    }\n\n    T.copy(DK, destPos)\n    destPos += hLen\n  }\n\n  return DK\n}\n\nmodule.exports = pbkdf2\n","/**\n * Parses an URI\n *\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\n * @api private\n */\n\nvar re = /^(?:(?![^:@]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\n\nvar parts = [\n    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\n];\n\nmodule.exports = function parseuri(str) {\n    var src = str,\n        b = str.indexOf('['),\n        e = str.indexOf(']');\n\n    if (b != -1 && e != -1) {\n        str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\n    }\n\n    var m = re.exec(str || ''),\n        uri = {},\n        i = 14;\n\n    while (i--) {\n        uri[parts[i]] = m[i] || '';\n    }\n\n    if (b != -1 && e != -1) {\n        uri.source = src;\n        uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\n        uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\n        uri.ipv6uri = true;\n    }\n\n    uri.pathNames = pathNames(uri, uri['path']);\n    uri.queryKey = queryKey(uri, uri['query']);\n\n    return uri;\n};\n\nfunction pathNames(obj, path) {\n    var regx = /\\/{2,9}/g,\n        names = path.replace(regx, \"/\").split(\"/\");\n\n    if (path.substr(0, 1) == '/' || path.length === 0) {\n        names.splice(0, 1);\n    }\n    if (path.substr(path.length - 1, 1) == '/') {\n        names.splice(names.length - 1, 1);\n    }\n\n    return names;\n}\n\nfunction queryKey(uri, query) {\n    var data = {};\n\n    query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) {\n        if ($1) {\n            data[$1] = $2;\n        }\n    });\n\n    return data;\n}\n","module.exports = require('./readable').PassThrough\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Sha256 = require('./sha256')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(64)\n\nfunction Sha224 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha224, Sha256)\n\nSha224.prototype.init = function () {\n  this._a = 0xc1059ed8\n  this._b = 0x367cd507\n  this._c = 0x3070dd17\n  this._d = 0xf70e5939\n  this._e = 0xffc00b31\n  this._f = 0x68581511\n  this._g = 0x64f98fa7\n  this._h = 0xbefa4fa4\n\n  return this\n}\n\nSha224.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(28)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n\n  return H\n}\n\nmodule.exports = Sha224\n","'use strict';\n\nif (typeof process === 'undefined' ||\n    !process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","module.exports = assert;\n\nfunction assert(val, msg) {\n  if (!val)\n    throw new Error(msg || 'Assertion failed');\n}\n\nassert.equal = function assertEqual(l, r, msg) {\n  if (l != r)\n    throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));\n};\n","var inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n]\n\nvar W = new Array(160)\n\nfunction Sha512 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha512, Hash)\n\nSha512.prototype.init = function () {\n  this._ah = 0x6a09e667\n  this._bh = 0xbb67ae85\n  this._ch = 0x3c6ef372\n  this._dh = 0xa54ff53a\n  this._eh = 0x510e527f\n  this._fh = 0x9b05688c\n  this._gh = 0x1f83d9ab\n  this._hh = 0x5be0cd19\n\n  this._al = 0xf3bcc908\n  this._bl = 0x84caa73b\n  this._cl = 0xfe94f82b\n  this._dl = 0x5f1d36f1\n  this._el = 0xade682d1\n  this._fl = 0x2b3e6c1f\n  this._gl = 0xfb41bd6b\n  this._hl = 0x137e2179\n\n  return this\n}\n\nfunction Ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x, xl) {\n  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)\n}\n\nfunction sigma1 (x, xl) {\n  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)\n}\n\nfunction Gamma0 (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)\n}\n\nfunction Gamma0l (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)\n}\n\nfunction Gamma1 (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)\n}\n\nfunction Gamma1l (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)\n}\n\nfunction getCarry (a, b) {\n  return (a >>> 0) < (b >>> 0) ? 1 : 0\n}\n\nSha512.prototype._update = function (M) {\n  var W = this._w\n\n  var ah = this._ah | 0\n  var bh = this._bh | 0\n  var ch = this._ch | 0\n  var dh = this._dh | 0\n  var eh = this._eh | 0\n  var fh = this._fh | 0\n  var gh = this._gh | 0\n  var hh = this._hh | 0\n\n  var al = this._al | 0\n  var bl = this._bl | 0\n  var cl = this._cl | 0\n  var dl = this._dl | 0\n  var el = this._el | 0\n  var fl = this._fl | 0\n  var gl = this._gl | 0\n  var hl = this._hl | 0\n\n  for (var i = 0; i < 32; i += 2) {\n    W[i] = M.readInt32BE(i * 4)\n    W[i + 1] = M.readInt32BE(i * 4 + 4)\n  }\n  for (; i < 160; i += 2) {\n    var xh = W[i - 15 * 2]\n    var xl = W[i - 15 * 2 + 1]\n    var gamma0 = Gamma0(xh, xl)\n    var gamma0l = Gamma0l(xl, xh)\n\n    xh = W[i - 2 * 2]\n    xl = W[i - 2 * 2 + 1]\n    var gamma1 = Gamma1(xh, xl)\n    var gamma1l = Gamma1l(xl, xh)\n\n    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]\n    var Wi7h = W[i - 7 * 2]\n    var Wi7l = W[i - 7 * 2 + 1]\n\n    var Wi16h = W[i - 16 * 2]\n    var Wi16l = W[i - 16 * 2 + 1]\n\n    var Wil = (gamma0l + Wi7l) | 0\n    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0\n    Wil = (Wil + gamma1l) | 0\n    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0\n    Wil = (Wil + Wi16l) | 0\n    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0\n\n    W[i] = Wih\n    W[i + 1] = Wil\n  }\n\n  for (var j = 0; j < 160; j += 2) {\n    Wih = W[j]\n    Wil = W[j + 1]\n\n    var majh = maj(ah, bh, ch)\n    var majl = maj(al, bl, cl)\n\n    var sigma0h = sigma0(ah, al)\n    var sigma0l = sigma0(al, ah)\n    var sigma1h = sigma1(eh, el)\n    var sigma1l = sigma1(el, eh)\n\n    // t1 = h + sigma1 + ch + K[j] + W[j]\n    var Kih = K[j]\n    var Kil = K[j + 1]\n\n    var chh = Ch(eh, fh, gh)\n    var chl = Ch(el, fl, gl)\n\n    var t1l = (hl + sigma1l) | 0\n    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0\n    t1l = (t1l + chl) | 0\n    t1h = (t1h + chh + getCarry(t1l, chl)) | 0\n    t1l = (t1l + Kil) | 0\n    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0\n    t1l = (t1l + Wil) | 0\n    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0\n\n    // t2 = sigma0 + maj\n    var t2l = (sigma0l + majl) | 0\n    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0\n\n    hh = gh\n    hl = gl\n    gh = fh\n    gl = fl\n    fh = eh\n    fl = el\n    el = (dl + t1l) | 0\n    eh = (dh + t1h + getCarry(el, dl)) | 0\n    dh = ch\n    dl = cl\n    ch = bh\n    cl = bl\n    bh = ah\n    bl = al\n    al = (t1l + t2l) | 0\n    ah = (t1h + t2h + getCarry(al, t1l)) | 0\n  }\n\n  this._al = (this._al + al) | 0\n  this._bl = (this._bl + bl) | 0\n  this._cl = (this._cl + cl) | 0\n  this._dl = (this._dl + dl) | 0\n  this._el = (this._el + el) | 0\n  this._fl = (this._fl + fl) | 0\n  this._gl = (this._gl + gl) | 0\n  this._hl = (this._hl + hl) | 0\n\n  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0\n  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0\n  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0\n  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0\n  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0\n  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0\n  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0\n  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0\n}\n\nSha512.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(64)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n  writeInt64BE(this._gh, this._gl, 48)\n  writeInt64BE(this._hh, this._hl, 56)\n\n  return H\n}\n\nmodule.exports = Sha512\n","/* eslint-disable node/no-deprecated-api */\n\n'use strict'\n\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\nvar safer = {}\n\nvar key\n\nfor (key in buffer) {\n  if (!buffer.hasOwnProperty(key)) continue\n  if (key === 'SlowBuffer' || key === 'Buffer') continue\n  safer[key] = buffer[key]\n}\n\nvar Safer = safer.Buffer = {}\nfor (key in Buffer) {\n  if (!Buffer.hasOwnProperty(key)) continue\n  if (key === 'allocUnsafe' || key === 'allocUnsafeSlow') continue\n  Safer[key] = Buffer[key]\n}\n\nsafer.Buffer.prototype = Buffer.prototype\n\nif (!Safer.from || Safer.from === Uint8Array.from) {\n  Safer.from = function (value, encodingOrOffset, length) {\n    if (typeof value === 'number') {\n      throw new TypeError('The \"value\" argument must not be of type number. Received type ' + typeof value)\n    }\n    if (value && typeof value.length === 'undefined') {\n      throw new TypeError('The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ' + typeof value)\n    }\n    return Buffer(value, encodingOrOffset, length)\n  }\n}\n\nif (!Safer.alloc) {\n  Safer.alloc = function (size, fill, encoding) {\n    if (typeof size !== 'number') {\n      throw new TypeError('The \"size\" argument must be of type number. Received type ' + typeof size)\n    }\n    if (size < 0 || size >= 2 * (1 << 30)) {\n      throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n    }\n    var buf = Buffer(size)\n    if (!fill || fill.length === 0) {\n      buf.fill(0)\n    } else if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n    return buf\n  }\n}\n\nif (!safer.kStringMaxLength) {\n  try {\n    safer.kStringMaxLength = process.binding('buffer').kStringMaxLength\n  } catch (e) {\n    // we can't determine kStringMaxLength in environments where process.binding\n    // is unsupported, so let's not set it\n  }\n}\n\nif (!safer.constants) {\n  safer.constants = {\n    MAX_LENGTH: safer.kMaxLength\n  }\n  if (safer.kStringMaxLength) {\n    safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength\n  }\n}\n\nmodule.exports = safer\n","var asn1 = require('./asn1')\nvar aesid = require('./aesid.json')\nvar fixProc = require('./fixProc')\nvar ciphers = require('browserify-aes')\nvar compat = require('pbkdf2')\nvar Buffer = require('safe-buffer').Buffer\nmodule.exports = parseKeys\n\nfunction parseKeys (buffer) {\n  var password\n  if (typeof buffer === 'object' && !Buffer.isBuffer(buffer)) {\n    password = buffer.passphrase\n    buffer = buffer.key\n  }\n  if (typeof buffer === 'string') {\n    buffer = Buffer.from(buffer)\n  }\n\n  var stripped = fixProc(buffer, password)\n\n  var type = stripped.tag\n  var data = stripped.data\n  var subtype, ndata\n  switch (type) {\n    case 'CERTIFICATE':\n      ndata = asn1.certificate.decode(data, 'der').tbsCertificate.subjectPublicKeyInfo\n      // falls through\n    case 'PUBLIC KEY':\n      if (!ndata) {\n        ndata = asn1.PublicKey.decode(data, 'der')\n      }\n      subtype = ndata.algorithm.algorithm.join('.')\n      switch (subtype) {\n        case '1.2.840.113549.1.1.1':\n          return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data, 'der')\n        case '1.2.840.10045.2.1':\n          ndata.subjectPrivateKey = ndata.subjectPublicKey\n          return {\n            type: 'ec',\n            data: ndata\n          }\n        case '1.2.840.10040.4.1':\n          ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey.data, 'der')\n          return {\n            type: 'dsa',\n            data: ndata.algorithm.params\n          }\n        default: throw new Error('unknown key id ' + subtype)\n      }\n      // throw new Error('unknown key type ' + type)\n    case 'ENCRYPTED PRIVATE KEY':\n      data = asn1.EncryptedPrivateKey.decode(data, 'der')\n      data = decrypt(data, password)\n      // falls through\n    case 'PRIVATE KEY':\n      ndata = asn1.PrivateKey.decode(data, 'der')\n      subtype = ndata.algorithm.algorithm.join('.')\n      switch (subtype) {\n        case '1.2.840.113549.1.1.1':\n          return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, 'der')\n        case '1.2.840.10045.2.1':\n          return {\n            curve: ndata.algorithm.curve,\n            privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey, 'der').privateKey\n          }\n        case '1.2.840.10040.4.1':\n          ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey, 'der')\n          return {\n            type: 'dsa',\n            params: ndata.algorithm.params\n          }\n        default: throw new Error('unknown key id ' + subtype)\n      }\n      // throw new Error('unknown key type ' + type)\n    case 'RSA PUBLIC KEY':\n      return asn1.RSAPublicKey.decode(data, 'der')\n    case 'RSA PRIVATE KEY':\n      return asn1.RSAPrivateKey.decode(data, 'der')\n    case 'DSA PRIVATE KEY':\n      return {\n        type: 'dsa',\n        params: asn1.DSAPrivateKey.decode(data, 'der')\n      }\n    case 'EC PRIVATE KEY':\n      data = asn1.ECPrivateKey.decode(data, 'der')\n      return {\n        curve: data.parameters.value,\n        privateKey: data.privateKey\n      }\n    default: throw new Error('unknown key type ' + type)\n  }\n}\nparseKeys.signature = asn1.signature\nfunction decrypt (data, password) {\n  var salt = data.algorithm.decrypt.kde.kdeparams.salt\n  var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10)\n  var algo = aesid[data.algorithm.decrypt.cipher.algo.join('.')]\n  var iv = data.algorithm.decrypt.cipher.iv\n  var cipherText = data.subjectPrivateKey\n  var keylen = parseInt(algo.split('-')[1], 10) / 8\n  var key = compat.pbkdf2Sync(password, salt, iters, keylen, 'sha1')\n  var cipher = ciphers.createDecipheriv(algo, key, iv)\n  var out = []\n  out.push(cipher.update(cipherText))\n  out.push(cipher.final())\n  return Buffer.concat(out)\n}\n","module.exports = require('./lib/_stream_duplex.js');\n","module.exports = function xor (a, b) {\n  var len = a.length\n  var i = -1\n  while (++i < len) {\n    a[i] ^= b[i]\n  }\n  return a\n}\n","'use strict';\n\n// there's 3 implementations written in increasing order of efficiency\n\n// 1 - no Set type is defined\nfunction uniqNoSet(arr) {\n\tvar ret = [];\n\n\tfor (var i = 0; i < arr.length; i++) {\n\t\tif (ret.indexOf(arr[i]) === -1) {\n\t\t\tret.push(arr[i]);\n\t\t}\n\t}\n\n\treturn ret;\n}\n\n// 2 - a simple Set type is defined\nfunction uniqSet(arr) {\n\tvar seen = new Set();\n\treturn arr.filter(function (el) {\n\t\tif (!seen.has(el)) {\n\t\t\tseen.add(el);\n\t\t\treturn true;\n\t\t}\n\t});\n}\n\n// 3 - a standard Set type is defined and it has a forEach method\nfunction uniqSetWithForEach(arr) {\n\tvar ret = [];\n\n\t(new Set(arr)).forEach(function (el) {\n\t\tret.push(el);\n\t});\n\n\treturn ret;\n}\n\n// V8 currently has a broken implementation\n// https://github.com/joyent/node/issues/8449\nfunction doesForEachActuallyWork() {\n\tvar ret = false;\n\n\t(new Set([true])).forEach(function (el) {\n\t\tret = el;\n\t});\n\n\treturn ret === true;\n}\n\nif ('Set' in global) {\n\tif (typeof Set.prototype.forEach === 'function' && doesForEachActuallyWork()) {\n\t\tmodule.exports = uniqSetWithForEach;\n\t} else {\n\t\tmodule.exports = uniqSet;\n\t}\n} else {\n\tmodule.exports = uniqNoSet;\n}\n","'use strict';\n\nvar utils = exports;\n\nfunction toArray(msg, enc) {\n  if (Array.isArray(msg))\n    return msg.slice();\n  if (!msg)\n    return [];\n  var res = [];\n  if (typeof msg !== 'string') {\n    for (var i = 0; i < msg.length; i++)\n      res[i] = msg[i] | 0;\n    return res;\n  }\n  if (enc === 'hex') {\n    msg = msg.replace(/[^a-z0-9]+/ig, '');\n    if (msg.length % 2 !== 0)\n      msg = '0' + msg;\n    for (var i = 0; i < msg.length; i += 2)\n      res.push(parseInt(msg[i] + msg[i + 1], 16));\n  } else {\n    for (var i = 0; i < msg.length; i++) {\n      var c = msg.charCodeAt(i);\n      var hi = c >> 8;\n      var lo = c & 0xff;\n      if (hi)\n        res.push(hi, lo);\n      else\n        res.push(lo);\n    }\n  }\n  return res;\n}\nutils.toArray = toArray;\n\nfunction zero2(word) {\n  if (word.length === 1)\n    return '0' + word;\n  else\n    return word;\n}\nutils.zero2 = zero2;\n\nfunction toHex(msg) {\n  var res = '';\n  for (var i = 0; i < msg.length; i++)\n    res += zero2(msg[i].toString(16));\n  return res;\n}\nutils.toHex = toHex;\n\nutils.encode = function encode(arr, enc) {\n  if (enc === 'hex')\n    return toHex(arr);\n  else\n    return arr;\n};\n","var exports = module.exports = function SHA (algorithm) {\n  algorithm = algorithm.toLowerCase()\n\n  var Algorithm = exports[algorithm]\n  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')\n\n  return new Algorithm()\n}\n\nexports.sha = require('./sha')\nexports.sha1 = require('./sha1')\nexports.sha224 = require('./sha224')\nexports.sha256 = require('./sha256')\nexports.sha384 = require('./sha384')\nexports.sha512 = require('./sha512')\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","exports.pbkdf2 = require('./lib/async')\nexports.pbkdf2Sync = require('./lib/sync')\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","module.exports = {\n  webm:\n    \"data:video/webm;base64,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\",\n  mp4:\n    \"data:video/mp4;base64,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\",\n};\n","module.exports = require(\"./lib/randomstring\");","var inherits = require('inherits')\nvar SHA512 = require('./sha512')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(160)\n\nfunction Sha384 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha384, SHA512)\n\nSha384.prototype.init = function () {\n  this._ah = 0xcbbb9d5d\n  this._bh = 0x629a292a\n  this._ch = 0x9159015a\n  this._dh = 0x152fecd8\n  this._eh = 0x67332667\n  this._fh = 0x8eb44a87\n  this._gh = 0xdb0c2e0d\n  this._hh = 0x47b5481d\n\n  this._al = 0xc1059ed8\n  this._bl = 0x367cd507\n  this._cl = 0x3070dd17\n  this._dl = 0xf70e5939\n  this._el = 0xffc00b31\n  this._fl = 0x68581511\n  this._gl = 0x64f98fa7\n  this._hl = 0xbefa4fa4\n\n  return this\n}\n\nSha384.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(48)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n\n  return H\n}\n\nmodule.exports = Sha384\n","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\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// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47 /*/*/;\n  var end = -1;\n  var matchedSlash = true;\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n  var f = basename(path);\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  var preDotState = 0;\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1)\n          startDot = i;\n        else if (preDotState !== 1)\n          preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 ||\n      // We saw a non-dot character immediately before the dot\n      preDotState === 0 ||\n      // The (right-most) trimmed path component is exactly '..'\n      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\n","module.exports = require('./readable').Transform\n","\"use strict\";\n\nvar randomBytes = require('randombytes');\nvar Charset = require('./charset.js');\n\nfunction safeRandomBytes(length) {\n  while (true) {\n    try {\n      return randomBytes(length);\n    } catch(e) {\n      continue;\n    }\n  }\n}\n\nfunction processString(buf, initialString, chars, reqLen, maxByte) {\n  var string = initialString;\n  for (var i = 0; i < buf.length && string.length < reqLen; i++) {\n    var randomByte = buf.readUInt8(i);\n    if (randomByte < maxByte) {\n      string += chars.charAt(randomByte % chars.length);\n    }\n  }\n  return string;\n}\n\nfunction getAsyncString(string, chars, length, maxByte, cb) {\n  randomBytes(length, function(err, buf) {\n    if (err) {\n      // Since it is waiting for entropy, errors are legit and we shouldn't just keep retrying\n      cb(err);\n    }\n    var generatedString = processString(buf, string, chars, length, maxByte);\n    if (generatedString.length < length) {\n      getAsyncString(generatedString, chars, length, maxByte, cb);\n    } else {\n      cb(null, generatedString);\n    }\n  })\n}\n\nexports.generate = function(options, cb) {\n  var charset = new Charset();\n\n  var length, chars, capitalization, string = '';\n\n  // Handle options\n  if (typeof options === 'object') {\n    length = options.length || 32;\n\n    if (options.charset) {\n      charset.setType(options.charset);\n    }\n    else {\n      charset.setType('alphanumeric');\n    }\n\n    if (options.capitalization) {\n      charset.setcapitalization(options.capitalization);\n    }\n\n    if (options.readable) {\n      charset.removeUnreadable();\n    }\n\n    charset.removeDuplicates();\n  }\n  else if (typeof options === 'number') {\n    length = options;\n    charset.setType('alphanumeric');\n  }\n  else {\n    length = 32;\n    charset.setType('alphanumeric');\n  }\n\n  // Generate the string\n  var charsLen = charset.chars.length;\n  var maxByte = 256 - (256 % charsLen);\n\n  if (!cb) {\n    while (string.length < length) {\n      var buf = safeRandomBytes(Math.ceil(length * 256 / maxByte));\n      string = processString(buf, string, charset.chars, length, maxByte);\n    }\n\n    return string;\n  }\n\n  getAsyncString(string, charset.chars, length, maxByte, cb);\n\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","var MAX_ALLOC = Math.pow(2, 30) - 1 // default in iojs\n\nmodule.exports = function (iterations, keylen) {\n  if (typeof iterations !== 'number') {\n    throw new TypeError('Iterations not a number')\n  }\n\n  if (iterations < 0) {\n    throw new TypeError('Bad iterations')\n  }\n\n  if (typeof keylen !== 'number') {\n    throw new TypeError('Key length not a number')\n  }\n\n  if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) { /* eslint no-self-compare: 0 */\n    throw new TypeError('Bad key length')\n  }\n}\n","// adapted from https://github.com/apatil/pemstrip\nvar findProc = /Proc-Type: 4,ENCRYPTED[\\n\\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\\n\\r]+([0-9A-z\\n\\r+/=]+)[\\n\\r]+/m\nvar startRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----/m\nvar fullRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----([0-9A-z\\n\\r+/=]+)-----END \\1-----$/m\nvar evp = require('evp_bytestokey')\nvar ciphers = require('browserify-aes')\nvar Buffer = require('safe-buffer').Buffer\nmodule.exports = function (okey, password) {\n  var key = okey.toString()\n  var match = key.match(findProc)\n  var decrypted\n  if (!match) {\n    var match2 = key.match(fullRegex)\n    decrypted = Buffer.from(match2[2].replace(/[\\r\\n]/g, ''), 'base64')\n  } else {\n    var suite = 'aes' + match[1]\n    var iv = Buffer.from(match[2], 'hex')\n    var cipherText = Buffer.from(match[3].replace(/[\\r\\n]/g, ''), 'base64')\n    var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key\n    var out = []\n    var cipher = ciphers.createDecipheriv(suite, cipherKey, iv)\n    out.push(cipher.update(cipherText))\n    out.push(cipher.final())\n    decrypted = Buffer.concat(out)\n  }\n  var tag = key.match(startRegex)[1]\n  return {\n    tag: tag,\n    data: decrypted\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// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","var arrayUniq = require('array-uniq');\n\nfunction Charset() {\n  this.chars = '';\n}\n\nCharset.prototype.setType = function(type) {\n  var chars;\n\n  var numbers     = '0123456789';\n  var charsLower  = 'abcdefghijklmnopqrstuvwxyz';\n  var charsUpper  = charsLower.toUpperCase();\n  var hexChars    = 'abcdef';\n  var binaryChars = '01';\n  var octalChars  = '01234567';\n\n  if (type === 'alphanumeric') {\n    chars = numbers + charsLower + charsUpper;\n  }\n  else if (type === 'numeric') {\n    chars = numbers;\n  }\n  else if (type === 'alphabetic') {\n    chars = charsLower + charsUpper;\n  }\n  else if (type === 'hex') {\n    chars = numbers + hexChars;\n  }\n  else if (type === 'binary') {\n    chars = binaryChars;\n  }\n  else if (type === 'octal') {\n    chars = octalChars;\n  }\n  else {\n    chars = type;\n  }\n\n  this.chars = chars;\n}\n\nCharset.prototype.removeUnreadable = function() {\n  var unreadableChars = /[0OIl]/g;\n  this.chars = this.chars.replace(unreadableChars, '');\n}\n\nCharset.prototype.setcapitalization = function(capitalization) {\n  if (capitalization === 'uppercase') {\n    this.chars = this.chars.toUpperCase();\n  }\n  else if (capitalization === 'lowercase') {\n    this.chars = this.chars.toLowerCase();\n  }\n}\n\nCharset.prototype.removeDuplicates = function() {\n  var charMap = this.chars.split('');\n  charMap = arrayUniq(charMap);\n  this.chars = charMap.join('');\n}\n\nmodule.exports = exports = Charset;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};","var defaultEncoding\n/* istanbul ignore next */\nif (global.process && global.process.browser) {\n  defaultEncoding = 'utf-8'\n} else if (global.process && global.process.version) {\n  var pVersionMajor = parseInt(process.version.split('.')[0].slice(1), 10)\n\n  defaultEncoding = pVersionMajor >= 6 ? 'utf-8' : 'binary'\n} else {\n  defaultEncoding = 'utf-8'\n}\nmodule.exports = defaultEncoding\n","/* eslint-disable promise/prefer-await-to-then */\n\nconst methodMap = [\n\t[\n\t\t'requestFullscreen',\n\t\t'exitFullscreen',\n\t\t'fullscreenElement',\n\t\t'fullscreenEnabled',\n\t\t'fullscreenchange',\n\t\t'fullscreenerror',\n\t],\n\t// New WebKit\n\t[\n\t\t'webkitRequestFullscreen',\n\t\t'webkitExitFullscreen',\n\t\t'webkitFullscreenElement',\n\t\t'webkitFullscreenEnabled',\n\t\t'webkitfullscreenchange',\n\t\t'webkitfullscreenerror',\n\n\t],\n\t// Old WebKit\n\t[\n\t\t'webkitRequestFullScreen',\n\t\t'webkitCancelFullScreen',\n\t\t'webkitCurrentFullScreenElement',\n\t\t'webkitCancelFullScreen',\n\t\t'webkitfullscreenchange',\n\t\t'webkitfullscreenerror',\n\n\t],\n\t[\n\t\t'mozRequestFullScreen',\n\t\t'mozCancelFullScreen',\n\t\t'mozFullScreenElement',\n\t\t'mozFullScreenEnabled',\n\t\t'mozfullscreenchange',\n\t\t'mozfullscreenerror',\n\t],\n\t[\n\t\t'msRequestFullscreen',\n\t\t'msExitFullscreen',\n\t\t'msFullscreenElement',\n\t\t'msFullscreenEnabled',\n\t\t'MSFullscreenChange',\n\t\t'MSFullscreenError',\n\t],\n];\n\nconst nativeAPI = (() => {\n\tif (typeof document === 'undefined') {\n\t\treturn false;\n\t}\n\n\tconst unprefixedMethods = methodMap[0];\n\tconst returnValue = {};\n\n\tfor (const methodList of methodMap) {\n\t\tconst exitFullscreenMethod = methodList?.[1];\n\t\tif (exitFullscreenMethod in document) {\n\t\t\tfor (const [index, method] of methodList.entries()) {\n\t\t\t\treturnValue[unprefixedMethods[index]] = method;\n\t\t\t}\n\n\t\t\treturn returnValue;\n\t\t}\n\t}\n\n\treturn false;\n})();\n\nconst eventNameMap = {\n\tchange: nativeAPI.fullscreenchange,\n\terror: nativeAPI.fullscreenerror,\n};\n\n// eslint-disable-next-line import/no-mutable-exports\nlet screenfull = {\n\t// eslint-disable-next-line default-param-last\n\trequest(element = document.documentElement, options) {\n\t\treturn new Promise((resolve, reject) => {\n\t\t\tconst onFullScreenEntered = () => {\n\t\t\t\tscreenfull.off('change', onFullScreenEntered);\n\t\t\t\tresolve();\n\t\t\t};\n\n\t\t\tscreenfull.on('change', onFullScreenEntered);\n\n\t\t\tconst returnPromise = element[nativeAPI.requestFullscreen](options);\n\n\t\t\tif (returnPromise instanceof Promise) {\n\t\t\t\treturnPromise.then(onFullScreenEntered).catch(reject);\n\t\t\t}\n\t\t});\n\t},\n\texit() {\n\t\treturn new Promise((resolve, reject) => {\n\t\t\tif (!screenfull.isFullscreen) {\n\t\t\t\tresolve();\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst onFullScreenExit = () => {\n\t\t\t\tscreenfull.off('change', onFullScreenExit);\n\t\t\t\tresolve();\n\t\t\t};\n\n\t\t\tscreenfull.on('change', onFullScreenExit);\n\n\t\t\tconst returnPromise = document[nativeAPI.exitFullscreen]();\n\n\t\t\tif (returnPromise instanceof Promise) {\n\t\t\t\treturnPromise.then(onFullScreenExit).catch(reject);\n\t\t\t}\n\t\t});\n\t},\n\ttoggle(element, options) {\n\t\treturn screenfull.isFullscreen ? screenfull.exit() : screenfull.request(element, options);\n\t},\n\tonchange(callback) {\n\t\tscreenfull.on('change', callback);\n\t},\n\tonerror(callback) {\n\t\tscreenfull.on('error', callback);\n\t},\n\ton(event, callback) {\n\t\tconst eventName = eventNameMap[event];\n\t\tif (eventName) {\n\t\t\tdocument.addEventListener(eventName, callback, false);\n\t\t}\n\t},\n\toff(event, callback) {\n\t\tconst eventName = eventNameMap[event];\n\t\tif (eventName) {\n\t\t\tdocument.removeEventListener(eventName, callback, false);\n\t\t}\n\t},\n\traw: nativeAPI,\n};\n\nObject.defineProperties(screenfull, {\n\tisFullscreen: {\n\t\tget: () => Boolean(document[nativeAPI.fullscreenElement]),\n\t},\n\telement: {\n\t\tenumerable: true,\n\t\tget: () => document[nativeAPI.fullscreenElement] ?? undefined,\n\t},\n\tisEnabled: {\n\t\tenumerable: true,\n\t\t// Coerce to boolean in case of old WebKit.\n\t\tget: () => Boolean(document[nativeAPI.fullscreenEnabled]),\n\t},\n});\n\nif (!nativeAPI) {\n\tscreenfull = {isEnabled: false};\n}\n\nexport default screenfull;\n","var bn = require('bn.js');\nvar brorand = require('brorand');\n\nfunction MillerRabin(rand) {\n  this.rand = rand || new brorand.Rand();\n}\nmodule.exports = MillerRabin;\n\nMillerRabin.create = function create(rand) {\n  return new MillerRabin(rand);\n};\n\nMillerRabin.prototype._randbelow = function _randbelow(n) {\n  var len = n.bitLength();\n  var min_bytes = Math.ceil(len / 8);\n\n  // Generage random bytes until a number less than n is found.\n  // This ensures that 0..n-1 have an equal probability of being selected.\n  do\n    var a = new bn(this.rand.generate(min_bytes));\n  while (a.cmp(n) >= 0);\n\n  return a;\n};\n\nMillerRabin.prototype._randrange = function _randrange(start, stop) {\n  // Generate a random number greater than or equal to start and less than stop.\n  var size = stop.sub(start);\n  return start.add(this._randbelow(size));\n};\n\nMillerRabin.prototype.test = function test(n, k, cb) {\n  var len = n.bitLength();\n  var red = bn.mont(n);\n  var rone = new bn(1).toRed(red);\n\n  if (!k)\n    k = Math.max(1, (len / 48) | 0);\n\n  // Find d and s, (n - 1) = (2 ^ s) * d;\n  var n1 = n.subn(1);\n  for (var s = 0; !n1.testn(s); s++) {}\n  var d = n.shrn(s);\n\n  var rn1 = n1.toRed(red);\n\n  var prime = true;\n  for (; k > 0; k--) {\n    var a = this._randrange(new bn(2), n1);\n    if (cb)\n      cb(a);\n\n    var x = a.toRed(red).redPow(d);\n    if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)\n      continue;\n\n    for (var i = 1; i < s; i++) {\n      x = x.redSqr();\n\n      if (x.cmp(rone) === 0)\n        return false;\n      if (x.cmp(rn1) === 0)\n        break;\n    }\n\n    if (i === s)\n      return false;\n  }\n\n  return prime;\n};\n\nMillerRabin.prototype.getDivisor = function getDivisor(n, k) {\n  var len = n.bitLength();\n  var red = bn.mont(n);\n  var rone = new bn(1).toRed(red);\n\n  if (!k)\n    k = Math.max(1, (len / 48) | 0);\n\n  // Find d and s, (n - 1) = (2 ^ s) * d;\n  var n1 = n.subn(1);\n  for (var s = 0; !n1.testn(s); s++) {}\n  var d = n.shrn(s);\n\n  var rn1 = n1.toRed(red);\n\n  for (; k > 0; k--) {\n    var a = this._randrange(new bn(2), n1);\n\n    var g = n.gcd(a);\n    if (g.cmpn(1) !== 0)\n      return g;\n\n    var x = a.toRed(red).redPow(d);\n    if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)\n      continue;\n\n    for (var i = 1; i < s; i++) {\n      x = x.redSqr();\n\n      if (x.cmp(rone) === 0)\n        return x.fromRed().subn(1).gcd(n);\n      if (x.cmp(rn1) === 0)\n        break;\n    }\n\n    if (i === s) {\n      x = x.redSqr();\n      return x.fromRed().subn(1).gcd(n);\n    }\n  }\n\n  return false;\n};\n","exports.publicEncrypt = require('./publicEncrypt')\nexports.privateDecrypt = require('./privateDecrypt')\n\nexports.privateEncrypt = function privateEncrypt (key, buf) {\n  return exports.publicEncrypt(key, buf, true)\n}\n\nexports.publicDecrypt = function publicDecrypt (key, buf) {\n  return exports.privateDecrypt(key, buf, true)\n}\n","module.exports = require('./lib/_stream_writable.js');\n","var Buffer = require('safe-buffer').Buffer\n\n// prototype class for hash functions\nfunction Hash (blockSize, finalSize) {\n  this._block = Buffer.alloc(blockSize)\n  this._finalSize = finalSize\n  this._blockSize = blockSize\n  this._len = 0\n}\n\nHash.prototype.update = function (data, enc) {\n  if (typeof data === 'string') {\n    enc = enc || 'utf8'\n    data = Buffer.from(data, enc)\n  }\n\n  var block = this._block\n  var blockSize = this._blockSize\n  var length = data.length\n  var accum = this._len\n\n  for (var offset = 0; offset < length;) {\n    var assigned = accum % blockSize\n    var remainder = Math.min(length - offset, blockSize - assigned)\n\n    for (var i = 0; i < remainder; i++) {\n      block[assigned + i] = data[offset + i]\n    }\n\n    accum += remainder\n    offset += remainder\n\n    if ((accum % blockSize) === 0) {\n      this._update(block)\n    }\n  }\n\n  this._len += length\n  return this\n}\n\nHash.prototype.digest = function (enc) {\n  var rem = this._len % this._blockSize\n\n  this._block[rem] = 0x80\n\n  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest\n  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize\n  this._block.fill(0, rem + 1)\n\n  if (rem >= this._finalSize) {\n    this._update(this._block)\n    this._block.fill(0)\n  }\n\n  var bits = this._len * 8\n\n  // uint32\n  if (bits <= 0xffffffff) {\n    this._block.writeUInt32BE(bits, this._blockSize - 4)\n\n  // uint64\n  } else {\n    var lowBits = (bits & 0xffffffff) >>> 0\n    var highBits = (bits - lowBits) / 0x100000000\n\n    this._block.writeUInt32BE(highBits, this._blockSize - 8)\n    this._block.writeUInt32BE(lowBits, this._blockSize - 4)\n  }\n\n  this._update(this._block)\n  var hash = this._hash()\n\n  return enc ? hash.toString(enc) : hash\n}\n\nHash.prototype._update = function () {\n  throw new Error('_update must be implemented by subclass')\n}\n\nmodule.exports = Hash\n","/**\n * Compiles a querystring\n * Returns string representation of the object\n *\n * @param {Object}\n * @api private\n */\n\nexports.encode = function (obj) {\n  var str = '';\n\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      if (str.length) str += '&';\n      str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\n    }\n  }\n\n  return str;\n};\n\n/**\n * Parses a simple querystring into an object\n *\n * @param {String} qs\n * @api private\n */\n\nexports.decode = function(qs){\n  var qry = {};\n  var pairs = qs.split('&');\n  for (var i = 0, l = pairs.length; i < l; i++) {\n    var pair = pairs[i].split('=');\n    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\n  }\n  return qry;\n};\n","'use strict'\nvar inherits = require('inherits')\nvar HashBase = require('hash-base')\nvar Buffer = require('safe-buffer').Buffer\n\nvar ARRAY16 = new Array(16)\n\nfunction MD5 () {\n  HashBase.call(this, 64)\n\n  // state\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n}\n\ninherits(MD5, HashBase)\n\nMD5.prototype._update = function () {\n  var M = ARRAY16\n  for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)\n\n  var a = this._a\n  var b = this._b\n  var c = this._c\n  var d = this._d\n\n  a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)\n  d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)\n  c = fnF(c, d, a, b, M[2], 0x242070db, 17)\n  b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)\n  a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)\n  d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)\n  c = fnF(c, d, a, b, M[6], 0xa8304613, 17)\n  b = fnF(b, c, d, a, M[7], 0xfd469501, 22)\n  a = fnF(a, b, c, d, M[8], 0x698098d8, 7)\n  d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)\n  c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)\n  b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)\n  a = fnF(a, b, c, d, M[12], 0x6b901122, 7)\n  d = fnF(d, a, b, c, M[13], 0xfd987193, 12)\n  c = fnF(c, d, a, b, M[14], 0xa679438e, 17)\n  b = fnF(b, c, d, a, M[15], 0x49b40821, 22)\n\n  a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)\n  d = fnG(d, a, b, c, M[6], 0xc040b340, 9)\n  c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)\n  b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)\n  a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)\n  d = fnG(d, a, b, c, M[10], 0x02441453, 9)\n  c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)\n  b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)\n  a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)\n  d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)\n  c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)\n  b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)\n  a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)\n  d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)\n  c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)\n  b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)\n\n  a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)\n  d = fnH(d, a, b, c, M[8], 0x8771f681, 11)\n  c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)\n  b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)\n  a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)\n  d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)\n  c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)\n  b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)\n  a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)\n  d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)\n  c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)\n  b = fnH(b, c, d, a, M[6], 0x04881d05, 23)\n  a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)\n  d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)\n  c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)\n  b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)\n\n  a = fnI(a, b, c, d, M[0], 0xf4292244, 6)\n  d = fnI(d, a, b, c, M[7], 0x432aff97, 10)\n  c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)\n  b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)\n  a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)\n  d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)\n  c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)\n  b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)\n  a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)\n  d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)\n  c = fnI(c, d, a, b, M[6], 0xa3014314, 15)\n  b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)\n  a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)\n  d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)\n  c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)\n  b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)\n\n  this._a = (this._a + a) | 0\n  this._b = (this._b + b) | 0\n  this._c = (this._c + c) | 0\n  this._d = (this._d + d) | 0\n}\n\nMD5.prototype._digest = function () {\n  // create padding and handle blocks\n  this._block[this._blockOffset++] = 0x80\n  if (this._blockOffset > 56) {\n    this._block.fill(0, this._blockOffset, 64)\n    this._update()\n    this._blockOffset = 0\n  }\n\n  this._block.fill(0, this._blockOffset, 56)\n  this._block.writeUInt32LE(this._length[0], 56)\n  this._block.writeUInt32LE(this._length[1], 60)\n  this._update()\n\n  // produce result\n  var buffer = Buffer.allocUnsafe(16)\n  buffer.writeInt32LE(this._a, 0)\n  buffer.writeInt32LE(this._b, 4)\n  buffer.writeInt32LE(this._c, 8)\n  buffer.writeInt32LE(this._d, 12)\n  return buffer\n}\n\nfunction rotl (x, n) {\n  return (x << n) | (x >>> (32 - n))\n}\n\nfunction fnF (a, b, c, d, m, k, s) {\n  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnG (a, b, c, d, m, k, s) {\n  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnH (a, b, c, d, m, k, s) {\n  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnI (a, b, c, d, m, k, s) {\n  return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0\n}\n\nmodule.exports = MD5\n","const { webm, mp4 } = require(\"./media.js\");\n\n// Detect iOS browsers < version 10\nconst oldIOS = () =>\n  typeof navigator !== \"undefined\" &&\n  parseFloat(\n    (\n      \"\" +\n      (/CPU.*OS ([0-9_]{3,4})[0-9_]{0,1}|(CPU like).*AppleWebKit.*Mobile/i.exec(\n        navigator.userAgent\n      ) || [0, \"\"])[1]\n    )\n      .replace(\"undefined\", \"3_2\")\n      .replace(\"_\", \".\")\n      .replace(\"_\", \"\")\n  ) < 10 &&\n  !window.MSStream;\n\n// Detect native Wake Lock API support\nconst nativeWakeLock = () => \"wakeLock\" in navigator;\n\nclass NoSleep {\n  constructor() {\n    this.enabled = false;\n    if (nativeWakeLock()) {\n      this._wakeLock = null;\n      const handleVisibilityChange = () => {\n        if (this._wakeLock !== null && document.visibilityState === \"visible\") {\n          this.enable();\n        }\n      };\n      document.addEventListener(\"visibilitychange\", handleVisibilityChange);\n      document.addEventListener(\"fullscreenchange\", handleVisibilityChange);\n    } else if (oldIOS()) {\n      this.noSleepTimer = null;\n    } else {\n      // Set up no sleep video element\n      this.noSleepVideo = document.createElement(\"video\");\n\n      this.noSleepVideo.setAttribute(\"title\", \"No Sleep\");\n      this.noSleepVideo.setAttribute(\"playsinline\", \"\");\n\n      this._addSourceToVideo(this.noSleepVideo, \"webm\", webm);\n      this._addSourceToVideo(this.noSleepVideo, \"mp4\", mp4);\n\n      this.noSleepVideo.addEventListener(\"loadedmetadata\", () => {\n        if (this.noSleepVideo.duration <= 1) {\n          // webm source\n          this.noSleepVideo.setAttribute(\"loop\", \"\");\n        } else {\n          // mp4 source\n          this.noSleepVideo.addEventListener(\"timeupdate\", () => {\n            if (this.noSleepVideo.currentTime > 0.5) {\n              this.noSleepVideo.currentTime = Math.random();\n            }\n          });\n        }\n      });\n    }\n  }\n\n  _addSourceToVideo(element, type, dataURI) {\n    var source = document.createElement(\"source\");\n    source.src = dataURI;\n    source.type = `video/${type}`;\n    element.appendChild(source);\n  }\n\n  get isEnabled() {\n    return this.enabled;\n  }\n\n  enable() {\n    if (nativeWakeLock()) {\n      return navigator.wakeLock\n        .request(\"screen\")\n        .then((wakeLock) => {\n          this._wakeLock = wakeLock;\n          this.enabled = true;\n          console.log(\"Wake Lock active.\");\n          this._wakeLock.addEventListener(\"release\", () => {\n            // ToDo: Potentially emit an event for the page to observe since\n            // Wake Lock releases happen when page visibility changes.\n            // (https://web.dev/wakelock/#wake-lock-lifecycle)\n            console.log(\"Wake Lock released.\");\n          });\n        })\n        .catch((err) => {\n          this.enabled = false;\n          console.error(`${err.name}, ${err.message}`);\n          throw err;\n        });\n    } else if (oldIOS()) {\n      this.disable();\n      console.warn(`\n        NoSleep enabled for older iOS devices. This can interrupt\n        active or long-running network requests from completing successfully.\n        See https://github.com/richtr/NoSleep.js/issues/15 for more details.\n      `);\n      this.noSleepTimer = window.setInterval(() => {\n        if (!document.hidden) {\n          window.location.href = window.location.href.split(\"#\")[0];\n          window.setTimeout(window.stop, 0);\n        }\n      }, 15000);\n      this.enabled = true;\n      return Promise.resolve();\n    } else {\n      let playPromise = this.noSleepVideo.play();\n      return playPromise\n        .then((res) => {\n          this.enabled = true;\n          return res;\n        })\n        .catch((err) => {\n          this.enabled = false;\n          throw err;\n        });\n    }\n  }\n\n  disable() {\n    if (nativeWakeLock()) {\n      if (this._wakeLock) {\n        this._wakeLock.release();\n      }\n      this._wakeLock = null;\n    } else if (oldIOS()) {\n      if (this.noSleepTimer) {\n        console.warn(`\n          NoSleep now disabled for older iOS devices.\n        `);\n        window.clearInterval(this.noSleepTimer);\n        this.noSleepTimer = null;\n      }\n    } else {\n      this.noSleepVideo.pause();\n    }\n    this.enabled = false;\n  }\n}\n\nmodule.exports = NoSleep;\n","// from https://github.com/indutny/self-signed/blob/gh-pages/lib/asn1.js\n// Fedor, you are amazing.\n'use strict'\n\nvar asn1 = require('asn1.js')\n\nexports.certificate = require('./certificate')\n\nvar RSAPrivateKey = asn1.define('RSAPrivateKey', function () {\n  this.seq().obj(\n    this.key('version').int(),\n    this.key('modulus').int(),\n    this.key('publicExponent').int(),\n    this.key('privateExponent').int(),\n    this.key('prime1').int(),\n    this.key('prime2').int(),\n    this.key('exponent1').int(),\n    this.key('exponent2').int(),\n    this.key('coefficient').int()\n  )\n})\nexports.RSAPrivateKey = RSAPrivateKey\n\nvar RSAPublicKey = asn1.define('RSAPublicKey', function () {\n  this.seq().obj(\n    this.key('modulus').int(),\n    this.key('publicExponent').int()\n  )\n})\nexports.RSAPublicKey = RSAPublicKey\n\nvar PublicKey = asn1.define('SubjectPublicKeyInfo', function () {\n  this.seq().obj(\n    this.key('algorithm').use(AlgorithmIdentifier),\n    this.key('subjectPublicKey').bitstr()\n  )\n})\nexports.PublicKey = PublicKey\n\nvar AlgorithmIdentifier = asn1.define('AlgorithmIdentifier', function () {\n  this.seq().obj(\n    this.key('algorithm').objid(),\n    this.key('none').null_().optional(),\n    this.key('curve').objid().optional(),\n    this.key('params').seq().obj(\n      this.key('p').int(),\n      this.key('q').int(),\n      this.key('g').int()\n    ).optional()\n  )\n})\n\nvar PrivateKeyInfo = asn1.define('PrivateKeyInfo', function () {\n  this.seq().obj(\n    this.key('version').int(),\n    this.key('algorithm').use(AlgorithmIdentifier),\n    this.key('subjectPrivateKey').octstr()\n  )\n})\nexports.PrivateKey = PrivateKeyInfo\nvar EncryptedPrivateKeyInfo = asn1.define('EncryptedPrivateKeyInfo', function () {\n  this.seq().obj(\n    this.key('algorithm').seq().obj(\n      this.key('id').objid(),\n      this.key('decrypt').seq().obj(\n        this.key('kde').seq().obj(\n          this.key('id').objid(),\n          this.key('kdeparams').seq().obj(\n            this.key('salt').octstr(),\n            this.key('iters').int()\n          )\n        ),\n        this.key('cipher').seq().obj(\n          this.key('algo').objid(),\n          this.key('iv').octstr()\n        )\n      )\n    ),\n    this.key('subjectPrivateKey').octstr()\n  )\n})\n\nexports.EncryptedPrivateKey = EncryptedPrivateKeyInfo\n\nvar DSAPrivateKey = asn1.define('DSAPrivateKey', function () {\n  this.seq().obj(\n    this.key('version').int(),\n    this.key('p').int(),\n    this.key('q').int(),\n    this.key('g').int(),\n    this.key('pub_key').int(),\n    this.key('priv_key').int()\n  )\n})\nexports.DSAPrivateKey = DSAPrivateKey\n\nexports.DSAparam = asn1.define('DSAparam', function () {\n  this.int()\n})\n\nvar ECPrivateKey = asn1.define('ECPrivateKey', function () {\n  this.seq().obj(\n    this.key('version').int(),\n    this.key('privateKey').octstr(),\n    this.key('parameters').optional().explicit(0).use(ECParameters),\n    this.key('publicKey').optional().explicit(1).bitstr()\n  )\n})\nexports.ECPrivateKey = ECPrivateKey\n\nvar ECParameters = asn1.define('ECParameters', function () {\n  this.choice({\n    namedCurve: this.objid()\n  })\n})\n\nexports.signature = asn1.define('signature', function () {\n  this.seq().obj(\n    this.key('r').int(),\n    this.key('s').int()\n  )\n})\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n * in FIPS PUB 180-1\n * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for details.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha1 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha1, Hash)\n\nSha1.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl1 (num) {\n  return (num << 1) | (num >>> 31)\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha1.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha1.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha1\n","// from https://github.com/Rantanen/node-dtls/blob/25a7dc861bda38cfeac93a723500eea4f0ac2e86/Certificate.js\n// thanks to @Rantanen\n\n'use strict'\n\nvar asn = require('asn1.js')\n\nvar Time = asn.define('Time', function () {\n  this.choice({\n    utcTime: this.utctime(),\n    generalTime: this.gentime()\n  })\n})\n\nvar AttributeTypeValue = asn.define('AttributeTypeValue', function () {\n  this.seq().obj(\n    this.key('type').objid(),\n    this.key('value').any()\n  )\n})\n\nvar AlgorithmIdentifier = asn.define('AlgorithmIdentifier', function () {\n  this.seq().obj(\n    this.key('algorithm').objid(),\n    this.key('parameters').optional(),\n    this.key('curve').objid().optional()\n  )\n})\n\nvar SubjectPublicKeyInfo = asn.define('SubjectPublicKeyInfo', function () {\n  this.seq().obj(\n    this.key('algorithm').use(AlgorithmIdentifier),\n    this.key('subjectPublicKey').bitstr()\n  )\n})\n\nvar RelativeDistinguishedName = asn.define('RelativeDistinguishedName', function () {\n  this.setof(AttributeTypeValue)\n})\n\nvar RDNSequence = asn.define('RDNSequence', function () {\n  this.seqof(RelativeDistinguishedName)\n})\n\nvar Name = asn.define('Name', function () {\n  this.choice({\n    rdnSequence: this.use(RDNSequence)\n  })\n})\n\nvar Validity = asn.define('Validity', function () {\n  this.seq().obj(\n    this.key('notBefore').use(Time),\n    this.key('notAfter').use(Time)\n  )\n})\n\nvar Extension = asn.define('Extension', function () {\n  this.seq().obj(\n    this.key('extnID').objid(),\n    this.key('critical').bool().def(false),\n    this.key('extnValue').octstr()\n  )\n})\n\nvar TBSCertificate = asn.define('TBSCertificate', function () {\n  this.seq().obj(\n    this.key('version').explicit(0).int().optional(),\n    this.key('serialNumber').int(),\n    this.key('signature').use(AlgorithmIdentifier),\n    this.key('issuer').use(Name),\n    this.key('validity').use(Validity),\n    this.key('subject').use(Name),\n    this.key('subjectPublicKeyInfo').use(SubjectPublicKeyInfo),\n    this.key('issuerUniqueID').implicit(1).bitstr().optional(),\n    this.key('subjectUniqueID').implicit(2).bitstr().optional(),\n    this.key('extensions').explicit(3).seqof(Extension).optional()\n  )\n})\n\nvar X509Certificate = asn.define('X509Certificate', function () {\n  this.seq().obj(\n    this.key('tbsCertificate').use(TBSCertificate),\n    this.key('signatureAlgorithm').use(AlgorithmIdentifier),\n    this.key('signatureValue').bitstr()\n  )\n})\n\nmodule.exports = X509Certificate\n","module.exports = require('events').EventEmitter;\n","'use strict'\nvar Buffer = require('buffer').Buffer\nvar inherits = require('inherits')\nvar HashBase = require('hash-base')\n\nvar ARRAY16 = new Array(16)\n\nvar zl = [\n  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13\n]\n\nvar zr = [\n  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11\n]\n\nvar sl = [\n  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6\n]\n\nvar sr = [\n  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11\n]\n\nvar hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]\nvar hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]\n\nfunction RIPEMD160 () {\n  HashBase.call(this, 64)\n\n  // state\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n}\n\ninherits(RIPEMD160, HashBase)\n\nRIPEMD160.prototype._update = function () {\n  var words = ARRAY16\n  for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)\n\n  var al = this._a | 0\n  var bl = this._b | 0\n  var cl = this._c | 0\n  var dl = this._d | 0\n  var el = this._e | 0\n\n  var ar = this._a | 0\n  var br = this._b | 0\n  var cr = this._c | 0\n  var dr = this._d | 0\n  var er = this._e | 0\n\n  // computation\n  for (var i = 0; i < 80; i += 1) {\n    var tl\n    var tr\n    if (i < 16) {\n      tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])\n      tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])\n    } else if (i < 32) {\n      tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])\n      tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])\n    } else if (i < 48) {\n      tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])\n      tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])\n    } else if (i < 64) {\n      tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])\n      tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])\n    } else { // if (i<80) {\n      tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])\n      tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])\n    }\n\n    al = el\n    el = dl\n    dl = rotl(cl, 10)\n    cl = bl\n    bl = tl\n\n    ar = er\n    er = dr\n    dr = rotl(cr, 10)\n    cr = br\n    br = tr\n  }\n\n  // update state\n  var t = (this._b + cl + dr) | 0\n  this._b = (this._c + dl + er) | 0\n  this._c = (this._d + el + ar) | 0\n  this._d = (this._e + al + br) | 0\n  this._e = (this._a + bl + cr) | 0\n  this._a = t\n}\n\nRIPEMD160.prototype._digest = function () {\n  // create padding and handle blocks\n  this._block[this._blockOffset++] = 0x80\n  if (this._blockOffset > 56) {\n    this._block.fill(0, this._blockOffset, 64)\n    this._update()\n    this._blockOffset = 0\n  }\n\n  this._block.fill(0, this._blockOffset, 56)\n  this._block.writeUInt32LE(this._length[0], 56)\n  this._block.writeUInt32LE(this._length[1], 60)\n  this._update()\n\n  // produce result\n  var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20)\n  buffer.writeInt32LE(this._a, 0)\n  buffer.writeInt32LE(this._b, 4)\n  buffer.writeInt32LE(this._c, 8)\n  buffer.writeInt32LE(this._d, 12)\n  buffer.writeInt32LE(this._e, 16)\n  return buffer\n}\n\nfunction rotl (x, n) {\n  return (x << n) | (x >>> (32 - n))\n}\n\nfunction fn1 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn2 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn3 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn4 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn5 (a, b, c, d, e, m, k, s) {\n  return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0\n}\n\nmodule.exports = RIPEMD160\n"],"sourceRoot":""}