@elizaos/cli 1.0.13 → 1.0.14

package/dist/assets/{index-D7iwnDvJ.js → index-BHRtDt-w.js}

@@ -1,4 +1,4 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/index-ojKLjt7K.js","assets/vendor-DSdxb8P-.js"])))=>i.map(i=>d[i]);
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/index-WVhZEObe.js","assets/vendor-DSdxb8P-.js"])))=>i.map(i=>d[i]);
 import { r as requireReact, a as requireReactDom, p as process$1, b as reactExports, g as getDefaultExportFromCjs, c as reactDomExports, R as React, d as ReactDOM, e as React$1, u as useNavigate, f as useLocation, N as NavLink, h as useParams, L as Link, i as useSearchParams, B as BrowserRouter, j as Routes, k as Route } from './vendor-DSdxb8P-.js';
 
 true              &&(function polyfill() {
@@ -44865,589 +44865,2083 @@ function requireMd5_js () {
 	return md5_js;
 }
 
-var buffer$2 = {};
-var base64Js$1 = {};
-base64Js$1.byteLength = byteLength$1;
-base64Js$1.toByteArray = toByteArray;
-base64Js$1.fromByteArray = fromByteArray;
-var lookup$2 = [];
-var revLookup = [];
-var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
-var code$2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-for (var i = 0, len = code$2.length; i < len; ++i) {
-  lookup$2[i] = code$2[i];
-  revLookup[code$2.charCodeAt(i)] = i;
-}
-revLookup["-".charCodeAt(0)] = 62;
-revLookup["_".charCodeAt(0)] = 63;
-function getLens(b64) {
-  var len = b64.length;
-  if (len % 4 > 0) {
-    throw new Error("Invalid string. Length must be a multiple of 4");
-  }
-  var validLen = b64.indexOf("=");
-  if (validLen === -1) validLen = len;
-  var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
-  return [validLen, placeHoldersLen];
-}
-function byteLength$1(b64) {
-  var lens = getLens(b64);
-  var validLen = lens[0];
-  var placeHoldersLen = lens[1];
-  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
-}
-function _byteLength(b64, validLen, placeHoldersLen) {
-  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+var ripemd160$1;
+var hasRequiredRipemd160$1;
+
+function requireRipemd160$1 () {
+	if (hasRequiredRipemd160$1) return ripemd160$1;
+	hasRequiredRipemd160$1 = 1;
+	var Buffer = requireDist$2().Buffer;
+	var inherits = requireInherits_browser();
+	var HashBase = requireHashBase$1();
+
+	var ARRAY16 = new Array(16);
+
+	var zl = [
+	  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+	  7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
+	  3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
+	  1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
+	  4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
+	];
+
+	var zr = [
+	  5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
+	  6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
+	  15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
+	  8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
+	  12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
+	];
+
+	var sl = [
+	  11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
+	  7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
+	  11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
+	  11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
+	  9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
+	];
+
+	var sr = [
+	  8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
+	  9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
+	  9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
+	  15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
+	  8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
+	];
+
+	var hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e];
+	var hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000];
+
+	function RIPEMD160 () {
+	  HashBase.call(this, 64);
+
+	  // state
+	  this._a = 0x67452301;
+	  this._b = 0xefcdab89;
+	  this._c = 0x98badcfe;
+	  this._d = 0x10325476;
+	  this._e = 0xc3d2e1f0;
+	}
+
+	inherits(RIPEMD160, HashBase);
+
+	RIPEMD160.prototype._update = function () {
+	  var words = ARRAY16;
+	  for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4);
+
+	  var al = this._a | 0;
+	  var bl = this._b | 0;
+	  var cl = this._c | 0;
+	  var dl = this._d | 0;
+	  var el = this._e | 0;
+
+	  var ar = this._a | 0;
+	  var br = this._b | 0;
+	  var cr = this._c | 0;
+	  var dr = this._d | 0;
+	  var er = this._e | 0;
+
+	  // computation
+	  for (var i = 0; i < 80; i += 1) {
+	    var tl;
+	    var tr;
+	    if (i < 16) {
+	      tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i]);
+	      tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i]);
+	    } else if (i < 32) {
+	      tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i]);
+	      tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i]);
+	    } else if (i < 48) {
+	      tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i]);
+	      tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i]);
+	    } else if (i < 64) {
+	      tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i]);
+	      tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i]);
+	    } else { // if (i<80) {
+	      tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i]);
+	      tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i]);
+	    }
+
+	    al = el;
+	    el = dl;
+	    dl = rotl(cl, 10);
+	    cl = bl;
+	    bl = tl;
+
+	    ar = er;
+	    er = dr;
+	    dr = rotl(cr, 10);
+	    cr = br;
+	    br = tr;
+	  }
+
+	  // update state
+	  var t = (this._b + cl + dr) | 0;
+	  this._b = (this._c + dl + er) | 0;
+	  this._c = (this._d + el + ar) | 0;
+	  this._d = (this._e + al + br) | 0;
+	  this._e = (this._a + bl + cr) | 0;
+	  this._a = t;
+	};
+
+	RIPEMD160.prototype._digest = function () {
+	  // create padding and handle blocks
+	  this._block[this._blockOffset++] = 0x80;
+	  if (this._blockOffset > 56) {
+	    this._block.fill(0, this._blockOffset, 64);
+	    this._update();
+	    this._blockOffset = 0;
+	  }
+
+	  this._block.fill(0, this._blockOffset, 56);
+	  this._block.writeUInt32LE(this._length[0], 56);
+	  this._block.writeUInt32LE(this._length[1], 60);
+	  this._update();
+
+	  // produce result
+	  var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20);
+	  buffer.writeInt32LE(this._a, 0);
+	  buffer.writeInt32LE(this._b, 4);
+	  buffer.writeInt32LE(this._c, 8);
+	  buffer.writeInt32LE(this._d, 12);
+	  buffer.writeInt32LE(this._e, 16);
+	  return buffer
+	};
+
+	function rotl (x, n) {
+	  return (x << n) | (x >>> (32 - n))
+	}
+
+	function fn1 (a, b, c, d, e, m, k, s) {
+	  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0
+	}
+
+	function fn2 (a, b, c, d, e, m, k, s) {
+	  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0
+	}
+
+	function fn3 (a, b, c, d, e, m, k, s) {
+	  return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0
+	}
+
+	function fn4 (a, b, c, d, e, m, k, s) {
+	  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0
+	}
+
+	function fn5 (a, b, c, d, e, m, k, s) {
+	  return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0
+	}
+
+	ripemd160$1 = RIPEMD160;
+	return ripemd160$1;
 }
-function toByteArray(b64) {
-  var tmp;
-  var lens = getLens(b64);
-  var validLen = lens[0];
-  var placeHoldersLen = lens[1];
-  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
-  var curByte = 0;
-  var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
-  var i;
-  for (i = 0; i < len; i += 4) {
-    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
-    arr[curByte++] = tmp >> 16 & 255;
-    arr[curByte++] = tmp >> 8 & 255;
-    arr[curByte++] = tmp & 255;
-  }
-  if (placeHoldersLen === 2) {
-    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
-    arr[curByte++] = tmp & 255;
-  }
-  if (placeHoldersLen === 1) {
-    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
-    arr[curByte++] = tmp >> 8 & 255;
-    arr[curByte++] = tmp & 255;
-  }
-  return arr;
+
+var sha_js = {exports: {}};
+
+var hash$1;
+var hasRequiredHash$1;
+
+function requireHash$1 () {
+	if (hasRequiredHash$1) return hash$1;
+	hasRequiredHash$1 = 1;
+	var Buffer = requireSafeBuffer$1().Buffer;
+
+	// prototype class for hash functions
+	function Hash (blockSize, finalSize) {
+	  this._block = Buffer.alloc(blockSize);
+	  this._finalSize = finalSize;
+	  this._blockSize = blockSize;
+	  this._len = 0;
+	}
+
+	Hash.prototype.update = function (data, enc) {
+	  if (typeof data === 'string') {
+	    enc = enc || 'utf8';
+	    data = Buffer.from(data, enc);
+	  }
+
+	  var block = this._block;
+	  var blockSize = this._blockSize;
+	  var length = data.length;
+	  var accum = this._len;
+
+	  for (var offset = 0; offset < length;) {
+	    var assigned = accum % blockSize;
+	    var remainder = Math.min(length - offset, blockSize - assigned);
+
+	    for (var i = 0; i < remainder; i++) {
+	      block[assigned + i] = data[offset + i];
+	    }
+
+	    accum += remainder;
+	    offset += remainder;
+
+	    if ((accum % blockSize) === 0) {
+	      this._update(block);
+	    }
+	  }
+
+	  this._len += length;
+	  return this
+	};
+
+	Hash.prototype.digest = function (enc) {
+	  var rem = this._len % this._blockSize;
+
+	  this._block[rem] = 0x80;
+
+	  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest
+	  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize
+	  this._block.fill(0, rem + 1);
+
+	  if (rem >= this._finalSize) {
+	    this._update(this._block);
+	    this._block.fill(0);
+	  }
+
+	  var bits = this._len * 8;
+
+	  // uint32
+	  if (bits <= 0xffffffff) {
+	    this._block.writeUInt32BE(bits, this._blockSize - 4);
+
+	  // uint64
+	  } else {
+	    var lowBits = (bits & 0xffffffff) >>> 0;
+	    var highBits = (bits - lowBits) / 0x100000000;
+
+	    this._block.writeUInt32BE(highBits, this._blockSize - 8);
+	    this._block.writeUInt32BE(lowBits, this._blockSize - 4);
+	  }
+
+	  this._update(this._block);
+	  var hash = this._hash();
+
+	  return enc ? hash.toString(enc) : hash
+	};
+
+	Hash.prototype._update = function () {
+	  throw new Error('_update must be implemented by subclass')
+	};
+
+	hash$1 = Hash;
+	return hash$1;
 }
-function tripletToBase64(num) {
-  return lookup$2[num >> 18 & 63] + lookup$2[num >> 12 & 63] + lookup$2[num >> 6 & 63] + lookup$2[num & 63];
+
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
+ * in FIPS PUB 180-1
+ * This source code is derived from sha1.js of the same repository.
+ * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
+ * operation was added.
+ */
+
+var sha$1;
+var hasRequiredSha$1;
+
+function requireSha$1 () {
+	if (hasRequiredSha$1) return sha$1;
+	hasRequiredSha$1 = 1;
+	var inherits = requireInherits_browser();
+	var Hash = requireHash$1();
+	var Buffer = requireSafeBuffer$1().Buffer;
+
+	var K = [
+	  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
+	];
+
+	var W = new Array(80);
+
+	function Sha () {
+	  this.init();
+	  this._w = W;
+
+	  Hash.call(this, 64, 56);
+	}
+
+	inherits(Sha, Hash);
+
+	Sha.prototype.init = function () {
+	  this._a = 0x67452301;
+	  this._b = 0xefcdab89;
+	  this._c = 0x98badcfe;
+	  this._d = 0x10325476;
+	  this._e = 0xc3d2e1f0;
+
+	  return this
+	};
+
+	function rotl5 (num) {
+	  return (num << 5) | (num >>> 27)
+	}
+
+	function rotl30 (num) {
+	  return (num << 30) | (num >>> 2)
+	}
+
+	function ft (s, b, c, d) {
+	  if (s === 0) return (b & c) | ((~b) & d)
+	  if (s === 2) return (b & c) | (b & d) | (c & d)
+	  return b ^ c ^ d
+	}
+
+	Sha.prototype._update = function (M) {
+	  var W = this._w;
+
+	  var a = this._a | 0;
+	  var b = this._b | 0;
+	  var c = this._c | 0;
+	  var d = this._d | 0;
+	  var e = this._e | 0;
+
+	  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4);
+	  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+
+	  for (var j = 0; j < 80; ++j) {
+	    var s = ~~(j / 20);
+	    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0;
+
+	    e = d;
+	    d = c;
+	    c = rotl30(b);
+	    b = a;
+	    a = t;
+	  }
+
+	  this._a = (a + this._a) | 0;
+	  this._b = (b + this._b) | 0;
+	  this._c = (c + this._c) | 0;
+	  this._d = (d + this._d) | 0;
+	  this._e = (e + this._e) | 0;
+	};
+
+	Sha.prototype._hash = function () {
+	  var H = Buffer.allocUnsafe(20);
+
+	  H.writeInt32BE(this._a | 0, 0);
+	  H.writeInt32BE(this._b | 0, 4);
+	  H.writeInt32BE(this._c | 0, 8);
+	  H.writeInt32BE(this._d | 0, 12);
+	  H.writeInt32BE(this._e | 0, 16);
+
+	  return H
+	};
+
+	sha$1 = Sha;
+	return sha$1;
 }
-function encodeChunk(uint8, start, end) {
-  var tmp;
-  var output = [];
-  for (var i = start; i < end; i += 3) {
-    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
-    output.push(tripletToBase64(tmp));
-  }
-  return output.join("");
+
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+
+var sha1;
+var hasRequiredSha1$1;
+
+function requireSha1$1 () {
+	if (hasRequiredSha1$1) return sha1;
+	hasRequiredSha1$1 = 1;
+	var inherits = requireInherits_browser();
+	var Hash = requireHash$1();
+	var Buffer = requireSafeBuffer$1().Buffer;
+
+	var K = [
+	  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
+	];
+
+	var W = new Array(80);
+
+	function Sha1 () {
+	  this.init();
+	  this._w = W;
+
+	  Hash.call(this, 64, 56);
+	}
+
+	inherits(Sha1, Hash);
+
+	Sha1.prototype.init = function () {
+	  this._a = 0x67452301;
+	  this._b = 0xefcdab89;
+	  this._c = 0x98badcfe;
+	  this._d = 0x10325476;
+	  this._e = 0xc3d2e1f0;
+
+	  return this
+	};
+
+	function rotl1 (num) {
+	  return (num << 1) | (num >>> 31)
+	}
+
+	function rotl5 (num) {
+	  return (num << 5) | (num >>> 27)
+	}
+
+	function rotl30 (num) {
+	  return (num << 30) | (num >>> 2)
+	}
+
+	function ft (s, b, c, d) {
+	  if (s === 0) return (b & c) | ((~b) & d)
+	  if (s === 2) return (b & c) | (b & d) | (c & d)
+	  return b ^ c ^ d
+	}
+
+	Sha1.prototype._update = function (M) {
+	  var W = this._w;
+
+	  var a = this._a | 0;
+	  var b = this._b | 0;
+	  var c = this._c | 0;
+	  var d = this._d | 0;
+	  var e = this._e | 0;
+
+	  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4);
+	  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]);
+
+	  for (var j = 0; j < 80; ++j) {
+	    var s = ~~(j / 20);
+	    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0;
+
+	    e = d;
+	    d = c;
+	    c = rotl30(b);
+	    b = a;
+	    a = t;
+	  }
+
+	  this._a = (a + this._a) | 0;
+	  this._b = (b + this._b) | 0;
+	  this._c = (c + this._c) | 0;
+	  this._d = (d + this._d) | 0;
+	  this._e = (e + this._e) | 0;
+	};
+
+	Sha1.prototype._hash = function () {
+	  var H = Buffer.allocUnsafe(20);
+
+	  H.writeInt32BE(this._a | 0, 0);
+	  H.writeInt32BE(this._b | 0, 4);
+	  H.writeInt32BE(this._c | 0, 8);
+	  H.writeInt32BE(this._d | 0, 12);
+	  H.writeInt32BE(this._e | 0, 16);
+
+	  return H
+	};
+
+	sha1 = Sha1;
+	return sha1;
 }
-function fromByteArray(uint8) {
-  var tmp;
-  var len = uint8.length;
-  var extraBytes = len % 3;
-  var parts = [];
-  var maxChunkLength = 16383;
-  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
-    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
-  }
-  if (extraBytes === 1) {
-    tmp = uint8[len - 1];
-    parts.push(
-      lookup$2[tmp >> 2] + lookup$2[tmp << 4 & 63] + "=="
-    );
-  } else if (extraBytes === 2) {
-    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
-    parts.push(
-      lookup$2[tmp >> 10] + lookup$2[tmp >> 4 & 63] + lookup$2[tmp << 2 & 63] + "="
-    );
-  }
-  return parts.join("");
+
+/**
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
+ * in FIPS 180-2
+ * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ *
+ */
+
+var sha256$1;
+var hasRequiredSha256;
+
+function requireSha256 () {
+	if (hasRequiredSha256) return sha256$1;
+	hasRequiredSha256 = 1;
+	var inherits = requireInherits_browser();
+	var Hash = requireHash$1();
+	var Buffer = requireSafeBuffer$1().Buffer;
+
+	var K = [
+	  0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
+	  0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
+	  0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
+	  0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
+	  0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
+	  0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
+	  0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
+	  0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
+	  0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
+	  0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
+	  0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
+	  0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
+	  0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
+	  0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
+	  0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
+	  0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
+	];
+
+	var W = new Array(64);
+
+	function Sha256 () {
+	  this.init();
+
+	  this._w = W; // new Array(64)
+
+	  Hash.call(this, 64, 56);
+	}
+
+	inherits(Sha256, Hash);
+
+	Sha256.prototype.init = function () {
+	  this._a = 0x6a09e667;
+	  this._b = 0xbb67ae85;
+	  this._c = 0x3c6ef372;
+	  this._d = 0xa54ff53a;
+	  this._e = 0x510e527f;
+	  this._f = 0x9b05688c;
+	  this._g = 0x1f83d9ab;
+	  this._h = 0x5be0cd19;
+
+	  return this
+	};
+
+	function ch (x, y, z) {
+	  return z ^ (x & (y ^ z))
+	}
+
+	function maj (x, y, z) {
+	  return (x & y) | (z & (x | y))
+	}
+
+	function sigma0 (x) {
+	  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)
+	}
+
+	function sigma1 (x) {
+	  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)
+	}
+
+	function gamma0 (x) {
+	  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)
+	}
+
+	function gamma1 (x) {
+	  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)
+	}
+
+	Sha256.prototype._update = function (M) {
+	  var W = this._w;
+
+	  var a = this._a | 0;
+	  var b = this._b | 0;
+	  var c = this._c | 0;
+	  var d = this._d | 0;
+	  var e = this._e | 0;
+	  var f = this._f | 0;
+	  var g = this._g | 0;
+	  var h = this._h | 0;
+
+	  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4);
+	  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0;
+
+	  for (var j = 0; j < 64; ++j) {
+	    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0;
+	    var T2 = (sigma0(a) + maj(a, b, c)) | 0;
+
+	    h = g;
+	    g = f;
+	    f = e;
+	    e = (d + T1) | 0;
+	    d = c;
+	    c = b;
+	    b = a;
+	    a = (T1 + T2) | 0;
+	  }
+
+	  this._a = (a + this._a) | 0;
+	  this._b = (b + this._b) | 0;
+	  this._c = (c + this._c) | 0;
+	  this._d = (d + this._d) | 0;
+	  this._e = (e + this._e) | 0;
+	  this._f = (f + this._f) | 0;
+	  this._g = (g + this._g) | 0;
+	  this._h = (h + this._h) | 0;
+	};
+
+	Sha256.prototype._hash = function () {
+	  var H = Buffer.allocUnsafe(32);
+
+	  H.writeInt32BE(this._a, 0);
+	  H.writeInt32BE(this._b, 4);
+	  H.writeInt32BE(this._c, 8);
+	  H.writeInt32BE(this._d, 12);
+	  H.writeInt32BE(this._e, 16);
+	  H.writeInt32BE(this._f, 20);
+	  H.writeInt32BE(this._g, 24);
+	  H.writeInt32BE(this._h, 28);
+
+	  return H
+	};
+
+	sha256$1 = Sha256;
+	return sha256$1;
 }
