web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/@noble/hashes/esm/blake2.js

@@ -0,0 +1,421 @@
+'use strict';
+
+var _blake = require('./_blake.js');
+var _u64 = require('./_u64.js');
+var utils = require('./utils.js');
+
+/**
+ * blake2b (64-bit) & blake2s (8 to 32-bit) hash functions.
+ * b could have been faster, but there is no fast u64 in js, so s is 1.5x faster.
+ * @module
+ */
+// Same as SHA512_IV, but swapped endianness: LE instead of BE. iv[1] is iv[0], etc.
+const B2B_IV = /* @__PURE__ */Uint32Array.from([0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a, 0xade682d1, 0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19]);
+// Temporary buffer
+const BBUF = /* @__PURE__ */new Uint32Array(32);
+// Mixing function G splitted in two halfs
+function G1b(a, b, c, d, msg, x) {
+  // NOTE: V is LE here
+  const Xl = msg[x],
+    Xh = msg[x + 1]; // prettier-ignore
+  let Al = BBUF[2 * a],
+    Ah = BBUF[2 * a + 1]; // prettier-ignore
+  let Bl = BBUF[2 * b],
+    Bh = BBUF[2 * b + 1]; // prettier-ignore
+  let Cl = BBUF[2 * c],
+    Ch = BBUF[2 * c + 1]; // prettier-ignore
+  let Dl = BBUF[2 * d],
+    Dh = BBUF[2 * d + 1]; // prettier-ignore
+  // v[a] = (v[a] + v[b] + x) | 0;
+  let ll = _u64.add3L(Al, Bl, Xl);
+  Ah = _u64.add3H(ll, Ah, Bh, Xh);
+  Al = ll | 0;
+  // v[d] = rotr(v[d] ^ v[a], 32)
+  ({
+    Dh,
+    Dl
+  } = {
+    Dh: Dh ^ Ah,
+    Dl: Dl ^ Al
+  });
+  ({
+    Dh,
+    Dl
+  } = {
+    Dh: _u64.rotr32H(Dh, Dl),
+    Dl: _u64.rotr32L(Dh)
+  });
+  // v[c] = (v[c] + v[d]) | 0;
+  ({
+    h: Ch,
+    l: Cl
+  } = _u64.add(Ch, Cl, Dh, Dl));
+  // v[b] = rotr(v[b] ^ v[c], 24)
+  ({
+    Bh,
+    Bl
+  } = {
+    Bh: Bh ^ Ch,
+    Bl: Bl ^ Cl
+  });
+  ({
+    Bh,
+    Bl
+  } = {
+    Bh: _u64.rotrSH(Bh, Bl, 24),
+    Bl: _u64.rotrSL(Bh, Bl, 24)
+  });
+  BBUF[2 * a] = Al, BBUF[2 * a + 1] = Ah;
+  BBUF[2 * b] = Bl, BBUF[2 * b + 1] = Bh;
+  BBUF[2 * c] = Cl, BBUF[2 * c + 1] = Ch;
+  BBUF[2 * d] = Dl, BBUF[2 * d + 1] = Dh;
+}
+function G2b(a, b, c, d, msg, x) {
+  // NOTE: V is LE here
+  const Xl = msg[x],
+    Xh = msg[x + 1]; // prettier-ignore
+  let Al = BBUF[2 * a],
+    Ah = BBUF[2 * a + 1]; // prettier-ignore
+  let Bl = BBUF[2 * b],
+    Bh = BBUF[2 * b + 1]; // prettier-ignore
+  let Cl = BBUF[2 * c],
+    Ch = BBUF[2 * c + 1]; // prettier-ignore
+  let Dl = BBUF[2 * d],
+    Dh = BBUF[2 * d + 1]; // prettier-ignore
+  // v[a] = (v[a] + v[b] + x) | 0;
+  let ll = _u64.add3L(Al, Bl, Xl);
+  Ah = _u64.add3H(ll, Ah, Bh, Xh);
+  Al = ll | 0;
+  // v[d] = rotr(v[d] ^ v[a], 16)
+  ({
+    Dh,
+    Dl
+  } = {
+    Dh: Dh ^ Ah,
+    Dl: Dl ^ Al
+  });
+  ({
+    Dh,
+    Dl
+  } = {
+    Dh: _u64.rotrSH(Dh, Dl, 16),
+    Dl: _u64.rotrSL(Dh, Dl, 16)
+  });
+  // v[c] = (v[c] + v[d]) | 0;
+  ({
+    h: Ch,
+    l: Cl
+  } = _u64.add(Ch, Cl, Dh, Dl));
+  // v[b] = rotr(v[b] ^ v[c], 63)
+  ({
+    Bh,
+    Bl
+  } = {
+    Bh: Bh ^ Ch,
+    Bl: Bl ^ Cl
+  });
+  ({
+    Bh,
+    Bl
+  } = {
+    Bh: _u64.rotrBH(Bh, Bl, 63),
+    Bl: _u64.rotrBL(Bh, Bl, 63)
+  });
+  BBUF[2 * a] = Al, BBUF[2 * a + 1] = Ah;
+  BBUF[2 * b] = Bl, BBUF[2 * b + 1] = Bh;
+  BBUF[2 * c] = Cl, BBUF[2 * c + 1] = Ch;
+  BBUF[2 * d] = Dl, BBUF[2 * d + 1] = Dh;
+}
+function checkBlake2Opts(outputLen) {
+  let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  let keyLen = arguments.length > 2 ? arguments[2] : undefined;
+  let saltLen = arguments.length > 3 ? arguments[3] : undefined;
+  let persLen = arguments.length > 4 ? arguments[4] : undefined;
+  utils.anumber(keyLen);
+  if (outputLen < 0 || outputLen > keyLen) throw new Error('outputLen bigger than keyLen');
+  const {
+    key,
+    salt,
+    personalization
+  } = opts;
+  if (key !== undefined && (key.length < 1 || key.length > keyLen)) throw new Error('key length must be undefined or 1..' + keyLen);
+  if (salt !== undefined && salt.length !== saltLen) throw new Error('salt must be undefined or ' + saltLen);
+  if (personalization !== undefined && personalization.length !== persLen) throw new Error('personalization must be undefined or ' + persLen);
+}
+/** Class, from which others are subclassed. */
+class BLAKE2 extends utils.Hash {
+  constructor(blockLen, outputLen) {
+    super();
+    this.finished = false;
+    this.destroyed = false;
+    this.length = 0;
+    this.pos = 0;
+    utils.anumber(blockLen);
+    utils.anumber(outputLen);
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.buffer = new Uint8Array(blockLen);
+    this.buffer32 = utils.u32(this.buffer);
+  }
+  update(data) {
+    utils.aexists(this);
+    data = utils.toBytes(data);
+    utils.abytes(data);
+    // Main difference with other hashes: there is flag for last block,
+    // so we cannot process current block before we know that there
+    // is the next one. This significantly complicates logic and reduces ability
+    // to do zero-copy processing
+    const {
+      blockLen,
+      buffer,
+      buffer32
+    } = this;
+    const len = data.length;
+    const offset = data.byteOffset;
+    const buf = data.buffer;
+    for (let pos = 0; pos < len;) {
+      // If buffer is full and we still have input (don't process last block, same as blake2s)
+      if (this.pos === blockLen) {
+        utils.swap32IfBE(buffer32);
+        this.compress(buffer32, 0, false);
+        utils.swap32IfBE(buffer32);
+        this.pos = 0;
+      }
+      const take = Math.min(blockLen - this.pos, len - pos);
+      const dataOffset = offset + pos;
+      // full block && aligned to 4 bytes && not last in input
+      if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+        const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+        utils.swap32IfBE(data32);
+        for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+          this.length += blockLen;
+          this.compress(data32, pos32, false);
+        }
+        utils.swap32IfBE(data32);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      this.length += take;
+      pos += take;
+    }
+    return this;
+  }
+  digestInto(out) {
+    utils.aexists(this);
+    utils.aoutput(out, this);
+    const {
+      pos,
+      buffer32
+    } = this;
+    this.finished = true;
+    // Padding
+    utils.clean(this.buffer.subarray(pos));
+    utils.swap32IfBE(buffer32);
+    this.compress(buffer32, 0, true);
+    utils.swap32IfBE(buffer32);
+    const out32 = utils.u32(out);
+    this.get().forEach((v, i) => out32[i] = utils.swap8IfBE(v));
+  }
+  digest() {
+    const {
+      buffer,
+      outputLen
+    } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    const {
+      buffer,
+      length,
+      finished,
+      destroyed,
+      outputLen,
+      pos
+    } = this;
+    to || (to = new this.constructor({
+      dkLen: outputLen
+    }));
+    to.set(...this.get());
+    to.buffer.set(buffer);
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    // @ts-ignore
+    to.outputLen = outputLen;
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+class BLAKE2b extends BLAKE2 {
+  constructor() {
+    let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const olen = opts.dkLen === undefined ? 64 : opts.dkLen;
+    super(128, olen);
+    // Same as SHA-512, but LE
+    this.v0l = B2B_IV[0] | 0;
+    this.v0h = B2B_IV[1] | 0;
+    this.v1l = B2B_IV[2] | 0;
+    this.v1h = B2B_IV[3] | 0;
+    this.v2l = B2B_IV[4] | 0;
+    this.v2h = B2B_IV[5] | 0;
+    this.v3l = B2B_IV[6] | 0;
+    this.v3h = B2B_IV[7] | 0;
+    this.v4l = B2B_IV[8] | 0;
+    this.v4h = B2B_IV[9] | 0;
+    this.v5l = B2B_IV[10] | 0;
+    this.v5h = B2B_IV[11] | 0;
+    this.v6l = B2B_IV[12] | 0;
+    this.v6h = B2B_IV[13] | 0;
+    this.v7l = B2B_IV[14] | 0;
+    this.v7h = B2B_IV[15] | 0;
+    checkBlake2Opts(olen, opts, 64, 16, 16);
+    let {
+      key,
+      personalization,
+      salt
+    } = opts;
+    let keyLength = 0;
+    if (key !== undefined) {
+      key = utils.toBytes(key);
+      keyLength = key.length;
+    }
+    this.v0l ^= this.outputLen | keyLength << 8 | 0x01 << 16 | 0x01 << 24;
+    if (salt !== undefined) {
+      salt = utils.toBytes(salt);
+      const slt = utils.u32(salt);
+      this.v4l ^= utils.swap8IfBE(slt[0]);
+      this.v4h ^= utils.swap8IfBE(slt[1]);
+      this.v5l ^= utils.swap8IfBE(slt[2]);
+      this.v5h ^= utils.swap8IfBE(slt[3]);
+    }
+    if (personalization !== undefined) {
+      personalization = utils.toBytes(personalization);
+      const pers = utils.u32(personalization);
+      this.v6l ^= utils.swap8IfBE(pers[0]);
+      this.v6h ^= utils.swap8IfBE(pers[1]);
+      this.v7l ^= utils.swap8IfBE(pers[2]);
+      this.v7h ^= utils.swap8IfBE(pers[3]);
+    }
+    if (key !== undefined) {
+      // Pad to blockLen and update
+      const tmp = new Uint8Array(this.blockLen);
+      tmp.set(key);
+      this.update(tmp);
+    }
+  }
+  // prettier-ignore
+  get() {
+    let {
+      v0l,
+      v0h,
+      v1l,
+      v1h,
+      v2l,
+      v2h,
+      v3l,
+      v3h,
+      v4l,
+      v4h,
+      v5l,
+      v5h,
+      v6l,
+      v6h,
+      v7l,
+      v7h
+    } = this;
+    return [v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h];
+  }
+  // prettier-ignore
+  set(v0l, v0h, v1l, v1h, v2l, v2h, v3l, v3h, v4l, v4h, v5l, v5h, v6l, v6h, v7l, v7h) {
+    this.v0l = v0l | 0;
+    this.v0h = v0h | 0;
+    this.v1l = v1l | 0;
+    this.v1h = v1h | 0;
+    this.v2l = v2l | 0;
+    this.v2h = v2h | 0;
+    this.v3l = v3l | 0;
+    this.v3h = v3h | 0;
+    this.v4l = v4l | 0;
+    this.v4h = v4h | 0;
+    this.v5l = v5l | 0;
+    this.v5h = v5h | 0;
+    this.v6l = v6l | 0;
+    this.v6h = v6h | 0;
+    this.v7l = v7l | 0;
+    this.v7h = v7h | 0;
+  }
+  compress(msg, offset, isLast) {
+    this.get().forEach((v, i) => BBUF[i] = v); // First half from state.
+    BBUF.set(B2B_IV, 16); // Second half from IV.
+    let {
+      h,
+      l
+    } = _u64.fromBig(BigInt(this.length));
+    BBUF[24] = B2B_IV[8] ^ l; // Low word of the offset.
+    BBUF[25] = B2B_IV[9] ^ h; // High word.
+    // Invert all bits for last block
+    if (isLast) {
+      BBUF[28] = ~BBUF[28];
+      BBUF[29] = ~BBUF[29];
+    }
+    let j = 0;
+    const s = _blake.BSIGMA;
+    for (let i = 0; i < 12; i++) {
+      G1b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+      G2b(0, 4, 8, 12, msg, offset + 2 * s[j++]);
+      G1b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+      G2b(1, 5, 9, 13, msg, offset + 2 * s[j++]);
+      G1b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+      G2b(2, 6, 10, 14, msg, offset + 2 * s[j++]);
+      G1b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+      G2b(3, 7, 11, 15, msg, offset + 2 * s[j++]);
+      G1b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+      G2b(0, 5, 10, 15, msg, offset + 2 * s[j++]);
+      G1b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+      G2b(1, 6, 11, 12, msg, offset + 2 * s[j++]);
+      G1b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+      G2b(2, 7, 8, 13, msg, offset + 2 * s[j++]);
+      G1b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+      G2b(3, 4, 9, 14, msg, offset + 2 * s[j++]);
+    }
+    this.v0l ^= BBUF[0] ^ BBUF[16];
+    this.v0h ^= BBUF[1] ^ BBUF[17];
+    this.v1l ^= BBUF[2] ^ BBUF[18];
+    this.v1h ^= BBUF[3] ^ BBUF[19];
+    this.v2l ^= BBUF[4] ^ BBUF[20];
+    this.v2h ^= BBUF[5] ^ BBUF[21];
+    this.v3l ^= BBUF[6] ^ BBUF[22];
+    this.v3h ^= BBUF[7] ^ BBUF[23];
+    this.v4l ^= BBUF[8] ^ BBUF[24];
+    this.v4h ^= BBUF[9] ^ BBUF[25];
+    this.v5l ^= BBUF[10] ^ BBUF[26];
+    this.v5h ^= BBUF[11] ^ BBUF[27];
+    this.v6l ^= BBUF[12] ^ BBUF[28];
+    this.v6h ^= BBUF[13] ^ BBUF[29];
+    this.v7l ^= BBUF[14] ^ BBUF[30];
+    this.v7h ^= BBUF[15] ^ BBUF[31];
+    utils.clean(BBUF);
+  }
+  destroy() {
+    this.destroyed = true;
+    utils.clean(this.buffer32);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+/**
+ * Blake2b hash function. 64-bit. 1.5x slower than blake2s in JS.
+ * @param msg - message that would be hashed
+ * @param opts - dkLen output length, key for MAC mode, salt, personalization
+ */
+const blake2b = /* @__PURE__ */utils.createOptHasher(opts => new BLAKE2b(opts));
+
+exports.BLAKE2 = BLAKE2;
+exports.BLAKE2b = BLAKE2b;
+exports.blake2b = blake2b;

package/dist/cjs/node_modules/@noble/hashes/esm/blake2b.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var blake2 = require('./blake2.js');
+
+/**
+ * Blake2b hash function. Focuses on 64-bit platforms, but in JS speed different from Blake2s is negligible.
+ * @module
+ * @deprecated
+ */
+/** @deprecated Use import from `noble/hashes/blake2` module */
+const blake2b = blake2.blake2b;
+
+exports.blake2b = blake2b;

package/dist/cjs/node_modules/@noble/hashes/esm/legacy.js

@@ -0,0 +1,208 @@
+'use strict';
+
+var _md = require('./_md.js');
+var utils = require('./utils.js');
+
+/**
+
+SHA1 (RFC 3174), MD5 (RFC 1321) and RIPEMD160 (RFC 2286) legacy, weak hash functions.
+Don't use them in a new protocol. What "weak" means:
+
+- Collisions can be made with 2^18 effort in MD5, 2^60 in SHA1, 2^80 in RIPEMD160.
+- No practical pre-image attacks (only theoretical, 2^123.4)
+- HMAC seems kinda ok: https://datatracker.ietf.org/doc/html/rfc6151
+ * @module
+ */
+/** Initial SHA1 state */
+const SHA1_IV = /* @__PURE__ */Uint32Array.from([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]);
+// Reusable temporary buffer
+const SHA1_W = /* @__PURE__ */new Uint32Array(80);
+/** SHA1 legacy hash class. */
+class SHA1 extends _md.HashMD {
+  constructor() {
+    super(64, 20, 8, false);
+    this.A = SHA1_IV[0] | 0;
+    this.B = SHA1_IV[1] | 0;
+    this.C = SHA1_IV[2] | 0;
+    this.D = SHA1_IV[3] | 0;
+    this.E = SHA1_IV[4] | 0;
+  }
+  get() {
+    const {
+      A,
+      B,
+      C,
+      D,
+      E
+    } = this;
+    return [A, B, C, D, E];
+  }
+  set(A, B, C, D, E) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4) SHA1_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 80; i++) SHA1_W[i] = utils.rotl(SHA1_W[i - 3] ^ SHA1_W[i - 8] ^ SHA1_W[i - 14] ^ SHA1_W[i - 16], 1);
+    // Compression function main loop, 80 rounds
+    let {
+      A,
+      B,
+      C,
+      D,
+      E
+    } = this;
+    for (let i = 0; i < 80; i++) {
+      let F, K;
+      if (i < 20) {
+        F = _md.Chi(B, C, D);
+        K = 0x5a827999;
+      } else if (i < 40) {
+        F = B ^ C ^ D;
+        K = 0x6ed9eba1;
+      } else if (i < 60) {
+        F = _md.Maj(B, C, D);
+        K = 0x8f1bbcdc;
+      } else {
+        F = B ^ C ^ D;
+        K = 0xca62c1d6;
+      }
+      const T = utils.rotl(A, 5) + F + E + K + SHA1_W[i] | 0;
+      E = D;
+      D = C;
+      C = utils.rotl(B, 30);
+      B = A;
+      A = T;
+    }
+    // Add the compressed chunk to the current hash value
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    this.set(A, B, C, D, E);
+  }
+  roundClean() {
+    utils.clean(SHA1_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0);
+    utils.clean(this.buffer);
+  }
+}
+/** SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
+const sha1 = /* @__PURE__ */utils.createHasher(() => new SHA1());
+// RIPEMD-160
+const Rho160 = /* @__PURE__ */Uint8Array.from([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
+const Id160 = /* @__PURE__ */(() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();
+const Pi160 = /* @__PURE__ */(() => Id160.map(i => (9 * i + 5) % 16))();
+const idxLR = /* @__PURE__ */(() => {
+  const L = [Id160];
+  const R = [Pi160];
+  const res = [L, R];
+  for (let i = 0; i < 4; i++) for (let j of res) j.push(j[i].map(k => Rho160[k]));
+  return res;
+})();
+const idxL = /* @__PURE__ */(() => idxLR[0])();
+const idxR = /* @__PURE__ */(() => idxLR[1])();
+// const [idxL, idxR] = idxLR;
+const shifts160 = /* @__PURE__ */[[11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8], [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7], [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9], [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6], [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]].map(i => Uint8Array.from(i));
+const shiftsL160 = /* @__PURE__ */idxL.map((idx, i) => idx.map(j => shifts160[i][j]));
+const shiftsR160 = /* @__PURE__ */idxR.map((idx, i) => idx.map(j => shifts160[i][j]));
+const Kl160 = /* @__PURE__ */Uint32Array.from([0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]);
+const Kr160 = /* @__PURE__ */Uint32Array.from([0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]);
+// It's called f() in spec.
+function ripemd_f(group, x, y, z) {
+  if (group === 0) return x ^ y ^ z;
+  if (group === 1) return x & y | ~x & z;
+  if (group === 2) return (x | ~y) ^ z;
+  if (group === 3) return x & z | y & ~z;
+  return x ^ (y | ~z);
+}
+// Reusable temporary buffer
+const BUF_160 = /* @__PURE__ */new Uint32Array(16);
+class RIPEMD160 extends _md.HashMD {
+  constructor() {
+    super(64, 20, 8, true);
+    this.h0 = 0x67452301 | 0;
+    this.h1 = 0xefcdab89 | 0;
+    this.h2 = 0x98badcfe | 0;
+    this.h3 = 0x10325476 | 0;
+    this.h4 = 0xc3d2e1f0 | 0;
+  }
+  get() {
+    const {
+      h0,
+      h1,
+      h2,
+      h3,
+      h4
+    } = this;
+    return [h0, h1, h2, h3, h4];
+  }
+  set(h0, h1, h2, h3, h4) {
+    this.h0 = h0 | 0;
+    this.h1 = h1 | 0;
+    this.h2 = h2 | 0;
+    this.h3 = h3 | 0;
+    this.h4 = h4 | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4) BUF_160[i] = view.getUint32(offset, true);
+    // prettier-ignore
+    let al = this.h0 | 0,
+      ar = al,
+      bl = this.h1 | 0,
+      br = bl,
+      cl = this.h2 | 0,
+      cr = cl,
+      dl = this.h3 | 0,
+      dr = dl,
+      el = this.h4 | 0,
+      er = el;
+    // Instead of iterating 0 to 80, we split it into 5 groups
+    // And use the groups in constants, functions, etc. Much simpler
+    for (let group = 0; group < 5; group++) {
+      const rGroup = 4 - group;
+      const hbl = Kl160[group],
+        hbr = Kr160[group]; // prettier-ignore
+      const rl = idxL[group],
+        rr = idxR[group]; // prettier-ignore
+      const sl = shiftsL160[group],
+        sr = shiftsR160[group]; // prettier-ignore
+      for (let i = 0; i < 16; i++) {
+        const tl = utils.rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el | 0;
+        al = el, el = dl, dl = utils.rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore
+      }
+      // 2 loops are 10% faster
+      for (let i = 0; i < 16; i++) {
+        const tr = utils.rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er | 0;
+        ar = er, er = dr, dr = utils.rotl(cr, 10) | 0, cr = br, br = tr; // prettier-ignore
+      }
+    }
+    // Add the compressed chunk to the current hash value
+    this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
+  }
+  roundClean() {
+    utils.clean(BUF_160);
+  }
+  destroy() {
+    this.destroyed = true;
+    utils.clean(this.buffer);
+    this.set(0, 0, 0, 0, 0);
+  }
+}
+/**
+ * RIPEMD-160 - a legacy hash function from 1990s.
+ * * https://homes.esat.kuleuven.be/~bosselae/ripemd160.html
+ * * https://homes.esat.kuleuven.be/~bosselae/ripemd160/pdf/AB-9601/AB-9601.pdf
+ */
+const ripemd160 = /* @__PURE__ */utils.createHasher(() => new RIPEMD160());
+
+exports.RIPEMD160 = RIPEMD160;
+exports.SHA1 = SHA1;
+exports.ripemd160 = ripemd160;
+exports.sha1 = sha1;