{"version":3,"sources":["../node_modules/browserify-aes/browser.js","../node_modules/browserify-aes/modes/index.js","../node_modules/brorand/index.js","../node_modules/browserify-sign/node_modules/safe-buffer/index.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","../node_modules/browserify-rsa/index.js","../node_modules/browser-or-node/lib/index.js","../node_modules/browserify-aes/modes/ctr.js","../node_modules/browserify-aes/incr32.js","../node_modules/browserify-aes/authCipher.js","../node_modules/browserify-aes/streamCipher.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_readable.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/stream-browser.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/destroy.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/state.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_writable.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_transform.js","../node_modules/browserify-sign/algos.js","../node_modules/browserify-cipher/browser.js","../node_modules/browserify-des/index.js","../node_modules/browserify-aes/encrypter.js","../node_modules/browserify-aes/modes/ecb.js","../node_modules/browserify-aes/modes/cbc.js","../node_modules/browserify-aes/modes/cfb.js","../node_modules/browserify-aes/modes/cfb8.js","../node_modules/browserify-aes/modes/cfb1.js","../node_modules/browserify-aes/modes/ofb.js","../node_modules/browserify-aes/ghash.js","../node_modules/browserify-aes/decrypter.js","../node_modules/browserify-des/modes.js","../node_modules/browserify-sign/browser/index.js","../node_modules/browserify-sign/node_modules/readable-stream/readable-browser.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/buffer_list.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/async_iterator.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/from-browser.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_passthrough.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/internal/streams/pipeline.js","../node_modules/browserify-sign/browser/sign.js","../node_modules/browserify-sign/browser/verify.js","../node_modules/browserify-sign/node_modules/readable-stream/errors-browser.js","../node_modules/browserify-sign/node_modules/readable-stream/lib/_stream_duplex.js","../node_modules/browserify-aes/aes.js"],"names":["ciphers","require","deciphers","modes","exports","createCipher","Cipher","createCipheriv","Cipheriv","createDecipher","Decipher","createDecipheriv","Decipheriv","listCiphers","getCiphers","Object","keys","modeModules","ECB","CBC","CFB","CFB8","CFB1","OFB","CTR","GCM","key","module","mode","r","Rand","rand","this","len","generate","prototype","_rand","n","getBytes","res","Uint8Array","i","length","getByte","self","crypto","getRandomValues","arr","msCrypto","window","Error","randomBytes","e","buffer","Buffer","copyProps","src","dst","SafeBuffer","arg","encodingOrOffset","from","alloc","allocUnsafe","allocUnsafeSlow","create","TypeError","size","fill","encoding","buf","undefined","SlowBuffer","ERR_STREAM_PREMATURE_CLOSE","codes","noop","eos","stream","opts","callback","called","_len","arguments","args","Array","_key","apply","once","readable","writable","onlegacyfinish","onfinish","writableEnded","_writableState","finished","call","readableEnded","_readableState","endEmitted","onend","onerror","err","onclose","ended","onrequest","req","on","setHeader","abort","isRequest","error","removeListener","BN","getr","priv","modulus","byteLength","cmp","umod","prime1","prime2","crt","msg","blinds","blinder","toRed","mont","redPow","publicExponent","fromRed","unblinder","invm","blind","blinded","mul","c1","c2","qinv","coefficient","p","q","m1","exponent1","m2","exponent2","h","isub","imul","iadd","toArrayLike","defineProperty","value","_typeof","Symbol","iterator","obj","constructor","isBrowser","document","isWebWorker","name","isNode","process","versions","node","isJsDom","navigator","userAgent","includes","xor","incr32","getBlock","out","_cipher","encryptBlockRaw","_prev","encrypt","chunk","chunkNum","Math","ceil","start","_cache","concat","offset","writeUInt32BE","pad","slice","iv","item","readUInt8","writeUInt8","aes","Transform","inherits","GHASH","StreamCipher","decrypt","AES","ck","encryptBlock","_ghash","_finID","ghash","toPad","update","ivBits","tail","writeUIntBE","state","calcIv","_secCache","_decrypt","_alen","_mode","_authTag","_called","_update","rump","_final","tag","final","a","b","min","xorTest","scrub","getAuthTag","isBuffer","setAuthTag","setAAD","Duplex","Readable","ReadableState","EventEmitter","EElistenerCount","emitter","type","listeners","Stream","OurUint8Array","global","debug","debugUtil","debuglog","StringDecoder","createReadableStreamAsyncIterator","BufferList","destroyImpl","getHighWaterMark","_require$codes","ERR_INVALID_ARG_TYPE","ERR_STREAM_PUSH_AFTER_EOF","ERR_METHOD_NOT_IMPLEMENTED","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","errorOrDestroy","kProxyEvents","options","isDuplex","objectMode","readableObjectMode","highWaterMark","pipes","pipesCount","flowing","reading","sync","needReadable","emittedReadable","readableListening","resumeScheduled","paused","emitClose","autoDestroy","destroyed","defaultEncoding","awaitDrain","readingMore","decoder","read","_read","destroy","_destroy","readableAddChunk","addToFront","skipChunkCheck","er","end","push","emitReadable","emitReadable_","onEofChunk","chunkInvalid","getPrototypeOf","_uint8ArrayToBuffer","addChunk","write","maybeReadMore","emit","unshift","enumerable","get","set","_undestroy","undestroy","cb","isPaused","setEncoding","enc","head","content","data","next","clear","howMuchToRead","computeNewHighWaterMark","nextTick","flow","maybeReadMore_","updateReadableListening","listenerCount","resume","nReadingNextTick","resume_","fromList","ret","shift","join","first","consume","endReadable","endReadableNT","wState","indexOf","xs","x","l","parseInt","nOrig","doRead","pipe","dest","pipeOpts","endFn","stdout","stderr","unpipe","onunpipe","unpipeInfo","hasUnpiped","ondrain","ondata","cleanedUp","needDrain","pipeOnDrain","pause","event","fn","prependListener","_events","isArray","dests","index","splice","ev","addListener","removeAllListeners","wrap","_this","method","bind","asyncIterator","_fromList","iterable","emitErrorAndCloseNT","emitErrorNT","emitCloseNT","readableDestroyed","writableDestroyed","errorEmitted","ending","finalCalled","prefinished","rState","ERR_INVALID_OPT_VALUE","duplexKey","hwm","highWaterMarkFrom","isFinite","floor","CorkedRequest","entry","finish","corkReq","pendingcb","corkedRequestsFree","onCorkedFinish","Writable","WritableState","internalUtil","deprecate","realHasInstance","ERR_MULTIPLE_CALLBACK","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_DESTROYED","ERR_STREAM_NULL_VALUES","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","nop","writableObjectMode","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writecb","writelen","onwriteStateUpdate","finishMaybe","onwriteError","needFinish","bufferedRequest","clearBuffer","afterWrite","lastBufferedRequest","bufferedRequestCount","_write","writev","_writev","doWrite","onwriteDrain","holder","count","allBuffers","isBuf","callFinal","need","prefinish","getBuffer","current","_","hasInstance","Function","object","writeAfterEnd","validChunk","newChunk","decodeChunk","last","writeOrBuffer","cork","uncork","setDefaultEncoding","toLowerCase","endWritable","ERR_TRANSFORM_ALREADY_TRANSFORMING","ERR_TRANSFORM_WITH_LENGTH_0","afterTransform","ts","_transformState","transforming","writechunk","rs","needTransform","writeencoding","transform","_transform","flush","_flush","done","err2","DES","aesModes","desModes","ebtk","suite","password","keyLen","ivLen","CipherBase","des","instantiate","EDE","modeName","_des","des3","MODES","AuthCipher","Splitter","_autopadding","thing","add","PADDING","cache","config","equals","setAutoPadding","setTo","padBuff","block","decryptBlock","encryptStart","encryptByte","byteParam","bit","shiftIn","ZEROES","fromArray","_multiply","j","lsbVi","Vi","readUInt32BE","Zi","abl","bl","_last","padded","unpad","autoPadding","createHash","sign","verify","algorithms","Sign","algorithm","_hashType","hash","_hash","_tag","id","_signType","Verify","createSign","createVerify","forEach","digest","sig","toString","PassThrough","pipeline","ownKeys","enumerableOnly","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","_objectSpread","target","source","_defineProperty","getOwnPropertyDescriptors","defineProperties","_toPropertyKey","configurable","_defineProperties","props","descriptor","input","hint","prim","toPrimitive","String","Number","_toPrimitive","inspect","custom","instance","Constructor","_classCallCheck","protoProps","staticProps","v","s","copy","hasStrings","_getString","_getBuffer","c","str","nb","depth","customInspect","_Object$setPrototypeO","kLastResolve","kLastReject","kError","kEnded","kLastPromise","kHandlePromise","kStream","createIterResult","readAndResolve","iter","resolve","onReadable","AsyncIteratorPrototype","ReadableStreamAsyncIteratorPrototype","setPrototypeOf","Promise","reject","promise","lastPromise","then","wrapForNext","_this2","_Object$create","code","ERR_MISSING_ARGS","destroyer","closed","to","popCallback","streams","pop","destroys","map","reduce","createHmac","EC","ec","parseKeys","curves","getKey","algo","toArray","zeros","hlen","hbits","bits","bits2int","mod","bits2octets","k","obits","bitLength","ishrn","makeKey","kv","t","makeR","g","hashType","signType","curve","curveId","keyFromPrivate","privateKey","toDER","ecSign","params","priv_key","H","cmpn","dsaSign","checkValue","pub","pubkey","subjectPrivateKey","ecVerify","y","pub_key","unpacked","signature","decode","montp","w","dsaVerify","padNum","red","createErrorType","message","Base","NodeError","_Base","subClass","superClass","arg1","arg2","arg3","getMessage","__proto__","oneOf","expected","actual","determiner","search","pos","substr","replace","this_len","substring","endsWith","objectKeys","allowHalfOpen","onEndNT","asUInt32Array","scrubVec","cryptBlock","M","keySchedule","SUB_MIX","SBOX","nRounds","t0","t1","t2","t3","SUB_MIX0","SUB_MIX1","SUB_MIX2","SUB_MIX3","s0","s1","s2","s3","ksRow","round","RCON","G","d","INV_SBOX","INV_SUB_MIX","xi","sx","x2","x4","x8","_reset","blockSize","keySize","keyWords","ksRows","invKeySchedule","ik","ksR","tt","_nRounds","_keySchedule","_invKeySchedule"],"mappings":"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","file":"static/js/main~4c3ada76.ad15af77.chunk.js","sourcesContent":["var ciphers = require('./encrypter')\nvar deciphers = require('./decrypter')\nvar modes = require('./modes/list.json')\n\nfunction getCiphers () {\n  return Object.keys(modes)\n}\n\nexports.createCipher = exports.Cipher = ciphers.createCipher\nexports.createCipheriv = exports.Cipheriv = ciphers.createCipheriv\nexports.createDecipher = exports.Decipher = deciphers.createDecipher\nexports.createDecipheriv = exports.Decipheriv = deciphers.createDecipheriv\nexports.listCiphers = exports.getCiphers = getCiphers\n","var modeModules = {\n  ECB: require('./ecb'),\n  CBC: require('./cbc'),\n  CFB: require('./cfb'),\n  CFB8: require('./cfb8'),\n  CFB1: require('./cfb1'),\n  OFB: require('./ofb'),\n  CTR: require('./ctr'),\n  GCM: require('./ctr')\n}\n\nvar modes = require('./list.json')\n\nfor (var key in modes) {\n  modes[key].module = modeModules[modes[key].mode]\n}\n\nmodule.exports = modes\n","var r;\n\nmodule.exports = function rand(len) {\n  if (!r)\n    r = new Rand(null);\n\n  return r.generate(len);\n};\n\nfunction Rand(rand) {\n  this.rand = rand;\n}\nmodule.exports.Rand = Rand;\n\nRand.prototype.generate = function generate(len) {\n  return this._rand(len);\n};\n\n// Emulate crypto API using randy\nRand.prototype._rand = function _rand(n) {\n  if (this.rand.getBytes)\n    return this.rand.getBytes(n);\n\n  var res = new Uint8Array(n);\n  for (var i = 0; i < res.length; i++)\n    res[i] = this.rand.getByte();\n  return res;\n};\n\nif (typeof self === 'object') {\n  if (self.crypto && self.crypto.getRandomValues) {\n    // Modern browsers\n    Rand.prototype._rand = function _rand(n) {\n      var arr = new Uint8Array(n);\n      self.crypto.getRandomValues(arr);\n      return arr;\n    };\n  } else if (self.msCrypto && self.msCrypto.getRandomValues) {\n    // IE\n    Rand.prototype._rand = function _rand(n) {\n      var arr = new Uint8Array(n);\n      self.msCrypto.getRandomValues(arr);\n      return arr;\n    };\n\n  // Safari's WebWorkers do not have `crypto`\n  } else if (typeof window === 'object') {\n    // Old junk\n    Rand.prototype._rand = function() {\n      throw new Error('Not implemented yet');\n    };\n  }\n} else {\n  // Node.js or Web worker with no crypto support\n  try {\n    var crypto = require('crypto');\n    if (typeof crypto.randomBytes !== 'function')\n      throw new Error('Not supported');\n\n    Rand.prototype._rand = function _rand(n) {\n      return crypto.randomBytes(n);\n    };\n  } catch (e) {\n  }\n}\n","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    callback.apply(this, args);\n  };\n}\nfunction noop() {}\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\nfunction eos(stream, opts, callback) {\n  if (typeof opts === 'function') return eos(stream, null, opts);\n  if (!opts) opts = {};\n  callback = once(callback || noop);\n  var readable = opts.readable || opts.readable !== false && stream.readable;\n  var writable = opts.writable || opts.writable !== false && stream.writable;\n  var onlegacyfinish = function onlegacyfinish() {\n    if (!stream.writable) onfinish();\n  };\n  var writableEnded = stream._writableState && stream._writableState.finished;\n  var onfinish = function onfinish() {\n    writable = false;\n    writableEnded = true;\n    if (!readable) callback.call(stream);\n  };\n  var readableEnded = stream._readableState && stream._readableState.endEmitted;\n  var onend = function onend() {\n    readable = false;\n    readableEnded = true;\n    if (!writable) callback.call(stream);\n  };\n  var onerror = function onerror(err) {\n    callback.call(stream, err);\n  };\n  var onclose = function onclose() {\n    var err;\n    if (readable && !readableEnded) {\n      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n    if (writable && !writableEnded) {\n      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n      return callback.call(stream, err);\n    }\n  };\n  var onrequest = function onrequest() {\n    stream.req.on('finish', onfinish);\n  };\n  if (isRequest(stream)) {\n    stream.on('complete', onfinish);\n    stream.on('abort', onclose);\n    if (stream.req) onrequest();else stream.on('request', onrequest);\n  } else if (writable && !stream._writableState) {\n    // legacy streams\n    stream.on('end', onlegacyfinish);\n    stream.on('close', onlegacyfinish);\n  }\n  stream.on('end', onend);\n  stream.on('finish', onfinish);\n  if (opts.error !== false) stream.on('error', onerror);\n  stream.on('close', onclose);\n  return function () {\n    stream.removeListener('complete', onfinish);\n    stream.removeListener('abort', onclose);\n    stream.removeListener('request', onrequest);\n    if (stream.req) stream.req.removeListener('finish', onfinish);\n    stream.removeListener('end', onlegacyfinish);\n    stream.removeListener('close', onlegacyfinish);\n    stream.removeListener('finish', onfinish);\n    stream.removeListener('end', onend);\n    stream.removeListener('error', onerror);\n    stream.removeListener('close', onclose);\n  };\n}\nmodule.exports = eos;","var BN = require('bn.js')\nvar randomBytes = require('randombytes')\n\nfunction blind (priv) {\n  var r = getr(priv)\n  var blinder = r.toRed(BN.mont(priv.modulus)).redPow(new BN(priv.publicExponent)).fromRed()\n  return { blinder: blinder, unblinder: r.invm(priv.modulus) }\n}\n\nfunction getr (priv) {\n  var len = priv.modulus.byteLength()\n  var r\n  do {\n    r = new BN(randomBytes(len))\n  } while (r.cmp(priv.modulus) >= 0 || !r.umod(priv.prime1) || !r.umod(priv.prime2))\n  return r\n}\n\nfunction crt (msg, priv) {\n  var blinds = blind(priv)\n  var len = priv.modulus.byteLength()\n  var blinded = new BN(msg).mul(blinds.blinder).umod(priv.modulus)\n  var c1 = blinded.toRed(BN.mont(priv.prime1))\n  var c2 = blinded.toRed(BN.mont(priv.prime2))\n  var qinv = priv.coefficient\n  var p = priv.prime1\n  var q = priv.prime2\n  var m1 = c1.redPow(priv.exponent1).fromRed()\n  var m2 = c2.redPow(priv.exponent2).fromRed()\n  var h = m1.isub(m2).imul(qinv).umod(p).imul(q)\n  return m2.iadd(h).imul(blinds.unblinder).umod(priv.modulus).toArrayLike(Buffer, 'be', len)\n}\ncrt.getr = getr\n\nmodule.exports = crt\n","'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\n/* global window self */\n\nvar isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';\n\n/* eslint-disable no-restricted-globals */\nvar isWebWorker = (typeof self === 'undefined' ? 'undefined' : _typeof(self)) === 'object' && self.constructor && self.constructor.name === 'DedicatedWorkerGlobalScope';\n/* eslint-enable no-restricted-globals */\n\nvar isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;\n\n/**\n * @see https://github.com/jsdom/jsdom/releases/tag/12.0.0\n * @see https://github.com/jsdom/jsdom/issues/1537\n */\n/* eslint-disable no-undef */\nvar isJsDom = function isJsDom() {\n  return typeof window !== 'undefined' && window.name === 'nodejs' || navigator.userAgent.includes('Node.js') || navigator.userAgent.includes('jsdom');\n};\n\nexports.isBrowser = isBrowser;\nexports.isWebWorker = isWebWorker;\nexports.isNode = isNode;\nexports.isJsDom = isJsDom;","var xor = require('buffer-xor')\nvar Buffer = require('safe-buffer').Buffer\nvar incr32 = require('../incr32')\n\nfunction getBlock (self) {\n  var out = self._cipher.encryptBlockRaw(self._prev)\n  incr32(self._prev)\n  return out\n}\n\nvar blockSize = 16\nexports.encrypt = function (self, chunk) {\n  var chunkNum = Math.ceil(chunk.length / blockSize)\n  var start = self._cache.length\n  self._cache = Buffer.concat([\n    self._cache,\n    Buffer.allocUnsafe(chunkNum * blockSize)\n  ])\n  for (var i = 0; i < chunkNum; i++) {\n    var out = getBlock(self)\n    var offset = start + i * blockSize\n    self._cache.writeUInt32BE(out[0], offset + 0)\n    self._cache.writeUInt32BE(out[1], offset + 4)\n    self._cache.writeUInt32BE(out[2], offset + 8)\n    self._cache.writeUInt32BE(out[3], offset + 12)\n  }\n  var pad = self._cache.slice(0, chunk.length)\n  self._cache = self._cache.slice(chunk.length)\n  return xor(chunk, pad)\n}\n","function incr32 (iv) {\n  var len = iv.length\n  var item\n  while (len--) {\n    item = iv.readUInt8(len)\n    if (item === 255) {\n      iv.writeUInt8(0, len)\n    } else {\n      item++\n      iv.writeUInt8(item, len)\n      break\n    }\n  }\n}\nmodule.exports = incr32\n","var aes = require('./aes')\nvar Buffer = require('safe-buffer').Buffer\nvar Transform = require('cipher-base')\nvar inherits = require('inherits')\nvar GHASH = require('./ghash')\nvar xor = require('buffer-xor')\nvar incr32 = require('./incr32')\n\nfunction xorTest (a, b) {\n  var out = 0\n  if (a.length !== b.length) out++\n\n  var len = Math.min(a.length, b.length)\n  for (var i = 0; i < len; ++i) {\n    out += (a[i] ^ b[i])\n  }\n\n  return out\n}\n\nfunction calcIv (self, iv, ck) {\n  if (iv.length === 12) {\n    self._finID = Buffer.concat([iv, Buffer.from([0, 0, 0, 1])])\n    return Buffer.concat([iv, Buffer.from([0, 0, 0, 2])])\n  }\n  var ghash = new GHASH(ck)\n  var len = iv.length\n  var toPad = len % 16\n  ghash.update(iv)\n  if (toPad) {\n    toPad = 16 - toPad\n    ghash.update(Buffer.alloc(toPad, 0))\n  }\n  ghash.update(Buffer.alloc(8, 0))\n  var ivBits = len * 8\n  var tail = Buffer.alloc(8)\n  tail.writeUIntBE(ivBits, 0, 8)\n  ghash.update(tail)\n  self._finID = ghash.state\n  var out = Buffer.from(self._finID)\n  incr32(out)\n  return out\n}\nfunction StreamCipher (mode, key, iv, decrypt) {\n  Transform.call(this)\n\n  var h = Buffer.alloc(4, 0)\n\n  this._cipher = new aes.AES(key)\n  var ck = this._cipher.encryptBlock(h)\n  this._ghash = new GHASH(ck)\n  iv = calcIv(this, iv, ck)\n\n  this._prev = Buffer.from(iv)\n  this._cache = Buffer.allocUnsafe(0)\n  this._secCache = Buffer.allocUnsafe(0)\n  this._decrypt = decrypt\n  this._alen = 0\n  this._len = 0\n  this._mode = mode\n\n  this._authTag = null\n  this._called = false\n}\n\ninherits(StreamCipher, Transform)\n\nStreamCipher.prototype._update = function (chunk) {\n  if (!this._called && this._alen) {\n    var rump = 16 - (this._alen % 16)\n    if (rump < 16) {\n      rump = Buffer.alloc(rump, 0)\n      this._ghash.update(rump)\n    }\n  }\n\n  this._called = true\n  var out = this._mode.encrypt(this, chunk)\n  if (this._decrypt) {\n    this._ghash.update(chunk)\n  } else {\n    this._ghash.update(out)\n  }\n  this._len += chunk.length\n  return out\n}\n\nStreamCipher.prototype._final = function () {\n  if (this._decrypt && !this._authTag) throw new Error('Unsupported state or unable to authenticate data')\n\n  var tag = xor(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(this._finID))\n  if (this._decrypt && xorTest(tag, this._authTag)) throw new Error('Unsupported state or unable to authenticate data')\n\n  this._authTag = tag\n  this._cipher.scrub()\n}\n\nStreamCipher.prototype.getAuthTag = function getAuthTag () {\n  if (this._decrypt || !Buffer.isBuffer(this._authTag)) throw new Error('Attempting to get auth tag in unsupported state')\n\n  return this._authTag\n}\n\nStreamCipher.prototype.setAuthTag = function setAuthTag (tag) {\n  if (!this._decrypt) throw new Error('Attempting to set auth tag in unsupported state')\n\n  this._authTag = tag\n}\n\nStreamCipher.prototype.setAAD = function setAAD (buf) {\n  if (this._called) throw new Error('Attempting to set AAD in unsupported state')\n\n  this._ghash.update(buf)\n  this._alen += buf.length\n}\n\nmodule.exports = StreamCipher\n","var aes = require('./aes')\nvar Buffer = require('safe-buffer').Buffer\nvar Transform = require('cipher-base')\nvar inherits = require('inherits')\n\nfunction StreamCipher (mode, key, iv, decrypt) {\n  Transform.call(this)\n\n  this._cipher = new aes.AES(key)\n  this._prev = Buffer.from(iv)\n  this._cache = Buffer.allocUnsafe(0)\n  this._secCache = Buffer.allocUnsafe(0)\n  this._decrypt = decrypt\n  this._mode = mode\n}\n\ninherits(StreamCipher, Transform)\n\nStreamCipher.prototype._update = function (chunk) {\n  return this._mode.encrypt(this, chunk, this._decrypt)\n}\n\nStreamCipher.prototype._final = function () {\n  this._cipher.scrub()\n}\n\nmodule.exports = StreamCipher\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\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\nvar Buffer = require('buffer').Buffer;\nvar OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function debug() {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/buffer_list');\nvar destroyImpl = require('./internal/streams/destroy');\nvar _require = require('./internal/streams/state'),\n  getHighWaterMark = _require.getHighWaterMark;\nvar _require$codes = require('../errors').codes,\n  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n  ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;\n\n// Lazy loaded to improve the startup performance.\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\nrequire('inherits')(Readable, Stream);\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\nfunction ReadableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n  this.paused = true;\n\n  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = options.emitClose !== false;\n\n  // Should .destroy() be called after 'end' (and potentially 'finish')\n  this.autoDestroy = !!options.autoDestroy;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5\n  var isDuplex = this instanceof Duplex;\n  this._readableState = new ReadableState(options, this, isDuplex);\n\n  // legacy\n  this.readable = true;\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n  Stream.call(this);\n}\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  debug('readableAddChunk', chunk);\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      errorOrDestroy(stream, er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n      if (addToFront) {\n        if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n      } else if (state.destroyed) {\n        return false;\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n      maybeReadMore(stream, state);\n    }\n  }\n\n  // We can push more data if we are below the highWaterMark.\n  // Also, if we have no data yet, we can stand some more bytes.\n  // This is to work around cases where hwm=0, such as the repl.\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    state.awaitDrain = 0;\n    stream.emit('data', chunk);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n  }\n  return er;\n}\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  var decoder = new StringDecoder(enc);\n  this._readableState.decoder = decoder;\n  // If setEncoding(null), decoder.encoding equals utf8\n  this._readableState.encoding = this._readableState.decoder.encoding;\n\n  // Iterate over current buffer to convert already stored Buffers:\n  var p = this._readableState.buffer.head;\n  var content = '';\n  while (p !== null) {\n    content += decoder.write(p.data);\n    p = p.next;\n  }\n  this._readableState.buffer.clear();\n  if (content !== '') this._readableState.buffer.push(content);\n  this._readableState.length = content.length;\n  return this;\n};\n\n// Don't raise the hwm > 1GB\nvar MAX_HWM = 0x40000000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n  if (ret === null) {\n    state.needReadable = state.length <= state.highWaterMark;\n    n = 0;\n  } else {\n    state.length -= n;\n    state.awaitDrain = 0;\n  }\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n  if (ret !== null) this.emit('data', ret);\n  return ret;\n};\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk');\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n  if (state.sync) {\n    // if we are sync, wait until next tick to emit the data.\n    // Otherwise we risk emitting data in the flow()\n    // the readable code triggers during a read() call\n    emitReadable(stream);\n  } else {\n    // emit 'readable' now to make sure it gets picked up.\n    state.needReadable = false;\n    if (!state.emittedReadable) {\n      state.emittedReadable = true;\n      emitReadable_(stream);\n    }\n  }\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  debug('emitReadable', state.needReadable, state.emittedReadable);\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    process.nextTick(emitReadable_, stream);\n  }\n}\nfunction emitReadable_(stream) {\n  var state = stream._readableState;\n  debug('emitReadable_', state.destroyed, state.length, state.ended);\n  if (!state.destroyed && (state.length || state.ended)) {\n    stream.emit('readable');\n    state.emittedReadable = false;\n  }\n\n  // The stream needs another readable event if\n  // 1. It is not flowing, as the flow mechanism will take\n  //    care of it.\n  // 2. It is not ended.\n  // 3. It is below the highWaterMark, so we can schedule\n  //    another readable later.\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    process.nextTick(maybeReadMore_, stream, state);\n  }\n}\nfunction maybeReadMore_(stream, state) {\n  // Attempt to read more data if we should.\n  //\n  // The conditions for reading more data are (one of):\n  // - Not enough data buffered (state.length < state.highWaterMark). The loop\n  //   is responsible for filling the buffer with enough data if such data\n  //   is available. If highWaterMark is 0 and we are not in the flowing mode\n  //   we should _not_ attempt to buffer any extra data. We'll get more data\n  //   when the stream consumer calls read() instead.\n  // - No data in the buffer, and the stream is in flowing mode. In this mode\n  //   the loop below is responsible for ensuring read() is called. Failing to\n  //   call read here would abort the flow and there's no other mechanism for\n  //   continuing the flow if the stream consumer has just subscribed to the\n  //   'data' event.\n  //\n  // In addition to the above conditions to keep reading data, the following\n  // conditions prevent the data from being read:\n  // - The stream has ended (state.ended).\n  // - There is already a pending 'read' operation (state.reading). This is a\n  //   case where the the stream has called the implementation defined _read()\n  //   method, but they are processing the call asynchronously and have _not_\n  //   called push() with new data. In this case we skip performing more\n  //   read()s. The execution ends in this method again after the _read() ends\n  //   up calling push() with more data.\n  while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n    var len = state.length;\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    var ret = dest.write(chunk);\n    debug('dest.write', ret);\n    if (ret === false) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', state.awaitDrain);\n        state.awaitDrain++;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n  return dest;\n};\nfunction pipeOnDrain(src) {\n  return function pipeOnDrainFunctionResult() {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = {\n    hasUnpiped: false\n  };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, {\n      hasUnpiped: false\n    });\n    return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n  dest.emit('unpipe', this, unpipeInfo);\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n  var state = this._readableState;\n  if (ev === 'data') {\n    // update readableListening so that resume() may be a no-op\n    // a few lines down. This is needed to support once('readable').\n    state.readableListening = this.listenerCount('readable') > 0;\n\n    // Try start flowing on next tick if stream isn't explicitly paused\n    if (state.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.flowing = false;\n      state.emittedReadable = false;\n      debug('on readable', state.length, state.reading);\n      if (state.length) {\n        emitReadable(this);\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this);\n      }\n    }\n  }\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\nReadable.prototype.removeListener = function (ev, fn) {\n  var res = Stream.prototype.removeListener.call(this, ev, fn);\n  if (ev === 'readable') {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n  return res;\n};\nReadable.prototype.removeAllListeners = function (ev) {\n  var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n  if (ev === 'readable' || ev === undefined) {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this);\n  }\n  return res;\n};\nfunction updateReadableListening(self) {\n  var state = self._readableState;\n  state.readableListening = self.listenerCount('readable') > 0;\n  if (state.resumeScheduled && !state.paused) {\n    // flowing needs to be set to true now, otherwise\n    // the upcoming resume will not flow.\n    state.flowing = true;\n\n    // crude way to check if we should resume\n  } else if (self.listenerCount('data') > 0) {\n    self.resume();\n  }\n}\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    // we flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume()\n    state.flowing = !state.readableListening;\n    resume(this, state);\n  }\n  state.paused = false;\n  return this;\n};\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    process.nextTick(resume_, stream, state);\n  }\n}\nfunction resume_(stream, state) {\n  debug('resume', state.reading);\n  if (!state.reading) {\n    stream.read(0);\n  }\n  state.resumeScheduled = false;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (this._readableState.flowing !== false) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  this._readableState.paused = true;\n  return this;\n};\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null);\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n  var state = this._readableState;\n  var paused = false;\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n    _this.push(null);\n  });\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function methodWrap(method) {\n        return function methodWrapReturnFunction() {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n  return this;\n};\nif (typeof Symbol === 'function') {\n  Readable.prototype[Symbol.asyncIterator] = function () {\n    if (createReadableStreamAsyncIterator === undefined) {\n      createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n    }\n    return createReadableStreamAsyncIterator(this);\n  };\n}\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.highWaterMark;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState && this._readableState.buffer;\n  }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.flowing;\n  },\n  set: function set(state) {\n    if (this._readableState) {\n      this._readableState.flowing = state;\n    }\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._readableState.length;\n  }\n});\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = state.buffer.consume(n, state.decoder);\n  }\n  return ret;\n}\nfunction endReadable(stream) {\n  var state = stream._readableState;\n  debug('endReadable', state.endEmitted);\n  if (!state.endEmitted) {\n    state.ended = true;\n    process.nextTick(endReadableNT, state, stream);\n  }\n}\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length);\n\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n    if (state.autoDestroy) {\n      // In case of duplex streams we need a way to detect\n      // if the writable side is ready for autoDestroy as well\n      var wState = stream._writableState;\n      if (!wState || wState.autoDestroy && wState.finished) {\n        stream.destroy();\n      }\n    }\n  }\n}\nif (typeof Symbol === 'function') {\n  Readable.from = function (iterable, opts) {\n    if (from === undefined) {\n      from = require('./internal/streams/from');\n    }\n    return from(Readable, iterable, opts);\n  };\n}\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","module.exports = require('events').EventEmitter;\n","'use strict';\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err) {\n      if (!this._writableState) {\n        process.nextTick(emitErrorNT, this, err);\n      } else if (!this._writableState.errorEmitted) {\n        this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorNT, this, err);\n      }\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      if (!_this._writableState) {\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else if (!_this._writableState.errorEmitted) {\n        _this._writableState.errorEmitted = true;\n        process.nextTick(emitErrorAndCloseNT, _this, err);\n      } else {\n        process.nextTick(emitCloseNT, _this);\n      }\n    } else if (cb) {\n      process.nextTick(emitCloseNT, _this);\n      cb(err);\n    } else {\n      process.nextTick(emitCloseNT, _this);\n    }\n  });\n  return this;\n}\nfunction emitErrorAndCloseNT(self, err) {\n  emitErrorNT(self, err);\n  emitCloseNT(self);\n}\nfunction emitCloseNT(self) {\n  if (self._writableState && !self._writableState.emitClose) return;\n  if (self._readableState && !self._readableState.emitClose) return;\n  self.emit('close');\n}\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finalCalled = false;\n    this._writableState.prefinished = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\nfunction errorOrDestroy(stream, err) {\n  // We have tests that rely on errors being emitted\n  // in the same tick, so changing this is semver major.\n  // For now when you opt-in to autoDestroy we allow\n  // the error to be emitted nextTick. In a future\n  // semver major update we should change the default to this.\n\n  var rState = stream._readableState;\n  var wState = stream._writableState;\n  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);\n}\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy,\n  errorOrDestroy: errorOrDestroy\n};","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n  if (hwm != null) {\n    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n      var name = isDuplex ? duplexKey : 'highWaterMark';\n      throw new ERR_INVALID_OPT_VALUE(name, hwm);\n    }\n    return Math.floor(hwm);\n  }\n\n  // Default value\n  return state.objectMode ? 16 : 16 * 1024;\n}\nmodule.exports = {\n  getHighWaterMark: getHighWaterMark\n};","// 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\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  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\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\nvar Buffer = require('buffer').Buffer;\nvar OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\nvar destroyImpl = require('./internal/streams/destroy');\nvar _require = require('./internal/streams/state'),\n  getHighWaterMark = _require.getHighWaterMark;\nvar _require$codes = require('../errors').codes,\n  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n  ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n  ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n  ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n  ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nrequire('inherits')(Writable, Stream);\nfunction nop() {}\nfunction WritableState(options, stream, isDuplex) {\n  Duplex = Duplex || require('./_stream_duplex');\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream,\n  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n  if (typeof isDuplex !== 'boolean') 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  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  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex);\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  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  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = options.emitClose !== false;\n\n  // Should .destroy() be called after 'finish' (and potentially 'end')\n  this.autoDestroy = !!options.autoDestroy;\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}\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(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function writableStateBufferGetter() {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\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 value(object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function realHasInstance(object) {\n    return object instanceof this;\n  };\n}\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\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5\n  var isDuplex = this instanceof Duplex;\n  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n  this._writableState = new WritableState(options, this, isDuplex);\n\n  // legacy.\n  this.writable = true;\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n    if (typeof options.writev === 'function') this._writev = options.writev;\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\nfunction writeAfterEnd(stream, cb) {\n  var er = new ERR_STREAM_WRITE_AFTER_END();\n  // TODO: defer error events consistently everywhere, not just the cb\n  errorOrDestroy(stream, er);\n  process.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 er;\n  if (chunk === null) {\n    er = new ERR_STREAM_NULL_VALUES();\n  } else if (typeof chunk !== 'string' && !state.objectMode) {\n    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n  }\n  if (er) {\n    errorOrDestroy(stream, er);\n    process.nextTick(cb, er);\n    return false;\n  }\n  return true;\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  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n  if (typeof cb !== 'function') cb = nop;\n  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n  return ret;\n};\nWritable.prototype.cork = function () {\n  this._writableState.corked++;\n};\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n  if (state.corked) {\n    state.corked--;\n    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\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}\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n});\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  state.length += len;\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  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  return ret;\n}\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    process.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    process.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    errorOrDestroy(stream, er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n  onwriteStateUpdate(state);\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state) || stream.destroyed;\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n    if (sync) {\n      process.nextTick(afterWrite, stream, state, finished, cb);\n    } else {\n      afterWrite(stream, state, finished, cb);\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  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n    var count = 0;\n    var allBuffers = true;\n    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    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      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    if (entry === null) state.lastBufferedRequest = null;\n  }\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\nWritable.prototype._writev = null;\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\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  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) endWritable(this, state, cb);\n  return this;\n};\nObject.defineProperty(Writable.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\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      errorOrDestroy(stream, 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' && !state.destroyed) {\n      state.pendingcb++;\n      state.finalCalled = true;\n      process.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\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      if (state.autoDestroy) {\n        // In case of duplex streams we need a way to detect\n        // if the readable side is ready for autoDestroy as well\n        var rState = stream._readableState;\n        if (!rState || rState.autoDestroy && rState.endEmitted) {\n          stream.destroy();\n        }\n      }\n    }\n  }\n  return need;\n}\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\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\n  // reuse the free corkReq.\n  state.corkedRequestsFree.next = corkReq;\n}\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  cb(err);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\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;\nvar _require$codes = require('../errors').codes,\n  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n  ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n  ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\nvar Duplex = require('./_stream_duplex');\nrequire('inherits')(Transform, Duplex);\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n  var cb = ts.writecb;\n  if (cb === null) {\n    return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n  }\n  ts.writechunk = null;\n  ts.writecb = null;\n  if (data != null)\n    // single equals check for both `null` and `undefined`\n    this.push(data);\n  cb(er);\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n  Duplex.call(this, options);\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\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  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\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}\nfunction prefinish() {\n  var _this = this;\n  if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\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  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\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  if (ts.writechunk !== null && !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};\nTransform.prototype._destroy = function (err, cb) {\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n  });\n};\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n  if (data != null)\n    // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // TODO(BridgeAR): Write a test for these two error cases\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n  return stream.push(null);\n}","module.exports = require('./browser/algorithms.json')\n","var DES = require('browserify-des')\nvar aes = require('browserify-aes/browser')\nvar aesModes = require('browserify-aes/modes')\nvar desModes = require('browserify-des/modes')\nvar ebtk = require('evp_bytestokey')\n\nfunction createCipher (suite, password) {\n  suite = suite.toLowerCase()\n\n  var keyLen, ivLen\n  if (aesModes[suite]) {\n    keyLen = aesModes[suite].key\n    ivLen = aesModes[suite].iv\n  } else if (desModes[suite]) {\n    keyLen = desModes[suite].key * 8\n    ivLen = desModes[suite].iv\n  } else {\n    throw new TypeError('invalid suite type')\n  }\n\n  var keys = ebtk(password, false, keyLen, ivLen)\n  return createCipheriv(suite, keys.key, keys.iv)\n}\n\nfunction createDecipher (suite, password) {\n  suite = suite.toLowerCase()\n\n  var keyLen, ivLen\n  if (aesModes[suite]) {\n    keyLen = aesModes[suite].key\n    ivLen = aesModes[suite].iv\n  } else if (desModes[suite]) {\n    keyLen = desModes[suite].key * 8\n    ivLen = desModes[suite].iv\n  } else {\n    throw new TypeError('invalid suite type')\n  }\n\n  var keys = ebtk(password, false, keyLen, ivLen)\n  return createDecipheriv(suite, keys.key, keys.iv)\n}\n\nfunction createCipheriv (suite, key, iv) {\n  suite = suite.toLowerCase()\n  if (aesModes[suite]) return aes.createCipheriv(suite, key, iv)\n  if (desModes[suite]) return new DES({ key: key, iv: iv, mode: suite })\n\n  throw new TypeError('invalid suite type')\n}\n\nfunction createDecipheriv (suite, key, iv) {\n  suite = suite.toLowerCase()\n  if (aesModes[suite]) return aes.createDecipheriv(suite, key, iv)\n  if (desModes[suite]) return new DES({ key: key, iv: iv, mode: suite, decrypt: true })\n\n  throw new TypeError('invalid suite type')\n}\n\nfunction getCiphers () {\n  return Object.keys(desModes).concat(aes.getCiphers())\n}\n\nexports.createCipher = exports.Cipher = createCipher\nexports.createCipheriv = exports.Cipheriv = createCipheriv\nexports.createDecipher = exports.Decipher = createDecipher\nexports.createDecipheriv = exports.Decipheriv = createDecipheriv\nexports.listCiphers = exports.getCiphers = getCiphers\n","var CipherBase = require('cipher-base')\nvar des = require('des.js')\nvar inherits = require('inherits')\nvar Buffer = require('safe-buffer').Buffer\n\nvar modes = {\n  'des-ede3-cbc': des.CBC.instantiate(des.EDE),\n  'des-ede3': des.EDE,\n  'des-ede-cbc': des.CBC.instantiate(des.EDE),\n  'des-ede': des.EDE,\n  'des-cbc': des.CBC.instantiate(des.DES),\n  'des-ecb': des.DES\n}\nmodes.des = modes['des-cbc']\nmodes.des3 = modes['des-ede3-cbc']\nmodule.exports = DES\ninherits(DES, CipherBase)\nfunction DES (opts) {\n  CipherBase.call(this)\n  var modeName = opts.mode.toLowerCase()\n  var mode = modes[modeName]\n  var type\n  if (opts.decrypt) {\n    type = 'decrypt'\n  } else {\n    type = 'encrypt'\n  }\n  var key = opts.key\n  if (!Buffer.isBuffer(key)) {\n    key = Buffer.from(key)\n  }\n  if (modeName === 'des-ede' || modeName === 'des-ede-cbc') {\n    key = Buffer.concat([key, key.slice(0, 8)])\n  }\n  var iv = opts.iv\n  if (!Buffer.isBuffer(iv)) {\n    iv = Buffer.from(iv)\n  }\n  this._des = mode.create({\n    key: key,\n    iv: iv,\n    type: type\n  })\n}\nDES.prototype._update = function (data) {\n  return Buffer.from(this._des.update(data))\n}\nDES.prototype._final = function () {\n  return Buffer.from(this._des.final())\n}\n","var MODES = require('./modes')\nvar AuthCipher = require('./authCipher')\nvar Buffer = require('safe-buffer').Buffer\nvar StreamCipher = require('./streamCipher')\nvar Transform = require('cipher-base')\nvar aes = require('./aes')\nvar ebtk = require('evp_bytestokey')\nvar inherits = require('inherits')\n\nfunction Cipher (mode, key, iv) {\n  Transform.call(this)\n\n  this._cache = new Splitter()\n  this._cipher = new aes.AES(key)\n  this._prev = Buffer.from(iv)\n  this._mode = mode\n  this._autopadding = true\n}\n\ninherits(Cipher, Transform)\n\nCipher.prototype._update = function (data) {\n  this._cache.add(data)\n  var chunk\n  var thing\n  var out = []\n\n  while ((chunk = this._cache.get())) {\n    thing = this._mode.encrypt(this, chunk)\n    out.push(thing)\n  }\n\n  return Buffer.concat(out)\n}\n\nvar PADDING = Buffer.alloc(16, 0x10)\n\nCipher.prototype._final = function () {\n  var chunk = this._cache.flush()\n  if (this._autopadding) {\n    chunk = this._mode.encrypt(this, chunk)\n    this._cipher.scrub()\n    return chunk\n  }\n\n  if (!chunk.equals(PADDING)) {\n    this._cipher.scrub()\n    throw new Error('data not multiple of block length')\n  }\n}\n\nCipher.prototype.setAutoPadding = function (setTo) {\n  this._autopadding = !!setTo\n  return this\n}\n\nfunction Splitter () {\n  this.cache = Buffer.allocUnsafe(0)\n}\n\nSplitter.prototype.add = function (data) {\n  this.cache = Buffer.concat([this.cache, data])\n}\n\nSplitter.prototype.get = function () {\n  if (this.cache.length > 15) {\n    var out = this.cache.slice(0, 16)\n    this.cache = this.cache.slice(16)\n    return out\n  }\n  return null\n}\n\nSplitter.prototype.flush = function () {\n  var len = 16 - this.cache.length\n  var padBuff = Buffer.allocUnsafe(len)\n\n  var i = -1\n  while (++i < len) {\n    padBuff.writeUInt8(len, i)\n  }\n\n  return Buffer.concat([this.cache, padBuff])\n}\n\nfunction createCipheriv (suite, password, iv) {\n  var config = MODES[suite.toLowerCase()]\n  if (!config) throw new TypeError('invalid suite type')\n\n  if (typeof password === 'string') password = Buffer.from(password)\n  if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length)\n\n  if (typeof iv === 'string') iv = Buffer.from(iv)\n  if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length)\n\n  if (config.type === 'stream') {\n    return new StreamCipher(config.module, password, iv)\n  } else if (config.type === 'auth') {\n    return new AuthCipher(config.module, password, iv)\n  }\n\n  return new Cipher(config.module, password, iv)\n}\n\nfunction createCipher (suite, password) {\n  var config = MODES[suite.toLowerCase()]\n  if (!config) throw new TypeError('invalid suite type')\n\n  var keys = ebtk(password, false, config.key, config.iv)\n  return createCipheriv(suite, keys.key, keys.iv)\n}\n\nexports.createCipheriv = createCipheriv\nexports.createCipher = createCipher\n","exports.encrypt = function (self, block) {\n  return self._cipher.encryptBlock(block)\n}\n\nexports.decrypt = function (self, block) {\n  return self._cipher.decryptBlock(block)\n}\n","var xor = require('buffer-xor')\n\nexports.encrypt = function (self, block) {\n  var data = xor(block, self._prev)\n\n  self._prev = self._cipher.encryptBlock(data)\n  return self._prev\n}\n\nexports.decrypt = function (self, block) {\n  var pad = self._prev\n\n  self._prev = block\n  var out = self._cipher.decryptBlock(block)\n\n  return xor(out, pad)\n}\n","var Buffer = require('safe-buffer').Buffer\nvar xor = require('buffer-xor')\n\nfunction encryptStart (self, data, decrypt) {\n  var len = data.length\n  var out = xor(data, self._cache)\n  self._cache = self._cache.slice(len)\n  self._prev = Buffer.concat([self._prev, decrypt ? data : out])\n  return out\n}\n\nexports.encrypt = function (self, data, decrypt) {\n  var out = Buffer.allocUnsafe(0)\n  var len\n\n  while (data.length) {\n    if (self._cache.length === 0) {\n      self._cache = self._cipher.encryptBlock(self._prev)\n      self._prev = Buffer.allocUnsafe(0)\n    }\n\n    if (self._cache.length <= data.length) {\n      len = self._cache.length\n      out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)])\n      data = data.slice(len)\n    } else {\n      out = Buffer.concat([out, encryptStart(self, data, decrypt)])\n      break\n    }\n  }\n\n  return out\n}\n","var Buffer = require('safe-buffer').Buffer\n\nfunction encryptByte (self, byteParam, decrypt) {\n  var pad = self._cipher.encryptBlock(self._prev)\n  var out = pad[0] ^ byteParam\n\n  self._prev = Buffer.concat([\n    self._prev.slice(1),\n    Buffer.from([decrypt ? byteParam : out])\n  ])\n\n  return out\n}\n\nexports.encrypt = function (self, chunk, decrypt) {\n  var len = chunk.length\n  var out = Buffer.allocUnsafe(len)\n  var i = -1\n\n  while (++i < len) {\n    out[i] = encryptByte(self, chunk[i], decrypt)\n  }\n\n  return out\n}\n","var Buffer = require('safe-buffer').Buffer\n\nfunction encryptByte (self, byteParam, decrypt) {\n  var pad\n  var i = -1\n  var len = 8\n  var out = 0\n  var bit, value\n  while (++i < len) {\n    pad = self._cipher.encryptBlock(self._prev)\n    bit = (byteParam & (1 << (7 - i))) ? 0x80 : 0\n    value = pad[0] ^ bit\n    out += ((value & 0x80) >> (i % 8))\n    self._prev = shiftIn(self._prev, decrypt ? bit : value)\n  }\n  return out\n}\n\nfunction shiftIn (buffer, value) {\n  var len = buffer.length\n  var i = -1\n  var out = Buffer.allocUnsafe(buffer.length)\n  buffer = Buffer.concat([buffer, Buffer.from([value])])\n\n  while (++i < len) {\n    out[i] = buffer[i] << 1 | buffer[i + 1] >> (7)\n  }\n\n  return out\n}\n\nexports.encrypt = function (self, chunk, decrypt) {\n  var len = chunk.length\n  var out = Buffer.allocUnsafe(len)\n  var i = -1\n\n  while (++i < len) {\n    out[i] = encryptByte(self, chunk[i], decrypt)\n  }\n\n  return out\n}\n","var xor = require('buffer-xor')\n\nfunction getBlock (self) {\n  self._prev = self._cipher.encryptBlock(self._prev)\n  return self._prev\n}\n\nexports.encrypt = function (self, chunk) {\n  while (self._cache.length < chunk.length) {\n    self._cache = Buffer.concat([self._cache, getBlock(self)])\n  }\n\n  var pad = self._cache.slice(0, chunk.length)\n  self._cache = self._cache.slice(chunk.length)\n  return xor(chunk, pad)\n}\n","var Buffer = require('safe-buffer').Buffer\nvar ZEROES = Buffer.alloc(16, 0)\n\nfunction toArray (buf) {\n  return [\n    buf.readUInt32BE(0),\n    buf.readUInt32BE(4),\n    buf.readUInt32BE(8),\n    buf.readUInt32BE(12)\n  ]\n}\n\nfunction fromArray (out) {\n  var buf = Buffer.allocUnsafe(16)\n  buf.writeUInt32BE(out[0] >>> 0, 0)\n  buf.writeUInt32BE(out[1] >>> 0, 4)\n  buf.writeUInt32BE(out[2] >>> 0, 8)\n  buf.writeUInt32BE(out[3] >>> 0, 12)\n  return buf\n}\n\nfunction GHASH (key) {\n  this.h = key\n  this.state = Buffer.alloc(16, 0)\n  this.cache = Buffer.allocUnsafe(0)\n}\n\n// from http://bitwiseshiftleft.github.io/sjcl/doc/symbols/src/core_gcm.js.html\n// by Juho Vähä-Herttua\nGHASH.prototype.ghash = function (block) {\n  var i = -1\n  while (++i < block.length) {\n    this.state[i] ^= block[i]\n  }\n  this._multiply()\n}\n\nGHASH.prototype._multiply = function () {\n  var Vi = toArray(this.h)\n  var Zi = [0, 0, 0, 0]\n  var j, xi, lsbVi\n  var i = -1\n  while (++i < 128) {\n    xi = (this.state[~~(i / 8)] & (1 << (7 - (i % 8)))) !== 0\n    if (xi) {\n      // Z_i+1 = Z_i ^ V_i\n      Zi[0] ^= Vi[0]\n      Zi[1] ^= Vi[1]\n      Zi[2] ^= Vi[2]\n      Zi[3] ^= Vi[3]\n    }\n\n    // Store the value of LSB(V_i)\n    lsbVi = (Vi[3] & 1) !== 0\n\n    // V_i+1 = V_i >> 1\n    for (j = 3; j > 0; j--) {\n      Vi[j] = (Vi[j] >>> 1) | ((Vi[j - 1] & 1) << 31)\n    }\n    Vi[0] = Vi[0] >>> 1\n\n    // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R\n    if (lsbVi) {\n      Vi[0] = Vi[0] ^ (0xe1 << 24)\n    }\n  }\n  this.state = fromArray(Zi)\n}\n\nGHASH.prototype.update = function (buf) {\n  this.cache = Buffer.concat([this.cache, buf])\n  var chunk\n  while (this.cache.length >= 16) {\n    chunk = this.cache.slice(0, 16)\n    this.cache = this.cache.slice(16)\n    this.ghash(chunk)\n  }\n}\n\nGHASH.prototype.final = function (abl, bl) {\n  if (this.cache.length) {\n    this.ghash(Buffer.concat([this.cache, ZEROES], 16))\n  }\n\n  this.ghash(fromArray([0, abl, 0, bl]))\n  return this.state\n}\n\nmodule.exports = GHASH\n","var AuthCipher = require('./authCipher')\nvar Buffer = require('safe-buffer').Buffer\nvar MODES = require('./modes')\nvar StreamCipher = require('./streamCipher')\nvar Transform = require('cipher-base')\nvar aes = require('./aes')\nvar ebtk = require('evp_bytestokey')\nvar inherits = require('inherits')\n\nfunction Decipher (mode, key, iv) {\n  Transform.call(this)\n\n  this._cache = new Splitter()\n  this._last = void 0\n  this._cipher = new aes.AES(key)\n  this._prev = Buffer.from(iv)\n  this._mode = mode\n  this._autopadding = true\n}\n\ninherits(Decipher, Transform)\n\nDecipher.prototype._update = function (data) {\n  this._cache.add(data)\n  var chunk\n  var thing\n  var out = []\n  while ((chunk = this._cache.get(this._autopadding))) {\n    thing = this._mode.decrypt(this, chunk)\n    out.push(thing)\n  }\n  return Buffer.concat(out)\n}\n\nDecipher.prototype._final = function () {\n  var chunk = this._cache.flush()\n  if (this._autopadding) {\n    return unpad(this._mode.decrypt(this, chunk))\n  } else if (chunk) {\n    throw new Error('data not multiple of block length')\n  }\n}\n\nDecipher.prototype.setAutoPadding = function (setTo) {\n  this._autopadding = !!setTo\n  return this\n}\n\nfunction Splitter () {\n  this.cache = Buffer.allocUnsafe(0)\n}\n\nSplitter.prototype.add = function (data) {\n  this.cache = Buffer.concat([this.cache, data])\n}\n\nSplitter.prototype.get = function (autoPadding) {\n  var out\n  if (autoPadding) {\n    if (this.cache.length > 16) {\n      out = this.cache.slice(0, 16)\n      this.cache = this.cache.slice(16)\n      return out\n    }\n  } else {\n    if (this.cache.length >= 16) {\n      out = this.cache.slice(0, 16)\n      this.cache = this.cache.slice(16)\n      return out\n    }\n  }\n\n  return null\n}\n\nSplitter.prototype.flush = function () {\n  if (this.cache.length) return this.cache\n}\n\nfunction unpad (last) {\n  var padded = last[15]\n  if (padded < 1 || padded > 16) {\n    throw new Error('unable to decrypt data')\n  }\n  var i = -1\n  while (++i < padded) {\n    if (last[(i + (16 - padded))] !== padded) {\n      throw new Error('unable to decrypt data')\n    }\n  }\n  if (padded === 16) return\n\n  return last.slice(0, 16 - padded)\n}\n\nfunction createDecipheriv (suite, password, iv) {\n  var config = MODES[suite.toLowerCase()]\n  if (!config) throw new TypeError('invalid suite type')\n\n  if (typeof iv === 'string') iv = Buffer.from(iv)\n  if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length)\n\n  if (typeof password === 'string') password = Buffer.from(password)\n  if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length)\n\n  if (config.type === 'stream') {\n    return new StreamCipher(config.module, password, iv, true)\n  } else if (config.type === 'auth') {\n    return new AuthCipher(config.module, password, iv, true)\n  }\n\n  return new Decipher(config.module, password, iv)\n}\n\nfunction createDecipher (suite, password) {\n  var config = MODES[suite.toLowerCase()]\n  if (!config) throw new TypeError('invalid suite type')\n\n  var keys = ebtk(password, false, config.key, config.iv)\n  return createDecipheriv(suite, keys.key, keys.iv)\n}\n\nexports.createDecipher = createDecipher\nexports.createDecipheriv = createDecipheriv\n","exports['des-ecb'] = {\n  key: 8,\n  iv: 0\n}\nexports['des-cbc'] = exports.des = {\n  key: 8,\n  iv: 8\n}\nexports['des-ede3-cbc'] = exports.des3 = {\n  key: 24,\n  iv: 8\n}\nexports['des-ede3'] = {\n  key: 24,\n  iv: 0\n}\nexports['des-ede-cbc'] = {\n  key: 16,\n  iv: 8\n}\nexports['des-ede'] = {\n  key: 16,\n  iv: 0\n}\n","var Buffer = require('safe-buffer').Buffer\nvar createHash = require('create-hash')\nvar stream = require('readable-stream')\nvar inherits = require('inherits')\nvar sign = require('./sign')\nvar verify = require('./verify')\n\nvar algorithms = require('./algorithms.json')\nObject.keys(algorithms).forEach(function (key) {\n  algorithms[key].id = Buffer.from(algorithms[key].id, 'hex')\n  algorithms[key.toLowerCase()] = algorithms[key]\n})\n\nfunction Sign (algorithm) {\n  stream.Writable.call(this)\n\n  var data = algorithms[algorithm]\n  if (!data) throw new Error('Unknown message digest')\n\n  this._hashType = data.hash\n  this._hash = createHash(data.hash)\n  this._tag = data.id\n  this._signType = data.sign\n}\ninherits(Sign, stream.Writable)\n\nSign.prototype._write = function _write (data, _, done) {\n  this._hash.update(data)\n  done()\n}\n\nSign.prototype.update = function update (data, enc) {\n  if (typeof data === 'string') data = Buffer.from(data, enc)\n\n  this._hash.update(data)\n  return this\n}\n\nSign.prototype.sign = function signMethod (key, enc) {\n  this.end()\n  var hash = this._hash.digest()\n  var sig = sign(hash, key, this._hashType, this._signType, this._tag)\n\n  return enc ? sig.toString(enc) : sig\n}\n\nfunction Verify (algorithm) {\n  stream.Writable.call(this)\n\n  var data = algorithms[algorithm]\n  if (!data) throw new Error('Unknown message digest')\n\n  this._hash = createHash(data.hash)\n  this._tag = data.id\n  this._signType = data.sign\n}\ninherits(Verify, stream.Writable)\n\nVerify.prototype._write = function _write (data, _, done) {\n  this._hash.update(data)\n  done()\n}\n\nVerify.prototype.update = function update (data, enc) {\n  if (typeof data === 'string') data = Buffer.from(data, enc)\n\n  this._hash.update(data)\n  return this\n}\n\nVerify.prototype.verify = function verifyMethod (key, sig, enc) {\n  if (typeof sig === 'string') sig = Buffer.from(sig, enc)\n\n  this.end()\n  var hash = this._hash.digest()\n  return verify(sig, hash, key, this._signType, this._tag)\n}\n\nfunction createSign (algorithm) {\n  return new Sign(algorithm)\n}\n\nfunction createVerify (algorithm) {\n  return new Verify(algorithm)\n}\n\nmodule.exports = {\n  Sign: createSign,\n  Verify: createVerify,\n  createSign: createSign,\n  createVerify: createVerify\n}\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');\n","'use strict';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nvar _require = require('buffer'),\n  Buffer = _require.Buffer;\nvar _require2 = require('util'),\n  inspect = _require2.inspect;\nvar custom = inspect && inspect.custom || 'inspect';\nfunction copyBuffer(src, target, offset) {\n  Buffer.prototype.copy.call(src, target, offset);\n}\nmodule.exports = /*#__PURE__*/function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n  _createClass(BufferList, [{\n    key: \"push\",\n    value: function push(v) {\n      var entry = {\n        data: v,\n        next: null\n      };\n      if (this.length > 0) this.tail.next = entry;else this.head = entry;\n      this.tail = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"unshift\",\n    value: function unshift(v) {\n      var entry = {\n        data: v,\n        next: this.head\n      };\n      if (this.length === 0) this.tail = entry;\n      this.head = entry;\n      ++this.length;\n    }\n  }, {\n    key: \"shift\",\n    value: function shift() {\n      if (this.length === 0) return;\n      var ret = this.head.data;\n      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n      --this.length;\n      return ret;\n    }\n  }, {\n    key: \"clear\",\n    value: function clear() {\n      this.head = this.tail = null;\n      this.length = 0;\n    }\n  }, {\n    key: \"join\",\n    value: function join(s) {\n      if (this.length === 0) return '';\n      var p = this.head;\n      var ret = '' + p.data;\n      while (p = p.next) ret += s + p.data;\n      return ret;\n    }\n  }, {\n    key: \"concat\",\n    value: function concat(n) {\n      if (this.length === 0) return Buffer.alloc(0);\n      var ret = Buffer.allocUnsafe(n >>> 0);\n      var p = this.head;\n      var i = 0;\n      while (p) {\n        copyBuffer(p.data, ret, i);\n        i += p.data.length;\n        p = p.next;\n      }\n      return ret;\n    }\n\n    // Consumes a specified amount of bytes or characters from the buffered data.\n  }, {\n    key: \"consume\",\n    value: function consume(n, hasStrings) {\n      var ret;\n      if (n < this.head.data.length) {\n        // `slice` is the same for buffers and strings.\n        ret = this.head.data.slice(0, n);\n        this.head.data = this.head.data.slice(n);\n      } else if (n === this.head.data.length) {\n        // First chunk is a perfect match.\n        ret = this.shift();\n      } else {\n        // Result spans more than one buffer.\n        ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n      }\n      return ret;\n    }\n  }, {\n    key: \"first\",\n    value: function first() {\n      return this.head.data;\n    }\n\n    // Consumes a specified amount of characters from the buffered data.\n  }, {\n    key: \"_getString\",\n    value: function _getString(n) {\n      var p = this.head;\n      var c = 1;\n      var ret = p.data;\n      n -= ret.length;\n      while (p = p.next) {\n        var str = p.data;\n        var nb = n > str.length ? str.length : n;\n        if (nb === str.length) ret += str;else ret += str.slice(0, n);\n        n -= nb;\n        if (n === 0) {\n          if (nb === str.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = str.slice(nb);\n          }\n          break;\n        }\n        ++c;\n      }\n      this.length -= c;\n      return ret;\n    }\n\n    // Consumes a specified amount of bytes from the buffered data.\n  }, {\n    key: \"_getBuffer\",\n    value: function _getBuffer(n) {\n      var ret = Buffer.allocUnsafe(n);\n      var p = this.head;\n      var c = 1;\n      p.data.copy(ret);\n      n -= p.data.length;\n      while (p = p.next) {\n        var buf = p.data;\n        var nb = n > buf.length ? buf.length : n;\n        buf.copy(ret, ret.length - n, 0, nb);\n        n -= nb;\n        if (n === 0) {\n          if (nb === buf.length) {\n            ++c;\n            if (p.next) this.head = p.next;else this.head = this.tail = null;\n          } else {\n            this.head = p;\n            p.data = buf.slice(nb);\n          }\n          break;\n        }\n        ++c;\n      }\n      this.length -= c;\n      return ret;\n    }\n\n    // Make sure the linked list only shows the minimal necessary information.\n  }, {\n    key: custom,\n    value: function value(_, options) {\n      return inspect(this, _objectSpread(_objectSpread({}, options), {}, {\n        // Only inspect one level.\n        depth: 0,\n        // It should not recurse.\n        customInspect: false\n      }));\n    }\n  }]);\n  return BufferList;\n}();","'use strict';\n\nvar _Object$setPrototypeO;\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return typeof key === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (typeof input !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (typeof res !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nvar finished = require('./end-of-stream');\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\nfunction createIterResult(value, done) {\n  return {\n    value: value,\n    done: done\n  };\n}\nfunction readAndResolve(iter) {\n  var resolve = iter[kLastResolve];\n  if (resolve !== null) {\n    var data = iter[kStream].read();\n    // we defer if data is null\n    // we can be expecting either 'end' or\n    // 'error'\n    if (data !== null) {\n      iter[kLastPromise] = null;\n      iter[kLastResolve] = null;\n      iter[kLastReject] = null;\n      resolve(createIterResult(data, false));\n    }\n  }\n}\nfunction onReadable(iter) {\n  // we wait for the next tick, because it might\n  // emit an error with process.nextTick\n  process.nextTick(readAndResolve, iter);\n}\nfunction wrapForNext(lastPromise, iter) {\n  return function (resolve, reject) {\n    lastPromise.then(function () {\n      if (iter[kEnded]) {\n        resolve(createIterResult(undefined, true));\n        return;\n      }\n      iter[kHandlePromise](resolve, reject);\n    }, reject);\n  };\n}\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n  get stream() {\n    return this[kStream];\n  },\n  next: function next() {\n    var _this = this;\n    // if we have detected an error in the meanwhile\n    // reject straight away\n    var error = this[kError];\n    if (error !== null) {\n      return Promise.reject(error);\n    }\n    if (this[kEnded]) {\n      return Promise.resolve(createIterResult(undefined, true));\n    }\n    if (this[kStream].destroyed) {\n      // We need to defer via nextTick because if .destroy(err) is\n      // called, the error will be emitted via nextTick, and\n      // we cannot guarantee that there is no error lingering around\n      // waiting to be emitted.\n      return new Promise(function (resolve, reject) {\n        process.nextTick(function () {\n          if (_this[kError]) {\n            reject(_this[kError]);\n          } else {\n            resolve(createIterResult(undefined, true));\n          }\n        });\n      });\n    }\n\n    // if we have multiple next() calls\n    // we will wait for the previous Promise to finish\n    // this logic is optimized to support for await loops,\n    // where next() is only called once at a time\n    var lastPromise = this[kLastPromise];\n    var promise;\n    if (lastPromise) {\n      promise = new Promise(wrapForNext(lastPromise, this));\n    } else {\n      // fast path needed to support multiple this.push()\n      // without triggering the next() queue\n      var data = this[kStream].read();\n      if (data !== null) {\n        return Promise.resolve(createIterResult(data, false));\n      }\n      promise = new Promise(this[kHandlePromise]);\n    }\n    this[kLastPromise] = promise;\n    return promise;\n  }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n  return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n  var _this2 = this;\n  // destroy(err, cb) is a private API\n  // we can guarantee we have that here, because we control the\n  // Readable class this is attached to\n  return new Promise(function (resolve, reject) {\n    _this2[kStream].destroy(null, function (err) {\n      if (err) {\n        reject(err);\n        return;\n      }\n      resolve(createIterResult(undefined, true));\n    });\n  });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n  var _Object$create;\n  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n    value: stream,\n    writable: true\n  }), _defineProperty(_Object$create, kLastResolve, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kLastReject, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kError, {\n    value: null,\n    writable: true\n  }), _defineProperty(_Object$create, kEnded, {\n    value: stream._readableState.endEmitted,\n    writable: true\n  }), _defineProperty(_Object$create, kHandlePromise, {\n    value: function value(resolve, reject) {\n      var data = iterator[kStream].read();\n      if (data) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        resolve(createIterResult(data, false));\n      } else {\n        iterator[kLastResolve] = resolve;\n        iterator[kLastReject] = reject;\n      }\n    },\n    writable: true\n  }), _Object$create));\n  iterator[kLastPromise] = null;\n  finished(stream, function (err) {\n    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n      var reject = iterator[kLastReject];\n      // reject if we are waiting for data in the Promise\n      // returned by next() and store the error\n      if (reject !== null) {\n        iterator[kLastPromise] = null;\n        iterator[kLastResolve] = null;\n        iterator[kLastReject] = null;\n        reject(err);\n      }\n      iterator[kError] = err;\n      return;\n    }\n    var resolve = iterator[kLastResolve];\n    if (resolve !== null) {\n      iterator[kLastPromise] = null;\n      iterator[kLastResolve] = null;\n      iterator[kLastReject] = null;\n      resolve(createIterResult(undefined, true));\n    }\n    iterator[kEnded] = true;\n  });\n  stream.on('readable', onReadable.bind(null, iterator));\n  return iterator;\n};\nmodule.exports = createReadableStreamAsyncIterator;","module.exports = function () {\n  throw new Error('Readable.from is not available in the browser')\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\nvar Transform = require('./_stream_transform');\nrequire('inherits')(PassThrough, Transform);\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n  Transform.call(this, options);\n}\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n\n'use strict';\n\nvar eos;\nfunction once(callback) {\n  var called = false;\n  return function () {\n    if (called) return;\n    called = true;\n    callback.apply(void 0, arguments);\n  };\n}\nvar _require$codes = require('../../../errors').codes,\n  ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\nfunction noop(err) {\n  // Rethrow the error if it exists to avoid swallowing it\n  if (err) throw err;\n}\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function';\n}\nfunction destroyer(stream, reading, writing, callback) {\n  callback = once(callback);\n  var closed = false;\n  stream.on('close', function () {\n    closed = true;\n  });\n  if (eos === undefined) eos = require('./end-of-stream');\n  eos(stream, {\n    readable: reading,\n    writable: writing\n  }, function (err) {\n    if (err) return callback(err);\n    closed = true;\n    callback();\n  });\n  var destroyed = false;\n  return function (err) {\n    if (closed) return;\n    if (destroyed) return;\n    destroyed = true;\n\n    // request.destroy just do .end - .abort is what we want\n    if (isRequest(stream)) return stream.abort();\n    if (typeof stream.destroy === 'function') return stream.destroy();\n    callback(err || new ERR_STREAM_DESTROYED('pipe'));\n  };\n}\nfunction call(fn) {\n  fn();\n}\nfunction pipe(from, to) {\n  return from.pipe(to);\n}\nfunction popCallback(streams) {\n  if (!streams.length) return noop;\n  if (typeof streams[streams.length - 1] !== 'function') return noop;\n  return streams.pop();\n}\nfunction pipeline() {\n  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n    streams[_key] = arguments[_key];\n  }\n  var callback = popCallback(streams);\n  if (Array.isArray(streams[0])) streams = streams[0];\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams');\n  }\n  var error;\n  var destroys = streams.map(function (stream, i) {\n    var reading = i < streams.length - 1;\n    var writing = i > 0;\n    return destroyer(stream, reading, writing, function (err) {\n      if (!error) error = err;\n      if (err) destroys.forEach(call);\n      if (reading) return;\n      destroys.forEach(call);\n      callback(error);\n    });\n  });\n  return streams.reduce(pipe);\n}\nmodule.exports = pipeline;","// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js\nvar Buffer = require('safe-buffer').Buffer\nvar createHmac = require('create-hmac')\nvar crt = require('browserify-rsa')\nvar EC = require('elliptic').ec\nvar BN = require('bn.js')\nvar parseKeys = require('parse-asn1')\nvar curves = require('./curves.json')\n\nfunction sign (hash, key, hashType, signType, tag) {\n  var priv = parseKeys(key)\n  if (priv.curve) {\n    // rsa keys can be interpreted as ecdsa ones in openssl\n    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type')\n    return ecSign(hash, priv)\n  } else if (priv.type === 'dsa') {\n    if (signType !== 'dsa') throw new Error('wrong private key type')\n    return dsaSign(hash, priv, hashType)\n  } else {\n    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type')\n  }\n  hash = Buffer.concat([tag, hash])\n  var len = priv.modulus.byteLength()\n  var pad = [0, 1]\n  while (hash.length + pad.length + 1 < len) pad.push(0xff)\n  pad.push(0x00)\n  var i = -1\n  while (++i < hash.length) pad.push(hash[i])\n\n  var out = crt(pad, priv)\n  return out\n}\n\nfunction ecSign (hash, priv) {\n  var curveId = curves[priv.curve.join('.')]\n  if (!curveId) throw new Error('unknown curve ' + priv.curve.join('.'))\n\n  var curve = new EC(curveId)\n  var key = curve.keyFromPrivate(priv.privateKey)\n  var out = key.sign(hash)\n\n  return Buffer.from(out.toDER())\n}\n\nfunction dsaSign (hash, priv, algo) {\n  var x = priv.params.priv_key\n  var p = priv.params.p\n  var q = priv.params.q\n  var g = priv.params.g\n  var r = new BN(0)\n  var k\n  var H = bits2int(hash, q).mod(q)\n  var s = false\n  var kv = getKey(x, q, hash, algo)\n  while (s === false) {\n    k = makeKey(q, kv, algo)\n    r = makeR(g, k, p, q)\n    s = k.invm(q).imul(H.add(x.mul(r))).mod(q)\n    if (s.cmpn(0) === 0) {\n      s = false\n      r = new BN(0)\n    }\n  }\n  return toDER(r, s)\n}\n\nfunction toDER (r, s) {\n  r = r.toArray()\n  s = s.toArray()\n\n  // Pad values\n  if (r[0] & 0x80) r = [0].concat(r)\n  if (s[0] & 0x80) s = [0].concat(s)\n\n  var total = r.length + s.length + 4\n  var res = [0x30, total, 0x02, r.length]\n  res = res.concat(r, [0x02, s.length], s)\n  return Buffer.from(res)\n}\n\nfunction getKey (x, q, hash, algo) {\n  x = Buffer.from(x.toArray())\n  if (x.length < q.byteLength()) {\n    var zeros = Buffer.alloc(q.byteLength() - x.length)\n    x = Buffer.concat([zeros, x])\n  }\n  var hlen = hash.length\n  var hbits = bits2octets(hash, q)\n  var v = Buffer.alloc(hlen)\n  v.fill(1)\n  var k = Buffer.alloc(hlen)\n  k = createHmac(algo, k).update(v).update(Buffer.from([0])).update(x).update(hbits).digest()\n  v = createHmac(algo, k).update(v).digest()\n  k = createHmac(algo, k).update(v).update(Buffer.from([1])).update(x).update(hbits).digest()\n  v = createHmac(algo, k).update(v).digest()\n  return { k: k, v: v }\n}\n\nfunction bits2int (obits, q) {\n  var bits = new BN(obits)\n  var shift = (obits.length << 3) - q.bitLength()\n  if (shift > 0) bits.ishrn(shift)\n  return bits\n}\n\nfunction bits2octets (bits, q) {\n  bits = bits2int(bits, q)\n  bits = bits.mod(q)\n  var out = Buffer.from(bits.toArray())\n  if (out.length < q.byteLength()) {\n    var zeros = Buffer.alloc(q.byteLength() - out.length)\n    out = Buffer.concat([zeros, out])\n  }\n  return out\n}\n\nfunction makeKey (q, kv, algo) {\n  var t\n  var k\n\n  do {\n    t = Buffer.alloc(0)\n\n    while (t.length * 8 < q.bitLength()) {\n      kv.v = createHmac(algo, kv.k).update(kv.v).digest()\n      t = Buffer.concat([t, kv.v])\n    }\n\n    k = bits2int(t, q)\n    kv.k = createHmac(algo, kv.k).update(kv.v).update(Buffer.from([0])).digest()\n    kv.v = createHmac(algo, kv.k).update(kv.v).digest()\n  } while (k.cmp(q) !== -1)\n\n  return k\n}\n\nfunction makeR (g, k, p, q) {\n  return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q)\n}\n\nmodule.exports = sign\nmodule.exports.getKey = getKey\nmodule.exports.makeKey = makeKey\n","// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js\nvar Buffer = require('safe-buffer').Buffer\nvar BN = require('bn.js')\nvar EC = require('elliptic').ec\nvar parseKeys = require('parse-asn1')\nvar curves = require('./curves.json')\n\nfunction verify (sig, hash, key, signType, tag) {\n  var pub = parseKeys(key)\n  if (pub.type === 'ec') {\n    // rsa keys can be interpreted as ecdsa ones in openssl\n    if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type')\n    return ecVerify(sig, hash, pub)\n  } else if (pub.type === 'dsa') {\n    if (signType !== 'dsa') throw new Error('wrong public key type')\n    return dsaVerify(sig, hash, pub)\n  } else {\n    if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type')\n  }\n  hash = Buffer.concat([tag, hash])\n  var len = pub.modulus.byteLength()\n  var pad = [1]\n  var padNum = 0\n  while (hash.length + pad.length + 2 < len) {\n    pad.push(0xff)\n    padNum++\n  }\n  pad.push(0x00)\n  var i = -1\n  while (++i < hash.length) {\n    pad.push(hash[i])\n  }\n  pad = Buffer.from(pad)\n  var red = BN.mont(pub.modulus)\n  sig = new BN(sig).toRed(red)\n\n  sig = sig.redPow(new BN(pub.publicExponent))\n  sig = Buffer.from(sig.fromRed().toArray())\n  var out = padNum < 8 ? 1 : 0\n  len = Math.min(sig.length, pad.length)\n  if (sig.length !== pad.length) out = 1\n\n  i = -1\n  while (++i < len) out |= sig[i] ^ pad[i]\n  return out === 0\n}\n\nfunction ecVerify (sig, hash, pub) {\n  var curveId = curves[pub.data.algorithm.curve.join('.')]\n  if (!curveId) throw new Error('unknown curve ' + pub.data.algorithm.curve.join('.'))\n\n  var curve = new EC(curveId)\n  var pubkey = pub.data.subjectPrivateKey.data\n\n  return curve.verify(hash, sig, pubkey)\n}\n\nfunction dsaVerify (sig, hash, pub) {\n  var p = pub.data.p\n  var q = pub.data.q\n  var g = pub.data.g\n  var y = pub.data.pub_key\n  var unpacked = parseKeys.signature.decode(sig, 'der')\n  var s = unpacked.s\n  var r = unpacked.r\n  checkValue(s, q)\n  checkValue(r, q)\n  var montp = BN.mont(p)\n  var w = s.invm(q)\n  var v = g.toRed(montp)\n    .redPow(new BN(hash).mul(w).mod(q))\n    .fromRed()\n    .mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed())\n    .mod(p)\n    .mod(q)\n  return v.cmp(r) === 0\n}\n\nfunction checkValue (b, q) {\n  if (b.cmpn(0) <= 0) throw new Error('invalid sig')\n  if (b.cmp(q) >= q) throw new Error('invalid sig')\n}\n\nmodule.exports = verify\n","'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\n\nfunction createErrorType(code, message, Base) {\n  if (!Base) {\n    Base = Error;\n  }\n\n  function getMessage(arg1, arg2, arg3) {\n    if (typeof message === 'string') {\n      return message;\n    } else {\n      return message(arg1, arg2, arg3);\n    }\n  }\n\n  var NodeError =\n  /*#__PURE__*/\n  function (_Base) {\n    _inheritsLoose(NodeError, _Base);\n\n    function NodeError(arg1, arg2, arg3) {\n      return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n    }\n\n    return NodeError;\n  }(Base);\n\n  NodeError.prototype.name = Base.name;\n  NodeError.prototype.code = code;\n  codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n  if (Array.isArray(expected)) {\n    var len = expected.length;\n    expected = expected.map(function (i) {\n      return String(i);\n    });\n\n    if (len > 2) {\n      return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n    } else if (len === 2) {\n      return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n    } else {\n      return \"of \".concat(thing, \" \").concat(expected[0]);\n    }\n  } else {\n    return \"of \".concat(thing, \" \").concat(String(expected));\n  }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n  return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n  if (this_len === undefined || this_len > str.length) {\n    this_len = str.length;\n  }\n\n  return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n  if (typeof start !== 'number') {\n    start = 0;\n  }\n\n  if (start + search.length > str.length) {\n    return false;\n  } else {\n    return str.indexOf(search, start) !== -1;\n  }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n  return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n  // determiner: 'must be' or 'must not be'\n  var determiner;\n\n  if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n    determiner = 'must not be';\n    expected = expected.replace(/^not /, '');\n  } else {\n    determiner = 'must be';\n  }\n\n  var msg;\n\n  if (endsWith(name, ' argument')) {\n    // For cases like 'first argument'\n    msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  } else {\n    var type = includes(name, '.') ? 'property' : 'argument';\n    msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n  }\n\n  msg += \". Received type \".concat(typeof actual);\n  return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n  return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n  return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n  return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) keys.push(key);\n  return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\nrequire('inherits')(Duplex, Readable);\n{\n  // Allow the keys array to be GC'ed.\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n  Readable.call(this, options);\n  Writable.call(this, options);\n  this.allowHalfOpen = true;\n  if (options) {\n    if (options.readable === false) this.readable = false;\n    if (options.writable === false) this.writable = false;\n    if (options.allowHalfOpen === false) {\n      this.allowHalfOpen = false;\n      this.once('end', onend);\n    }\n  }\n}\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.highWaterMark;\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState && this._writableState.getBuffer();\n  }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    return this._writableState.length;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // If the writable side ended, then we're ok.\n  if (this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  process.nextTick(onEndNT, this);\n}\nfunction onEndNT(self) {\n  self.end();\n}\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function get() {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function set(value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});","// based on the aes implimentation in triple sec\n// https://github.com/keybase/triplesec\n// which is in turn based on the one from crypto-js\n// https://code.google.com/p/crypto-js/\n\nvar Buffer = require('safe-buffer').Buffer\n\nfunction asUInt32Array (buf) {\n  if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n\n  var len = (buf.length / 4) | 0\n  var out = new Array(len)\n\n  for (var i = 0; i < len; i++) {\n    out[i] = buf.readUInt32BE(i * 4)\n  }\n\n  return out\n}\n\nfunction scrubVec (v) {\n  for (var i = 0; i < v.length; v++) {\n    v[i] = 0\n  }\n}\n\nfunction cryptBlock (M, keySchedule, SUB_MIX, SBOX, nRounds) {\n  var SUB_MIX0 = SUB_MIX[0]\n  var SUB_MIX1 = SUB_MIX[1]\n  var SUB_MIX2 = SUB_MIX[2]\n  var SUB_MIX3 = SUB_MIX[3]\n\n  var s0 = M[0] ^ keySchedule[0]\n  var s1 = M[1] ^ keySchedule[1]\n  var s2 = M[2] ^ keySchedule[2]\n  var s3 = M[3] ^ keySchedule[3]\n  var t0, t1, t2, t3\n  var ksRow = 4\n\n  for (var round = 1; round < nRounds; round++) {\n    t0 = SUB_MIX0[s0 >>> 24] ^ SUB_MIX1[(s1 >>> 16) & 0xff] ^ SUB_MIX2[(s2 >>> 8) & 0xff] ^ SUB_MIX3[s3 & 0xff] ^ keySchedule[ksRow++]\n    t1 = SUB_MIX0[s1 >>> 24] ^ SUB_MIX1[(s2 >>> 16) & 0xff] ^ SUB_MIX2[(s3 >>> 8) & 0xff] ^ SUB_MIX3[s0 & 0xff] ^ keySchedule[ksRow++]\n    t2 = SUB_MIX0[s2 >>> 24] ^ SUB_MIX1[(s3 >>> 16) & 0xff] ^ SUB_MIX2[(s0 >>> 8) & 0xff] ^ SUB_MIX3[s1 & 0xff] ^ keySchedule[ksRow++]\n    t3 = SUB_MIX0[s3 >>> 24] ^ SUB_MIX1[(s0 >>> 16) & 0xff] ^ SUB_MIX2[(s1 >>> 8) & 0xff] ^ SUB_MIX3[s2 & 0xff] ^ keySchedule[ksRow++]\n    s0 = t0\n    s1 = t1\n    s2 = t2\n    s3 = t3\n  }\n\n  t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++]\n  t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++]\n  t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++]\n  t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]\n  t0 = t0 >>> 0\n  t1 = t1 >>> 0\n  t2 = t2 >>> 0\n  t3 = t3 >>> 0\n\n  return [t0, t1, t2, t3]\n}\n\n// AES constants\nvar RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]\nvar G = (function () {\n  // Compute double table\n  var d = new Array(256)\n  for (var j = 0; j < 256; j++) {\n    if (j < 128) {\n      d[j] = j << 1\n    } else {\n      d[j] = (j << 1) ^ 0x11b\n    }\n  }\n\n  var SBOX = []\n  var INV_SBOX = []\n  var SUB_MIX = [[], [], [], []]\n  var INV_SUB_MIX = [[], [], [], []]\n\n  // Walk GF(2^8)\n  var x = 0\n  var xi = 0\n  for (var i = 0; i < 256; ++i) {\n    // Compute sbox\n    var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4)\n    sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63\n    SBOX[x] = sx\n    INV_SBOX[sx] = x\n\n    // Compute multiplication\n    var x2 = d[x]\n    var x4 = d[x2]\n    var x8 = d[x4]\n\n    // Compute sub bytes, mix columns tables\n    var t = (d[sx] * 0x101) ^ (sx * 0x1010100)\n    SUB_MIX[0][x] = (t << 24) | (t >>> 8)\n    SUB_MIX[1][x] = (t << 16) | (t >>> 16)\n    SUB_MIX[2][x] = (t << 8) | (t >>> 24)\n    SUB_MIX[3][x] = t\n\n    // Compute inv sub bytes, inv mix columns tables\n    t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100)\n    INV_SUB_MIX[0][sx] = (t << 24) | (t >>> 8)\n    INV_SUB_MIX[1][sx] = (t << 16) | (t >>> 16)\n    INV_SUB_MIX[2][sx] = (t << 8) | (t >>> 24)\n    INV_SUB_MIX[3][sx] = t\n\n    if (x === 0) {\n      x = xi = 1\n    } else {\n      x = x2 ^ d[d[d[x8 ^ x2]]]\n      xi ^= d[d[xi]]\n    }\n  }\n\n  return {\n    SBOX: SBOX,\n    INV_SBOX: INV_SBOX,\n    SUB_MIX: SUB_MIX,\n    INV_SUB_MIX: INV_SUB_MIX\n  }\n})()\n\nfunction AES (key) {\n  this._key = asUInt32Array(key)\n  this._reset()\n}\n\nAES.blockSize = 4 * 4\nAES.keySize = 256 / 8\nAES.prototype.blockSize = AES.blockSize\nAES.prototype.keySize = AES.keySize\nAES.prototype._reset = function () {\n  var keyWords = this._key\n  var keySize = keyWords.length\n  var nRounds = keySize + 6\n  var ksRows = (nRounds + 1) * 4\n\n  var keySchedule = []\n  for (var k = 0; k < keySize; k++) {\n    keySchedule[k] = keyWords[k]\n  }\n\n  for (k = keySize; k < ksRows; k++) {\n    var t = keySchedule[k - 1]\n\n    if (k % keySize === 0) {\n      t = (t << 8) | (t >>> 24)\n      t =\n        (G.SBOX[t >>> 24] << 24) |\n        (G.SBOX[(t >>> 16) & 0xff] << 16) |\n        (G.SBOX[(t >>> 8) & 0xff] << 8) |\n        (G.SBOX[t & 0xff])\n\n      t ^= RCON[(k / keySize) | 0] << 24\n    } else if (keySize > 6 && k % keySize === 4) {\n      t =\n        (G.SBOX[t >>> 24] << 24) |\n        (G.SBOX[(t >>> 16) & 0xff] << 16) |\n        (G.SBOX[(t >>> 8) & 0xff] << 8) |\n        (G.SBOX[t & 0xff])\n    }\n\n    keySchedule[k] = keySchedule[k - keySize] ^ t\n  }\n\n  var invKeySchedule = []\n  for (var ik = 0; ik < ksRows; ik++) {\n    var ksR = ksRows - ik\n    var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)]\n\n    if (ik < 4 || ksR <= 4) {\n      invKeySchedule[ik] = tt\n    } else {\n      invKeySchedule[ik] =\n        G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^\n        G.INV_SUB_MIX[1][G.SBOX[(tt >>> 16) & 0xff]] ^\n        G.INV_SUB_MIX[2][G.SBOX[(tt >>> 8) & 0xff]] ^\n        G.INV_SUB_MIX[3][G.SBOX[tt & 0xff]]\n    }\n  }\n\n  this._nRounds = nRounds\n  this._keySchedule = keySchedule\n  this._invKeySchedule = invKeySchedule\n}\n\nAES.prototype.encryptBlockRaw = function (M) {\n  M = asUInt32Array(M)\n  return cryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX, this._nRounds)\n}\n\nAES.prototype.encryptBlock = function (M) {\n  var out = this.encryptBlockRaw(M)\n  var buf = Buffer.allocUnsafe(16)\n  buf.writeUInt32BE(out[0], 0)\n  buf.writeUInt32BE(out[1], 4)\n  buf.writeUInt32BE(out[2], 8)\n  buf.writeUInt32BE(out[3], 12)\n  return buf\n}\n\nAES.prototype.decryptBlock = function (M) {\n  M = asUInt32Array(M)\n\n  // swap\n  var m1 = M[1]\n  M[1] = M[3]\n  M[3] = m1\n\n  var out = cryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX, this._nRounds)\n  var buf = Buffer.allocUnsafe(16)\n  buf.writeUInt32BE(out[0], 0)\n  buf.writeUInt32BE(out[3], 4)\n  buf.writeUInt32BE(out[2], 8)\n  buf.writeUInt32BE(out[1], 12)\n  return buf\n}\n\nAES.prototype.scrub = function () {\n  scrubVec(this._keySchedule)\n  scrubVec(this._invKeySchedule)\n  scrubVec(this._key)\n}\n\nmodule.exports.AES = AES\n"],"sourceRoot":""}