-var ieee754 = {};
-/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
-ieee754.read = function(buffer2, offset, isLE, mLen, nBytes) {
-  var e, m;
-  var eLen = nBytes * 8 - mLen - 1;
-  var eMax = (1 << eLen) - 1;
-  var eBias = eMax >> 1;
-  var nBits = -7;
-  var i = isLE ? nBytes - 1 : 0;
-  var d = isLE ? -1 : 1;
-  var s = buffer2[offset + i];
-  i += d;
-  e = s & (1 << -nBits) - 1;
-  s >>= -nBits;
-  nBits += eLen;
-  for (; nBits > 0; e = e * 256 + buffer2[offset + i], i += d, nBits -= 8) {
-  }
-  m = e & (1 << -nBits) - 1;
-  e >>= -nBits;
-  nBits += mLen;
-  for (; nBits > 0; m = m * 256 + buffer2[offset + i], i += d, nBits -= 8) {
-  }
-  if (e === 0) {
-    e = 1 - eBias;
-  } else if (e === eMax) {
-    return m ? NaN : (s ? -1 : 1) * Infinity;
-  } else {
-    m = m + Math.pow(2, mLen);
-    e = e - eBias;
-  }
-  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
-};
-ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
-  var e, m, c;
-  var eLen = nBytes * 8 - mLen - 1;
-  var eMax = (1 << eLen) - 1;
-  var eBias = eMax >> 1;
-  var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
-  var i = isLE ? 0 : nBytes - 1;
-  var d = isLE ? 1 : -1;
-  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
-  value = Math.abs(value);
-  if (isNaN(value) || value === Infinity) {
-    m = isNaN(value) ? 1 : 0;
-    e = eMax;
-  } else {
-    e = Math.floor(Math.log(value) / Math.LN2);
-    if (value * (c = Math.pow(2, -e)) < 1) {
-      e--;
-      c *= 2;
-    }
-    if (e + eBias >= 1) {
-      value += rt / c;
-    } else {
-      value += rt * Math.pow(2, 1 - eBias);
-    }
-    if (value * c >= 2) {
-      e++;
-      c /= 2;
-    }
-    if (e + eBias >= eMax) {
-      m = 0;
-      e = eMax;
-    } else if (e + eBias >= 1) {
-      m = (value * c - 1) * Math.pow(2, mLen);
-      e = e + eBias;
-    } else {
-      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
-      e = 0;
-    }
-  }
-  for (; mLen >= 8; buffer2[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
-  }
-  e = e << mLen | m;
-  eLen += mLen;
-  for (; eLen > 0; buffer2[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
-  }
-  buffer2[offset + i - d] |= s * 128;
-};
-/*!
- * The buffer module from node.js, for the browser.
+
+/**
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
+ * in FIPS 180-2
+ * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
  *
- * @author   Feross Aboukhadijeh <https://feross.org>
- * @license  MIT
  */
-(function(exports) {
-  const base64 = base64Js$1;
-  const ieee754$1 = ieee754;
-  const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
-  exports.Buffer = Buffer2;
-  exports.SlowBuffer = SlowBuffer2;
-  exports.INSPECT_MAX_BYTES = 50;
-  const K_MAX_LENGTH = 2147483647;
-  exports.kMaxLength = K_MAX_LENGTH;
-  const { Uint8Array: GlobalUint8Array, ArrayBuffer: GlobalArrayBuffer, SharedArrayBuffer: GlobalSharedArrayBuffer } = globalThis;
-  Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
-  if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
-    console.error(
-      "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
-    );
-  }
-  function typedArraySupport() {
-    try {
-      const arr = new GlobalUint8Array(1);
-      const proto = { foo: function() {
-        return 42;
-      } };
-      Object.setPrototypeOf(proto, GlobalUint8Array.prototype);
-      Object.setPrototypeOf(arr, proto);
-      return arr.foo() === 42;
-    } catch (e) {
-      return false;
-    }
-  }
-  Object.defineProperty(Buffer2.prototype, "parent", {
-    enumerable: true,
-    get: function() {
-      if (!Buffer2.isBuffer(this)) return void 0;
-      return this.buffer;
-    }
-  });
-  Object.defineProperty(Buffer2.prototype, "offset", {
-    enumerable: true,
-    get: function() {
-      if (!Buffer2.isBuffer(this)) return void 0;
-      return this.byteOffset;
-    }
-  });
-  function createBuffer(length) {
-    if (length > K_MAX_LENGTH) {
-      throw new RangeError('The value "' + length + '" is invalid for option "size"');
-    }
-    const buf = new GlobalUint8Array(length);
-    Object.setPrototypeOf(buf, Buffer2.prototype);
-    return buf;
-  }
-  function Buffer2(arg, encodingOrOffset, length) {
-    if (typeof arg === "number") {
-      if (typeof encodingOrOffset === "string") {
-        throw new TypeError(
-          'The "string" argument must be of type string. Received type number'
-        );
-      }
-      return allocUnsafe(arg);
-    }
-    return from(arg, encodingOrOffset, length);
-  }
-  Buffer2.poolSize = 8192;
-  function from(value, encodingOrOffset, length) {
-    if (typeof value === "string") {
-      return fromString(value, encodingOrOffset);
-    }
-    if (GlobalArrayBuffer.isView(value)) {
-      return fromArrayView(value);
-    }
-    if (value == null) {
-      throw new TypeError(
-        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
-      );
-    }
-    if (isInstance(value, GlobalArrayBuffer) || value && isInstance(value.buffer, GlobalArrayBuffer)) {
-      return fromArrayBuffer(value, encodingOrOffset, length);
-    }
-    if (typeof GlobalSharedArrayBuffer !== "undefined" && (isInstance(value, GlobalSharedArrayBuffer) || value && isInstance(value.buffer, GlobalSharedArrayBuffer))) {
-      return fromArrayBuffer(value, encodingOrOffset, length);
-    }
-    if (typeof value === "number") {
-      throw new TypeError(
-        'The "value" argument must not be of type number. Received type number'
-      );
-    }
-    const valueOf = value.valueOf && value.valueOf();
-    if (valueOf != null && valueOf !== value) {
-      return Buffer2.from(valueOf, encodingOrOffset, length);
-    }
-    const b = fromObject(value);
-    if (b) return b;
-    if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
-      return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
-    }
-    throw new TypeError(
-      "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
-    );
-  }
-  Buffer2.from = function(value, encodingOrOffset, length) {
-    return from(value, encodingOrOffset, length);
-  };
-  Object.setPrototypeOf(Buffer2.prototype, GlobalUint8Array.prototype);
-  Object.setPrototypeOf(Buffer2, GlobalUint8Array);
-  function assertSize(size) {
-    if (typeof size !== "number") {
-      throw new TypeError('"size" argument must be of type number');
-    } else if (size < 0) {
-      throw new RangeError('The value "' + size + '" is invalid for option "size"');
-    }
-  }
-  function alloc(size, fill, encoding) {
-    assertSize(size);
-    if (size <= 0) {
-      return createBuffer(size);
-    }
-    if (fill !== void 0) {
-      return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
-    }
-    return createBuffer(size);
-  }
-  Buffer2.alloc = function(size, fill, encoding) {
-    return alloc(size, fill, encoding);
-  };
-  function allocUnsafe(size) {
-    assertSize(size);
-    return createBuffer(size < 0 ? 0 : checked(size) | 0);
-  }
-  Buffer2.allocUnsafe = function(size) {
-    return allocUnsafe(size);
-  };
-  Buffer2.allocUnsafeSlow = function(size) {
-    return allocUnsafe(size);
-  };
-  function fromString(string, encoding) {
-    if (typeof encoding !== "string" || encoding === "") {
-      encoding = "utf8";
-    }
-    if (!Buffer2.isEncoding(encoding)) {
-      throw new TypeError("Unknown encoding: " + encoding);
-    }
-    const length = byteLength2(string, encoding) | 0;
-    let buf = createBuffer(length);
-    const actual = buf.write(string, encoding);
-    if (actual !== length) {
-      buf = buf.slice(0, actual);
-    }
-    return buf;
-  }
-  function fromArrayLike(array) {
-    const length = array.length < 0 ? 0 : checked(array.length) | 0;
-    const buf = createBuffer(length);
-    for (let i = 0; i < length; i += 1) {
-      buf[i] = array[i] & 255;
-    }
-    return buf;
-  }
-  function fromArrayView(arrayView) {
-    if (isInstance(arrayView, GlobalUint8Array)) {
-      const copy = new GlobalUint8Array(arrayView);
-      return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
-    }
-    return fromArrayLike(arrayView);
-  }
-  function fromArrayBuffer(array, byteOffset, length) {
-    if (byteOffset < 0 || array.byteLength < byteOffset) {
-      throw new RangeError('"offset" is outside of buffer bounds');
-    }
-    if (array.byteLength < byteOffset + (length || 0)) {
-      throw new RangeError('"length" is outside of buffer bounds');
-    }
-    let buf;
-    if (byteOffset === void 0 && length === void 0) {
-      buf = new GlobalUint8Array(array);
-    } else if (length === void 0) {
-      buf = new GlobalUint8Array(array, byteOffset);
-    } else {
-      buf = new GlobalUint8Array(array, byteOffset, length);
-    }
-    Object.setPrototypeOf(buf, Buffer2.prototype);
-    return buf;
-  }
-  function fromObject(obj) {
-    if (Buffer2.isBuffer(obj)) {
-      const len = checked(obj.length) | 0;
-      const buf = createBuffer(len);
-      if (buf.length === 0) {
-        return buf;
-      }
-      obj.copy(buf, 0, 0, len);
-      return buf;
-    }
-    if (obj.length !== void 0) {
-      if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
-        return createBuffer(0);
-      }
-      return fromArrayLike(obj);
-    }
-    if (obj.type === "Buffer" && Array.isArray(obj.data)) {
-      return fromArrayLike(obj.data);
-    }
-  }
-  function checked(length) {
-    if (length >= K_MAX_LENGTH) {
-      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
-    }
-    return length | 0;
-  }
-  function SlowBuffer2(length) {
-    if (+length != length) {
-      length = 0;
-    }
-    return Buffer2.alloc(+length);
-  }
-  Buffer2.isBuffer = function isBuffer(b) {
-    return b != null && b._isBuffer === true && b !== Buffer2.prototype;
-  };
-  Buffer2.compare = function compare(a, b) {
-    if (isInstance(a, GlobalUint8Array)) a = Buffer2.from(a, a.offset, a.byteLength);
-    if (isInstance(b, GlobalUint8Array)) b = Buffer2.from(b, b.offset, b.byteLength);
-    if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
-      throw new TypeError(
-        'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
-      );
-    }
-    if (a === b) return 0;
-    let x = a.length;
-    let y = b.length;
-    for (let i = 0, len = Math.min(x, y); i < len; ++i) {
-      if (a[i] !== b[i]) {
-        x = a[i];
-        y = b[i];
-        break;
-      }
-    }
-    if (x < y) return -1;
-    if (y < x) return 1;
-    return 0;
-  };
-  Buffer2.isEncoding = function isEncoding(encoding) {
-    switch (String(encoding).toLowerCase()) {
-      case "hex":
-      case "utf8":
-      case "utf-8":
-      case "ascii":
-      case "latin1":
-      case "binary":
-      case "base64":
-      case "ucs2":
-      case "ucs-2":
-      case "utf16le":
-      case "utf-16le":
-        return true;
-      default:
-        return false;
-    }
-  };
-  Buffer2.concat = function concat(list, length) {
-    if (!Array.isArray(list)) {
-      throw new TypeError('"list" argument must be an Array of Buffers');
-    }
-    if (list.length === 0) {
-      return Buffer2.alloc(0);
-    }
-    let i;
-    if (length === void 0) {
-      length = 0;
-      for (i = 0; i < list.length; ++i) {
-        length += list[i].length;
-      }
-    }
-    const buffer2 = Buffer2.allocUnsafe(length);
-    let pos = 0;
-    for (i = 0; i < list.length; ++i) {
-      let buf = list[i];
-      if (isInstance(buf, GlobalUint8Array)) {
-        if (pos + buf.length > buffer2.length) {
-          if (!Buffer2.isBuffer(buf)) buf = Buffer2.from(buf);
-          buf.copy(buffer2, pos);
-        } else {
-          GlobalUint8Array.prototype.set.call(
-            buffer2,
-            buf,
-            pos
-          );
-        }
-      } else if (!Buffer2.isBuffer(buf)) {
-        throw new TypeError('"list" argument must be an Array of Buffers');
-      } else {
-        buf.copy(buffer2, pos);
-      }
-      pos += buf.length;
-    }
-    return buffer2;
-  };
-  function byteLength2(string, encoding) {
-    if (Buffer2.isBuffer(string)) {
-      return string.length;
-    }
-    if (GlobalArrayBuffer.isView(string) || isInstance(string, GlobalArrayBuffer)) {
-      return string.byteLength;
-    }
-    if (typeof string !== "string") {
-      throw new TypeError(
-        'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
-      );
-    }
-    const len = string.length;
-    const mustMatch = arguments.length > 2 && arguments[2] === true;
-    if (!mustMatch && len === 0) return 0;
-    let loweredCase = false;
-    for (; ; ) {
-      switch (encoding) {
-        case "ascii":
-        case "latin1":
-        case "binary":
-          return len;
-        case "utf8":
-        case "utf-8":
-          return utf8ToBytes(string).length;
-        case "ucs2":
-        case "ucs-2":
-        case "utf16le":
-        case "utf-16le":
-          return len * 2;
-        case "hex":
-          return len >>> 1;
-        case "base64":
-          return base64ToBytes(string).length;
-        default:
-          if (loweredCase) {
-            return mustMatch ? -1 : utf8ToBytes(string).length;
-          }
-          encoding = ("" + encoding).toLowerCase();
-          loweredCase = true;
-      }
-    }
+
+var sha224$1;
+var hasRequiredSha224;
+
+function requireSha224 () {
+	if (hasRequiredSha224) return sha224$1;
+	hasRequiredSha224 = 1;
+	var inherits = requireInherits_browser();
+	var Sha256 = requireSha256();
+	var Hash = requireHash$1();
+	var Buffer = requireSafeBuffer$1().Buffer;
+
+	var W = new Array(64);
+
+	function Sha224 () {
+	  this.init();
+
+	  this._w = W; // new Array(64)
+
+	  Hash.call(this, 64, 56);
+	}
+
+	inherits(Sha224, Sha256);
+
+	Sha224.prototype.init = function () {
+	  this._a = 0xc1059ed8;
+	  this._b = 0x367cd507;
+	  this._c = 0x3070dd17;
+	  this._d = 0xf70e5939;
+	  this._e = 0xffc00b31;
+	  this._f = 0x68581511;
+	  this._g = 0x64f98fa7;
+	  this._h = 0xbefa4fa4;
+
+	  return this
+	};
+
+	Sha224.prototype._hash = function () {
+	  var H = Buffer.allocUnsafe(28);
+
+	  H.writeInt32BE(this._a, 0);
+	  H.writeInt32BE(this._b, 4);
+	  H.writeInt32BE(this._c, 8);
+	  H.writeInt32BE(this._d, 12);
+	  H.writeInt32BE(this._e, 16);
+	  H.writeInt32BE(this._f, 20);
+	  H.writeInt32BE(this._g, 24);
+
+	  return H
+	};
+
+	sha224$1 = Sha224;
+	return sha224$1;
+}
+
+var sha512$1;
+var hasRequiredSha512;
+
+function requireSha512 () {
+	if (hasRequiredSha512) return sha512$1;
+	hasRequiredSha512 = 1;
+	var inherits = requireInherits_browser();
+	var Hash = requireHash$1();
+	var Buffer = requireSafeBuffer$1().Buffer;
+
+	var K = [
+	  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
+	  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
+	  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
+	  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
+	  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
+	  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
+	  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
+	  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
+	  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
+	  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
+	  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
+	  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
+	  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
+	  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
+	  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
+	  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
+	  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
+	  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
+	  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
+	  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
+	  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
+	  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
+	  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
+	  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
+	  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
+	  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
+	  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
+	  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
+	  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
+	  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
+	  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
+	  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
+	  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
+	  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
+	  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
+	  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
+	  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
+	  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
+	  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
+	  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
+	];
+
+	var W = new Array(160);
+
+	function Sha512 () {
+	  this.init();
+	  this._w = W;
+
+	  Hash.call(this, 128, 112);
+	}
+
+	inherits(Sha512, Hash);
+
+	Sha512.prototype.init = function () {
+	  this._ah = 0x6a09e667;
+	  this._bh = 0xbb67ae85;
+	  this._ch = 0x3c6ef372;
+	  this._dh = 0xa54ff53a;
+	  this._eh = 0x510e527f;
+	  this._fh = 0x9b05688c;
+	  this._gh = 0x1f83d9ab;
+	  this._hh = 0x5be0cd19;
+
+	  this._al = 0xf3bcc908;
+	  this._bl = 0x84caa73b;
+	  this._cl = 0xfe94f82b;
+	  this._dl = 0x5f1d36f1;
+	  this._el = 0xade682d1;
+	  this._fl = 0x2b3e6c1f;
+	  this._gl = 0xfb41bd6b;
+	  this._hl = 0x137e2179;
+
+	  return this
+	};
+
+	function Ch (x, y, z) {
+	  return z ^ (x & (y ^ z))
+	}
+
+	function maj (x, y, z) {
+	  return (x & y) | (z & (x | y))
+	}
+
+	function sigma0 (x, xl) {
+	  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)
+	}
+
+	function sigma1 (x, xl) {
+	  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)
+	}
+
+	function Gamma0 (x, xl) {
+	  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)
+	}
+
+	function Gamma0l (x, xl) {
+	  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)
+	}
+
+	function Gamma1 (x, xl) {
+	  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)
+	}
+
+	function Gamma1l (x, xl) {
+	  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)
+	}
+
+	function getCarry (a, b) {
+	  return (a >>> 0) < (b >>> 0) ? 1 : 0
+	}
+
+	Sha512.prototype._update = function (M) {
+	  var W = this._w;
+
+	  var ah = this._ah | 0;
+	  var bh = this._bh | 0;
+	  var ch = this._ch | 0;
+	  var dh = this._dh | 0;
+	  var eh = this._eh | 0;
+	  var fh = this._fh | 0;
+	  var gh = this._gh | 0;
+	  var hh = this._hh | 0;
+
+	  var al = this._al | 0;
+	  var bl = this._bl | 0;
+	  var cl = this._cl | 0;
+	  var dl = this._dl | 0;
+	  var el = this._el | 0;
+	  var fl = this._fl | 0;
+	  var gl = this._gl | 0;
+	  var hl = this._hl | 0;
+
+	  for (var i = 0; i < 32; i += 2) {
+	    W[i] = M.readInt32BE(i * 4);
+	    W[i + 1] = M.readInt32BE(i * 4 + 4);
+	  }
+	  for (; i < 160; i += 2) {
+	    var xh = W[i - 15 * 2];
+	    var xl = W[i - 15 * 2 + 1];
+	    var gamma0 = Gamma0(xh, xl);
+	    var gamma0l = Gamma0l(xl, xh);
+
+	    xh = W[i - 2 * 2];
+	    xl = W[i - 2 * 2 + 1];
+	    var gamma1 = Gamma1(xh, xl);
+	    var gamma1l = Gamma1l(xl, xh);
+
+	    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
+	    var Wi7h = W[i - 7 * 2];
+	    var Wi7l = W[i - 7 * 2 + 1];
+
+	    var Wi16h = W[i - 16 * 2];
+	    var Wi16l = W[i - 16 * 2 + 1];
+
+	    var Wil = (gamma0l + Wi7l) | 0;
+	    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0;
+	    Wil = (Wil + gamma1l) | 0;
+	    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0;
+	    Wil = (Wil + Wi16l) | 0;
+	    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0;
+
+	    W[i] = Wih;
+	    W[i + 1] = Wil;
+	  }
+
+	  for (var j = 0; j < 160; j += 2) {
+	    Wih = W[j];
+	    Wil = W[j + 1];
+
+	    var majh = maj(ah, bh, ch);
+	    var majl = maj(al, bl, cl);
+
+	    var sigma0h = sigma0(ah, al);
+	    var sigma0l = sigma0(al, ah);
+	    var sigma1h = sigma1(eh, el);
+	    var sigma1l = sigma1(el, eh);
+
+	    // t1 = h + sigma1 + ch + K[j] + W[j]
+	    var Kih = K[j];
+	    var Kil = K[j + 1];
+
+	    var chh = Ch(eh, fh, gh);
+	    var chl = Ch(el, fl, gl);
+
+	    var t1l = (hl + sigma1l) | 0;
+	    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0;
+	    t1l = (t1l + chl) | 0;
+	    t1h = (t1h + chh + getCarry(t1l, chl)) | 0;
+	    t1l = (t1l + Kil) | 0;
+	    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0;
+	    t1l = (t1l + Wil) | 0;
+	    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0;
+
+	    // t2 = sigma0 + maj
+	    var t2l = (sigma0l + majl) | 0;
+	    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0;
+
+	    hh = gh;
+	    hl = gl;
+	    gh = fh;
+	    gl = fl;
+	    fh = eh;
+	    fl = el;
+	    el = (dl + t1l) | 0;
+	    eh = (dh + t1h + getCarry(el, dl)) | 0;
+	    dh = ch;
+	    dl = cl;
+	    ch = bh;
+	    cl = bl;
+	    bh = ah;
+	    bl = al;
+	    al = (t1l + t2l) | 0;
+	    ah = (t1h + t2h + getCarry(al, t1l)) | 0;
+	  }
+
+	  this._al = (this._al + al) | 0;
+	  this._bl = (this._bl + bl) | 0;
+	  this._cl = (this._cl + cl) | 0;
+	  this._dl = (this._dl + dl) | 0;
+	  this._el = (this._el + el) | 0;
+	  this._fl = (this._fl + fl) | 0;
+	  this._gl = (this._gl + gl) | 0;
+	  this._hl = (this._hl + hl) | 0;
+
+	  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0;
+	  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0;
+	  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0;
+	  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0;
+	  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0;
+	  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0;
+	  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0;
+	  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0;
+	};
+
+	Sha512.prototype._hash = function () {
+	  var H = Buffer.allocUnsafe(64);
+
+	  function writeInt64BE (h, l, offset) {
+	    H.writeInt32BE(h, offset);
+	    H.writeInt32BE(l, offset + 4);
+	  }
+
+	  writeInt64BE(this._ah, this._al, 0);
+	  writeInt64BE(this._bh, this._bl, 8);
+	  writeInt64BE(this._ch, this._cl, 16);
+	  writeInt64BE(this._dh, this._dl, 24);
+	  writeInt64BE(this._eh, this._el, 32);
+	  writeInt64BE(this._fh, this._fl, 40);
+	  writeInt64BE(this._gh, this._gl, 48);
+	  writeInt64BE(this._hh, this._hl, 56);
+
+	  return H
+	};
+
+	sha512$1 = Sha512;
+	return sha512$1;
+}
+
+var sha384$1;
+var hasRequiredSha384;
+
+function requireSha384 () {
+	if (hasRequiredSha384) return sha384$1;
+	hasRequiredSha384 = 1;
+	var inherits = requireInherits_browser();
+	var SHA512 = requireSha512();
+	var Hash = requireHash$1();
+	var Buffer = requireSafeBuffer$1().Buffer;
+
+	var W = new Array(160);
+
+	function Sha384 () {
+	  this.init();
+	  this._w = W;
+
+	  Hash.call(this, 128, 112);
+	}
+
+	inherits(Sha384, SHA512);
+
+	Sha384.prototype.init = function () {
+	  this._ah = 0xcbbb9d5d;
+	  this._bh = 0x629a292a;
+	  this._ch = 0x9159015a;
+	  this._dh = 0x152fecd8;
+	  this._eh = 0x67332667;
+	  this._fh = 0x8eb44a87;
+	  this._gh = 0xdb0c2e0d;
+	  this._hh = 0x47b5481d;
+
+	  this._al = 0xc1059ed8;
+	  this._bl = 0x367cd507;
+	  this._cl = 0x3070dd17;
+	  this._dl = 0xf70e5939;
+	  this._el = 0xffc00b31;
+	  this._fl = 0x68581511;
+	  this._gl = 0x64f98fa7;
+	  this._hl = 0xbefa4fa4;
+
+	  return this
+	};
+
+	Sha384.prototype._hash = function () {
+	  var H = Buffer.allocUnsafe(48);
+
+	  function writeInt64BE (h, l, offset) {
+	    H.writeInt32BE(h, offset);
+	    H.writeInt32BE(l, offset + 4);
+	  }
+
+	  writeInt64BE(this._ah, this._al, 0);
+	  writeInt64BE(this._bh, this._bl, 8);
+	  writeInt64BE(this._ch, this._cl, 16);
+	  writeInt64BE(this._dh, this._dl, 24);
+	  writeInt64BE(this._eh, this._el, 32);
+	  writeInt64BE(this._fh, this._fl, 40);
+
+	  return H
+	};
+
+	sha384$1 = Sha384;
+	return sha384$1;
+}
+
+var hasRequiredSha_js;
+
+function requireSha_js () {
+	if (hasRequiredSha_js) return sha_js.exports;
+	hasRequiredSha_js = 1;
+	var exports = sha_js.exports = function SHA (algorithm) {
+	  algorithm = algorithm.toLowerCase();
+
+	  var Algorithm = exports[algorithm];
+	  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')
+
+	  return new Algorithm()
+	};
+
+	exports.sha = requireSha$1();
+	exports.sha1 = requireSha1$1();
+	exports.sha224 = requireSha224();
+	exports.sha256 = requireSha256();
+	exports.sha384 = requireSha384();
+	exports.sha512 = requireSha512();
+	return sha_js.exports;
+}
+
+var cipherBase;
+var hasRequiredCipherBase;
+
+function requireCipherBase () {
+	if (hasRequiredCipherBase) return cipherBase;
+	hasRequiredCipherBase = 1;
+
+	var Buffer = requireSafeBuffer$1().Buffer;
+	var Transform = requireStreamBrowserify().Transform;
+	var StringDecoder = requireString_decoder().StringDecoder;
+	var inherits = requireInherits_browser();
+
+	function CipherBase(hashMode) {
+		Transform.call(this);
+		this.hashMode = typeof hashMode === 'string';
+		if (this.hashMode) {
+			this[hashMode] = this._finalOrDigest;
+		} else {
+			this['final'] = this._finalOrDigest;
+		}
+		if (this._final) {
+			this.__final = this._final;
+			this._final = null;
+		}
+		this._decoder = null;
+		this._encoding = null;
+	}
+	inherits(CipherBase, Transform);
+
+	var useUint8Array = typeof Uint8Array !== 'undefined';
+	var useArrayBuffer = typeof ArrayBuffer !== 'undefined'
+		&& typeof Uint8Array !== 'undefined'
+		&& ArrayBuffer.isView
+		&& (Buffer.prototype instanceof Uint8Array || Buffer.TYPED_ARRAY_SUPPORT);
+
+	function toBuffer(data, encoding) {
+		/*
+		 * No need to do anything for exact instance
+		 * This is only valid when safe-buffer.Buffer === buffer.Buffer, i.e. when Buffer.from/Buffer.alloc existed
+		 */
+		if (data instanceof Buffer) {
+			return data;
+		}
+
+		// Convert strings to Buffer
+		if (typeof data === 'string') {
+			return Buffer.from(data, encoding);
+		}
+
+		/*
+		 * Wrap any TypedArray instances and DataViews
+		 * Makes sense only on engines with full TypedArray support -- let Buffer detect that
+		 */
+		if (useArrayBuffer && ArrayBuffer.isView(data)) {
+			// Bug in Node.js <6.3.1, which treats this as out-of-bounds
+			if (data.byteLength === 0) {
+				return Buffer.alloc(0);
+			}
+
+			var res = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+			/*
+			 * Recheck result size, as offset/length doesn't work on Node.js <5.10
+			 * We just go to Uint8Array case if this fails
+			 */
+			if (res.byteLength === data.byteLength) {
+				return res;
+			}
+		}
+
+		/*
+		 * Uint8Array in engines where Buffer.from might not work with ArrayBuffer, just copy over
+		 * Doesn't make sense with other TypedArray instances
+		 */
+		if (useUint8Array && data instanceof Uint8Array) {
+			return Buffer.from(data);
+		}
+
+		/*
+		 * Old Buffer polyfill on an engine that doesn't have TypedArray support
+		 * Also, this is from a different Buffer polyfill implementation then we have, as instanceof check failed
+		 * Convert to our current Buffer implementation
+		 */
+		if (
+			Buffer.isBuffer(data)
+				&& data.constructor
+				&& typeof data.constructor.isBuffer === 'function'
+				&& data.constructor.isBuffer(data)
+		) {
+			return Buffer.from(data);
+		}
+
+		throw new TypeError('The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView.');
+	}
+
+	CipherBase.prototype.update = function (data, inputEnc, outputEnc) {
+		var bufferData = toBuffer(data, inputEnc); // asserts correct input type
+		var outData = this._update(bufferData);
+		if (this.hashMode) {
+			return this;
+		}
+
+		if (outputEnc) {
+			outData = this._toString(outData, outputEnc);
+		}
+
+		return outData;
+	};
+
+	CipherBase.prototype.setAutoPadding = function () {};
+	CipherBase.prototype.getAuthTag = function () {
+		throw new Error('trying to get auth tag in unsupported state');
+	};
+
+	CipherBase.prototype.setAuthTag = function () {
+		throw new Error('trying to set auth tag in unsupported state');
+	};
+
+	CipherBase.prototype.setAAD = function () {
+		throw new Error('trying to set aad in unsupported state');
+	};
+
+	CipherBase.prototype._transform = function (data, _, next) {
+		var err;
+		try {
+			if (this.hashMode) {
+				this._update(data);
+			} else {
+				this.push(this._update(data));
+			}
+		} catch (e) {
+			err = e;
+		} finally {
+			next(err);
+		}
+	};
+	CipherBase.prototype._flush = function (done) {
+		var err;
+		try {
+			this.push(this.__final());
+		} catch (e) {
+			err = e;
+		}
+
+		done(err);
+	};
+	CipherBase.prototype._finalOrDigest = function (outputEnc) {
+		var outData = this.__final() || Buffer.alloc(0);
+		if (outputEnc) {
+			outData = this._toString(outData, outputEnc, true);
+		}
+		return outData;
+	};
+
+	CipherBase.prototype._toString = function (value, enc, fin) {
+		if (!this._decoder) {
+			this._decoder = new StringDecoder(enc);
+			this._encoding = enc;
+		}
+
+		if (this._encoding !== enc) {
+			throw new Error('can’t switch encodings');
+		}
+
+		var out = this._decoder.write(value);
+		if (fin) {
+			out += this._decoder.end();
+		}
+
+		return out;
+	};
+
+	cipherBase = CipherBase;
+	return cipherBase;
+}
+
+var browser$a;
+var hasRequiredBrowser$a;
+
+function requireBrowser$a () {
+	if (hasRequiredBrowser$a) return browser$a;
+	hasRequiredBrowser$a = 1;
+	var inherits = requireInherits_browser();
+	var MD5 = requireMd5_js();
+	var RIPEMD160 = requireRipemd160$1();
+	var sha = requireSha_js();
+	var Base = requireCipherBase();
+
+	function Hash (hash) {
+	  Base.call(this, 'digest');
+
+	  this._hash = hash;
+	}
+
+	inherits(Hash, Base);
+
+	Hash.prototype._update = function (data) {
+	  this._hash.update(data);
+	};
+
+	Hash.prototype._final = function () {
+	  return this._hash.digest()
+	};
+
+	browser$a = function createHash (alg) {
+	  alg = alg.toLowerCase();
+	  if (alg === 'md5') return new MD5()
+	  if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()
+
+	  return new Hash(sha(alg))
+	};
+	return browser$a;
+}
+
+var legacy;
+var hasRequiredLegacy;
+
+function requireLegacy () {
+	if (hasRequiredLegacy) return legacy;
+	hasRequiredLegacy = 1;
+	var inherits = requireInherits_browser();
+	var Buffer = requireSafeBuffer$1().Buffer;
+
+	var Base = requireCipherBase();
+
+	var ZEROS = Buffer.alloc(128);
+	var blocksize = 64;
+
+	function Hmac (alg, key) {
+	  Base.call(this, 'digest');
+	  if (typeof key === 'string') {
+	    key = Buffer.from(key);
+	  }
+
+	  this._alg = alg;
+	  this._key = key;
+
+	  if (key.length > blocksize) {
+	    key = alg(key);
+	  } else if (key.length < blocksize) {
+	    key = Buffer.concat([key, ZEROS], blocksize);
+	  }
+
+	  var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
+	  var opad = this._opad = Buffer.allocUnsafe(blocksize);
+
+	  for (var i = 0; i < blocksize; i++) {
+	    ipad[i] = key[i] ^ 0x36;
+	    opad[i] = key[i] ^ 0x5C;
+	  }
+
+	  this._hash = [ipad];
+	}
+
+	inherits(Hmac, Base);
+
+	Hmac.prototype._update = function (data) {
+	  this._hash.push(data);
+	};
+
+	Hmac.prototype._final = function () {
+	  var h = this._alg(Buffer.concat(this._hash));
+	  return this._alg(Buffer.concat([this._opad, h]))
+	};
+	legacy = Hmac;
+	return legacy;
+}
+
+var md5$1;
+var hasRequiredMd5$1;
+
+function requireMd5$1 () {
+	if (hasRequiredMd5$1) return md5$1;
+	hasRequiredMd5$1 = 1;
+	var MD5 = requireMd5_js();
+
+	md5$1 = function (buffer) {
+	  return new MD5().update(buffer).digest()
+	};
+	return md5$1;
+}
+
+var browser$9;
+var hasRequiredBrowser$9;
+
+function requireBrowser$9 () {
+	if (hasRequiredBrowser$9) return browser$9;
+	hasRequiredBrowser$9 = 1;
+	var inherits = requireInherits_browser();
+	var Legacy = requireLegacy();
+	var Base = requireCipherBase();
+	var Buffer = requireSafeBuffer$1().Buffer;
+	var md5 = requireMd5$1();
+	var RIPEMD160 = requireRipemd160$1();
+
+	var sha = requireSha_js();
+
+	var ZEROS = Buffer.alloc(128);
+
+	function Hmac (alg, key) {
+	  Base.call(this, 'digest');
+	  if (typeof key === 'string') {
+	    key = Buffer.from(key);
+	  }
+
+	  var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64;
+
+	  this._alg = alg;
+	  this._key = key;
+	  if (key.length > blocksize) {
+	    var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg);
+	    key = hash.update(key).digest();
+	  } else if (key.length < blocksize) {
+	    key = Buffer.concat([key, ZEROS], blocksize);
+	  }
+
+	  var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
+	  var opad = this._opad = Buffer.allocUnsafe(blocksize);
+
+	  for (var i = 0; i < blocksize; i++) {
+	    ipad[i] = key[i] ^ 0x36;
+	    opad[i] = key[i] ^ 0x5C;
+	  }
+	  this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg);
+	  this._hash.update(ipad);
+	}
+
+	inherits(Hmac, Base);
+
+	Hmac.prototype._update = function (data) {
+	  this._hash.update(data);
+	};
+
+	Hmac.prototype._final = function () {
+	  var h = this._hash.digest();
+	  var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg);
+	  return hash.update(this._opad).update(h).digest()
+	};
+
+	browser$9 = function createHmac (alg, key) {
+	  alg = alg.toLowerCase();
+	  if (alg === 'rmd160' || alg === 'ripemd160') {
+	    return new Hmac('rmd160', key)
+	  }
+	  if (alg === 'md5') {
+	    return new Legacy(md5, key)
+	  }
+	  return new Hmac(alg, key)
+	};
+	return browser$9;
+}
+
+const sha224WithRSAEncryption = {"sign":"rsa","hash":"sha224","id":"302d300d06096086480165030402040500041c"};
+const sha256WithRSAEncryption = {"sign":"rsa","hash":"sha256","id":"3031300d060960864801650304020105000420"};
+const sha384WithRSAEncryption = {"sign":"rsa","hash":"sha384","id":"3041300d060960864801650304020205000430"};
+const sha512WithRSAEncryption = {"sign":"rsa","hash":"sha512","id":"3051300d060960864801650304020305000440"};
+const sha256 = {"sign":"ecdsa","hash":"sha256","id":""};
+const sha224 = {"sign":"ecdsa","hash":"sha224","id":""};
+const sha384 = {"sign":"ecdsa","hash":"sha384","id":""};
+const sha512 = {"sign":"ecdsa","hash":"sha512","id":""};
+const DSA = {"sign":"dsa","hash":"sha1","id":""};
+const ripemd160WithRSA = {"sign":"rsa","hash":"rmd160","id":"3021300906052b2403020105000414"};
+const md5WithRSAEncryption = {"sign":"rsa","hash":"md5","id":"3020300c06082a864886f70d020505000410"};
+const require$$6 = {
+  sha224WithRSAEncryption,
+  "RSA-SHA224": {"sign":"ecdsa/rsa","hash":"sha224","id":"302d300d06096086480165030402040500041c"},
+  sha256WithRSAEncryption,
+  "RSA-SHA256": {"sign":"ecdsa/rsa","hash":"sha256","id":"3031300d060960864801650304020105000420"},
+  sha384WithRSAEncryption,
+  "RSA-SHA384": {"sign":"ecdsa/rsa","hash":"sha384","id":"3041300d060960864801650304020205000430"},
+  sha512WithRSAEncryption,
+  "RSA-SHA512": {"sign":"ecdsa/rsa","hash":"sha512","id":"3051300d060960864801650304020305000440"},
+  "RSA-SHA1": {"sign":"rsa","hash":"sha1","id":"3021300906052b0e03021a05000414"},
+  "ecdsa-with-SHA1": {"sign":"ecdsa","hash":"sha1","id":""},
+  sha256,
+  sha224,
+  sha384,
+  sha512,
+  "DSA-SHA": {"sign":"dsa","hash":"sha1","id":""},
+  "DSA-SHA1": {"sign":"dsa","hash":"sha1","id":""},
+  DSA,
+  "DSA-WITH-SHA224": {"sign":"dsa","hash":"sha224","id":""},
+  "DSA-SHA224": {"sign":"dsa","hash":"sha224","id":""},
+  "DSA-WITH-SHA256": {"sign":"dsa","hash":"sha256","id":""},
+  "DSA-SHA256": {"sign":"dsa","hash":"sha256","id":""},
+  "DSA-WITH-SHA384": {"sign":"dsa","hash":"sha384","id":""},
+  "DSA-SHA384": {"sign":"dsa","hash":"sha384","id":""},
+  "DSA-WITH-SHA512": {"sign":"dsa","hash":"sha512","id":""},
+  "DSA-SHA512": {"sign":"dsa","hash":"sha512","id":""},
+  "DSA-RIPEMD160": {"sign":"dsa","hash":"rmd160","id":""},
+  ripemd160WithRSA,
+  "RSA-RIPEMD160": {"sign":"rsa","hash":"rmd160","id":"3021300906052b2403020105000414"},
+  md5WithRSAEncryption,
+  "RSA-MD5": {"sign":"rsa","hash":"md5","id":"3020300c06082a864886f70d020505000410"},
+};
+
+var algos;
+var hasRequiredAlgos;
+
+function requireAlgos () {
+	if (hasRequiredAlgos) return algos;
+	hasRequiredAlgos = 1;
+
+	algos = require$$6;
+	return algos;
+}
+
+var browser$8 = {};
+
+var precondition;
+var hasRequiredPrecondition;
+
+function requirePrecondition () {
+	if (hasRequiredPrecondition) return precondition;
+	hasRequiredPrecondition = 1;
+
+	var MAX_ALLOC = Math.pow(2, 30) - 1; // default in iojs
+
+	precondition = function (iterations, keylen) {
+		if (typeof iterations !== 'number') {
+			throw new TypeError('Iterations not a number');
+		}
+
+		if (iterations < 0) {
+			throw new TypeError('Bad iterations');
+		}
+
+		if (typeof keylen !== 'number') {
+			throw new TypeError('Key length not a number');
+		}
+
+		if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) { /* eslint no-self-compare: 0 */
+			throw new TypeError('Bad key length');
+		}
+	};
+	return precondition;
+}
+
+var defaultEncoding_1;
+var hasRequiredDefaultEncoding;
+
+function requireDefaultEncoding () {
+	if (hasRequiredDefaultEncoding) return defaultEncoding_1;
+	hasRequiredDefaultEncoding = 1;
+	var defaultEncoding;
+	if (globalThis.process && globalThis.process.browser) {
+	  defaultEncoding = "utf-8";
+	} else if (globalThis.process && globalThis.process.version) {
+	  var pVersionMajor = parseInt(process$1.version.split(".")[0].slice(1), 10);
+	  defaultEncoding = pVersionMajor >= 6 ? "utf-8" : "binary";
+	} else {
+	  defaultEncoding = "utf-8";
+	}
+	defaultEncoding_1 = defaultEncoding;
+	return defaultEncoding_1;
+}
+
+var buffer$2 = {};
+var base64Js$1 = {};
+base64Js$1.byteLength = byteLength$1;
+base64Js$1.toByteArray = toByteArray;
+base64Js$1.fromByteArray = fromByteArray;
+var lookup$2 = [];
+var revLookup = [];
+var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+var code$2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var i = 0, len = code$2.length; i < len; ++i) {
+  lookup$2[i] = code$2[i];
+  revLookup[code$2.charCodeAt(i)] = i;
+}
+revLookup["-".charCodeAt(0)] = 62;
+revLookup["_".charCodeAt(0)] = 63;
+function getLens(b64) {
+  var len = b64.length;
+  if (len % 4 > 0) {
+    throw new Error("Invalid string. Length must be a multiple of 4");
   }
-  Buffer2.byteLength = byteLength2;
-  function slowToString(encoding, start, end) {
-    let loweredCase = false;
-    if (start === void 0 || start < 0) {
-      start = 0;
-    }
-    if (start > this.length) {
-      return "";
-    }
-    if (end === void 0 || end > this.length) {
-      end = this.length;
-    }
-    if (end <= 0) {
-      return "";
-    }
-    end >>>= 0;
-    start >>>= 0;
-    if (end <= start) {
-      return "";
-    }
-    if (!encoding) encoding = "utf8";
-    while (true) {
-      switch (encoding) {
-        case "hex":
-          return hexSlice(this, start, end);
-        case "utf8":
-        case "utf-8":
-          return utf8Slice(this, start, end);
-        case "ascii":
-          return asciiSlice(this, start, end);
-        case "latin1":
-        case "binary":
-          return latin1Slice(this, start, end);
-        case "base64":
-          return base64Slice(this, start, end);
-        case "ucs2":
-        case "ucs-2":
-        case "utf16le":
-        case "utf-16le":
-          return utf16leSlice(this, start, end);
-        default:
-          if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
-          encoding = (encoding + "").toLowerCase();
-          loweredCase = true;
-      }
-    }
+  var validLen = b64.indexOf("=");
+  if (validLen === -1) validLen = len;
+  var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+  return [validLen, placeHoldersLen];
+}
+function byteLength$1(b64) {
+  var lens = getLens(b64);
+  var validLen = lens[0];
+  var placeHoldersLen = lens[1];
+  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function _byteLength(b64, validLen, placeHoldersLen) {
+  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function toByteArray(b64) {
+  var tmp;
+  var lens = getLens(b64);
+  var validLen = lens[0];
+  var placeHoldersLen = lens[1];
+  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+  var curByte = 0;
+  var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+  var i;
+  for (i = 0; i < len; i += 4) {
+    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+    arr[curByte++] = tmp >> 16 & 255;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
   }
-  Buffer2.prototype._isBuffer = true;
-  function swap(b, n, m) {
-    const i = b[n];
-    b[n] = b[m];
-    b[m] = i;
+  if (placeHoldersLen === 2) {
+    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+    arr[curByte++] = tmp & 255;
   }
-  Buffer2.prototype.swap16 = function swap16() {
-    const len = this.length;
-    if (len % 2 !== 0) {
-      throw new RangeError("Buffer size must be a multiple of 16-bits");
-    }
-    for (let i = 0; i < len; i += 2) {
-      swap(this, i, i + 1);
-    }
-    return this;
-  };
-  Buffer2.prototype.swap32 = function swap32() {
-    const len = this.length;
-    if (len % 4 !== 0) {
+  if (placeHoldersLen === 1) {
+    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  return arr;
+}
+function tripletToBase64(num) {
+  return lookup$2[num >> 18 & 63] + lookup$2[num >> 12 & 63] + lookup$2[num >> 6 & 63] + lookup$2[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+  var tmp;
+  var output = [];
+  for (var i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join("");
+}
+function fromByteArray(uint8) {
+  var tmp;
+  var len = uint8.length;
+  var extraBytes = len % 3;
+  var parts = [];
+  var maxChunkLength = 16383;
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+  }
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1];
+    parts.push(
+      lookup$2[tmp >> 2] + lookup$2[tmp << 4 & 63] + "=="
+    );
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+    parts.push(
+      lookup$2[tmp >> 10] + lookup$2[tmp >> 4 & 63] + lookup$2[tmp << 2 & 63] + "="
+    );
+  }
+  return parts.join("");
+}
+var ieee754 = {};
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+ieee754.read = function(buffer2, offset, isLE, mLen, nBytes) {
+  var e, m;
+  var eLen = nBytes * 8 - mLen - 1;
+  var eMax = (1 << eLen) - 1;
+  var eBias = eMax >> 1;
+  var nBits = -7;
+  var i = isLE ? nBytes - 1 : 0;
+  var d = isLE ? -1 : 1;
+  var s = buffer2[offset + i];
+  i += d;
+  e = s & (1 << -nBits) - 1;
+  s >>= -nBits;
+  nBits += eLen;
+  for (; nBits > 0; e = e * 256 + buffer2[offset + i], i += d, nBits -= 8) {
+  }
+  m = e & (1 << -nBits) - 1;
+  e >>= -nBits;
+  nBits += mLen;
+  for (; nBits > 0; m = m * 256 + buffer2[offset + i], i += d, nBits -= 8) {
+  }
+  if (e === 0) {
+    e = 1 - eBias;
+  } else if (e === eMax) {
+    return m ? NaN : (s ? -1 : 1) * Infinity;
+  } else {
+    m = m + Math.pow(2, mLen);
+    e = e - eBias;
+  }
+  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+};
+ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
+  var e, m, c;
+  var eLen = nBytes * 8 - mLen - 1;
+  var eMax = (1 << eLen) - 1;
+  var eBias = eMax >> 1;
+  var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+  var i = isLE ? 0 : nBytes - 1;
+  var d = isLE ? 1 : -1;
+  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+  value = Math.abs(value);
+  if (isNaN(value) || value === Infinity) {
+    m = isNaN(value) ? 1 : 0;
+    e = eMax;
+  } else {
+    e = Math.floor(Math.log(value) / Math.LN2);
+    if (value * (c = Math.pow(2, -e)) < 1) {
+      e--;
+      c *= 2;
+    }
+    if (e + eBias >= 1) {
+      value += rt / c;
+    } else {
+      value += rt * Math.pow(2, 1 - eBias);
+    }
+    if (value * c >= 2) {
+      e++;
+      c /= 2;
+    }
+    if (e + eBias >= eMax) {
+      m = 0;
+      e = eMax;
+    } else if (e + eBias >= 1) {
+      m = (value * c - 1) * Math.pow(2, mLen);
+      e = e + eBias;
+    } else {
+      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+      e = 0;
+    }
+  }
+  for (; mLen >= 8; buffer2[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+  }
+  e = e << mLen | m;
+  eLen += mLen;
+  for (; eLen > 0; buffer2[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+  }
+  buffer2[offset + i - d] |= s * 128;
+};
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+(function(exports) {
+  const base64 = base64Js$1;
+  const ieee754$1 = ieee754;
+  const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+  exports.Buffer = Buffer2;
+  exports.SlowBuffer = SlowBuffer2;
+  exports.INSPECT_MAX_BYTES = 50;
+  const K_MAX_LENGTH = 2147483647;
+  exports.kMaxLength = K_MAX_LENGTH;
+  const { Uint8Array: GlobalUint8Array, ArrayBuffer: GlobalArrayBuffer, SharedArrayBuffer: GlobalSharedArrayBuffer } = globalThis;
+  Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
+  if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+    console.error(
+      "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+    );
+  }
+  function typedArraySupport() {
+    try {
+      const arr = new GlobalUint8Array(1);
+      const proto = { foo: function() {
+        return 42;
+      } };
+      Object.setPrototypeOf(proto, GlobalUint8Array.prototype);
+      Object.setPrototypeOf(arr, proto);
+      return arr.foo() === 42;
+    } catch (e) {
+      return false;
+    }
+  }
+  Object.defineProperty(Buffer2.prototype, "parent", {
+    enumerable: true,
+    get: function() {
+      if (!Buffer2.isBuffer(this)) return void 0;
+      return this.buffer;
+    }
+  });
+  Object.defineProperty(Buffer2.prototype, "offset", {
+    enumerable: true,
+    get: function() {
+      if (!Buffer2.isBuffer(this)) return void 0;
+      return this.byteOffset;
+    }
+  });
+  function createBuffer(length) {
+    if (length > K_MAX_LENGTH) {
+      throw new RangeError('The value "' + length + '" is invalid for option "size"');
+    }
+    const buf = new GlobalUint8Array(length);
+    Object.setPrototypeOf(buf, Buffer2.prototype);
+    return buf;
+  }
+  function Buffer2(arg, encodingOrOffset, length) {
+    if (typeof arg === "number") {
+      if (typeof encodingOrOffset === "string") {
+        throw new TypeError(
+          'The "string" argument must be of type string. Received type number'
+        );
+      }
+      return allocUnsafe(arg);
+    }
+    return from(arg, encodingOrOffset, length);
+  }
+  Buffer2.poolSize = 8192;
+  function from(value, encodingOrOffset, length) {
+    if (typeof value === "string") {
+      return fromString(value, encodingOrOffset);
+    }
+    if (GlobalArrayBuffer.isView(value)) {
+      return fromArrayView(value);
+    }
+    if (value == null) {
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+      );
+    }
+    if (isInstance(value, GlobalArrayBuffer) || value && isInstance(value.buffer, GlobalArrayBuffer)) {
+      return fromArrayBuffer(value, encodingOrOffset, length);
+    }
+    if (typeof GlobalSharedArrayBuffer !== "undefined" && (isInstance(value, GlobalSharedArrayBuffer) || value && isInstance(value.buffer, GlobalSharedArrayBuffer))) {
+      return fromArrayBuffer(value, encodingOrOffset, length);
+    }
+    if (typeof value === "number") {
+      throw new TypeError(
+        'The "value" argument must not be of type number. Received type number'
+      );
+    }
+    const valueOf = value.valueOf && value.valueOf();
+    if (valueOf != null && valueOf !== value) {
+      return Buffer2.from(valueOf, encodingOrOffset, length);
+    }
+    const b = fromObject(value);
+    if (b) return b;
+    if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+      return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+    }
+    throw new TypeError(
+      "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+    );
+  }
+  Buffer2.from = function(value, encodingOrOffset, length) {
+    return from(value, encodingOrOffset, length);
+  };
+  Object.setPrototypeOf(Buffer2.prototype, GlobalUint8Array.prototype);
+  Object.setPrototypeOf(Buffer2, GlobalUint8Array);
+  function assertSize(size) {
+    if (typeof size !== "number") {
+      throw new TypeError('"size" argument must be of type number');
+    } else if (size < 0) {
+      throw new RangeError('The value "' + size + '" is invalid for option "size"');
+    }
+  }
+  function alloc(size, fill, encoding) {
+    assertSize(size);
+    if (size <= 0) {
+      return createBuffer(size);
+    }
+    if (fill !== void 0) {
+      return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+    }
+    return createBuffer(size);
+  }
+  Buffer2.alloc = function(size, fill, encoding) {
+    return alloc(size, fill, encoding);
+  };
+  function allocUnsafe(size) {
+    assertSize(size);
+    return createBuffer(size < 0 ? 0 : checked(size) | 0);
+  }
+  Buffer2.allocUnsafe = function(size) {
+    return allocUnsafe(size);
+  };
+  Buffer2.allocUnsafeSlow = function(size) {
+    return allocUnsafe(size);
+  };
+  function fromString(string, encoding) {
+    if (typeof encoding !== "string" || encoding === "") {
+      encoding = "utf8";
+    }
+    if (!Buffer2.isEncoding(encoding)) {
+      throw new TypeError("Unknown encoding: " + encoding);
+    }
+    const length = byteLength2(string, encoding) | 0;
+    let buf = createBuffer(length);
+    const actual = buf.write(string, encoding);
+    if (actual !== length) {
+      buf = buf.slice(0, actual);
+    }
+    return buf;
+  }
+  function fromArrayLike(array) {
+    const length = array.length < 0 ? 0 : checked(array.length) | 0;
+    const buf = createBuffer(length);
+    for (let i = 0; i < length; i += 1) {
+      buf[i] = array[i] & 255;
+    }
+    return buf;
+  }
+  function fromArrayView(arrayView) {
+    if (isInstance(arrayView, GlobalUint8Array)) {
+      const copy = new GlobalUint8Array(arrayView);
+      return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+    }
+    return fromArrayLike(arrayView);
+  }
+  function fromArrayBuffer(array, byteOffset, length) {
+    if (byteOffset < 0 || array.byteLength < byteOffset) {
+      throw new RangeError('"offset" is outside of buffer bounds');
+    }
+    if (array.byteLength < byteOffset + (length || 0)) {
+      throw new RangeError('"length" is outside of buffer bounds');
+    }
+    let buf;
+    if (byteOffset === void 0 && length === void 0) {
+      buf = new GlobalUint8Array(array);
+    } else if (length === void 0) {
+      buf = new GlobalUint8Array(array, byteOffset);
+    } else {
+      buf = new GlobalUint8Array(array, byteOffset, length);
+    }
+    Object.setPrototypeOf(buf, Buffer2.prototype);
+    return buf;
+  }
+  function fromObject(obj) {
+    if (Buffer2.isBuffer(obj)) {
+      const len = checked(obj.length) | 0;
+      const buf = createBuffer(len);
+      if (buf.length === 0) {
+        return buf;
+      }
+      obj.copy(buf, 0, 0, len);
+      return buf;
+    }
+    if (obj.length !== void 0) {
+      if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+        return createBuffer(0);
+      }
+      return fromArrayLike(obj);
+    }
+    if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+      return fromArrayLike(obj.data);
+    }
+  }
+  function checked(length) {
+    if (length >= K_MAX_LENGTH) {
+      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+    }
+    return length | 0;
+  }
+  function SlowBuffer2(length) {
+    if (+length != length) {
+      length = 0;
+    }
+    return Buffer2.alloc(+length);
+  }
+  Buffer2.isBuffer = function isBuffer(b) {
+    return b != null && b._isBuffer === true && b !== Buffer2.prototype;
+  };
+  Buffer2.compare = function compare(a, b) {
+    if (isInstance(a, GlobalUint8Array)) a = Buffer2.from(a, a.offset, a.byteLength);
+    if (isInstance(b, GlobalUint8Array)) b = Buffer2.from(b, b.offset, b.byteLength);
+    if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
+      throw new TypeError(
+        'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+      );
+    }
+    if (a === b) return 0;
+    let x = a.length;
+    let y = b.length;
+    for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+      if (a[i] !== b[i]) {
+        x = a[i];
+        y = b[i];
+        break;
+      }
+    }
+    if (x < y) return -1;
+    if (y < x) return 1;
+    return 0;
+  };
+  Buffer2.isEncoding = function isEncoding(encoding) {
+    switch (String(encoding).toLowerCase()) {
+      case "hex":
+      case "utf8":
+      case "utf-8":
+      case "ascii":
+      case "latin1":
+      case "binary":
+      case "base64":
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return true;
+      default:
+        return false;
+    }
+  };
+  Buffer2.concat = function concat(list, length) {
+    if (!Array.isArray(list)) {
+      throw new TypeError('"list" argument must be an Array of Buffers');
+    }
+    if (list.length === 0) {
+      return Buffer2.alloc(0);
+    }
+    let i;
+    if (length === void 0) {
+      length = 0;
+      for (i = 0; i < list.length; ++i) {
+        length += list[i].length;
+      }
+    }
+    const buffer2 = Buffer2.allocUnsafe(length);
+    let pos = 0;
+    for (i = 0; i < list.length; ++i) {
+      let buf = list[i];
+      if (isInstance(buf, GlobalUint8Array)) {
+        if (pos + buf.length > buffer2.length) {
+          if (!Buffer2.isBuffer(buf)) buf = Buffer2.from(buf);
+          buf.copy(buffer2, pos);
+        } else {
+          GlobalUint8Array.prototype.set.call(
+            buffer2,
+            buf,
+            pos
+          );
+        }
+      } else if (!Buffer2.isBuffer(buf)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      } else {
+        buf.copy(buffer2, pos);
+      }
+      pos += buf.length;
+    }
+    return buffer2;
+  };
+  function byteLength2(string, encoding) {
+    if (Buffer2.isBuffer(string)) {
+      return string.length;
+    }
+    if (GlobalArrayBuffer.isView(string) || isInstance(string, GlobalArrayBuffer)) {
+      return string.byteLength;
+    }
+    if (typeof string !== "string") {
+      throw new TypeError(
+        'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
+      );
+    }
+    const len = string.length;
+    const mustMatch = arguments.length > 2 && arguments[2] === true;
+    if (!mustMatch && len === 0) return 0;
+    let loweredCase = false;
+    for (; ; ) {
+      switch (encoding) {
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return len;
+        case "utf8":
+        case "utf-8":
+          return utf8ToBytes(string).length;
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return len * 2;
+        case "hex":
+          return len >>> 1;
+        case "base64":
+          return base64ToBytes(string).length;
+        default:
+          if (loweredCase) {
+            return mustMatch ? -1 : utf8ToBytes(string).length;
+          }
+          encoding = ("" + encoding).toLowerCase();
+          loweredCase = true;
+      }
+    }
+  }
+  Buffer2.byteLength = byteLength2;
+  function slowToString(encoding, start, end) {
+    let loweredCase = false;
+    if (start === void 0 || start < 0) {
+      start = 0;
+    }
+    if (start > this.length) {
+      return "";
+    }
+    if (end === void 0 || end > this.length) {
+      end = this.length;
+    }
+    if (end <= 0) {
+      return "";
+    }
+    end >>>= 0;
+    start >>>= 0;
+    if (end <= start) {
+      return "";
+    }
+    if (!encoding) encoding = "utf8";
+    while (true) {
+      switch (encoding) {
+        case "hex":
+          return hexSlice(this, start, end);
+        case "utf8":
+        case "utf-8":
+          return utf8Slice(this, start, end);
+        case "ascii":
+          return asciiSlice(this, start, end);
+        case "latin1":
+        case "binary":
+          return latin1Slice(this, start, end);
+        case "base64":
+          return base64Slice(this, start, end);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return utf16leSlice(this, start, end);
+        default:
+          if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+          encoding = (encoding + "").toLowerCase();
+          loweredCase = true;
+      }
+    }
+  }
+  Buffer2.prototype._isBuffer = true;
+  function swap(b, n, m) {
+    const i = b[n];
+    b[n] = b[m];
+    b[m] = i;
+  }
+  Buffer2.prototype.swap16 = function swap16() {
+    const len = this.length;
+    if (len % 2 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 16-bits");
+    }
+    for (let i = 0; i < len; i += 2) {
+      swap(this, i, i + 1);
+    }
+    return this;
+  };
+  Buffer2.prototype.swap32 = function swap32() {
+    const len = this.length;
+    if (len % 4 !== 0) {
       throw new RangeError("Buffer size must be a multiple of 32-bits");
     }
     for (let i = 0; i < len; i += 4) {
@@ -46632,1719 +48126,6 @@ ieee754.write = function(buffer2, value, offset, isLE, mLen, nBytes) {
 })(buffer$2);
 const Buffer = buffer$2.Buffer;
 
-var hashBase;
-var hasRequiredHashBase;
-
-function requireHashBase () {
-	if (hasRequiredHashBase) return hashBase;
-	hasRequiredHashBase = 1;
-	var Transform = requireStreamBrowserify().Transform;
-	var inherits = requireInherits_browser();
-
-	function HashBase (blockSize) {
-	  Transform.call(this);
-
-	  this._block = new Buffer(blockSize);
-	  this._blockSize = blockSize;
-	  this._blockOffset = 0;
-	  this._length = [0, 0, 0, 0];
-
-	  this._finalized = false;
-	}
-
-	inherits(HashBase, Transform);
-
-	HashBase.prototype._transform = function (chunk, encoding, callback) {
-	  var error = null;
-	  try {
-	    if (encoding !== 'buffer') chunk = new Buffer(chunk, encoding);
-	    this.update(chunk);
-	  } catch (err) {
-	    error = err;
-	  }
-
-	  callback(error);
-	};
-
-	HashBase.prototype._flush = function (callback) {
-	  var error = null;
-	  try {
-	    this.push(this._digest());
-	  } catch (err) {
-	    error = err;
-	  }
-
-	  callback(error);
-	};
-
-	HashBase.prototype.update = function (data, encoding) {
-	  if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer')
-	  if (this._finalized) throw new Error('Digest already called')
-	  if (!Buffer.isBuffer(data)) data = new Buffer(data, encoding || 'binary');
-
-	  // consume data
-	  var block = this._block;
-	  var offset = 0;
-	  while (this._blockOffset + data.length - offset >= this._blockSize) {
-	    for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++];
-	    this._update();
-	    this._blockOffset = 0;
-	  }
-	  while (offset < data.length) block[this._blockOffset++] = data[offset++];
-
-	  // update length
-	  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
-	    this._length[j] += carry;
-	    carry = (this._length[j] / 0x0100000000) | 0;
-	    if (carry > 0) this._length[j] -= 0x0100000000 * carry;
-	  }
-
-	  return this
-	};
-
-	HashBase.prototype._update = function (data) {
-	  throw new Error('_update is not implemented')
-	};
-
-	HashBase.prototype.digest = function (encoding) {
-	  if (this._finalized) throw new Error('Digest already called')
-	  this._finalized = true;
-
-	  var digest = this._digest();
-	  if (encoding !== undefined) digest = digest.toString(encoding);
-	  return digest
-	};
-
-	HashBase.prototype._digest = function () {
-	  throw new Error('_digest is not implemented')
-	};
-
-	hashBase = HashBase;
-	return hashBase;
-}
-
-var ripemd160;
-var hasRequiredRipemd160;
-
-function requireRipemd160 () {
-	if (hasRequiredRipemd160) return ripemd160;
-	hasRequiredRipemd160 = 1;
-	var inherits = requireInherits_browser();
-	var HashBase = requireHashBase();
-
-	function RIPEMD160 () {
-	  HashBase.call(this, 64);
-
-	  // state
-	  this._a = 0x67452301;
-	  this._b = 0xefcdab89;
-	  this._c = 0x98badcfe;
-	  this._d = 0x10325476;
-	  this._e = 0xc3d2e1f0;
-	}
-
-	inherits(RIPEMD160, HashBase);
-
-	RIPEMD160.prototype._update = function () {
-	  var m = new Array(16);
-	  for (var i = 0; i < 16; ++i) m[i] = this._block.readInt32LE(i * 4);
-
-	  var al = this._a;
-	  var bl = this._b;
-	  var cl = this._c;
-	  var dl = this._d;
-	  var el = this._e;
-
-	  // Mj = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
-	  // K = 0x00000000
-	  // Sj = 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8
-	  al = fn1(al, bl, cl, dl, el, m[0], 0x00000000, 11); cl = rotl(cl, 10);
-	  el = fn1(el, al, bl, cl, dl, m[1], 0x00000000, 14); bl = rotl(bl, 10);
-	  dl = fn1(dl, el, al, bl, cl, m[2], 0x00000000, 15); al = rotl(al, 10);
-	  cl = fn1(cl, dl, el, al, bl, m[3], 0x00000000, 12); el = rotl(el, 10);
-	  bl = fn1(bl, cl, dl, el, al, m[4], 0x00000000, 5); dl = rotl(dl, 10);
-	  al = fn1(al, bl, cl, dl, el, m[5], 0x00000000, 8); cl = rotl(cl, 10);
-	  el = fn1(el, al, bl, cl, dl, m[6], 0x00000000, 7); bl = rotl(bl, 10);
-	  dl = fn1(dl, el, al, bl, cl, m[7], 0x00000000, 9); al = rotl(al, 10);
-	  cl = fn1(cl, dl, el, al, bl, m[8], 0x00000000, 11); el = rotl(el, 10);
-	  bl = fn1(bl, cl, dl, el, al, m[9], 0x00000000, 13); dl = rotl(dl, 10);
-	  al = fn1(al, bl, cl, dl, el, m[10], 0x00000000, 14); cl = rotl(cl, 10);
-	  el = fn1(el, al, bl, cl, dl, m[11], 0x00000000, 15); bl = rotl(bl, 10);
-	  dl = fn1(dl, el, al, bl, cl, m[12], 0x00000000, 6); al = rotl(al, 10);
-	  cl = fn1(cl, dl, el, al, bl, m[13], 0x00000000, 7); el = rotl(el, 10);
-	  bl = fn1(bl, cl, dl, el, al, m[14], 0x00000000, 9); dl = rotl(dl, 10);
-	  al = fn1(al, bl, cl, dl, el, m[15], 0x00000000, 8); cl = rotl(cl, 10);
-
-	  // Mj = 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8
-	  // K = 0x5a827999
-	  // Sj = 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12
-	  el = fn2(el, al, bl, cl, dl, m[7], 0x5a827999, 7); bl = rotl(bl, 10);
-	  dl = fn2(dl, el, al, bl, cl, m[4], 0x5a827999, 6); al = rotl(al, 10);
-	  cl = fn2(cl, dl, el, al, bl, m[13], 0x5a827999, 8); el = rotl(el, 10);
-	  bl = fn2(bl, cl, dl, el, al, m[1], 0x5a827999, 13); dl = rotl(dl, 10);
-	  al = fn2(al, bl, cl, dl, el, m[10], 0x5a827999, 11); cl = rotl(cl, 10);
-	  el = fn2(el, al, bl, cl, dl, m[6], 0x5a827999, 9); bl = rotl(bl, 10);
-	  dl = fn2(dl, el, al, bl, cl, m[15], 0x5a827999, 7); al = rotl(al, 10);
-	  cl = fn2(cl, dl, el, al, bl, m[3], 0x5a827999, 15); el = rotl(el, 10);
-	  bl = fn2(bl, cl, dl, el, al, m[12], 0x5a827999, 7); dl = rotl(dl, 10);
-	  al = fn2(al, bl, cl, dl, el, m[0], 0x5a827999, 12); cl = rotl(cl, 10);
-	  el = fn2(el, al, bl, cl, dl, m[9], 0x5a827999, 15); bl = rotl(bl, 10);
-	  dl = fn2(dl, el, al, bl, cl, m[5], 0x5a827999, 9); al = rotl(al, 10);
-	  cl = fn2(cl, dl, el, al, bl, m[2], 0x5a827999, 11); el = rotl(el, 10);
-	  bl = fn2(bl, cl, dl, el, al, m[14], 0x5a827999, 7); dl = rotl(dl, 10);
-	  al = fn2(al, bl, cl, dl, el, m[11], 0x5a827999, 13); cl = rotl(cl, 10);
-	  el = fn2(el, al, bl, cl, dl, m[8], 0x5a827999, 12); bl = rotl(bl, 10);
-
-	  // Mj = 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12
-	  // K = 0x6ed9eba1
-	  // Sj = 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5
-	  dl = fn3(dl, el, al, bl, cl, m[3], 0x6ed9eba1, 11); al = rotl(al, 10);
-	  cl = fn3(cl, dl, el, al, bl, m[10], 0x6ed9eba1, 13); el = rotl(el, 10);
-	  bl = fn3(bl, cl, dl, el, al, m[14], 0x6ed9eba1, 6); dl = rotl(dl, 10);
-	  al = fn3(al, bl, cl, dl, el, m[4], 0x6ed9eba1, 7); cl = rotl(cl, 10);
-	  el = fn3(el, al, bl, cl, dl, m[9], 0x6ed9eba1, 14); bl = rotl(bl, 10);
-	  dl = fn3(dl, el, al, bl, cl, m[15], 0x6ed9eba1, 9); al = rotl(al, 10);
-	  cl = fn3(cl, dl, el, al, bl, m[8], 0x6ed9eba1, 13); el = rotl(el, 10);
-	  bl = fn3(bl, cl, dl, el, al, m[1], 0x6ed9eba1, 15); dl = rotl(dl, 10);
-	  al = fn3(al, bl, cl, dl, el, m[2], 0x6ed9eba1, 14); cl = rotl(cl, 10);
-	  el = fn3(el, al, bl, cl, dl, m[7], 0x6ed9eba1, 8); bl = rotl(bl, 10);
-	  dl = fn3(dl, el, al, bl, cl, m[0], 0x6ed9eba1, 13); al = rotl(al, 10);
-	  cl = fn3(cl, dl, el, al, bl, m[6], 0x6ed9eba1, 6); el = rotl(el, 10);
-	  bl = fn3(bl, cl, dl, el, al, m[13], 0x6ed9eba1, 5); dl = rotl(dl, 10);
-	  al = fn3(al, bl, cl, dl, el, m[11], 0x6ed9eba1, 12); cl = rotl(cl, 10);
-	  el = fn3(el, al, bl, cl, dl, m[5], 0x6ed9eba1, 7); bl = rotl(bl, 10);
-	  dl = fn3(dl, el, al, bl, cl, m[12], 0x6ed9eba1, 5); al = rotl(al, 10);
-
-	  // Mj = 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2
-	  // K = 0x8f1bbcdc
-	  // Sj = 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12
-	  cl = fn4(cl, dl, el, al, bl, m[1], 0x8f1bbcdc, 11); el = rotl(el, 10);
-	  bl = fn4(bl, cl, dl, el, al, m[9], 0x8f1bbcdc, 12); dl = rotl(dl, 10);
-	  al = fn4(al, bl, cl, dl, el, m[11], 0x8f1bbcdc, 14); cl = rotl(cl, 10);
-	  el = fn4(el, al, bl, cl, dl, m[10], 0x8f1bbcdc, 15); bl = rotl(bl, 10);
-	  dl = fn4(dl, el, al, bl, cl, m[0], 0x8f1bbcdc, 14); al = rotl(al, 10);
-	  cl = fn4(cl, dl, el, al, bl, m[8], 0x8f1bbcdc, 15); el = rotl(el, 10);
-	  bl = fn4(bl, cl, dl, el, al, m[12], 0x8f1bbcdc, 9); dl = rotl(dl, 10);
-	  al = fn4(al, bl, cl, dl, el, m[4], 0x8f1bbcdc, 8); cl = rotl(cl, 10);
-	  el = fn4(el, al, bl, cl, dl, m[13], 0x8f1bbcdc, 9); bl = rotl(bl, 10);
-	  dl = fn4(dl, el, al, bl, cl, m[3], 0x8f1bbcdc, 14); al = rotl(al, 10);
-	  cl = fn4(cl, dl, el, al, bl, m[7], 0x8f1bbcdc, 5); el = rotl(el, 10);
-	  bl = fn4(bl, cl, dl, el, al, m[15], 0x8f1bbcdc, 6); dl = rotl(dl, 10);
-	  al = fn4(al, bl, cl, dl, el, m[14], 0x8f1bbcdc, 8); cl = rotl(cl, 10);
-	  el = fn4(el, al, bl, cl, dl, m[5], 0x8f1bbcdc, 6); bl = rotl(bl, 10);
-	  dl = fn4(dl, el, al, bl, cl, m[6], 0x8f1bbcdc, 5); al = rotl(al, 10);
-	  cl = fn4(cl, dl, el, al, bl, m[2], 0x8f1bbcdc, 12); el = rotl(el, 10);
-
-	  // Mj = 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
-	  // K = 0xa953fd4e
-	  // Sj = 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
-	  bl = fn5(bl, cl, dl, el, al, m[4], 0xa953fd4e, 9); dl = rotl(dl, 10);
-	  al = fn5(al, bl, cl, dl, el, m[0], 0xa953fd4e, 15); cl = rotl(cl, 10);
-	  el = fn5(el, al, bl, cl, dl, m[5], 0xa953fd4e, 5); bl = rotl(bl, 10);
-	  dl = fn5(dl, el, al, bl, cl, m[9], 0xa953fd4e, 11); al = rotl(al, 10);
-	  cl = fn5(cl, dl, el, al, bl, m[7], 0xa953fd4e, 6); el = rotl(el, 10);
-	  bl = fn5(bl, cl, dl, el, al, m[12], 0xa953fd4e, 8); dl = rotl(dl, 10);
-	  al = fn5(al, bl, cl, dl, el, m[2], 0xa953fd4e, 13); cl = rotl(cl, 10);
-	  el = fn5(el, al, bl, cl, dl, m[10], 0xa953fd4e, 12); bl = rotl(bl, 10);
-	  dl = fn5(dl, el, al, bl, cl, m[14], 0xa953fd4e, 5); al = rotl(al, 10);
-	  cl = fn5(cl, dl, el, al, bl, m[1], 0xa953fd4e, 12); el = rotl(el, 10);
-	  bl = fn5(bl, cl, dl, el, al, m[3], 0xa953fd4e, 13); dl = rotl(dl, 10);
-	  al = fn5(al, bl, cl, dl, el, m[8], 0xa953fd4e, 14); cl = rotl(cl, 10);
-	  el = fn5(el, al, bl, cl, dl, m[11], 0xa953fd4e, 11); bl = rotl(bl, 10);
-	  dl = fn5(dl, el, al, bl, cl, m[6], 0xa953fd4e, 8); al = rotl(al, 10);
-	  cl = fn5(cl, dl, el, al, bl, m[15], 0xa953fd4e, 5); el = rotl(el, 10);
-	  bl = fn5(bl, cl, dl, el, al, m[13], 0xa953fd4e, 6); dl = rotl(dl, 10);
-
-	  var ar = this._a;
-	  var br = this._b;
-	  var cr = this._c;
-	  var dr = this._d;
-	  var er = this._e;
-
-	  // M'j = 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12
-	  // K' = 0x50a28be6
-	  // S'j = 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6
-	  ar = fn5(ar, br, cr, dr, er, m[5], 0x50a28be6, 8); cr = rotl(cr, 10);
-	  er = fn5(er, ar, br, cr, dr, m[14], 0x50a28be6, 9); br = rotl(br, 10);
-	  dr = fn5(dr, er, ar, br, cr, m[7], 0x50a28be6, 9); ar = rotl(ar, 10);
-	  cr = fn5(cr, dr, er, ar, br, m[0], 0x50a28be6, 11); er = rotl(er, 10);
-	  br = fn5(br, cr, dr, er, ar, m[9], 0x50a28be6, 13); dr = rotl(dr, 10);
-	  ar = fn5(ar, br, cr, dr, er, m[2], 0x50a28be6, 15); cr = rotl(cr, 10);
-	  er = fn5(er, ar, br, cr, dr, m[11], 0x50a28be6, 15); br = rotl(br, 10);
-	  dr = fn5(dr, er, ar, br, cr, m[4], 0x50a28be6, 5); ar = rotl(ar, 10);
-	  cr = fn5(cr, dr, er, ar, br, m[13], 0x50a28be6, 7); er = rotl(er, 10);
-	  br = fn5(br, cr, dr, er, ar, m[6], 0x50a28be6, 7); dr = rotl(dr, 10);
-	  ar = fn5(ar, br, cr, dr, er, m[15], 0x50a28be6, 8); cr = rotl(cr, 10);
-	  er = fn5(er, ar, br, cr, dr, m[8], 0x50a28be6, 11); br = rotl(br, 10);
-	  dr = fn5(dr, er, ar, br, cr, m[1], 0x50a28be6, 14); ar = rotl(ar, 10);
-	  cr = fn5(cr, dr, er, ar, br, m[10], 0x50a28be6, 14); er = rotl(er, 10);
-	  br = fn5(br, cr, dr, er, ar, m[3], 0x50a28be6, 12); dr = rotl(dr, 10);
-	  ar = fn5(ar, br, cr, dr, er, m[12], 0x50a28be6, 6); cr = rotl(cr, 10);
-
-	  // M'j = 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2
-	  // K' = 0x5c4dd124
-	  // S'j = 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11
-	  er = fn4(er, ar, br, cr, dr, m[6], 0x5c4dd124, 9); br = rotl(br, 10);
-	  dr = fn4(dr, er, ar, br, cr, m[11], 0x5c4dd124, 13); ar = rotl(ar, 10);
-	  cr = fn4(cr, dr, er, ar, br, m[3], 0x5c4dd124, 15); er = rotl(er, 10);
-	  br = fn4(br, cr, dr, er, ar, m[7], 0x5c4dd124, 7); dr = rotl(dr, 10);
-	  ar = fn4(ar, br, cr, dr, er, m[0], 0x5c4dd124, 12); cr = rotl(cr, 10);
-	  er = fn4(er, ar, br, cr, dr, m[13], 0x5c4dd124, 8); br = rotl(br, 10);
-	  dr = fn4(dr, er, ar, br, cr, m[5], 0x5c4dd124, 9); ar = rotl(ar, 10);
-	  cr = fn4(cr, dr, er, ar, br, m[10], 0x5c4dd124, 11); er = rotl(er, 10);
-	  br = fn4(br, cr, dr, er, ar, m[14], 0x5c4dd124, 7); dr = rotl(dr, 10);
-	  ar = fn4(ar, br, cr, dr, er, m[15], 0x5c4dd124, 7); cr = rotl(cr, 10);
-	  er = fn4(er, ar, br, cr, dr, m[8], 0x5c4dd124, 12); br = rotl(br, 10);
-	  dr = fn4(dr, er, ar, br, cr, m[12], 0x5c4dd124, 7); ar = rotl(ar, 10);
-	  cr = fn4(cr, dr, er, ar, br, m[4], 0x5c4dd124, 6); er = rotl(er, 10);
-	  br = fn4(br, cr, dr, er, ar, m[9], 0x5c4dd124, 15); dr = rotl(dr, 10);
-	  ar = fn4(ar, br, cr, dr, er, m[1], 0x5c4dd124, 13); cr = rotl(cr, 10);
-	  er = fn4(er, ar, br, cr, dr, m[2], 0x5c4dd124, 11); br = rotl(br, 10);
-
-	  // M'j = 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13
-	  // K' = 0x6d703ef3
-	  // S'j = 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5
-	  dr = fn3(dr, er, ar, br, cr, m[15], 0x6d703ef3, 9); ar = rotl(ar, 10);
-	  cr = fn3(cr, dr, er, ar, br, m[5], 0x6d703ef3, 7); er = rotl(er, 10);
-	  br = fn3(br, cr, dr, er, ar, m[1], 0x6d703ef3, 15); dr = rotl(dr, 10);
-	  ar = fn3(ar, br, cr, dr, er, m[3], 0x6d703ef3, 11); cr = rotl(cr, 10);
-	  er = fn3(er, ar, br, cr, dr, m[7], 0x6d703ef3, 8); br = rotl(br, 10);
-	  dr = fn3(dr, er, ar, br, cr, m[14], 0x6d703ef3, 6); ar = rotl(ar, 10);
-	  cr = fn3(cr, dr, er, ar, br, m[6], 0x6d703ef3, 6); er = rotl(er, 10);
-	  br = fn3(br, cr, dr, er, ar, m[9], 0x6d703ef3, 14); dr = rotl(dr, 10);
-	  ar = fn3(ar, br, cr, dr, er, m[11], 0x6d703ef3, 12); cr = rotl(cr, 10);
-	  er = fn3(er, ar, br, cr, dr, m[8], 0x6d703ef3, 13); br = rotl(br, 10);
-	  dr = fn3(dr, er, ar, br, cr, m[12], 0x6d703ef3, 5); ar = rotl(ar, 10);
-	  cr = fn3(cr, dr, er, ar, br, m[2], 0x6d703ef3, 14); er = rotl(er, 10);
-	  br = fn3(br, cr, dr, er, ar, m[10], 0x6d703ef3, 13); dr = rotl(dr, 10);
-	  ar = fn3(ar, br, cr, dr, er, m[0], 0x6d703ef3, 13); cr = rotl(cr, 10);
-	  er = fn3(er, ar, br, cr, dr, m[4], 0x6d703ef3, 7); br = rotl(br, 10);
-	  dr = fn3(dr, er, ar, br, cr, m[13], 0x6d703ef3, 5); ar = rotl(ar, 10);
-
-	  // M'j = 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14
-	  // K' = 0x7a6d76e9
-	  // S'j = 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8
-	  cr = fn2(cr, dr, er, ar, br, m[8], 0x7a6d76e9, 15); er = rotl(er, 10);
-	  br = fn2(br, cr, dr, er, ar, m[6], 0x7a6d76e9, 5); dr = rotl(dr, 10);
-	  ar = fn2(ar, br, cr, dr, er, m[4], 0x7a6d76e9, 8); cr = rotl(cr, 10);
-	  er = fn2(er, ar, br, cr, dr, m[1], 0x7a6d76e9, 11); br = rotl(br, 10);
-	  dr = fn2(dr, er, ar, br, cr, m[3], 0x7a6d76e9, 14); ar = rotl(ar, 10);
-	  cr = fn2(cr, dr, er, ar, br, m[11], 0x7a6d76e9, 14); er = rotl(er, 10);
-	  br = fn2(br, cr, dr, er, ar, m[15], 0x7a6d76e9, 6); dr = rotl(dr, 10);
-	  ar = fn2(ar, br, cr, dr, er, m[0], 0x7a6d76e9, 14); cr = rotl(cr, 10);
-	  er = fn2(er, ar, br, cr, dr, m[5], 0x7a6d76e9, 6); br = rotl(br, 10);
-	  dr = fn2(dr, er, ar, br, cr, m[12], 0x7a6d76e9, 9); ar = rotl(ar, 10);
-	  cr = fn2(cr, dr, er, ar, br, m[2], 0x7a6d76e9, 12); er = rotl(er, 10);
-	  br = fn2(br, cr, dr, er, ar, m[13], 0x7a6d76e9, 9); dr = rotl(dr, 10);
-	  ar = fn2(ar, br, cr, dr, er, m[9], 0x7a6d76e9, 12); cr = rotl(cr, 10);
-	  er = fn2(er, ar, br, cr, dr, m[7], 0x7a6d76e9, 5); br = rotl(br, 10);
-	  dr = fn2(dr, er, ar, br, cr, m[10], 0x7a6d76e9, 15); ar = rotl(ar, 10);
-	  cr = fn2(cr, dr, er, ar, br, m[14], 0x7a6d76e9, 8); er = rotl(er, 10);
-
-	  // M'j = 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
-	  // K' = 0x00000000
-	  // S'j = 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
-	  br = fn1(br, cr, dr, er, ar, m[12], 0x00000000, 8); dr = rotl(dr, 10);
-	  ar = fn1(ar, br, cr, dr, er, m[15], 0x00000000, 5); cr = rotl(cr, 10);
-	  er = fn1(er, ar, br, cr, dr, m[10], 0x00000000, 12); br = rotl(br, 10);
-	  dr = fn1(dr, er, ar, br, cr, m[4], 0x00000000, 9); ar = rotl(ar, 10);
-	  cr = fn1(cr, dr, er, ar, br, m[1], 0x00000000, 12); er = rotl(er, 10);
-	  br = fn1(br, cr, dr, er, ar, m[5], 0x00000000, 5); dr = rotl(dr, 10);
-	  ar = fn1(ar, br, cr, dr, er, m[8], 0x00000000, 14); cr = rotl(cr, 10);
-	  er = fn1(er, ar, br, cr, dr, m[7], 0x00000000, 6); br = rotl(br, 10);
-	  dr = fn1(dr, er, ar, br, cr, m[6], 0x00000000, 8); ar = rotl(ar, 10);
-	  cr = fn1(cr, dr, er, ar, br, m[2], 0x00000000, 13); er = rotl(er, 10);
-	  br = fn1(br, cr, dr, er, ar, m[13], 0x00000000, 6); dr = rotl(dr, 10);
-	  ar = fn1(ar, br, cr, dr, er, m[14], 0x00000000, 5); cr = rotl(cr, 10);
-	  er = fn1(er, ar, br, cr, dr, m[0], 0x00000000, 15); br = rotl(br, 10);
-	  dr = fn1(dr, er, ar, br, cr, m[3], 0x00000000, 13); ar = rotl(ar, 10);
-	  cr = fn1(cr, dr, er, ar, br, m[9], 0x00000000, 11); er = rotl(er, 10);
-	  br = fn1(br, cr, dr, er, ar, m[11], 0x00000000, 11); dr = rotl(dr, 10);
-
-	  // change state
-	  var t = (this._b + cl + dr) | 0;
-	  this._b = (this._c + dl + er) | 0;
-	  this._c = (this._d + el + ar) | 0;
-	  this._d = (this._e + al + br) | 0;
-	  this._e = (this._a + bl + cr) | 0;
-	  this._a = t;
-	};
-
-	RIPEMD160.prototype._digest = function () {
-	  // create padding and handle blocks
-	  this._block[this._blockOffset++] = 0x80;
-	  if (this._blockOffset > 56) {
-	    this._block.fill(0, this._blockOffset, 64);
-	    this._update();
-	    this._blockOffset = 0;
-	  }
-
-	  this._block.fill(0, this._blockOffset, 56);
-	  this._block.writeUInt32LE(this._length[0], 56);
-	  this._block.writeUInt32LE(this._length[1], 60);
-	  this._update();
-
-	  // produce result
-	  var buffer = new Buffer(20);
-	  buffer.writeInt32LE(this._a, 0);
-	  buffer.writeInt32LE(this._b, 4);
-	  buffer.writeInt32LE(this._c, 8);
-	  buffer.writeInt32LE(this._d, 12);
-	  buffer.writeInt32LE(this._e, 16);
-	  return buffer
-	};
-
-	function rotl (x, n) {
-	  return (x << n) | (x >>> (32 - n))
-	}
-
-	function fn1 (a, b, c, d, e, m, k, s) {
-	  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0
-	}
-
-	function fn2 (a, b, c, d, e, m, k, s) {
-	  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0
-	}
-
-	function fn3 (a, b, c, d, e, m, k, s) {
-	  return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0
-	}
-
-	function fn4 (a, b, c, d, e, m, k, s) {
-	  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0
-	}
-
-	function fn5 (a, b, c, d, e, m, k, s) {
-	  return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0
-	}
-
-	ripemd160 = RIPEMD160;
-	return ripemd160;
-}
-
-var sha_js = {exports: {}};
-
-var hash$1;
-var hasRequiredHash$1;
-
-function requireHash$1 () {
-	if (hasRequiredHash$1) return hash$1;
-	hasRequiredHash$1 = 1;
-	var Buffer = requireSafeBuffer$1().Buffer;
-
-	// prototype class for hash functions
-	function Hash (blockSize, finalSize) {
-	  this._block = Buffer.alloc(blockSize);
-	  this._finalSize = finalSize;
-	  this._blockSize = blockSize;
-	  this._len = 0;
-	}
-
-	Hash.prototype.update = function (data, enc) {
-	  if (typeof data === 'string') {
-	    enc = enc || 'utf8';
-	    data = Buffer.from(data, enc);
-	  }
-
-	  var block = this._block;
-	  var blockSize = this._blockSize;
-	  var length = data.length;
-	  var accum = this._len;
-
-	  for (var offset = 0; offset < length;) {
-	    var assigned = accum % blockSize;
-	    var remainder = Math.min(length - offset, blockSize - assigned);
-
-	    for (var i = 0; i < remainder; i++) {
-	      block[assigned + i] = data[offset + i];
-	    }
-
-	    accum += remainder;
-	    offset += remainder;
-
-	    if ((accum % blockSize) === 0) {
-	      this._update(block);
-	    }
-	  }
-
-	  this._len += length;
-	  return this
-	};
-
-	Hash.prototype.digest = function (enc) {
-	  var rem = this._len % this._blockSize;
-
-	  this._block[rem] = 0x80;
-
-	  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest
-	  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize
-	  this._block.fill(0, rem + 1);
-
-	  if (rem >= this._finalSize) {
-	    this._update(this._block);
-	    this._block.fill(0);
-	  }
-
-	  var bits = this._len * 8;
-
-	  // uint32
-	  if (bits <= 0xffffffff) {
-	    this._block.writeUInt32BE(bits, this._blockSize - 4);
-
-	  // uint64
-	  } else {
-	    var lowBits = (bits & 0xffffffff) >>> 0;
-	    var highBits = (bits - lowBits) / 0x100000000;
-
-	    this._block.writeUInt32BE(highBits, this._blockSize - 8);
-	    this._block.writeUInt32BE(lowBits, this._blockSize - 4);
-	  }
-
-	  this._update(this._block);
-	  var hash = this._hash();
-
-	  return enc ? hash.toString(enc) : hash
-	};
-
-	Hash.prototype._update = function () {
-	  throw new Error('_update must be implemented by subclass')
-	};
-
-	hash$1 = Hash;
-	return hash$1;
-}
-
-/*
- * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined
- * in FIPS PUB 180-1
- * This source code is derived from sha1.js of the same repository.
- * The difference between SHA-0 and SHA-1 is just a bitwise rotate left
- * operation was added.
- */
-
-var sha$1;
-var hasRequiredSha$1;
-
-function requireSha$1 () {
-	if (hasRequiredSha$1) return sha$1;
-	hasRequiredSha$1 = 1;
-	var inherits = requireInherits_browser();
-	var Hash = requireHash$1();
-	var Buffer = requireSafeBuffer$1().Buffer;
-
-	var K = [
-	  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
-	];
-
-	var W = new Array(80);
-
-	function Sha () {
-	  this.init();
-	  this._w = W;
-
-	  Hash.call(this, 64, 56);
-	}
-
-	inherits(Sha, Hash);
-
-	Sha.prototype.init = function () {
-	  this._a = 0x67452301;
-	  this._b = 0xefcdab89;
-	  this._c = 0x98badcfe;
-	  this._d = 0x10325476;
-	  this._e = 0xc3d2e1f0;
-
-	  return this
-	};
-
-	function rotl5 (num) {
-	  return (num << 5) | (num >>> 27)
-	}
-
-	function rotl30 (num) {
-	  return (num << 30) | (num >>> 2)
-	}
-
-	function ft (s, b, c, d) {
-	  if (s === 0) return (b & c) | ((~b) & d)
-	  if (s === 2) return (b & c) | (b & d) | (c & d)
-	  return b ^ c ^ d
-	}
-
-	Sha.prototype._update = function (M) {
-	  var W = this._w;
-
-	  var a = this._a | 0;
-	  var b = this._b | 0;
-	  var c = this._c | 0;
-	  var d = this._d | 0;
-	  var e = this._e | 0;
-
-	  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4);
-	  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
-
-	  for (var j = 0; j < 80; ++j) {
-	    var s = ~~(j / 20);
-	    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0;
-
-	    e = d;
-	    d = c;
-	    c = rotl30(b);
-	    b = a;
-	    a = t;
-	  }
-
-	  this._a = (a + this._a) | 0;
-	  this._b = (b + this._b) | 0;
-	  this._c = (c + this._c) | 0;
-	  this._d = (d + this._d) | 0;
-	  this._e = (e + this._e) | 0;
-	};
-
-	Sha.prototype._hash = function () {
-	  var H = Buffer.allocUnsafe(20);
-
-	  H.writeInt32BE(this._a | 0, 0);
-	  H.writeInt32BE(this._b | 0, 4);
-	  H.writeInt32BE(this._c | 0, 8);
-	  H.writeInt32BE(this._d | 0, 12);
-	  H.writeInt32BE(this._e | 0, 16);
-
-	  return H
-	};
-
-	sha$1 = Sha;
-	return sha$1;
-}
-
-/*
- * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
- * in FIPS PUB 180-1
- * Version 2.1a Copyright Paul Johnston 2000 - 2002.
- * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
- * Distributed under the BSD License
- * See http://pajhome.org.uk/crypt/md5 for details.
- */
-
-var sha1;
-var hasRequiredSha1$1;
-
-function requireSha1$1 () {
-	if (hasRequiredSha1$1) return sha1;
-	hasRequiredSha1$1 = 1;
-	var inherits = requireInherits_browser();
-	var Hash = requireHash$1();
-	var Buffer = requireSafeBuffer$1().Buffer;
-
-	var K = [
-	  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0
-	];
-
-	var W = new Array(80);
-
-	function Sha1 () {
-	  this.init();
-	  this._w = W;
-
-	  Hash.call(this, 64, 56);
-	}
-
-	inherits(Sha1, Hash);
-
-	Sha1.prototype.init = function () {
-	  this._a = 0x67452301;
-	  this._b = 0xefcdab89;
-	  this._c = 0x98badcfe;
-	  this._d = 0x10325476;
-	  this._e = 0xc3d2e1f0;
-
-	  return this
-	};
-
-	function rotl1 (num) {
-	  return (num << 1) | (num >>> 31)
-	}
-
-	function rotl5 (num) {
-	  return (num << 5) | (num >>> 27)
-	}
-
-	function rotl30 (num) {
-	  return (num << 30) | (num >>> 2)
-	}
-
-	function ft (s, b, c, d) {
-	  if (s === 0) return (b & c) | ((~b) & d)
-	  if (s === 2) return (b & c) | (b & d) | (c & d)
-	  return b ^ c ^ d
-	}
-
-	Sha1.prototype._update = function (M) {
-	  var W = this._w;
-
-	  var a = this._a | 0;
-	  var b = this._b | 0;
-	  var c = this._c | 0;
-	  var d = this._d | 0;
-	  var e = this._e | 0;
-
-	  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4);
-	  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]);
-
-	  for (var j = 0; j < 80; ++j) {
-	    var s = ~~(j / 20);
-	    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0;
-
-	    e = d;
-	    d = c;
-	    c = rotl30(b);
-	    b = a;
-	    a = t;
-	  }
-
-	  this._a = (a + this._a) | 0;
-	  this._b = (b + this._b) | 0;
-	  this._c = (c + this._c) | 0;
-	  this._d = (d + this._d) | 0;
-	  this._e = (e + this._e) | 0;
-	};
-
-	Sha1.prototype._hash = function () {
-	  var H = Buffer.allocUnsafe(20);
-
-	  H.writeInt32BE(this._a | 0, 0);
-	  H.writeInt32BE(this._b | 0, 4);
-	  H.writeInt32BE(this._c | 0, 8);
-	  H.writeInt32BE(this._d | 0, 12);
-	  H.writeInt32BE(this._e | 0, 16);
-
-	  return H
-	};
-
-	sha1 = Sha1;
-	return sha1;
-}
-
-/**
- * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
- * in FIPS 180-2
- * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
- * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
- *
- */
-
-var sha256$1;
-var hasRequiredSha256;
-
-function requireSha256 () {
-	if (hasRequiredSha256) return sha256$1;
-	hasRequiredSha256 = 1;
-	var inherits = requireInherits_browser();
-	var Hash = requireHash$1();
-	var Buffer = requireSafeBuffer$1().Buffer;
-
-	var K = [
-	  0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
-	  0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
-	  0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
-	  0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
-	  0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
-	  0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
-	  0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
-	  0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
-	  0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
-	  0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
-	  0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
-	  0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
-	  0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
-	  0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
-	  0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
-	  0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
-	];
-
-	var W = new Array(64);
-
-	function Sha256 () {
-	  this.init();
-
-	  this._w = W; // new Array(64)
-
-	  Hash.call(this, 64, 56);
-	}
-
-	inherits(Sha256, Hash);
-
-	Sha256.prototype.init = function () {
-	  this._a = 0x6a09e667;
-	  this._b = 0xbb67ae85;
-	  this._c = 0x3c6ef372;
-	  this._d = 0xa54ff53a;
-	  this._e = 0x510e527f;
-	  this._f = 0x9b05688c;
-	  this._g = 0x1f83d9ab;
-	  this._h = 0x5be0cd19;
-
-	  return this
-	};
-
-	function ch (x, y, z) {
-	  return z ^ (x & (y ^ z))
-	}
-
-	function maj (x, y, z) {
-	  return (x & y) | (z & (x | y))
-	}
-
-	function sigma0 (x) {
-	  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)
-	}
-
-	function sigma1 (x) {
-	  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)
-	}
-
-	function gamma0 (x) {
-	  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)
-	}
-
-	function gamma1 (x) {
-	  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)
-	}
-
-	Sha256.prototype._update = function (M) {
-	  var W = this._w;
-
-	  var a = this._a | 0;
-	  var b = this._b | 0;
-	  var c = this._c | 0;
-	  var d = this._d | 0;
-	  var e = this._e | 0;
-	  var f = this._f | 0;
-	  var g = this._g | 0;
-	  var h = this._h | 0;
-
-	  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4);
-	  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0;
-
-	  for (var j = 0; j < 64; ++j) {
-	    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0;
-	    var T2 = (sigma0(a) + maj(a, b, c)) | 0;
-
-	    h = g;
-	    g = f;
-	    f = e;
-	    e = (d + T1) | 0;
-	    d = c;
-	    c = b;
-	    b = a;
-	    a = (T1 + T2) | 0;
-	  }
-
-	  this._a = (a + this._a) | 0;
-	  this._b = (b + this._b) | 0;
-	  this._c = (c + this._c) | 0;
-	  this._d = (d + this._d) | 0;
-	  this._e = (e + this._e) | 0;
-	  this._f = (f + this._f) | 0;
-	  this._g = (g + this._g) | 0;
-	  this._h = (h + this._h) | 0;
-	};
-
-	Sha256.prototype._hash = function () {
-	  var H = Buffer.allocUnsafe(32);
-
-	  H.writeInt32BE(this._a, 0);
-	  H.writeInt32BE(this._b, 4);
-	  H.writeInt32BE(this._c, 8);
-	  H.writeInt32BE(this._d, 12);
-	  H.writeInt32BE(this._e, 16);
-	  H.writeInt32BE(this._f, 20);
-	  H.writeInt32BE(this._g, 24);
-	  H.writeInt32BE(this._h, 28);
-
-	  return H
-	};
-
-	sha256$1 = Sha256;
-	return sha256$1;
-}
-
-/**
- * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
- * in FIPS 180-2
- * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
- * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
- *
- */
-
-var sha224$1;
-var hasRequiredSha224;
-
-function requireSha224 () {
-	if (hasRequiredSha224) return sha224$1;
-	hasRequiredSha224 = 1;
-	var inherits = requireInherits_browser();
-	var Sha256 = requireSha256();
-	var Hash = requireHash$1();
-	var Buffer = requireSafeBuffer$1().Buffer;
-
-	var W = new Array(64);
-
-	function Sha224 () {
-	  this.init();
-
-	  this._w = W; // new Array(64)
-
-	  Hash.call(this, 64, 56);
-	}
-
-	inherits(Sha224, Sha256);
-
-	Sha224.prototype.init = function () {
-	  this._a = 0xc1059ed8;
-	  this._b = 0x367cd507;
-	  this._c = 0x3070dd17;
-	  this._d = 0xf70e5939;
-	  this._e = 0xffc00b31;
-	  this._f = 0x68581511;
-	  this._g = 0x64f98fa7;
-	  this._h = 0xbefa4fa4;
-
-	  return this
-	};
-
-	Sha224.prototype._hash = function () {
-	  var H = Buffer.allocUnsafe(28);
-
-	  H.writeInt32BE(this._a, 0);
-	  H.writeInt32BE(this._b, 4);
-	  H.writeInt32BE(this._c, 8);
-	  H.writeInt32BE(this._d, 12);
-	  H.writeInt32BE(this._e, 16);
-	  H.writeInt32BE(this._f, 20);
-	  H.writeInt32BE(this._g, 24);
-
-	  return H
-	};
-
-	sha224$1 = Sha224;
-	return sha224$1;
-}
-
-var sha512$1;
-var hasRequiredSha512;
-
-function requireSha512 () {
-	if (hasRequiredSha512) return sha512$1;
-	hasRequiredSha512 = 1;
-	var inherits = requireInherits_browser();
-	var Hash = requireHash$1();
-	var Buffer = requireSafeBuffer$1().Buffer;
-
-	var K = [
-	  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
-	  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
-	  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
-	  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
-	  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
-	  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
-	  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
-	  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
-	  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
-	  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
-	  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
-	  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
-	  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
-	  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
-	  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
-	  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
-	  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
-	  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
-	  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
-	  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
-	  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
-	  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
-	  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
-	  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
-	  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
-	  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
-	  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
-	  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
-	  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
-	  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
-	  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
-	  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
-	  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
-	  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
-	  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
-	  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
-	  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
-	  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
-	  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
-	  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
-	];
-
-	var W = new Array(160);
-
-	function Sha512 () {
-	  this.init();
-	  this._w = W;
-
-	  Hash.call(this, 128, 112);
-	}
-
-	inherits(Sha512, Hash);
-
-	Sha512.prototype.init = function () {
-	  this._ah = 0x6a09e667;
-	  this._bh = 0xbb67ae85;
-	  this._ch = 0x3c6ef372;
-	  this._dh = 0xa54ff53a;
-	  this._eh = 0x510e527f;
-	  this._fh = 0x9b05688c;
-	  this._gh = 0x1f83d9ab;
-	  this._hh = 0x5be0cd19;
-
-	  this._al = 0xf3bcc908;
-	  this._bl = 0x84caa73b;
-	  this._cl = 0xfe94f82b;
-	  this._dl = 0x5f1d36f1;
-	  this._el = 0xade682d1;
-	  this._fl = 0x2b3e6c1f;
-	  this._gl = 0xfb41bd6b;
-	  this._hl = 0x137e2179;
-
-	  return this
-	};
-
-	function Ch (x, y, z) {
-	  return z ^ (x & (y ^ z))
-	}
-
-	function maj (x, y, z) {
-	  return (x & y) | (z & (x | y))
-	}
-
-	function sigma0 (x, xl) {
-	  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)
-	}
-
-	function sigma1 (x, xl) {
-	  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)
-	}
-
-	function Gamma0 (x, xl) {
-	  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)
-	}
-
-	function Gamma0l (x, xl) {
-	  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)
-	}
-
-	function Gamma1 (x, xl) {
-	  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)
-	}
-
-	function Gamma1l (x, xl) {
-	  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)
-	}
-
-	function getCarry (a, b) {
-	  return (a >>> 0) < (b >>> 0) ? 1 : 0
-	}
-
-	Sha512.prototype._update = function (M) {
-	  var W = this._w;
-
-	  var ah = this._ah | 0;
-	  var bh = this._bh | 0;
-	  var ch = this._ch | 0;
-	  var dh = this._dh | 0;
-	  var eh = this._eh | 0;
-	  var fh = this._fh | 0;
-	  var gh = this._gh | 0;
-	  var hh = this._hh | 0;
-
-	  var al = this._al | 0;
-	  var bl = this._bl | 0;
-	  var cl = this._cl | 0;
-	  var dl = this._dl | 0;
-	  var el = this._el | 0;
-	  var fl = this._fl | 0;
-	  var gl = this._gl | 0;
-	  var hl = this._hl | 0;
-
-	  for (var i = 0; i < 32; i += 2) {
-	    W[i] = M.readInt32BE(i * 4);
-	    W[i + 1] = M.readInt32BE(i * 4 + 4);
-	  }
-	  for (; i < 160; i += 2) {
-	    var xh = W[i - 15 * 2];
-	    var xl = W[i - 15 * 2 + 1];
-	    var gamma0 = Gamma0(xh, xl);
-	    var gamma0l = Gamma0l(xl, xh);
-
-	    xh = W[i - 2 * 2];
-	    xl = W[i - 2 * 2 + 1];
-	    var gamma1 = Gamma1(xh, xl);
-	    var gamma1l = Gamma1l(xl, xh);
-
-	    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
-	    var Wi7h = W[i - 7 * 2];
-	    var Wi7l = W[i - 7 * 2 + 1];
-
-	    var Wi16h = W[i - 16 * 2];
-	    var Wi16l = W[i - 16 * 2 + 1];
-
-	    var Wil = (gamma0l + Wi7l) | 0;
-	    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0;
-	    Wil = (Wil + gamma1l) | 0;
-	    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0;
-	    Wil = (Wil + Wi16l) | 0;
-	    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0;
-
-	    W[i] = Wih;
-	    W[i + 1] = Wil;
-	  }
-
-	  for (var j = 0; j < 160; j += 2) {
-	    Wih = W[j];
-	    Wil = W[j + 1];
-
-	    var majh = maj(ah, bh, ch);
-	    var majl = maj(al, bl, cl);
-
-	    var sigma0h = sigma0(ah, al);
-	    var sigma0l = sigma0(al, ah);
-	    var sigma1h = sigma1(eh, el);
-	    var sigma1l = sigma1(el, eh);
-
-	    // t1 = h + sigma1 + ch + K[j] + W[j]
-	    var Kih = K[j];
-	    var Kil = K[j + 1];
-
-	    var chh = Ch(eh, fh, gh);
-	    var chl = Ch(el, fl, gl);
-
-	    var t1l = (hl + sigma1l) | 0;
-	    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0;
-	    t1l = (t1l + chl) | 0;
-	    t1h = (t1h + chh + getCarry(t1l, chl)) | 0;
-	    t1l = (t1l + Kil) | 0;
-	    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0;
-	    t1l = (t1l + Wil) | 0;
-	    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0;
-
-	    // t2 = sigma0 + maj
-	    var t2l = (sigma0l + majl) | 0;
-	    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0;
-
-	    hh = gh;
-	    hl = gl;
-	    gh = fh;
-	    gl = fl;
-	    fh = eh;
-	    fl = el;
-	    el = (dl + t1l) | 0;
-	    eh = (dh + t1h + getCarry(el, dl)) | 0;
-	    dh = ch;
-	    dl = cl;
-	    ch = bh;
-	    cl = bl;
-	    bh = ah;
-	    bl = al;
-	    al = (t1l + t2l) | 0;
-	    ah = (t1h + t2h + getCarry(al, t1l)) | 0;
-	  }
-
-	  this._al = (this._al + al) | 0;
-	  this._bl = (this._bl + bl) | 0;
-	  this._cl = (this._cl + cl) | 0;
-	  this._dl = (this._dl + dl) | 0;
-	  this._el = (this._el + el) | 0;
-	  this._fl = (this._fl + fl) | 0;
-	  this._gl = (this._gl + gl) | 0;
-	  this._hl = (this._hl + hl) | 0;
-
-	  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0;
-	  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0;
-	  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0;
-	  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0;
-	  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0;
-	  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0;
-	  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0;
-	  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0;
-	};
-
-	Sha512.prototype._hash = function () {
-	  var H = Buffer.allocUnsafe(64);
-
-	  function writeInt64BE (h, l, offset) {
-	    H.writeInt32BE(h, offset);
-	    H.writeInt32BE(l, offset + 4);
-	  }
-
-	  writeInt64BE(this._ah, this._al, 0);
-	  writeInt64BE(this._bh, this._bl, 8);
-	  writeInt64BE(this._ch, this._cl, 16);
-	  writeInt64BE(this._dh, this._dl, 24);
-	  writeInt64BE(this._eh, this._el, 32);
-	  writeInt64BE(this._fh, this._fl, 40);
-	  writeInt64BE(this._gh, this._gl, 48);
-	  writeInt64BE(this._hh, this._hl, 56);
-
-	  return H
-	};
-
-	sha512$1 = Sha512;
-	return sha512$1;
-}
-
-var sha384$1;
-var hasRequiredSha384;
-
-function requireSha384 () {
-	if (hasRequiredSha384) return sha384$1;
-	hasRequiredSha384 = 1;
-	var inherits = requireInherits_browser();
-	var SHA512 = requireSha512();
-	var Hash = requireHash$1();
-	var Buffer = requireSafeBuffer$1().Buffer;
-
-	var W = new Array(160);
-
-	function Sha384 () {
-	  this.init();
-	  this._w = W;
-
-	  Hash.call(this, 128, 112);
-	}
-
-	inherits(Sha384, SHA512);
-
-	Sha384.prototype.init = function () {
-	  this._ah = 0xcbbb9d5d;
-	  this._bh = 0x629a292a;
-	  this._ch = 0x9159015a;
-	  this._dh = 0x152fecd8;
-	  this._eh = 0x67332667;
-	  this._fh = 0x8eb44a87;
-	  this._gh = 0xdb0c2e0d;
-	  this._hh = 0x47b5481d;
-
-	  this._al = 0xc1059ed8;
-	  this._bl = 0x367cd507;
-	  this._cl = 0x3070dd17;
-	  this._dl = 0xf70e5939;
-	  this._el = 0xffc00b31;
-	  this._fl = 0x68581511;
-	  this._gl = 0x64f98fa7;
-	  this._hl = 0xbefa4fa4;
-
-	  return this
-	};
-
-	Sha384.prototype._hash = function () {
-	  var H = Buffer.allocUnsafe(48);
-
-	  function writeInt64BE (h, l, offset) {
-	    H.writeInt32BE(h, offset);
-	    H.writeInt32BE(l, offset + 4);
-	  }
-
-	  writeInt64BE(this._ah, this._al, 0);
-	  writeInt64BE(this._bh, this._bl, 8);
-	  writeInt64BE(this._ch, this._cl, 16);
-	  writeInt64BE(this._dh, this._dl, 24);
-	  writeInt64BE(this._eh, this._el, 32);
-	  writeInt64BE(this._fh, this._fl, 40);
-
-	  return H
-	};
-
-	sha384$1 = Sha384;
-	return sha384$1;
-}
-
-var hasRequiredSha_js;
-
-function requireSha_js () {
-	if (hasRequiredSha_js) return sha_js.exports;
-	hasRequiredSha_js = 1;
-	var exports = sha_js.exports = function SHA (algorithm) {
-	  algorithm = algorithm.toLowerCase();
-
-	  var Algorithm = exports[algorithm];
-	  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')
-
-	  return new Algorithm()
-	};
-
-	exports.sha = requireSha$1();
-	exports.sha1 = requireSha1$1();
-	exports.sha224 = requireSha224();
-	exports.sha256 = requireSha256();
-	exports.sha384 = requireSha384();
-	exports.sha512 = requireSha512();
-	return sha_js.exports;
-}
-
-var cipherBase;
-var hasRequiredCipherBase;
-
-function requireCipherBase () {
-	if (hasRequiredCipherBase) return cipherBase;
-	hasRequiredCipherBase = 1;
-
-	var Buffer = requireSafeBuffer$1().Buffer;
-	var Transform = requireStreamBrowserify().Transform;
-	var StringDecoder = requireString_decoder().StringDecoder;
-	var inherits = requireInherits_browser();
-
-	function CipherBase(hashMode) {
-		Transform.call(this);
-		this.hashMode = typeof hashMode === 'string';
-		if (this.hashMode) {
-			this[hashMode] = this._finalOrDigest;
-		} else {
-			this['final'] = this._finalOrDigest;
-		}
-		if (this._final) {
-			this.__final = this._final;
-			this._final = null;
-		}
-		this._decoder = null;
-		this._encoding = null;
-	}
-	inherits(CipherBase, Transform);
-
-	var useUint8Array = typeof Uint8Array !== 'undefined';
-	var useArrayBuffer = typeof ArrayBuffer !== 'undefined'
-		&& typeof Uint8Array !== 'undefined'
-		&& ArrayBuffer.isView
-		&& (Buffer.prototype instanceof Uint8Array || Buffer.TYPED_ARRAY_SUPPORT);
-
-	function toBuffer(data, encoding) {
-		/*
-		 * No need to do anything for exact instance
-		 * This is only valid when safe-buffer.Buffer === buffer.Buffer, i.e. when Buffer.from/Buffer.alloc existed
-		 */
-		if (data instanceof Buffer) {
-			return data;
-		}
-
-		// Convert strings to Buffer
-		if (typeof data === 'string') {
-			return Buffer.from(data, encoding);
-		}
-
-		/*
-		 * Wrap any TypedArray instances and DataViews
-		 * Makes sense only on engines with full TypedArray support -- let Buffer detect that
-		 */
-		if (useArrayBuffer && ArrayBuffer.isView(data)) {
-			// Bug in Node.js <6.3.1, which treats this as out-of-bounds
-			if (data.byteLength === 0) {
-				return Buffer.alloc(0);
-			}
-
-			var res = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-			/*
-			 * Recheck result size, as offset/length doesn't work on Node.js <5.10
-			 * We just go to Uint8Array case if this fails
-			 */
-			if (res.byteLength === data.byteLength) {
-				return res;
-			}
-		}
-
-		/*
-		 * Uint8Array in engines where Buffer.from might not work with ArrayBuffer, just copy over
-		 * Doesn't make sense with other TypedArray instances
-		 */
-		if (useUint8Array && data instanceof Uint8Array) {
-			return Buffer.from(data);
-		}
-
-		/*
-		 * Old Buffer polyfill on an engine that doesn't have TypedArray support
-		 * Also, this is from a different Buffer polyfill implementation then we have, as instanceof check failed
-		 * Convert to our current Buffer implementation
-		 */
-		if (
-			Buffer.isBuffer(data)
-				&& data.constructor
-				&& typeof data.constructor.isBuffer === 'function'
-				&& data.constructor.isBuffer(data)
-		) {
-			return Buffer.from(data);
-		}
-
-		throw new TypeError('The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView.');
-	}
-
-	CipherBase.prototype.update = function (data, inputEnc, outputEnc) {
-		var bufferData = toBuffer(data, inputEnc); // asserts correct input type
-		var outData = this._update(bufferData);
-		if (this.hashMode) {
-			return this;
-		}
-
-		if (outputEnc) {
-			outData = this._toString(outData, outputEnc);
-		}
-
-		return outData;
-	};
-
-	CipherBase.prototype.setAutoPadding = function () {};
-	CipherBase.prototype.getAuthTag = function () {
-		throw new Error('trying to get auth tag in unsupported state');
-	};
-
-	CipherBase.prototype.setAuthTag = function () {
-		throw new Error('trying to set auth tag in unsupported state');
-	};
-
-	CipherBase.prototype.setAAD = function () {
-		throw new Error('trying to set aad in unsupported state');
-	};
-
-	CipherBase.prototype._transform = function (data, _, next) {
-		var err;
-		try {
-			if (this.hashMode) {
-				this._update(data);
-			} else {
-				this.push(this._update(data));
-			}
-		} catch (e) {
-			err = e;
-		} finally {
-			next(err);
-		}
-	};
-	CipherBase.prototype._flush = function (done) {
-		var err;
-		try {
-			this.push(this.__final());
-		} catch (e) {
-			err = e;
-		}
-
-		done(err);
-	};
-	CipherBase.prototype._finalOrDigest = function (outputEnc) {
-		var outData = this.__final() || Buffer.alloc(0);
-		if (outputEnc) {
-			outData = this._toString(outData, outputEnc, true);
-		}
-		return outData;
-	};
-
-	CipherBase.prototype._toString = function (value, enc, fin) {
-		if (!this._decoder) {
-			this._decoder = new StringDecoder(enc);
-			this._encoding = enc;
-		}
-
-		if (this._encoding !== enc) {
-			throw new Error('can’t switch encodings');
-		}
-
-		var out = this._decoder.write(value);
-		if (fin) {
-			out += this._decoder.end();
-		}
-
-		return out;
-	};
-
-	cipherBase = CipherBase;
-	return cipherBase;
-}
-
-var browser$a;
-var hasRequiredBrowser$a;
-
-function requireBrowser$a () {
-	if (hasRequiredBrowser$a) return browser$a;
-	hasRequiredBrowser$a = 1;
-	var inherits = requireInherits_browser();
-	var MD5 = requireMd5_js();
-	var RIPEMD160 = requireRipemd160();
-	var sha = requireSha_js();
-	var Base = requireCipherBase();
-
-	function Hash (hash) {
-	  Base.call(this, 'digest');
-
-	  this._hash = hash;
-	}
-
-	inherits(Hash, Base);
-
-	Hash.prototype._update = function (data) {
-	  this._hash.update(data);
-	};
-
-	Hash.prototype._final = function () {
-	  return this._hash.digest()
-	};
-
-	browser$a = function createHash (alg) {
-	  alg = alg.toLowerCase();
-	  if (alg === 'md5') return new MD5()
-	  if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()
-
-	  return new Hash(sha(alg))
-	};
-	return browser$a;
-}
-
-var legacy;
-var hasRequiredLegacy;
-
-function requireLegacy () {
-	if (hasRequiredLegacy) return legacy;
-	hasRequiredLegacy = 1;
-	var inherits = requireInherits_browser();
-	var Buffer = requireSafeBuffer$1().Buffer;
-
-	var Base = requireCipherBase();
-
-	var ZEROS = Buffer.alloc(128);
-	var blocksize = 64;
-
-	function Hmac (alg, key) {
-	  Base.call(this, 'digest');
-	  if (typeof key === 'string') {
-	    key = Buffer.from(key);
-	  }
-
-	  this._alg = alg;
-	  this._key = key;
-
-	  if (key.length > blocksize) {
-	    key = alg(key);
-	  } else if (key.length < blocksize) {
-	    key = Buffer.concat([key, ZEROS], blocksize);
-	  }
-
-	  var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
-	  var opad = this._opad = Buffer.allocUnsafe(blocksize);
-
-	  for (var i = 0; i < blocksize; i++) {
-	    ipad[i] = key[i] ^ 0x36;
-	    opad[i] = key[i] ^ 0x5C;
-	  }
-
-	  this._hash = [ipad];
-	}
-
-	inherits(Hmac, Base);
-
-	Hmac.prototype._update = function (data) {
-	  this._hash.push(data);
-	};
-
-	Hmac.prototype._final = function () {
-	  var h = this._alg(Buffer.concat(this._hash));
-	  return this._alg(Buffer.concat([this._opad, h]))
-	};
-	legacy = Hmac;
-	return legacy;
-}
-
-var md5$1;
-var hasRequiredMd5$1;
-
-function requireMd5$1 () {
-	if (hasRequiredMd5$1) return md5$1;
-	hasRequiredMd5$1 = 1;
-	var MD5 = requireMd5_js();
-
-	md5$1 = function (buffer) {
-	  return new MD5().update(buffer).digest()
-	};
-	return md5$1;
-}
-
-var browser$9;
-var hasRequiredBrowser$9;
-
-function requireBrowser$9 () {
-	if (hasRequiredBrowser$9) return browser$9;
-	hasRequiredBrowser$9 = 1;
-	var inherits = requireInherits_browser();
-	var Legacy = requireLegacy();
-	var Base = requireCipherBase();
-	var Buffer = requireSafeBuffer$1().Buffer;
-	var md5 = requireMd5$1();
-	var RIPEMD160 = requireRipemd160();
-
-	var sha = requireSha_js();
-
-	var ZEROS = Buffer.alloc(128);
-
-	function Hmac (alg, key) {
-	  Base.call(this, 'digest');
-	  if (typeof key === 'string') {
-	    key = Buffer.from(key);
-	  }
-
-	  var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64;
-
-	  this._alg = alg;
-	  this._key = key;
-	  if (key.length > blocksize) {
-	    var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg);
-	    key = hash.update(key).digest();
-	  } else if (key.length < blocksize) {
-	    key = Buffer.concat([key, ZEROS], blocksize);
-	  }
-
-	  var ipad = this._ipad = Buffer.allocUnsafe(blocksize);
-	  var opad = this._opad = Buffer.allocUnsafe(blocksize);
-
-	  for (var i = 0; i < blocksize; i++) {
-	    ipad[i] = key[i] ^ 0x36;
-	    opad[i] = key[i] ^ 0x5C;
-	  }
-	  this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg);
-	  this._hash.update(ipad);
-	}
-
-	inherits(Hmac, Base);
-
-	Hmac.prototype._update = function (data) {
-	  this._hash.update(data);
-	};
-
-	Hmac.prototype._final = function () {
-	  var h = this._hash.digest();
-	  var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg);
-	  return hash.update(this._opad).update(h).digest()
-	};
-
-	browser$9 = function createHmac (alg, key) {
-	  alg = alg.toLowerCase();
-	  if (alg === 'rmd160' || alg === 'ripemd160') {
-	    return new Hmac('rmd160', key)
-	  }
-	  if (alg === 'md5') {
-	    return new Legacy(md5, key)
-	  }
-	  return new Hmac(alg, key)
-	};
-	return browser$9;
-}
-
-const sha224WithRSAEncryption = {"sign":"rsa","hash":"sha224","id":"302d300d06096086480165030402040500041c"};
-const sha256WithRSAEncryption = {"sign":"rsa","hash":"sha256","id":"3031300d060960864801650304020105000420"};
-const sha384WithRSAEncryption = {"sign":"rsa","hash":"sha384","id":"3041300d060960864801650304020205000430"};
-const sha512WithRSAEncryption = {"sign":"rsa","hash":"sha512","id":"3051300d060960864801650304020305000440"};
-const sha256 = {"sign":"ecdsa","hash":"sha256","id":""};
-const sha224 = {"sign":"ecdsa","hash":"sha224","id":""};
-const sha384 = {"sign":"ecdsa","hash":"sha384","id":""};
-const sha512 = {"sign":"ecdsa","hash":"sha512","id":""};
-const DSA = {"sign":"dsa","hash":"sha1","id":""};
-const ripemd160WithRSA = {"sign":"rsa","hash":"rmd160","id":"3021300906052b2403020105000414"};
-const md5WithRSAEncryption = {"sign":"rsa","hash":"md5","id":"3020300c06082a864886f70d020505000410"};
-const require$$6 = {
-  sha224WithRSAEncryption,
-  "RSA-SHA224": {"sign":"ecdsa/rsa","hash":"sha224","id":"302d300d06096086480165030402040500041c"},
-  sha256WithRSAEncryption,
-  "RSA-SHA256": {"sign":"ecdsa/rsa","hash":"sha256","id":"3031300d060960864801650304020105000420"},
-  sha384WithRSAEncryption,
-  "RSA-SHA384": {"sign":"ecdsa/rsa","hash":"sha384","id":"3041300d060960864801650304020205000430"},
-  sha512WithRSAEncryption,
-  "RSA-SHA512": {"sign":"ecdsa/rsa","hash":"sha512","id":"3051300d060960864801650304020305000440"},
-  "RSA-SHA1": {"sign":"rsa","hash":"sha1","id":"3021300906052b0e03021a05000414"},
-  "ecdsa-with-SHA1": {"sign":"ecdsa","hash":"sha1","id":""},
-  sha256,
-  sha224,
-  sha384,
-  sha512,
-  "DSA-SHA": {"sign":"dsa","hash":"sha1","id":""},
-  "DSA-SHA1": {"sign":"dsa","hash":"sha1","id":""},
-  DSA,
-  "DSA-WITH-SHA224": {"sign":"dsa","hash":"sha224","id":""},
-  "DSA-SHA224": {"sign":"dsa","hash":"sha224","id":""},
-  "DSA-WITH-SHA256": {"sign":"dsa","hash":"sha256","id":""},
-  "DSA-SHA256": {"sign":"dsa","hash":"sha256","id":""},
-  "DSA-WITH-SHA384": {"sign":"dsa","hash":"sha384","id":""},
-  "DSA-SHA384": {"sign":"dsa","hash":"sha384","id":""},
-  "DSA-WITH-SHA512": {"sign":"dsa","hash":"sha512","id":""},
-  "DSA-SHA512": {"sign":"dsa","hash":"sha512","id":""},
-  "DSA-RIPEMD160": {"sign":"dsa","hash":"rmd160","id":""},
-  ripemd160WithRSA,
-  "RSA-RIPEMD160": {"sign":"rsa","hash":"rmd160","id":"3021300906052b2403020105000414"},
-  md5WithRSAEncryption,
-  "RSA-MD5": {"sign":"rsa","hash":"md5","id":"3020300c06082a864886f70d020505000410"},
-};
-
-var algos;
-var hasRequiredAlgos;
-
-function requireAlgos () {
-	if (hasRequiredAlgos) return algos;
-	hasRequiredAlgos = 1;
-
-	algos = require$$6;
-	return algos;
-}
-
-var browser$8 = {};
-
-var precondition;
-var hasRequiredPrecondition;
-
-function requirePrecondition () {
-	if (hasRequiredPrecondition) return precondition;
-	hasRequiredPrecondition = 1;
-
-	var MAX_ALLOC = Math.pow(2, 30) - 1; // default in iojs
-
-	precondition = function (iterations, keylen) {
-		if (typeof iterations !== 'number') {
-			throw new TypeError('Iterations not a number');
-		}
-
-		if (iterations < 0) {
-			throw new TypeError('Bad iterations');
-		}
-
-		if (typeof keylen !== 'number') {
-			throw new TypeError('Key length not a number');
-		}
-
-		if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) { /* eslint no-self-compare: 0 */
-			throw new TypeError('Bad key length');
-		}
-	};
-	return precondition;
-}
-
-var defaultEncoding_1;
-var hasRequiredDefaultEncoding;
-
-function requireDefaultEncoding () {
-	if (hasRequiredDefaultEncoding) return defaultEncoding_1;
-	hasRequiredDefaultEncoding = 1;
-	var defaultEncoding;
-	if (globalThis.process && globalThis.process.browser) {
-	  defaultEncoding = "utf-8";
-	} else if (globalThis.process && globalThis.process.version) {
-	  var pVersionMajor = parseInt(process$1.version.split(".")[0].slice(1), 10);
-	  defaultEncoding = pVersionMajor >= 6 ? "utf-8" : "binary";
-	} else {
-	  defaultEncoding = "utf-8";
-	}
-	defaultEncoding_1 = defaultEncoding;
-	return defaultEncoding_1;
-}
-
 var makeHash;
 var hasRequiredMakeHash;
 
