web-dc-api 0.0.62 → 0.0.64

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

@@ -1,203 +0,0 @@
-import { HashMD, Chi, Maj } from './_md.js';
-import { createHasher, rotl, clean } from './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 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] = 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 = Chi(B, C, D);
-        K = 0x5a827999;
-      } else if (i < 40) {
-        F = B ^ C ^ D;
-        K = 0x6ed9eba1;
-      } else if (i < 60) {
-        F = Maj(B, C, D);
-        K = 0x8f1bbcdc;
-      } else {
-        F = B ^ C ^ D;
-        K = 0xca62c1d6;
-      }
-      const T = rotl(A, 5) + F + E + K + SHA1_W[i] | 0;
-      E = D;
-      D = C;
-      C = 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() {
-    clean(SHA1_W);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0);
-    clean(this.buffer);
-  }
-}
-/** SHA1 (RFC 3174) legacy hash function. It was cryptographically broken. */
-const sha1 = /* @__PURE__ */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 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 = rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el | 0;
-        al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl; // prettier-ignore
-      }
-      // 2 loops are 10% faster
-      for (let i = 0; i < 16; i++) {
-        const tr = rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er | 0;
-        ar = er, er = dr, dr = 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() {
-    clean(BUF_160);
-  }
-  destroy() {
-    this.destroyed = true;
-    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__ */createHasher(() => new RIPEMD160());
-
-export { RIPEMD160, SHA1, ripemd160, sha1 };

package/dist/esm/node_modules/@noble/hashes/esm/pbkdf2.js

@@ -1,121 +0,0 @@
-import { hmac } from './hmac.js';
-import { createView, asyncLoop, ahash, checkOpts, anumber, kdfInputToBytes, clean } from './utils.js';
-
-/**
- * PBKDF (RFC 2898). Can be used to create a key from password and salt.
- * @module
- */
-// Common prologue and epilogue for sync/async functions
-function pbkdf2Init(hash, _password, _salt, _opts) {
-  ahash(hash);
-  const opts = checkOpts({
-    dkLen: 32,
-    asyncTick: 10
-  }, _opts);
-  const {
-    c,
-    dkLen,
-    asyncTick
-  } = opts;
-  anumber(c);
-  anumber(dkLen);
-  anumber(asyncTick);
-  if (c < 1) throw new Error('iterations (c) should be >= 1');
-  const password = kdfInputToBytes(_password);
-  const salt = kdfInputToBytes(_salt);
-  // DK = PBKDF2(PRF, Password, Salt, c, dkLen);
-  const DK = new Uint8Array(dkLen);
-  // U1 = PRF(Password, Salt + INT_32_BE(i))
-  const PRF = hmac.create(hash, password);
-  const PRFSalt = PRF._cloneInto().update(salt);
-  return {
-    c,
-    dkLen,
-    asyncTick,
-    DK,
-    PRF,
-    PRFSalt
-  };
-}
-function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
-  PRF.destroy();
-  PRFSalt.destroy();
-  if (prfW) prfW.destroy();
-  clean(u);
-  return DK;
-}
-/**
- * PBKDF2-HMAC: RFC 2898 key derivation function
- * @param hash - hash function that would be used e.g. sha256
- * @param password - password from which a derived key is generated
- * @param salt - cryptographic salt
- * @param opts - {c, dkLen} where c is work factor and dkLen is output message size
- * @example
- * const key = pbkdf2(sha256, 'password', 'salt', { dkLen: 32, c: Math.pow(2, 18) });
- */
-function pbkdf2(hash, password, salt, opts) {
-  const {
-    c,
-    dkLen,
-    DK,
-    PRF,
-    PRFSalt
-  } = pbkdf2Init(hash, password, salt, opts);
-  let prfW; // Working copy
-  const arr = new Uint8Array(4);
-  const view = createView(arr);
-  const u = new Uint8Array(PRF.outputLen);
-  // DK = T1 + T2 + ⋯ + Tdklen/hlen
-  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
-    // Ti = F(Password, Salt, c, i)
-    const Ti = DK.subarray(pos, pos + PRF.outputLen);
-    view.setInt32(0, ti, false);
-    // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
-    // U1 = PRF(Password, Salt + INT_32_BE(i))
-    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
-    Ti.set(u.subarray(0, Ti.length));
-    for (let ui = 1; ui < c; ui++) {
-      // Uc = PRF(Password, Uc−1)
-      PRF._cloneInto(prfW).update(u).digestInto(u);
-      for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
-    }
-  }
-  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
-}
-/**
- * PBKDF2-HMAC: RFC 2898 key derivation function. Async version.
- * @example
- * await pbkdf2Async(sha256, 'password', 'salt', { dkLen: 32, c: 500_000 });
- */
-async function pbkdf2Async(hash, password, salt, opts) {
-  const {
-    c,
-    dkLen,
-    asyncTick,
-    DK,
-    PRF,
-    PRFSalt
-  } = pbkdf2Init(hash, password, salt, opts);
-  let prfW; // Working copy
-  const arr = new Uint8Array(4);
-  const view = createView(arr);
-  const u = new Uint8Array(PRF.outputLen);
-  // DK = T1 + T2 + ⋯ + Tdklen/hlen
-  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
-    // Ti = F(Password, Salt, c, i)
-    const Ti = DK.subarray(pos, pos + PRF.outputLen);
-    view.setInt32(0, ti, false);
-    // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
-    // U1 = PRF(Password, Salt + INT_32_BE(i))
-    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
-    Ti.set(u.subarray(0, Ti.length));
-    await asyncLoop(c - 1, asyncTick, () => {
-      // Uc = PRF(Password, Uc−1)
-      PRF._cloneInto(prfW).update(u).digestInto(u);
-      for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
-    });
-  }
-  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
-}
-
-export { pbkdf2, pbkdf2Async };