@@ -48542,6 +48323,396 @@ function requireMd5 () {
 	return md5;
 }
 
+var hashBase;
+var hasRequiredHashBase;
+
+function requireHashBase () {
+	if (hasRequiredHashBase) return hashBase;
+	hasRequiredHashBase = 1;
+	var Transform = requireStreamBrowserify().Transform;
+	var inherits = requireInherits_browser();
+
+	function HashBase (blockSize) {
+	  Transform.call(this);
+
+	  this._block = new Buffer(blockSize);
+	  this._blockSize = blockSize;
+	  this._blockOffset = 0;
+	  this._length = [0, 0, 0, 0];
+
+	  this._finalized = false;
+	}
+
+	inherits(HashBase, Transform);
+
+	HashBase.prototype._transform = function (chunk, encoding, callback) {
+	  var error = null;
+	  try {
+	    if (encoding !== 'buffer') chunk = new Buffer(chunk, encoding);
+	    this.update(chunk);
+	  } catch (err) {
+	    error = err;
+	  }
+
+	  callback(error);
+	};
+
+	HashBase.prototype._flush = function (callback) {
+	  var error = null;
+	  try {
+	    this.push(this._digest());
+	  } catch (err) {
+	    error = err;
+	  }
+
+	  callback(error);
+	};
+
+	HashBase.prototype.update = function (data, encoding) {
+	  if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer')
+	  if (this._finalized) throw new Error('Digest already called')
+	  if (!Buffer.isBuffer(data)) data = new Buffer(data, encoding || 'binary');
+
+	  // consume data
+	  var block = this._block;
+	  var offset = 0;
+	  while (this._blockOffset + data.length - offset >= this._blockSize) {
+	    for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++];
+	    this._update();
+	    this._blockOffset = 0;
+	  }
+	  while (offset < data.length) block[this._blockOffset++] = data[offset++];
+
+	  // update length
+	  for (var j = 0, carry = data.length * 8; carry > 0; ++j) {
+	    this._length[j] += carry;
+	    carry = (this._length[j] / 0x0100000000) | 0;
+	    if (carry > 0) this._length[j] -= 0x0100000000 * carry;
+	  }
+
+	  return this
+	};
+
+	HashBase.prototype._update = function (data) {
+	  throw new Error('_update is not implemented')
+	};
+
+	HashBase.prototype.digest = function (encoding) {
+	  if (this._finalized) throw new Error('Digest already called')
+	  this._finalized = true;
+
+	  var digest = this._digest();
+	  if (encoding !== undefined) digest = digest.toString(encoding);
+	  return digest
+	};
+
+	HashBase.prototype._digest = function () {
+	  throw new Error('_digest is not implemented')
+	};
+
+	hashBase = HashBase;
+	return hashBase;
+}
+
+var ripemd160;
+var hasRequiredRipemd160;
+
+function requireRipemd160 () {
+	if (hasRequiredRipemd160) return ripemd160;
+	hasRequiredRipemd160 = 1;
+	var inherits = requireInherits_browser();
+	var HashBase = requireHashBase();
+
+	function RIPEMD160 () {
+	  HashBase.call(this, 64);
+
+	  // state
+	  this._a = 0x67452301;
+	  this._b = 0xefcdab89;
+	  this._c = 0x98badcfe;
+	  this._d = 0x10325476;
+	  this._e = 0xc3d2e1f0;
+	}
+
+	inherits(RIPEMD160, HashBase);
+
+	RIPEMD160.prototype._update = function () {
+	  var m = new Array(16);
+	  for (var i = 0; i < 16; ++i) m[i] = this._block.readInt32LE(i * 4);
+
+	  var al = this._a;
+	  var bl = this._b;
+	  var cl = this._c;
+	  var dl = this._d;
+	  var el = this._e;
+
+	  // Mj = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
+	  // K = 0x00000000
+	  // Sj = 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8
+	  al = fn1(al, bl, cl, dl, el, m[0], 0x00000000, 11); cl = rotl(cl, 10);
+	  el = fn1(el, al, bl, cl, dl, m[1], 0x00000000, 14); bl = rotl(bl, 10);
+	  dl = fn1(dl, el, al, bl, cl, m[2], 0x00000000, 15); al = rotl(al, 10);
+	  cl = fn1(cl, dl, el, al, bl, m[3], 0x00000000, 12); el = rotl(el, 10);
+	  bl = fn1(bl, cl, dl, el, al, m[4], 0x00000000, 5); dl = rotl(dl, 10);
+	  al = fn1(al, bl, cl, dl, el, m[5], 0x00000000, 8); cl = rotl(cl, 10);
+	  el = fn1(el, al, bl, cl, dl, m[6], 0x00000000, 7); bl = rotl(bl, 10);
+	  dl = fn1(dl, el, al, bl, cl, m[7], 0x00000000, 9); al = rotl(al, 10);
+	  cl = fn1(cl, dl, el, al, bl, m[8], 0x00000000, 11); el = rotl(el, 10);
+	  bl = fn1(bl, cl, dl, el, al, m[9], 0x00000000, 13); dl = rotl(dl, 10);
+	  al = fn1(al, bl, cl, dl, el, m[10], 0x00000000, 14); cl = rotl(cl, 10);
+	  el = fn1(el, al, bl, cl, dl, m[11], 0x00000000, 15); bl = rotl(bl, 10);
+	  dl = fn1(dl, el, al, bl, cl, m[12], 0x00000000, 6); al = rotl(al, 10);
+	  cl = fn1(cl, dl, el, al, bl, m[13], 0x00000000, 7); el = rotl(el, 10);
+	  bl = fn1(bl, cl, dl, el, al, m[14], 0x00000000, 9); dl = rotl(dl, 10);
+	  al = fn1(al, bl, cl, dl, el, m[15], 0x00000000, 8); cl = rotl(cl, 10);
+
+	  // Mj = 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8
+	  // K = 0x5a827999
+	  // Sj = 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12
+	  el = fn2(el, al, bl, cl, dl, m[7], 0x5a827999, 7); bl = rotl(bl, 10);
+	  dl = fn2(dl, el, al, bl, cl, m[4], 0x5a827999, 6); al = rotl(al, 10);
+	  cl = fn2(cl, dl, el, al, bl, m[13], 0x5a827999, 8); el = rotl(el, 10);
+	  bl = fn2(bl, cl, dl, el, al, m[1], 0x5a827999, 13); dl = rotl(dl, 10);
+	  al = fn2(al, bl, cl, dl, el, m[10], 0x5a827999, 11); cl = rotl(cl, 10);
+	  el = fn2(el, al, bl, cl, dl, m[6], 0x5a827999, 9); bl = rotl(bl, 10);
+	  dl = fn2(dl, el, al, bl, cl, m[15], 0x5a827999, 7); al = rotl(al, 10);
+	  cl = fn2(cl, dl, el, al, bl, m[3], 0x5a827999, 15); el = rotl(el, 10);
+	  bl = fn2(bl, cl, dl, el, al, m[12], 0x5a827999, 7); dl = rotl(dl, 10);
+	  al = fn2(al, bl, cl, dl, el, m[0], 0x5a827999, 12); cl = rotl(cl, 10);
+	  el = fn2(el, al, bl, cl, dl, m[9], 0x5a827999, 15); bl = rotl(bl, 10);
+	  dl = fn2(dl, el, al, bl, cl, m[5], 0x5a827999, 9); al = rotl(al, 10);
+	  cl = fn2(cl, dl, el, al, bl, m[2], 0x5a827999, 11); el = rotl(el, 10);
+	  bl = fn2(bl, cl, dl, el, al, m[14], 0x5a827999, 7); dl = rotl(dl, 10);
+	  al = fn2(al, bl, cl, dl, el, m[11], 0x5a827999, 13); cl = rotl(cl, 10);
+	  el = fn2(el, al, bl, cl, dl, m[8], 0x5a827999, 12); bl = rotl(bl, 10);
+
+	  // Mj = 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12
+	  // K = 0x6ed9eba1
+	  // Sj = 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5
+	  dl = fn3(dl, el, al, bl, cl, m[3], 0x6ed9eba1, 11); al = rotl(al, 10);
+	  cl = fn3(cl, dl, el, al, bl, m[10], 0x6ed9eba1, 13); el = rotl(el, 10);
+	  bl = fn3(bl, cl, dl, el, al, m[14], 0x6ed9eba1, 6); dl = rotl(dl, 10);
+	  al = fn3(al, bl, cl, dl, el, m[4], 0x6ed9eba1, 7); cl = rotl(cl, 10);
+	  el = fn3(el, al, bl, cl, dl, m[9], 0x6ed9eba1, 14); bl = rotl(bl, 10);
+	  dl = fn3(dl, el, al, bl, cl, m[15], 0x6ed9eba1, 9); al = rotl(al, 10);
+	  cl = fn3(cl, dl, el, al, bl, m[8], 0x6ed9eba1, 13); el = rotl(el, 10);
+	  bl = fn3(bl, cl, dl, el, al, m[1], 0x6ed9eba1, 15); dl = rotl(dl, 10);
+	  al = fn3(al, bl, cl, dl, el, m[2], 0x6ed9eba1, 14); cl = rotl(cl, 10);
+	  el = fn3(el, al, bl, cl, dl, m[7], 0x6ed9eba1, 8); bl = rotl(bl, 10);
+	  dl = fn3(dl, el, al, bl, cl, m[0], 0x6ed9eba1, 13); al = rotl(al, 10);
+	  cl = fn3(cl, dl, el, al, bl, m[6], 0x6ed9eba1, 6); el = rotl(el, 10);
+	  bl = fn3(bl, cl, dl, el, al, m[13], 0x6ed9eba1, 5); dl = rotl(dl, 10);
+	  al = fn3(al, bl, cl, dl, el, m[11], 0x6ed9eba1, 12); cl = rotl(cl, 10);
+	  el = fn3(el, al, bl, cl, dl, m[5], 0x6ed9eba1, 7); bl = rotl(bl, 10);
+	  dl = fn3(dl, el, al, bl, cl, m[12], 0x6ed9eba1, 5); al = rotl(al, 10);
+
+	  // Mj = 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2
+	  // K = 0x8f1bbcdc
+	  // Sj = 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12
+	  cl = fn4(cl, dl, el, al, bl, m[1], 0x8f1bbcdc, 11); el = rotl(el, 10);
+	  bl = fn4(bl, cl, dl, el, al, m[9], 0x8f1bbcdc, 12); dl = rotl(dl, 10);
+	  al = fn4(al, bl, cl, dl, el, m[11], 0x8f1bbcdc, 14); cl = rotl(cl, 10);
+	  el = fn4(el, al, bl, cl, dl, m[10], 0x8f1bbcdc, 15); bl = rotl(bl, 10);
+	  dl = fn4(dl, el, al, bl, cl, m[0], 0x8f1bbcdc, 14); al = rotl(al, 10);
+	  cl = fn4(cl, dl, el, al, bl, m[8], 0x8f1bbcdc, 15); el = rotl(el, 10);
+	  bl = fn4(bl, cl, dl, el, al, m[12], 0x8f1bbcdc, 9); dl = rotl(dl, 10);
+	  al = fn4(al, bl, cl, dl, el, m[4], 0x8f1bbcdc, 8); cl = rotl(cl, 10);
+	  el = fn4(el, al, bl, cl, dl, m[13], 0x8f1bbcdc, 9); bl = rotl(bl, 10);
+	  dl = fn4(dl, el, al, bl, cl, m[3], 0x8f1bbcdc, 14); al = rotl(al, 10);
+	  cl = fn4(cl, dl, el, al, bl, m[7], 0x8f1bbcdc, 5); el = rotl(el, 10);
+	  bl = fn4(bl, cl, dl, el, al, m[15], 0x8f1bbcdc, 6); dl = rotl(dl, 10);
+	  al = fn4(al, bl, cl, dl, el, m[14], 0x8f1bbcdc, 8); cl = rotl(cl, 10);
+	  el = fn4(el, al, bl, cl, dl, m[5], 0x8f1bbcdc, 6); bl = rotl(bl, 10);
+	  dl = fn4(dl, el, al, bl, cl, m[6], 0x8f1bbcdc, 5); al = rotl(al, 10);
+	  cl = fn4(cl, dl, el, al, bl, m[2], 0x8f1bbcdc, 12); el = rotl(el, 10);
+
+	  // Mj = 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
+	  // K = 0xa953fd4e
+	  // Sj = 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
+	  bl = fn5(bl, cl, dl, el, al, m[4], 0xa953fd4e, 9); dl = rotl(dl, 10);
+	  al = fn5(al, bl, cl, dl, el, m[0], 0xa953fd4e, 15); cl = rotl(cl, 10);
+	  el = fn5(el, al, bl, cl, dl, m[5], 0xa953fd4e, 5); bl = rotl(bl, 10);
+	  dl = fn5(dl, el, al, bl, cl, m[9], 0xa953fd4e, 11); al = rotl(al, 10);
+	  cl = fn5(cl, dl, el, al, bl, m[7], 0xa953fd4e, 6); el = rotl(el, 10);
+	  bl = fn5(bl, cl, dl, el, al, m[12], 0xa953fd4e, 8); dl = rotl(dl, 10);
+	  al = fn5(al, bl, cl, dl, el, m[2], 0xa953fd4e, 13); cl = rotl(cl, 10);
+	  el = fn5(el, al, bl, cl, dl, m[10], 0xa953fd4e, 12); bl = rotl(bl, 10);
+	  dl = fn5(dl, el, al, bl, cl, m[14], 0xa953fd4e, 5); al = rotl(al, 10);
+	  cl = fn5(cl, dl, el, al, bl, m[1], 0xa953fd4e, 12); el = rotl(el, 10);
+	  bl = fn5(bl, cl, dl, el, al, m[3], 0xa953fd4e, 13); dl = rotl(dl, 10);
+	  al = fn5(al, bl, cl, dl, el, m[8], 0xa953fd4e, 14); cl = rotl(cl, 10);
+	  el = fn5(el, al, bl, cl, dl, m[11], 0xa953fd4e, 11); bl = rotl(bl, 10);
+	  dl = fn5(dl, el, al, bl, cl, m[6], 0xa953fd4e, 8); al = rotl(al, 10);
+	  cl = fn5(cl, dl, el, al, bl, m[15], 0xa953fd4e, 5); el = rotl(el, 10);
+	  bl = fn5(bl, cl, dl, el, al, m[13], 0xa953fd4e, 6); dl = rotl(dl, 10);
+
+	  var ar = this._a;
+	  var br = this._b;
+	  var cr = this._c;
+	  var dr = this._d;
+	  var er = this._e;
+
+	  // M'j = 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12
+	  // K' = 0x50a28be6
+	  // S'j = 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6
+	  ar = fn5(ar, br, cr, dr, er, m[5], 0x50a28be6, 8); cr = rotl(cr, 10);
+	  er = fn5(er, ar, br, cr, dr, m[14], 0x50a28be6, 9); br = rotl(br, 10);
+	  dr = fn5(dr, er, ar, br, cr, m[7], 0x50a28be6, 9); ar = rotl(ar, 10);
+	  cr = fn5(cr, dr, er, ar, br, m[0], 0x50a28be6, 11); er = rotl(er, 10);
+	  br = fn5(br, cr, dr, er, ar, m[9], 0x50a28be6, 13); dr = rotl(dr, 10);
+	  ar = fn5(ar, br, cr, dr, er, m[2], 0x50a28be6, 15); cr = rotl(cr, 10);
+	  er = fn5(er, ar, br, cr, dr, m[11], 0x50a28be6, 15); br = rotl(br, 10);
+	  dr = fn5(dr, er, ar, br, cr, m[4], 0x50a28be6, 5); ar = rotl(ar, 10);
+	  cr = fn5(cr, dr, er, ar, br, m[13], 0x50a28be6, 7); er = rotl(er, 10);
+	  br = fn5(br, cr, dr, er, ar, m[6], 0x50a28be6, 7); dr = rotl(dr, 10);
+	  ar = fn5(ar, br, cr, dr, er, m[15], 0x50a28be6, 8); cr = rotl(cr, 10);
+	  er = fn5(er, ar, br, cr, dr, m[8], 0x50a28be6, 11); br = rotl(br, 10);
+	  dr = fn5(dr, er, ar, br, cr, m[1], 0x50a28be6, 14); ar = rotl(ar, 10);
+	  cr = fn5(cr, dr, er, ar, br, m[10], 0x50a28be6, 14); er = rotl(er, 10);
+	  br = fn5(br, cr, dr, er, ar, m[3], 0x50a28be6, 12); dr = rotl(dr, 10);
+	  ar = fn5(ar, br, cr, dr, er, m[12], 0x50a28be6, 6); cr = rotl(cr, 10);
+
+	  // M'j = 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2
+	  // K' = 0x5c4dd124
+	  // S'j = 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11
+	  er = fn4(er, ar, br, cr, dr, m[6], 0x5c4dd124, 9); br = rotl(br, 10);
+	  dr = fn4(dr, er, ar, br, cr, m[11], 0x5c4dd124, 13); ar = rotl(ar, 10);
+	  cr = fn4(cr, dr, er, ar, br, m[3], 0x5c4dd124, 15); er = rotl(er, 10);
+	  br = fn4(br, cr, dr, er, ar, m[7], 0x5c4dd124, 7); dr = rotl(dr, 10);
+	  ar = fn4(ar, br, cr, dr, er, m[0], 0x5c4dd124, 12); cr = rotl(cr, 10);
+	  er = fn4(er, ar, br, cr, dr, m[13], 0x5c4dd124, 8); br = rotl(br, 10);
+	  dr = fn4(dr, er, ar, br, cr, m[5], 0x5c4dd124, 9); ar = rotl(ar, 10);
+	  cr = fn4(cr, dr, er, ar, br, m[10], 0x5c4dd124, 11); er = rotl(er, 10);
+	  br = fn4(br, cr, dr, er, ar, m[14], 0x5c4dd124, 7); dr = rotl(dr, 10);
+	  ar = fn4(ar, br, cr, dr, er, m[15], 0x5c4dd124, 7); cr = rotl(cr, 10);
+	  er = fn4(er, ar, br, cr, dr, m[8], 0x5c4dd124, 12); br = rotl(br, 10);
+	  dr = fn4(dr, er, ar, br, cr, m[12], 0x5c4dd124, 7); ar = rotl(ar, 10);
+	  cr = fn4(cr, dr, er, ar, br, m[4], 0x5c4dd124, 6); er = rotl(er, 10);
+	  br = fn4(br, cr, dr, er, ar, m[9], 0x5c4dd124, 15); dr = rotl(dr, 10);
+	  ar = fn4(ar, br, cr, dr, er, m[1], 0x5c4dd124, 13); cr = rotl(cr, 10);
+	  er = fn4(er, ar, br, cr, dr, m[2], 0x5c4dd124, 11); br = rotl(br, 10);
+
+	  // M'j = 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13
+	  // K' = 0x6d703ef3
+	  // S'j = 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5
+	  dr = fn3(dr, er, ar, br, cr, m[15], 0x6d703ef3, 9); ar = rotl(ar, 10);
+	  cr = fn3(cr, dr, er, ar, br, m[5], 0x6d703ef3, 7); er = rotl(er, 10);
+	  br = fn3(br, cr, dr, er, ar, m[1], 0x6d703ef3, 15); dr = rotl(dr, 10);
+	  ar = fn3(ar, br, cr, dr, er, m[3], 0x6d703ef3, 11); cr = rotl(cr, 10);
+	  er = fn3(er, ar, br, cr, dr, m[7], 0x6d703ef3, 8); br = rotl(br, 10);
+	  dr = fn3(dr, er, ar, br, cr, m[14], 0x6d703ef3, 6); ar = rotl(ar, 10);
+	  cr = fn3(cr, dr, er, ar, br, m[6], 0x6d703ef3, 6); er = rotl(er, 10);
+	  br = fn3(br, cr, dr, er, ar, m[9], 0x6d703ef3, 14); dr = rotl(dr, 10);
+	  ar = fn3(ar, br, cr, dr, er, m[11], 0x6d703ef3, 12); cr = rotl(cr, 10);
+	  er = fn3(er, ar, br, cr, dr, m[8], 0x6d703ef3, 13); br = rotl(br, 10);
+	  dr = fn3(dr, er, ar, br, cr, m[12], 0x6d703ef3, 5); ar = rotl(ar, 10);
+	  cr = fn3(cr, dr, er, ar, br, m[2], 0x6d703ef3, 14); er = rotl(er, 10);
+	  br = fn3(br, cr, dr, er, ar, m[10], 0x6d703ef3, 13); dr = rotl(dr, 10);
+	  ar = fn3(ar, br, cr, dr, er, m[0], 0x6d703ef3, 13); cr = rotl(cr, 10);
+	  er = fn3(er, ar, br, cr, dr, m[4], 0x6d703ef3, 7); br = rotl(br, 10);
+	  dr = fn3(dr, er, ar, br, cr, m[13], 0x6d703ef3, 5); ar = rotl(ar, 10);
+
+	  // M'j = 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14
+	  // K' = 0x7a6d76e9
+	  // S'j = 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8
+	  cr = fn2(cr, dr, er, ar, br, m[8], 0x7a6d76e9, 15); er = rotl(er, 10);
+	  br = fn2(br, cr, dr, er, ar, m[6], 0x7a6d76e9, 5); dr = rotl(dr, 10);
+	  ar = fn2(ar, br, cr, dr, er, m[4], 0x7a6d76e9, 8); cr = rotl(cr, 10);
+	  er = fn2(er, ar, br, cr, dr, m[1], 0x7a6d76e9, 11); br = rotl(br, 10);
+	  dr = fn2(dr, er, ar, br, cr, m[3], 0x7a6d76e9, 14); ar = rotl(ar, 10);
+	  cr = fn2(cr, dr, er, ar, br, m[11], 0x7a6d76e9, 14); er = rotl(er, 10);
+	  br = fn2(br, cr, dr, er, ar, m[15], 0x7a6d76e9, 6); dr = rotl(dr, 10);
+	  ar = fn2(ar, br, cr, dr, er, m[0], 0x7a6d76e9, 14); cr = rotl(cr, 10);
+	  er = fn2(er, ar, br, cr, dr, m[5], 0x7a6d76e9, 6); br = rotl(br, 10);
+	  dr = fn2(dr, er, ar, br, cr, m[12], 0x7a6d76e9, 9); ar = rotl(ar, 10);
+	  cr = fn2(cr, dr, er, ar, br, m[2], 0x7a6d76e9, 12); er = rotl(er, 10);
+	  br = fn2(br, cr, dr, er, ar, m[13], 0x7a6d76e9, 9); dr = rotl(dr, 10);
+	  ar = fn2(ar, br, cr, dr, er, m[9], 0x7a6d76e9, 12); cr = rotl(cr, 10);
+	  er = fn2(er, ar, br, cr, dr, m[7], 0x7a6d76e9, 5); br = rotl(br, 10);
+	  dr = fn2(dr, er, ar, br, cr, m[10], 0x7a6d76e9, 15); ar = rotl(ar, 10);
+	  cr = fn2(cr, dr, er, ar, br, m[14], 0x7a6d76e9, 8); er = rotl(er, 10);
+
+	  // M'j = 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
+	  // K' = 0x00000000
+	  // S'j = 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
+	  br = fn1(br, cr, dr, er, ar, m[12], 0x00000000, 8); dr = rotl(dr, 10);
+	  ar = fn1(ar, br, cr, dr, er, m[15], 0x00000000, 5); cr = rotl(cr, 10);
+	  er = fn1(er, ar, br, cr, dr, m[10], 0x00000000, 12); br = rotl(br, 10);
+	  dr = fn1(dr, er, ar, br, cr, m[4], 0x00000000, 9); ar = rotl(ar, 10);
+	  cr = fn1(cr, dr, er, ar, br, m[1], 0x00000000, 12); er = rotl(er, 10);
+	  br = fn1(br, cr, dr, er, ar, m[5], 0x00000000, 5); dr = rotl(dr, 10);
+	  ar = fn1(ar, br, cr, dr, er, m[8], 0x00000000, 14); cr = rotl(cr, 10);
+	  er = fn1(er, ar, br, cr, dr, m[7], 0x00000000, 6); br = rotl(br, 10);
+	  dr = fn1(dr, er, ar, br, cr, m[6], 0x00000000, 8); ar = rotl(ar, 10);
+	  cr = fn1(cr, dr, er, ar, br, m[2], 0x00000000, 13); er = rotl(er, 10);
+	  br = fn1(br, cr, dr, er, ar, m[13], 0x00000000, 6); dr = rotl(dr, 10);
+	  ar = fn1(ar, br, cr, dr, er, m[14], 0x00000000, 5); cr = rotl(cr, 10);
+	  er = fn1(er, ar, br, cr, dr, m[0], 0x00000000, 15); br = rotl(br, 10);
+	  dr = fn1(dr, er, ar, br, cr, m[3], 0x00000000, 13); ar = rotl(ar, 10);
+	  cr = fn1(cr, dr, er, ar, br, m[9], 0x00000000, 11); er = rotl(er, 10);
+	  br = fn1(br, cr, dr, er, ar, m[11], 0x00000000, 11); dr = rotl(dr, 10);
+
+	  // change state
+	  var t = (this._b + cl + dr) | 0;
+	  this._b = (this._c + dl + er) | 0;
+	  this._c = (this._d + el + ar) | 0;
+	  this._d = (this._e + al + br) | 0;
+	  this._e = (this._a + bl + cr) | 0;
+	  this._a = t;
+	};
+
+	RIPEMD160.prototype._digest = function () {
+	  // create padding and handle blocks
+	  this._block[this._blockOffset++] = 0x80;
+	  if (this._blockOffset > 56) {
+	    this._block.fill(0, this._blockOffset, 64);
+	    this._update();
+	    this._blockOffset = 0;
+	  }
+
+	  this._block.fill(0, this._blockOffset, 56);
+	  this._block.writeUInt32LE(this._length[0], 56);
+	  this._block.writeUInt32LE(this._length[1], 60);
+	  this._update();
+
+	  // produce result
+	  var buffer = new Buffer(20);
+	  buffer.writeInt32LE(this._a, 0);
+	  buffer.writeInt32LE(this._b, 4);
+	  buffer.writeInt32LE(this._c, 8);
+	  buffer.writeInt32LE(this._d, 12);
+	  buffer.writeInt32LE(this._e, 16);
+	  return buffer
+	};
+
+	function rotl (x, n) {
+	  return (x << n) | (x >>> (32 - n))
+	}
+
+	function fn1 (a, b, c, d, e, m, k, s) {
+	  return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0
+	}
+
+	function fn2 (a, b, c, d, e, m, k, s) {
+	  return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0
+	}
+
+	function fn3 (a, b, c, d, e, m, k, s) {
+	  return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0
+	}
+
+	function fn4 (a, b, c, d, e, m, k, s) {
+	  return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0
+	}
+
+	function fn5 (a, b, c, d, e, m, k, s) {
+	  return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0
+	}
+
+	ripemd160 = RIPEMD160;
+	return ripemd160;
+}
+
 var isarray$1;
 var hasRequiredIsarray$1;
 
@@ -104842,7 +105013,7 @@ const createStream = async () => {
   if (raw) {
     return void 0;
   }
-  const pretty = await __vitePreload(() => import('./index-ojKLjt7K.js').then(n => n.i),true              ?__vite__mapDeps([0,1]):void 0);
+  const pretty = await __vitePreload(() => import('./index-WVhZEObe.js').then(n => n.i),true              ?__vite__mapDeps([0,1]):void 0);
   return pretty.default(createPrettyConfig());
 };
 const options = {
@@ -107435,18 +107606,7 @@ function PluginsPanel({
               variant: "ghost",
               size: "sm",
               className: `inline-flex items-center rounded-full ${isEssential ? "bg-blue-800 text-blue-700 hover:bg-blue-600" : "bg-primary/10 text-primary hover:bg-primary/20"} px-2.5 py-0.5 text-xs font-medium h-auto`,
-              onClick: () => {
-                if (isRequiredByVoice) {
-                  toast({
-                    title: "Can't Remove Plugin",
-                    description: "This plugin is required by the selected voice model.",
-                    variant: "destructive"
-                  });
-                  return;
-                }
-                handlePluginRemove(plugin);
-              },
-              title: isRequiredByVoice ? "Required by voice model" : isEssential ? "Essential plugin for agent functionality (click to remove)" : "Click to remove",
+              title: isRequiredByVoice ? "Required by voice model" : isEssential ? "Essential plugin for agent functionality" : "",
               children: [
                 isEssential && /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "w-2 h-2 rounded-full bg-white inline-block" }),
                 /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "text-white font-semibold", children: plugin }),