package/dist/esm/node_modules/@noble/hashes/esm/sha1.js

@@ -1,11 +0,0 @@
-import { sha1 as sha1$1 } from './legacy.js';
-
-/**
- * SHA1 (RFC 3174) legacy hash function.
- * @module
- * @deprecated
- */
-/** @deprecated Use import from `noble/hashes/legacy` module */
-const sha1 = sha1$1;
-
-export { sha1 };

package/dist/esm/node_modules/@noble/hashes/esm/sha2.js

@@ -1,321 +0,0 @@
-import { HashMD, SHA256_IV, Chi, Maj, SHA512_IV } from './_md.js';
-import { add4L, add4H, add5L, split, add5H, add, add3H, rotrSH, shrSH, rotrSL, shrSL, rotrBH, rotrBL, add3L } from './_u64.js';
-import { createHasher, clean, rotr } from './utils.js';
-
-/**
- * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
- * SHA256 is the fastest hash implementable in JS, even faster than Blake3.
- * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
- * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
- * @module
- */
-/**
- * Round constants:
- * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
- */
-// prettier-ignore
-const SHA256_K = /* @__PURE__ */Uint32Array.from([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]);
-/** Reusable temporary buffer. "W" comes straight from spec. */
-const SHA256_W = /* @__PURE__ */new Uint32Array(64);
-class SHA256 extends HashMD {
-  constructor() {
-    let outputLen = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 32;
-    super(64, outputLen, 8, false);
-    // We cannot use array here since array allows indexing by variable
-    // which means optimizer/compiler cannot use registers.
-    this.A = SHA256_IV[0] | 0;
-    this.B = SHA256_IV[1] | 0;
-    this.C = SHA256_IV[2] | 0;
-    this.D = SHA256_IV[3] | 0;
-    this.E = SHA256_IV[4] | 0;
-    this.F = SHA256_IV[5] | 0;
-    this.G = SHA256_IV[6] | 0;
-    this.H = SHA256_IV[7] | 0;
-  }
-  get() {
-    const {
-      A,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G,
-      H
-    } = this;
-    return [A, B, C, D, E, F, G, H];
-  }
-  // prettier-ignore
-  set(A, B, C, D, E, F, G, H) {
-    this.A = A | 0;
-    this.B = B | 0;
-    this.C = C | 0;
-    this.D = D | 0;
-    this.E = E | 0;
-    this.F = F | 0;
-    this.G = G | 0;
-    this.H = H | 0;
-  }
-  process(view, offset) {
-    // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
-    for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
-    for (let i = 16; i < 64; i++) {
-      const W15 = SHA256_W[i - 15];
-      const W2 = SHA256_W[i - 2];
-      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-    }
-    // Compression function main loop, 64 rounds
-    let {
-      A,
-      B,
-      C,
-      D,
-      E,
-      F,
-      G,
-      H
-    } = this;
-    for (let i = 0; i < 64; i++) {
-      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-      const T2 = sigma0 + 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;
-    }
-    // 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;
-    F = F + this.F | 0;
-    G = G + this.G | 0;
-    H = H + this.H | 0;
-    this.set(A, B, C, D, E, F, G, H);
-  }
-  roundClean() {
-    clean(SHA256_W);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    clean(this.buffer);
-  }
-}
-// SHA2-512 is slower than sha256 in js because u64 operations are slow.
-// Round contants
-// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409
-// prettier-ignore
-const K512 = /* @__PURE__ */(() => split(['0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc', '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118', '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2', '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694', '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65', '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5', '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4', '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70', '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df', '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b', '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30', '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8', '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8', '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3', '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec', '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b', '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178', '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b', '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c', '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'].map(n => BigInt(n))))();
-const SHA512_Kh = /* @__PURE__ */(() => K512[0])();
-const SHA512_Kl = /* @__PURE__ */(() => K512[1])();
-// Reusable temporary buffers
-const SHA512_W_H = /* @__PURE__ */new Uint32Array(80);
-const SHA512_W_L = /* @__PURE__ */new Uint32Array(80);
-class SHA512 extends HashMD {
-  constructor() {
-    let outputLen = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 64;
-    super(128, outputLen, 16, false);
-    // We cannot use array here since array allows indexing by variable
-    // which means optimizer/compiler cannot use registers.
-    // h -- high 32 bits, l -- low 32 bits
-    this.Ah = SHA512_IV[0] | 0;
-    this.Al = SHA512_IV[1] | 0;
-    this.Bh = SHA512_IV[2] | 0;
-    this.Bl = SHA512_IV[3] | 0;
-    this.Ch = SHA512_IV[4] | 0;
-    this.Cl = SHA512_IV[5] | 0;
-    this.Dh = SHA512_IV[6] | 0;
-    this.Dl = SHA512_IV[7] | 0;
-    this.Eh = SHA512_IV[8] | 0;
-    this.El = SHA512_IV[9] | 0;
-    this.Fh = SHA512_IV[10] | 0;
-    this.Fl = SHA512_IV[11] | 0;
-    this.Gh = SHA512_IV[12] | 0;
-    this.Gl = SHA512_IV[13] | 0;
-    this.Hh = SHA512_IV[14] | 0;
-    this.Hl = SHA512_IV[15] | 0;
-  }
-  // prettier-ignore
-  get() {
-    const {
-      Ah,
-      Al,
-      Bh,
-      Bl,
-      Ch,
-      Cl,
-      Dh,
-      Dl,
-      Eh,
-      El,
-      Fh,
-      Fl,
-      Gh,
-      Gl,
-      Hh,
-      Hl
-    } = this;
-    return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
-  }
-  // prettier-ignore
-  set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
-    this.Ah = Ah | 0;
-    this.Al = Al | 0;
-    this.Bh = Bh | 0;
-    this.Bl = Bl | 0;
-    this.Ch = Ch | 0;
-    this.Cl = Cl | 0;
-    this.Dh = Dh | 0;
-    this.Dl = Dl | 0;
-    this.Eh = Eh | 0;
-    this.El = El | 0;
-    this.Fh = Fh | 0;
-    this.Fl = Fl | 0;
-    this.Gh = Gh | 0;
-    this.Gl = Gl | 0;
-    this.Hh = Hh | 0;
-    this.Hl = Hl | 0;
-  }
-  process(view, offset) {
-    // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array
-    for (let i = 0; i < 16; i++, offset += 4) {
-      SHA512_W_H[i] = view.getUint32(offset);
-      SHA512_W_L[i] = view.getUint32(offset += 4);
-    }
-    for (let i = 16; i < 80; i++) {
-      // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
-      const W15h = SHA512_W_H[i - 15] | 0;
-      const W15l = SHA512_W_L[i - 15] | 0;
-      const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
-      const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
-      // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
-      const W2h = SHA512_W_H[i - 2] | 0;
-      const W2l = SHA512_W_L[i - 2] | 0;
-      const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
-      const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
-      // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];
-      const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
-      const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
-      SHA512_W_H[i] = SUMh | 0;
-      SHA512_W_L[i] = SUMl | 0;
-    }
-    let {
-      Ah,
-      Al,
-      Bh,
-      Bl,
-      Ch,
-      Cl,
-      Dh,
-      Dl,
-      Eh,
-      El,
-      Fh,
-      Fl,
-      Gh,
-      Gl,
-      Hh,
-      Hl
-    } = this;
-    // Compression function main loop, 80 rounds
-    for (let i = 0; i < 80; i++) {
-      // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
-      const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
-      const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
-      //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
-      const CHIh = Eh & Fh ^ ~Eh & Gh;
-      const CHIl = El & Fl ^ ~El & Gl;
-      // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]
-      // prettier-ignore
-      const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
-      const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
-      const T1l = T1ll | 0;
-      // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
-      const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
-      const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
-      const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
-      const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
-      Hh = Gh | 0;
-      Hl = Gl | 0;
-      Gh = Fh | 0;
-      Gl = Fl | 0;
-      Fh = Eh | 0;
-      Fl = El | 0;
-      ({
-        h: Eh,
-        l: El
-      } = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
-      Dh = Ch | 0;
-      Dl = Cl | 0;
-      Ch = Bh | 0;
-      Cl = Bl | 0;
-      Bh = Ah | 0;
-      Bl = Al | 0;
-      const All = add3L(T1l, sigma0l, MAJl);
-      Ah = add3H(All, T1h, sigma0h, MAJh);
-      Al = All | 0;
-    }
-    // Add the compressed chunk to the current hash value
-    ({
-      h: Ah,
-      l: Al
-    } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
-    ({
-      h: Bh,
-      l: Bl
-    } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
-    ({
-      h: Ch,
-      l: Cl
-    } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
-    ({
-      h: Dh,
-      l: Dl
-    } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
-    ({
-      h: Eh,
-      l: El
-    } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
-    ({
-      h: Fh,
-      l: Fl
-    } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
-    ({
-      h: Gh,
-      l: Gl
-    } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
-    ({
-      h: Hh,
-      l: Hl
-    } = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
-    this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
-  }
-  roundClean() {
-    clean(SHA512_W_H, SHA512_W_L);
-  }
-  destroy() {
-    clean(this.buffer);
-    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-  }
-}
-/**
- * SHA2-256 hash function from RFC 4634.
- *
- * It is the fastest JS hash, even faster than Blake3.
- * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
- * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
- */
-const sha256 = /* @__PURE__ */createHasher(() => new SHA256());
-/** SHA2-512 hash function from RFC 4634. */
-const sha512 = /* @__PURE__ */createHasher(() => new SHA512());
-
-export { SHA256, SHA512, sha256, sha512 };

package/dist/esm/node_modules/@noble/hashes/esm/sha256.js

@@ -1,16 +0,0 @@
-import { sha256 as sha256$1 } from './sha2.js';
-
-/**
- * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
- *
- * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
- * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
- *
- * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
- * @module
- * @deprecated
- */
-/** @deprecated Use import from `noble/hashes/sha2` module */
-const sha256 = sha256$1;
-
-export { sha256 };