@@ -107457,6 +107617,17 @@ function PluginsPanel({
                       "ml-1 opacity-70 hover:opacity-100",
                       isEssential && "text-white"
                     ),
+                    onClick: () => {
+                      if (isRequiredByVoice) {
+                        toast({
+                          title: "Can't Remove Plugin",
+                          description: "This plugin is required by the selected voice model.",
+                          variant: "destructive"
+                        });
+                        return;
+                      }
+                      handlePluginRemove(plugin);
+                    },
                     children: "×"
                   }
                 )
@@ -156789,13 +156960,13 @@ function GroupPanel({ onClose, channelId }) {
       });
     },
     onSuccess: (response) => {
-      if (response.data) {
+      if (response) {
         toast({ title: "Success", description: "Group created successfully." });
         queryClient.invalidateQueries({ queryKey: ["channels", serverId] });
         queryClient.invalidateQueries({ queryKey: ["channels"] });
         onClose();
         setTimeout(() => {
-          navigate(`/group/${response.data.id}?serverId=${serverId}`);
+          navigate(`/group/${response.id}?serverId=${serverId}`);
         }, 100);
       }
     },
@@ -159257,4 +159428,4 @@ clientExports.createRoot(rootElement).render(
 );
 
 export { Buffer as B, requireString_decoder as a, requireUtil$3 as b, requireShams$1 as c, requireCallBound as d, requireEsObjectAtoms as e, requireCallBind as f, requireGetIntrinsic as g, requireDefineDataProperty as h, requireHasPropertyDescriptors as i, requireEvents as j, requireStreamBrowserify as r };
-//# sourceMappingURL=index-D7iwnDvJ.js.map
+//# sourceMappingURL=index-BHRtDt-w.js.map