@btc-vision/transaction 1.7.19 → 1.7.23

package/browser/noble-hashes.js

@@ -0,0 +1,1608 @@
+const ct = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+function le(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function Bt(t) {
+  if (!Number.isSafeInteger(t) || t < 0)
+    throw new Error("positive integer expected, got " + t);
+}
+function ht(t, ...e) {
+  if (!le(t))
+    throw new Error("Uint8Array expected");
+  if (e.length > 0 && !e.includes(t.length))
+    throw new Error("Uint8Array expected of length " + e + ", got length=" + t.length);
+}
+function be(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  Bt(t.outputLen), Bt(t.blockLen);
+}
+function pt(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function xe(t, e) {
+  ht(t);
+  const s = e.outputLen;
+  if (t.length < s)
+    throw new Error("digestInto() expects output buffer of length at least " + s);
+}
+function nt(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function yt(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function Y(t, e) {
+  return t << 32 - e | t >>> e;
+}
+function it(t, e) {
+  return t << e | t >>> 32 - e >>> 0;
+}
+const Xt = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", pe = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+function rs(t) {
+  if (ht(t), Xt)
+    return t.toHex();
+  let e = "";
+  for (let s = 0; s < t.length; s++)
+    e += pe[t[s]];
+  return e;
+}
+const Z = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function Ut(t) {
+  if (t >= Z._0 && t <= Z._9)
+    return t - Z._0;
+  if (t >= Z.A && t <= Z.F)
+    return t - (Z.A - 10);
+  if (t >= Z.a && t <= Z.f)
+    return t - (Z.a - 10);
+}
+function is(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  if (Xt)
+    return Uint8Array.fromHex(t);
+  const e = t.length, s = e / 2;
+  if (e % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + e);
+  const i = new Uint8Array(s);
+  for (let o = 0, n = 0; o < s; o++, n += 2) {
+    const r = Ut(t.charCodeAt(n)), h = Ut(t.charCodeAt(n + 1));
+    if (r === void 0 || h === void 0) {
+      const d = t[n] + t[n + 1];
+      throw new Error('hex string expected, got non-hex character "' + d + '" at index ' + n);
+    }
+    i[o] = r * 16 + h;
+  }
+  return i;
+}
+function He(t) {
+  if (typeof t != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function wt(t) {
+  return typeof t == "string" && (t = He(t)), ht(t), t;
+}
+function os(...t) {
+  let e = 0;
+  for (let i = 0; i < t.length; i++) {
+    const o = t[i];
+    ht(o), e += o.length;
+  }
+  const s = new Uint8Array(e);
+  for (let i = 0, o = 0; i < t.length; i++) {
+    const n = t[i];
+    s.set(n, o), o += n.length;
+  }
+  return s;
+}
+class Jt {
+}
+function St(t) {
+  const e = (i) => t().update(wt(i)).digest(), s = t();
+  return e.outputLen = s.outputLen, e.blockLen = s.blockLen, e.create = () => t(), e;
+}
+function cs(t = 32) {
+  if (ct && typeof ct.getRandomValues == "function")
+    return ct.getRandomValues(new Uint8Array(t));
+  if (ct && typeof ct.randomBytes == "function")
+    return Uint8Array.from(ct.randomBytes(t));
+  throw new Error("crypto.getRandomValues must be defined");
+}
+function Ae(t, e, s, i) {
+  if (typeof t.setBigUint64 == "function")
+    return t.setBigUint64(e, s, i);
+  const o = BigInt(32), n = BigInt(4294967295), r = Number(s >> o & n), h = Number(s & n), d = i ? 4 : 0, x = i ? 0 : 4;
+  t.setUint32(e + d, r, i), t.setUint32(e + x, h, i);
+}
+function Qt(t, e, s) {
+  return t & e ^ ~t & s;
+}
+function Yt(t, e, s) {
+  return t & e ^ t & s ^ e & s;
+}
+class It extends Jt {
+  constructor(e, s, i, o) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = e, this.outputLen = s, this.padOffset = i, this.isLE = o, this.buffer = new Uint8Array(e), this.view = yt(this.buffer);
+  }
+  update(e) {
+    pt(this), e = wt(e), ht(e);
+    const { view: s, buffer: i, blockLen: o } = this, n = e.length;
+    for (let r = 0; r < n; ) {
+      const h = Math.min(o - this.pos, n - r);
+      if (h === o) {
+        const d = yt(e);
+        for (; o <= n - r; r += o)
+          this.process(d, r);
+        continue;
+      }
+      i.set(e.subarray(r, r + h), this.pos), this.pos += h, r += h, this.pos === o && (this.process(s, 0), this.pos = 0);
+    }
+    return this.length += e.length, this.roundClean(), this;
+  }
+  digestInto(e) {
+    pt(this), xe(e, this), this.finished = !0;
+    const { buffer: s, view: i, blockLen: o, isLE: n } = this;
+    let { pos: r } = this;
+    s[r++] = 128, nt(this.buffer.subarray(r)), this.padOffset > o - r && (this.process(i, 0), r = 0);
+    for (let b = r; b < o; b++)
+      s[b] = 0;
+    Ae(i, o - 8, BigInt(this.length * 8), n), this.process(i, 0);
+    const h = yt(e), d = this.outputLen;
+    if (d % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const x = d / 4, p = this.get();
+    if (x > p.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let b = 0; b < x; b++)
+      h.setUint32(4 * b, p[b], n);
+  }
+  digest() {
+    const { buffer: e, outputLen: s } = this;
+    this.digestInto(e);
+    const i = e.slice(0, s);
+    return this.destroy(), i;
+  }
+  _cloneInto(e) {
+    e || (e = new this.constructor()), e.set(...this.get());
+    const { blockLen: s, buffer: i, length: o, finished: n, destroyed: r, pos: h } = this;
+    return e.destroyed = r, e.finished = n, e.length = o, e.pos = h, o % s && e.buffer.set(i), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const tt = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), ye = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), et = /* @__PURE__ */ new Uint32Array(64);
+class ge extends It {
+  constructor(e = 32) {
+    super(64, e, 8, !1), this.A = tt[0] | 0, this.B = tt[1] | 0, this.C = tt[2] | 0, this.D = tt[3] | 0, this.E = tt[4] | 0, this.F = tt[5] | 0, this.G = tt[6] | 0, this.H = tt[7] | 0;
+  }
+  get() {
+    const { A: e, B: s, C: i, D: o, E: n, F: r, G: h, H: d } = this;
+    return [e, s, i, o, n, r, h, d];
+  }
+  // prettier-ignore
+  set(e, s, i, o, n, r, h, d) {
+    this.A = e | 0, this.B = s | 0, this.C = i | 0, this.D = o | 0, this.E = n | 0, this.F = r | 0, this.G = h | 0, this.H = d | 0;
+  }
+  process(e, s) {
+    for (let b = 0; b < 16; b++, s += 4)
+      et[b] = e.getUint32(s, !1);
+    for (let b = 16; b < 64; b++) {
+      const U = et[b - 15], w = et[b - 2], m = Y(U, 7) ^ Y(U, 18) ^ U >>> 3, k = Y(w, 17) ^ Y(w, 19) ^ w >>> 10;
+      et[b] = k + et[b - 7] + m + et[b - 16] | 0;
+    }
+    let { A: i, B: o, C: n, D: r, E: h, F: d, G: x, H: p } = this;
+    for (let b = 0; b < 64; b++) {
+      const U = Y(h, 6) ^ Y(h, 11) ^ Y(h, 25), w = p + U + Qt(h, d, x) + ye[b] + et[b] | 0, k = (Y(i, 2) ^ Y(i, 13) ^ Y(i, 22)) + Yt(i, o, n) | 0;
+      p = x, x = d, d = h, h = r + w | 0, r = n, n = o, o = i, i = w + k | 0;
+    }
+    i = i + this.A | 0, o = o + this.B | 0, n = n + this.C | 0, r = r + this.D | 0, h = h + this.E | 0, d = d + this.F | 0, x = x + this.G | 0, p = p + this.H | 0, this.set(i, o, n, r, h, d, x, p);
+  }
+  roundClean() {
+    nt(et);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), nt(this.buffer);
+  }
+}
+const _e = /* @__PURE__ */ St(() => new ge()), hs = _e, at = /* @__PURE__ */ Uint32Array.from([
+  1732584193,
+  4023233417,
+  2562383102,
+  271733878,
+  3285377520
+]), st = /* @__PURE__ */ new Uint32Array(80);
+class we extends It {
+  constructor() {
+    super(64, 20, 8, !1), this.A = at[0] | 0, this.B = at[1] | 0, this.C = at[2] | 0, this.D = at[3] | 0, this.E = at[4] | 0;
+  }
+  get() {
+    const { A: e, B: s, C: i, D: o, E: n } = this;
+    return [e, s, i, o, n];
+  }
+  set(e, s, i, o, n) {
+    this.A = e | 0, this.B = s | 0, this.C = i | 0, this.D = o | 0, this.E = n | 0;
+  }
+  process(e, s) {
+    for (let d = 0; d < 16; d++, s += 4)
+      st[d] = e.getUint32(s, !1);
+    for (let d = 16; d < 80; d++)
+      st[d] = it(st[d - 3] ^ st[d - 8] ^ st[d - 14] ^ st[d - 16], 1);
+    let { A: i, B: o, C: n, D: r, E: h } = this;
+    for (let d = 0; d < 80; d++) {
+      let x, p;
+      d < 20 ? (x = Qt(o, n, r), p = 1518500249) : d < 40 ? (x = o ^ n ^ r, p = 1859775393) : d < 60 ? (x = Yt(o, n, r), p = 2400959708) : (x = o ^ n ^ r, p = 3395469782);
+      const b = it(i, 5) + x + h + p + st[d] | 0;
+      h = r, r = n, n = it(o, 30), o = i, i = b;
+    }
+    i = i + this.A | 0, o = o + this.B | 0, n = n + this.C | 0, r = r + this.D | 0, h = h + this.E | 0, this.set(i, o, n, r, h);
+  }
+  roundClean() {
+    nt(st);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0), nt(this.buffer);
+  }
+}
+const Se = /* @__PURE__ */ St(() => new we()), Ie = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), Zt = Uint8Array.from(new Array(16).fill(0).map((t, e) => e)), Le = Zt.map((t) => (9 * t + 5) % 16), zt = /* @__PURE__ */ (() => {
+  const s = [[Zt], [Le]];
+  for (let i = 0; i < 4; i++)
+    for (let o of s)
+      o.push(o[i].map((n) => Ie[n]));
+  return s;
+})(), $t = zt[0], te = zt[1], ee = /* @__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((t) => Uint8Array.from(t)), me = /* @__PURE__ */ $t.map((t, e) => t.map((s) => ee[e][s])), Be = /* @__PURE__ */ te.map((t, e) => t.map((s) => ee[e][s])), Ue = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), Ee = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function Et(t, e, s, i) {
+  return t === 0 ? e ^ s ^ i : t === 1 ? e & s | ~e & i : t === 2 ? (e | ~s) ^ i : t === 3 ? e & i | s & ~i : e ^ (s | ~i);
+}
+const bt = /* @__PURE__ */ new Uint32Array(16);
+class ke extends It {
+  constructor() {
+    super(64, 20, 8, !0), this.h0 = 1732584193, this.h1 = -271733879, this.h2 = -1732584194, this.h3 = 271733878, this.h4 = -1009589776;
+  }
+  get() {
+    const { h0: e, h1: s, h2: i, h3: o, h4: n } = this;
+    return [e, s, i, o, n];
+  }
+  set(e, s, i, o, n) {
+    this.h0 = e | 0, this.h1 = s | 0, this.h2 = i | 0, this.h3 = o | 0, this.h4 = n | 0;
+  }
+  process(e, s) {
+    for (let w = 0; w < 16; w++, s += 4)
+      bt[w] = e.getUint32(s, !0);
+    let i = this.h0 | 0, o = i, n = this.h1 | 0, r = n, h = this.h2 | 0, d = h, x = this.h3 | 0, p = x, b = this.h4 | 0, U = b;
+    for (let w = 0; w < 5; w++) {
+      const m = 4 - w, k = Ue[w], M = Ee[w], P = $t[w], R = te[w], V = me[w], T = Be[w];
+      for (let g = 0; g < 16; g++) {
+        const S = it(i + Et(w, n, h, x) + bt[P[g]] + k, V[g]) + b | 0;
+        i = b, b = x, x = it(h, 10) | 0, h = n, n = S;
+      }
+      for (let g = 0; g < 16; g++) {
+        const S = it(o + Et(m, r, d, p) + bt[R[g]] + M, T[g]) + U | 0;
+        o = U, U = p, p = it(d, 10) | 0, d = r, r = S;
+      }
+    }
+    this.set(this.h1 + h + p | 0, this.h2 + x + U | 0, this.h3 + b + o | 0, this.h4 + i + r | 0, this.h0 + n + d | 0);
+  }
+  roundClean() {
+    nt(bt);
+  }
+  destroy() {
+    this.destroyed = !0, nt(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const Ve = /* @__PURE__ */ St(() => new ke()), as = Ve, fs = Se;
+var j = {}, W = {}, gt = {}, ft = {}, kt;
+function Ce() {
+  return kt || (kt = 1, Object.defineProperty(ft, "__esModule", { value: !0 }), ft.crypto = void 0, ft.crypto = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0), ft;
+}
+var Vt;
+function lt() {
+  return Vt || (Vt = 1, (function(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.wrapXOFConstructorWithOpts = t.wrapConstructorWithOpts = t.wrapConstructor = t.Hash = t.nextTick = t.swap32IfBE = t.byteSwapIfBE = t.swap8IfBE = t.isLE = void 0, t.isBytes = s, t.anumber = i, t.abytes = o, t.ahash = n, t.aexists = r, t.aoutput = h, t.u8 = d, t.u32 = x, t.clean = p, t.createView = b, t.rotr = U, t.rotl = w, t.byteSwap = m, t.byteSwap32 = k, t.bytesToHex = R, t.hexToBytes = g, t.asyncLoop = C, t.utf8ToBytes = B, t.bytesToUtf8 = a, t.toBytes = u, t.kdfInputToBytes = f, t.concatBytes = H, t.checkOpts = l, t.createHasher = I, t.createOptHasher = L, t.createXOFer = D, t.randomBytes = v;
+    const e = /* @__PURE__ */ Ce();
+    function s(c) {
+      return c instanceof Uint8Array || ArrayBuffer.isView(c) && c.constructor.name === "Uint8Array";
+    }
+    function i(c) {
+      if (!Number.isSafeInteger(c) || c < 0)
+        throw new Error("positive integer expected, got " + c);
+    }
+    function o(c, ...A) {
+      if (!s(c))
+        throw new Error("Uint8Array expected");
+      if (A.length > 0 && !A.includes(c.length))
+        throw new Error("Uint8Array expected of length " + A + ", got length=" + c.length);
+    }
+    function n(c) {
+      if (typeof c != "function" || typeof c.create != "function")
+        throw new Error("Hash should be wrapped by utils.createHasher");
+      i(c.outputLen), i(c.blockLen);
+    }
+    function r(c, A = !0) {
+      if (c.destroyed)
+        throw new Error("Hash instance has been destroyed");
+      if (A && c.finished)
+        throw new Error("Hash#digest() has already been called");
+    }
+    function h(c, A) {
+      o(c);
+      const y = A.outputLen;
+      if (c.length < y)
+        throw new Error("digestInto() expects output buffer of length at least " + y);
+    }
+    function d(c) {
+      return new Uint8Array(c.buffer, c.byteOffset, c.byteLength);
+    }
+    function x(c) {
+      return new Uint32Array(c.buffer, c.byteOffset, Math.floor(c.byteLength / 4));
+    }
+    function p(...c) {
+      for (let A = 0; A < c.length; A++)
+        c[A].fill(0);
+    }
+    function b(c) {
+      return new DataView(c.buffer, c.byteOffset, c.byteLength);
+    }
+    function U(c, A) {
+      return c << 32 - A | c >>> A;
+    }
+    function w(c, A) {
+      return c << A | c >>> 32 - A >>> 0;
+    }
+    t.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+    function m(c) {
+      return c << 24 & 4278190080 | c << 8 & 16711680 | c >>> 8 & 65280 | c >>> 24 & 255;
+    }
+    t.swap8IfBE = t.isLE ? (c) => c : (c) => m(c), t.byteSwapIfBE = t.swap8IfBE;
+    function k(c) {
+      for (let A = 0; A < c.length; A++)
+        c[A] = m(c[A]);
+      return c;
+    }
+    t.swap32IfBE = t.isLE ? (c) => c : k;
+    const M = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", P = /* @__PURE__ */ Array.from({ length: 256 }, (c, A) => A.toString(16).padStart(2, "0"));
+    function R(c) {
+      if (o(c), M)
+        return c.toHex();
+      let A = "";
+      for (let y = 0; y < c.length; y++)
+        A += P[c[y]];
+      return A;
+    }
+    const V = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+    function T(c) {
+      if (c >= V._0 && c <= V._9)
+        return c - V._0;
+      if (c >= V.A && c <= V.F)
+        return c - (V.A - 10);
+      if (c >= V.a && c <= V.f)
+        return c - (V.a - 10);
+    }
+    function g(c) {
+      if (typeof c != "string")
+        throw new Error("hex string expected, got " + typeof c);
+      if (M)
+        return Uint8Array.fromHex(c);
+      const A = c.length, y = A / 2;
+      if (A % 2)
+        throw new Error("hex string expected, got unpadded hex of length " + A);
+      const O = new Uint8Array(y);
+      for (let F = 0, G = 0; F < y; F++, G += 2) {
+        const z = T(c.charCodeAt(G)), N = T(c.charCodeAt(G + 1));
+        if (z === void 0 || N === void 0) {
+          const X = c[G] + c[G + 1];
+          throw new Error('hex string expected, got non-hex character "' + X + '" at index ' + G);
+        }
+        O[F] = z * 16 + N;
+      }
+      return O;
+    }
+    const S = async () => {
+    };
+    t.nextTick = S;
+    async function C(c, A, y) {
+      let O = Date.now();
+      for (let F = 0; F < c; F++) {
+        y(F);
+        const G = Date.now() - O;
+        G >= 0 && G < A || (await (0, t.nextTick)(), O += G);
+      }
+    }
+    function B(c) {
+      if (typeof c != "string")
+        throw new Error("string expected");
+      return new Uint8Array(new TextEncoder().encode(c));
+    }
+    function a(c) {
+      return new TextDecoder().decode(c);
+    }
+    function u(c) {
+      return typeof c == "string" && (c = B(c)), o(c), c;
+    }
+    function f(c) {
+      return typeof c == "string" && (c = B(c)), o(c), c;
+    }
+    function H(...c) {
+      let A = 0;
+      for (let O = 0; O < c.length; O++) {
+        const F = c[O];
+        o(F), A += F.length;
+      }
+      const y = new Uint8Array(A);
+      for (let O = 0, F = 0; O < c.length; O++) {
+        const G = c[O];
+        y.set(G, F), F += G.length;
+      }
+      return y;
+    }
+    function l(c, A) {
+      if (A !== void 0 && {}.toString.call(A) !== "[object Object]")
+        throw new Error("options should be object or undefined");
+      return Object.assign(c, A);
+    }
+    class _ {
+    }
+    t.Hash = _;
+    function I(c) {
+      const A = (O) => c().update(u(O)).digest(), y = c();
+      return A.outputLen = y.outputLen, A.blockLen = y.blockLen, A.create = () => c(), A;
+    }
+    function L(c) {
+      const A = (O, F) => c(F).update(u(O)).digest(), y = c({});
+      return A.outputLen = y.outputLen, A.blockLen = y.blockLen, A.create = (O) => c(O), A;
+    }
+    function D(c) {
+      const A = (O, F) => c(F).update(u(O)).digest(), y = c({});
+      return A.outputLen = y.outputLen, A.blockLen = y.blockLen, A.create = (O) => c(O), A;
+    }
+    t.wrapConstructor = I, t.wrapConstructorWithOpts = L, t.wrapXOFConstructorWithOpts = D;
+    function v(c = 32) {
+      if (e.crypto && typeof e.crypto.getRandomValues == "function")
+        return e.crypto.getRandomValues(new Uint8Array(c));
+      if (e.crypto && typeof e.crypto.randomBytes == "function")
+        return Uint8Array.from(e.crypto.randomBytes(c));
+      throw new Error("crypto.getRandomValues must be defined");
+    }
+  })(gt)), gt;
+}
+var Ct;
+function se() {
+  if (Ct) return W;
+  Ct = 1, Object.defineProperty(W, "__esModule", { value: !0 }), W.SHA512_IV = W.SHA384_IV = W.SHA224_IV = W.SHA256_IV = W.HashMD = void 0, W.setBigUint64 = e, W.Chi = s, W.Maj = i;
+  const t = /* @__PURE__ */ lt();
+  function e(n, r, h, d) {
+    if (typeof n.setBigUint64 == "function")
+      return n.setBigUint64(r, h, d);
+    const x = BigInt(32), p = BigInt(4294967295), b = Number(h >> x & p), U = Number(h & p), w = d ? 4 : 0, m = d ? 0 : 4;
+    n.setUint32(r + w, b, d), n.setUint32(r + m, U, d);
+  }
+  function s(n, r, h) {
+    return n & r ^ ~n & h;
+  }
+  function i(n, r, h) {
+    return n & r ^ n & h ^ r & h;
+  }
+  class o extends t.Hash {
+    constructor(r, h, d, x) {
+      super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = r, this.outputLen = h, this.padOffset = d, this.isLE = x, this.buffer = new Uint8Array(r), this.view = (0, t.createView)(this.buffer);
+    }
+    update(r) {
+      (0, t.aexists)(this), r = (0, t.toBytes)(r), (0, t.abytes)(r);
+      const { view: h, buffer: d, blockLen: x } = this, p = r.length;
+      for (let b = 0; b < p; ) {
+        const U = Math.min(x - this.pos, p - b);
+        if (U === x) {
+          const w = (0, t.createView)(r);
+          for (; x <= p - b; b += x)
+            this.process(w, b);
+          continue;
+        }
+        d.set(r.subarray(b, b + U), this.pos), this.pos += U, b += U, this.pos === x && (this.process(h, 0), this.pos = 0);
+      }
+      return this.length += r.length, this.roundClean(), this;
+    }
+    digestInto(r) {
+      (0, t.aexists)(this), (0, t.aoutput)(r, this), this.finished = !0;
+      const { buffer: h, view: d, blockLen: x, isLE: p } = this;
+      let { pos: b } = this;
+      h[b++] = 128, (0, t.clean)(this.buffer.subarray(b)), this.padOffset > x - b && (this.process(d, 0), b = 0);
+      for (let M = b; M < x; M++)
+        h[M] = 0;
+      e(d, x - 8, BigInt(this.length * 8), p), this.process(d, 0);
+      const U = (0, t.createView)(r), w = this.outputLen;
+      if (w % 4)
+        throw new Error("_sha2: outputLen should be aligned to 32bit");
+      const m = w / 4, k = this.get();
+      if (m > k.length)
+        throw new Error("_sha2: outputLen bigger than state");
+      for (let M = 0; M < m; M++)
+        U.setUint32(4 * M, k[M], p);
+    }
+    digest() {
+      const { buffer: r, outputLen: h } = this;
+      this.digestInto(r);
+      const d = r.slice(0, h);
+      return this.destroy(), d;
+    }
+    _cloneInto(r) {
+      r || (r = new this.constructor()), r.set(...this.get());
+      const { blockLen: h, buffer: d, length: x, finished: p, destroyed: b, pos: U } = this;
+      return r.destroyed = b, r.finished = p, r.length = x, r.pos = U, x % h && r.buffer.set(d), r;
+    }
+    clone() {
+      return this._cloneInto();
+    }
+  }
+  return W.HashMD = o, W.SHA256_IV = Uint32Array.from([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]), W.SHA224_IV = Uint32Array.from([
+    3238371032,
+    914150663,
+    812702999,
+    4144912697,
+    4290775857,
+    1750603025,
+    1694076839,
+    3204075428
+  ]), W.SHA384_IV = Uint32Array.from([
+    3418070365,
+    3238371032,
+    1654270250,
+    914150663,
+    2438529370,
+    812702999,
+    355462360,
+    4144912697,
+    1731405415,
+    4290775857,
+    2394180231,
+    1750603025,
+    3675008525,
+    1694076839,
+    1203062813,
+    3204075428
+  ]), W.SHA512_IV = Uint32Array.from([
+    1779033703,
+    4089235720,
+    3144134277,
+    2227873595,
+    1013904242,
+    4271175723,
+    2773480762,
+    1595750129,
+    1359893119,
+    2917565137,
+    2600822924,
+    725511199,
+    528734635,
+    4215389547,
+    1541459225,
+    327033209
+  ]), W;
+}
+var E = {}, Dt;
+function De() {
+  if (Dt) return E;
+  Dt = 1, Object.defineProperty(E, "__esModule", { value: !0 }), E.toBig = E.shrSL = E.shrSH = E.rotrSL = E.rotrSH = E.rotrBL = E.rotrBH = E.rotr32L = E.rotr32H = E.rotlSL = E.rotlSH = E.rotlBL = E.rotlBH = E.add5L = E.add5H = E.add4L = E.add4H = E.add3L = E.add3H = void 0, E.add = P, E.fromBig = s, E.split = i;
+  const t = /* @__PURE__ */ BigInt(2 ** 32 - 1), e = /* @__PURE__ */ BigInt(32);
+  function s(a, u = !1) {
+    return u ? { h: Number(a & t), l: Number(a >> e & t) } : { h: Number(a >> e & t) | 0, l: Number(a & t) | 0 };
+  }
+  function i(a, u = !1) {
+    const f = a.length;
+    let H = new Uint32Array(f), l = new Uint32Array(f);
+    for (let _ = 0; _ < f; _++) {
+      const { h: I, l: L } = s(a[_], u);
+      [H[_], l[_]] = [I, L];
+    }
+    return [H, l];
+  }
+  const o = (a, u) => BigInt(a >>> 0) << e | BigInt(u >>> 0);
+  E.toBig = o;
+  const n = (a, u, f) => a >>> f;
+  E.shrSH = n;
+  const r = (a, u, f) => a << 32 - f | u >>> f;
+  E.shrSL = r;
+  const h = (a, u, f) => a >>> f | u << 32 - f;
+  E.rotrSH = h;
+  const d = (a, u, f) => a << 32 - f | u >>> f;
+  E.rotrSL = d;
+  const x = (a, u, f) => a << 64 - f | u >>> f - 32;
+  E.rotrBH = x;
+  const p = (a, u, f) => a >>> f - 32 | u << 64 - f;
+  E.rotrBL = p;
+  const b = (a, u) => u;
+  E.rotr32H = b;
+  const U = (a, u) => a;
+  E.rotr32L = U;
+  const w = (a, u, f) => a << f | u >>> 32 - f;
+  E.rotlSH = w;
+  const m = (a, u, f) => u << f | a >>> 32 - f;
+  E.rotlSL = m;
+  const k = (a, u, f) => u << f - 32 | a >>> 64 - f;
+  E.rotlBH = k;
+  const M = (a, u, f) => a << f - 32 | u >>> 64 - f;
+  E.rotlBL = M;
+  function P(a, u, f, H) {
+    const l = (u >>> 0) + (H >>> 0);
+    return { h: a + f + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+  }
+  const R = (a, u, f) => (a >>> 0) + (u >>> 0) + (f >>> 0);
+  E.add3L = R;
+  const V = (a, u, f, H) => u + f + H + (a / 2 ** 32 | 0) | 0;
+  E.add3H = V;
+  const T = (a, u, f, H) => (a >>> 0) + (u >>> 0) + (f >>> 0) + (H >>> 0);
+  E.add4L = T;
+  const g = (a, u, f, H, l) => u + f + H + l + (a / 2 ** 32 | 0) | 0;
+  E.add4H = g;
+  const S = (a, u, f, H, l) => (a >>> 0) + (u >>> 0) + (f >>> 0) + (H >>> 0) + (l >>> 0);
+  E.add5L = S;
+  const C = (a, u, f, H, l, _) => u + f + H + l + _ + (a / 2 ** 32 | 0) | 0;
+  E.add5H = C;
+  const B = {
+    fromBig: s,
+    split: i,
+    toBig: o,
+    shrSH: n,
+    shrSL: r,
+    rotrSH: h,
+    rotrSL: d,
+    rotrBH: x,
+    rotrBL: p,
+    rotr32H: b,
+    rotr32L: U,
+    rotlSH: w,
+    rotlSL: m,
+    rotlBH: k,
+    rotlBL: M,
+    add: P,
+    add3L: R,
+    add3H: V,
+    add4L: T,
+    add4H: g,
+    add5H: C,
+    add5L: S
+  };
+  return E.default = B, E;
+}
+var Ot;
+function ne() {
+  if (Ot) return j;
+  Ot = 1, Object.defineProperty(j, "__esModule", { value: !0 }), j.sha512_224 = j.sha512_256 = j.sha384 = j.sha512 = j.sha224 = j.sha256 = j.SHA512_256 = j.SHA512_224 = j.SHA384 = j.SHA512 = j.SHA224 = j.SHA256 = void 0;
+  const t = /* @__PURE__ */ se(), e = /* @__PURE__ */ De(), s = /* @__PURE__ */ lt(), i = /* @__PURE__ */ Uint32Array.from([
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ]), o = /* @__PURE__ */ new Uint32Array(64);
+  class n extends t.HashMD {
+    constructor(V = 32) {
+      super(64, V, 8, !1), this.A = t.SHA256_IV[0] | 0, this.B = t.SHA256_IV[1] | 0, this.C = t.SHA256_IV[2] | 0, this.D = t.SHA256_IV[3] | 0, this.E = t.SHA256_IV[4] | 0, this.F = t.SHA256_IV[5] | 0, this.G = t.SHA256_IV[6] | 0, this.H = t.SHA256_IV[7] | 0;
+    }
+    get() {
+      const { A: V, B: T, C: g, D: S, E: C, F: B, G: a, H: u } = this;
+      return [V, T, g, S, C, B, a, u];
+    }
+    // prettier-ignore
+    set(V, T, g, S, C, B, a, u) {
+      this.A = V | 0, this.B = T | 0, this.C = g | 0, this.D = S | 0, this.E = C | 0, this.F = B | 0, this.G = a | 0, this.H = u | 0;
+    }
+    process(V, T) {
+      for (let l = 0; l < 16; l++, T += 4)
+        o[l] = V.getUint32(T, !1);
+      for (let l = 16; l < 64; l++) {
+        const _ = o[l - 15], I = o[l - 2], L = (0, s.rotr)(_, 7) ^ (0, s.rotr)(_, 18) ^ _ >>> 3, D = (0, s.rotr)(I, 17) ^ (0, s.rotr)(I, 19) ^ I >>> 10;
+        o[l] = D + o[l - 7] + L + o[l - 16] | 0;
+      }
+      let { A: g, B: S, C, D: B, E: a, F: u, G: f, H } = this;
+      for (let l = 0; l < 64; l++) {
+        const _ = (0, s.rotr)(a, 6) ^ (0, s.rotr)(a, 11) ^ (0, s.rotr)(a, 25), I = H + _ + (0, t.Chi)(a, u, f) + i[l] + o[l] | 0, D = ((0, s.rotr)(g, 2) ^ (0, s.rotr)(g, 13) ^ (0, s.rotr)(g, 22)) + (0, t.Maj)(g, S, C) | 0;
+        H = f, f = u, u = a, a = B + I | 0, B = C, C = S, S = g, g = I + D | 0;
+      }
+      g = g + this.A | 0, S = S + this.B | 0, C = C + this.C | 0, B = B + this.D | 0, a = a + this.E | 0, u = u + this.F | 0, f = f + this.G | 0, H = H + this.H | 0, this.set(g, S, C, B, a, u, f, H);
+    }
+    roundClean() {
+      (0, s.clean)(o);
+    }
+    destroy() {
+      this.set(0, 0, 0, 0, 0, 0, 0, 0), (0, s.clean)(this.buffer);
+    }
+  }
+  j.SHA256 = n;
+  class r extends n {
+    constructor() {
+      super(28), this.A = t.SHA224_IV[0] | 0, this.B = t.SHA224_IV[1] | 0, this.C = t.SHA224_IV[2] | 0, this.D = t.SHA224_IV[3] | 0, this.E = t.SHA224_IV[4] | 0, this.F = t.SHA224_IV[5] | 0, this.G = t.SHA224_IV[6] | 0, this.H = t.SHA224_IV[7] | 0;
+    }
+  }
+  j.SHA224 = r;
+  const h = e.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((R) => BigInt(R))), d = h[0], x = h[1], p = /* @__PURE__ */ new Uint32Array(80), b = /* @__PURE__ */ new Uint32Array(80);
+  class U extends t.HashMD {
+    constructor(V = 64) {
+      super(128, V, 16, !1), this.Ah = t.SHA512_IV[0] | 0, this.Al = t.SHA512_IV[1] | 0, this.Bh = t.SHA512_IV[2] | 0, this.Bl = t.SHA512_IV[3] | 0, this.Ch = t.SHA512_IV[4] | 0, this.Cl = t.SHA512_IV[5] | 0, this.Dh = t.SHA512_IV[6] | 0, this.Dl = t.SHA512_IV[7] | 0, this.Eh = t.SHA512_IV[8] | 0, this.El = t.SHA512_IV[9] | 0, this.Fh = t.SHA512_IV[10] | 0, this.Fl = t.SHA512_IV[11] | 0, this.Gh = t.SHA512_IV[12] | 0, this.Gl = t.SHA512_IV[13] | 0, this.Hh = t.SHA512_IV[14] | 0, this.Hl = t.SHA512_IV[15] | 0;
+    }
+    // prettier-ignore
+    get() {
+      const { Ah: V, Al: T, Bh: g, Bl: S, Ch: C, Cl: B, Dh: a, Dl: u, Eh: f, El: H, Fh: l, Fl: _, Gh: I, Gl: L, Hh: D, Hl: v } = this;
+      return [V, T, g, S, C, B, a, u, f, H, l, _, I, L, D, v];
+    }
+    // prettier-ignore
+    set(V, T, g, S, C, B, a, u, f, H, l, _, I, L, D, v) {
+      this.Ah = V | 0, this.Al = T | 0, this.Bh = g | 0, this.Bl = S | 0, this.Ch = C | 0, this.Cl = B | 0, this.Dh = a | 0, this.Dl = u | 0, this.Eh = f | 0, this.El = H | 0, this.Fh = l | 0, this.Fl = _ | 0, this.Gh = I | 0, this.Gl = L | 0, this.Hh = D | 0, this.Hl = v | 0;
+    }
+    process(V, T) {
+      for (let y = 0; y < 16; y++, T += 4)
+        p[y] = V.getUint32(T), b[y] = V.getUint32(T += 4);
+      for (let y = 16; y < 80; y++) {
+        const O = p[y - 15] | 0, F = b[y - 15] | 0, G = e.rotrSH(O, F, 1) ^ e.rotrSH(O, F, 8) ^ e.shrSH(O, F, 7), z = e.rotrSL(O, F, 1) ^ e.rotrSL(O, F, 8) ^ e.shrSL(O, F, 7), N = p[y - 2] | 0, X = b[y - 2] | 0, ot = e.rotrSH(N, X, 19) ^ e.rotrBH(N, X, 61) ^ e.shrSH(N, X, 6), J = e.rotrSL(N, X, 19) ^ e.rotrBL(N, X, 61) ^ e.shrSL(N, X, 6), $ = e.add4L(z, J, b[y - 7], b[y - 16]), At = e.add4H($, G, ot, p[y - 7], p[y - 16]);
+        p[y] = At | 0, b[y] = $ | 0;
+      }
+      let { Ah: g, Al: S, Bh: C, Bl: B, Ch: a, Cl: u, Dh: f, Dl: H, Eh: l, El: _, Fh: I, Fl: L, Gh: D, Gl: v, Hh: c, Hl: A } = this;
+      for (let y = 0; y < 80; y++) {
+        const O = e.rotrSH(l, _, 14) ^ e.rotrSH(l, _, 18) ^ e.rotrBH(l, _, 41), F = e.rotrSL(l, _, 14) ^ e.rotrSL(l, _, 18) ^ e.rotrBL(l, _, 41), G = l & I ^ ~l & D, z = _ & L ^ ~_ & v, N = e.add5L(A, F, z, x[y], b[y]), X = e.add5H(N, c, O, G, d[y], p[y]), ot = N | 0, J = e.rotrSH(g, S, 28) ^ e.rotrBH(g, S, 34) ^ e.rotrBH(g, S, 39), $ = e.rotrSL(g, S, 28) ^ e.rotrBL(g, S, 34) ^ e.rotrBL(g, S, 39), At = g & C ^ g & a ^ C & a, de = S & B ^ S & u ^ B & u;
+        c = D | 0, A = v | 0, D = I | 0, v = L | 0, I = l | 0, L = _ | 0, { h: l, l: _ } = e.add(f | 0, H | 0, X | 0, ot | 0), f = a | 0, H = u | 0, a = C | 0, u = B | 0, C = g | 0, B = S | 0;
+        const mt = e.add3L(ot, $, de);
+        g = e.add3H(mt, X, J, At), S = mt | 0;
+      }
+      ({ h: g, l: S } = e.add(this.Ah | 0, this.Al | 0, g | 0, S | 0)), { h: C, l: B } = e.add(this.Bh | 0, this.Bl | 0, C | 0, B | 0), { h: a, l: u } = e.add(this.Ch | 0, this.Cl | 0, a | 0, u | 0), { h: f, l: H } = e.add(this.Dh | 0, this.Dl | 0, f | 0, H | 0), { h: l, l: _ } = e.add(this.Eh | 0, this.El | 0, l | 0, _ | 0), { h: I, l: L } = e.add(this.Fh | 0, this.Fl | 0, I | 0, L | 0), { h: D, l: v } = e.add(this.Gh | 0, this.Gl | 0, D | 0, v | 0), { h: c, l: A } = e.add(this.Hh | 0, this.Hl | 0, c | 0, A | 0), this.set(g, S, C, B, a, u, f, H, l, _, I, L, D, v, c, A);
+    }
+    roundClean() {
+      (0, s.clean)(p, b);
+    }
+    destroy() {
+      (0, s.clean)(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    }
+  }
+  j.SHA512 = U;
+  class w extends U {
+    constructor() {
+      super(48), this.Ah = t.SHA384_IV[0] | 0, this.Al = t.SHA384_IV[1] | 0, this.Bh = t.SHA384_IV[2] | 0, this.Bl = t.SHA384_IV[3] | 0, this.Ch = t.SHA384_IV[4] | 0, this.Cl = t.SHA384_IV[5] | 0, this.Dh = t.SHA384_IV[6] | 0, this.Dl = t.SHA384_IV[7] | 0, this.Eh = t.SHA384_IV[8] | 0, this.El = t.SHA384_IV[9] | 0, this.Fh = t.SHA384_IV[10] | 0, this.Fl = t.SHA384_IV[11] | 0, this.Gh = t.SHA384_IV[12] | 0, this.Gl = t.SHA384_IV[13] | 0, this.Hh = t.SHA384_IV[14] | 0, this.Hl = t.SHA384_IV[15] | 0;
+    }
+  }
+  j.SHA384 = w;
+  const m = /* @__PURE__ */ Uint32Array.from([
+    2352822216,
+    424955298,
+    1944164710,
+    2312950998,
+    502970286,
+    855612546,
+    1738396948,
+    1479516111,
+    258812777,
+    2077511080,
+    2011393907,
+    79989058,
+    1067287976,
+    1780299464,
+    286451373,
+    2446758561
+  ]), k = /* @__PURE__ */ Uint32Array.from([
+    573645204,
+    4230739756,
+    2673172387,
+    3360449730,
+    596883563,
+    1867755857,
+    2520282905,
+    1497426621,
+    2519219938,
+    2827943907,
+    3193839141,
+    1401305490,
+    721525244,
+    746961066,
+    246885852,
+    2177182882
+  ]);
+  class M extends U {
+    constructor() {
+      super(28), this.Ah = m[0] | 0, this.Al = m[1] | 0, this.Bh = m[2] | 0, this.Bl = m[3] | 0, this.Ch = m[4] | 0, this.Cl = m[5] | 0, this.Dh = m[6] | 0, this.Dl = m[7] | 0, this.Eh = m[8] | 0, this.El = m[9] | 0, this.Fh = m[10] | 0, this.Fl = m[11] | 0, this.Gh = m[12] | 0, this.Gl = m[13] | 0, this.Hh = m[14] | 0, this.Hl = m[15] | 0;
+    }
+  }
+  j.SHA512_224 = M;
+  class P extends U {
+    constructor() {
+      super(32), this.Ah = k[0] | 0, this.Al = k[1] | 0, this.Bh = k[2] | 0, this.Bl = k[3] | 0, this.Ch = k[4] | 0, this.Cl = k[5] | 0, this.Dh = k[6] | 0, this.Dl = k[7] | 0, this.Eh = k[8] | 0, this.El = k[9] | 0, this.Fh = k[10] | 0, this.Fl = k[11] | 0, this.Gh = k[12] | 0, this.Gl = k[13] | 0, this.Hh = k[14] | 0, this.Hl = k[15] | 0;
+    }
+  }
+  return j.SHA512_256 = P, j.sha256 = (0, s.createHasher)(() => new n()), j.sha224 = (0, s.createHasher)(() => new r()), j.sha512 = (0, s.createHasher)(() => new U()), j.sha384 = (0, s.createHasher)(() => new w()), j.sha512_256 = (0, s.createHasher)(() => new P()), j.sha512_224 = (0, s.createHasher)(() => new M()), j;
+}
+var _t = {}, Mt;
+function Oe() {
+  return Mt || (Mt = 1, (function(t) {
+    Object.defineProperty(t, "__esModule", { value: !0 }), t.hmac = t.HMAC = void 0;
+    const e = /* @__PURE__ */ lt();
+    class s extends e.Hash {
+      constructor(n, r) {
+        super(), this.finished = !1, this.destroyed = !1, (0, e.ahash)(n);
+        const h = (0, e.toBytes)(r);
+        if (this.iHash = n.create(), typeof this.iHash.update != "function")
+          throw new Error("Expected instance of class which extends utils.Hash");
+        this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
+        const d = this.blockLen, x = new Uint8Array(d);
+        x.set(h.length > d ? n.create().update(h).digest() : h);
+        for (let p = 0; p < x.length; p++)
+          x[p] ^= 54;
+        this.iHash.update(x), this.oHash = n.create();
+        for (let p = 0; p < x.length; p++)
+          x[p] ^= 106;
+        this.oHash.update(x), (0, e.clean)(x);
+      }
+      update(n) {
+        return (0, e.aexists)(this), this.iHash.update(n), this;
+      }
+      digestInto(n) {
+        (0, e.aexists)(this), (0, e.abytes)(n, this.outputLen), this.finished = !0, this.iHash.digestInto(n), this.oHash.update(n), this.oHash.digestInto(n), this.destroy();
+      }
+      digest() {
+        const n = new Uint8Array(this.oHash.outputLen);
+        return this.digestInto(n), n;
+      }
+      _cloneInto(n) {
+        n || (n = Object.create(Object.getPrototypeOf(this), {}));
+        const { oHash: r, iHash: h, finished: d, destroyed: x, blockLen: p, outputLen: b } = this;
+        return n = n, n.finished = d, n.destroyed = x, n.blockLen = p, n.outputLen = b, n.oHash = r._cloneInto(n.oHash), n.iHash = h._cloneInto(n.iHash), n;
+      }
+      clone() {
+        return this._cloneInto();
+      }
+      destroy() {
+        this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+      }
+    }
+    t.HMAC = s;
+    const i = (o, n, r) => new s(o, n).update(r).digest();
+    t.hmac = i, t.hmac.create = (o, n) => new s(o, n);
+  })(_t)), _t;
+}
+var rt = {}, K = {}, Tt;
+function Me() {
+  if (Tt) return K;
+  Tt = 1, Object.defineProperty(K, "__esModule", { value: !0 }), K.ripemd160 = K.RIPEMD160 = K.md5 = K.MD5 = K.sha1 = K.SHA1 = void 0;
+  const t = /* @__PURE__ */ se(), e = /* @__PURE__ */ lt(), s = /* @__PURE__ */ Uint32Array.from([
+    1732584193,
+    4023233417,
+    2562383102,
+    271733878,
+    3285377520
+  ]), i = /* @__PURE__ */ new Uint32Array(80);
+  class o extends t.HashMD {
+    constructor() {
+      super(64, 20, 8, !1), this.A = s[0] | 0, this.B = s[1] | 0, this.C = s[2] | 0, this.D = s[3] | 0, this.E = s[4] | 0;
+    }
+    get() {
+      const { A: a, B: u, C: f, D: H, E: l } = this;
+      return [a, u, f, H, l];
+    }
+    set(a, u, f, H, l) {
+      this.A = a | 0, this.B = u | 0, this.C = f | 0, this.D = H | 0, this.E = l | 0;
+    }
+    process(a, u) {
+      for (let L = 0; L < 16; L++, u += 4)
+        i[L] = a.getUint32(u, !1);
+      for (let L = 16; L < 80; L++)
+        i[L] = (0, e.rotl)(i[L - 3] ^ i[L - 8] ^ i[L - 14] ^ i[L - 16], 1);
+      let { A: f, B: H, C: l, D: _, E: I } = this;
+      for (let L = 0; L < 80; L++) {
+        let D, v;
+        L < 20 ? (D = (0, t.Chi)(H, l, _), v = 1518500249) : L < 40 ? (D = H ^ l ^ _, v = 1859775393) : L < 60 ? (D = (0, t.Maj)(H, l, _), v = 2400959708) : (D = H ^ l ^ _, v = 3395469782);
+        const c = (0, e.rotl)(f, 5) + D + I + v + i[L] | 0;
+        I = _, _ = l, l = (0, e.rotl)(H, 30), H = f, f = c;
+      }
+      f = f + this.A | 0, H = H + this.B | 0, l = l + this.C | 0, _ = _ + this.D | 0, I = I + this.E | 0, this.set(f, H, l, _, I);
+    }
+    roundClean() {
+      (0, e.clean)(i);
+    }
+    destroy() {
+      this.set(0, 0, 0, 0, 0), (0, e.clean)(this.buffer);
+    }
+  }
+  K.SHA1 = o, K.sha1 = (0, e.createHasher)(() => new o());
+  const n = /* @__PURE__ */ Math.pow(2, 32), r = /* @__PURE__ */ Array.from({ length: 64 }, (B, a) => Math.floor(n * Math.abs(Math.sin(a + 1)))), h = /* @__PURE__ */ s.slice(0, 4), d = /* @__PURE__ */ new Uint32Array(16);
+  class x extends t.HashMD {
+    constructor() {
+      super(64, 16, 8, !0), this.A = h[0] | 0, this.B = h[1] | 0, this.C = h[2] | 0, this.D = h[3] | 0;
+    }
+    get() {
+      const { A: a, B: u, C: f, D: H } = this;
+      return [a, u, f, H];
+    }
+    set(a, u, f, H) {
+      this.A = a | 0, this.B = u | 0, this.C = f | 0, this.D = H | 0;
+    }
+    process(a, u) {
+      for (let I = 0; I < 16; I++, u += 4)
+        d[I] = a.getUint32(u, !0);
+      let { A: f, B: H, C: l, D: _ } = this;
+      for (let I = 0; I < 64; I++) {
+        let L, D, v;
+        I < 16 ? (L = (0, t.Chi)(H, l, _), D = I, v = [7, 12, 17, 22]) : I < 32 ? (L = (0, t.Chi)(_, H, l), D = (5 * I + 1) % 16, v = [5, 9, 14, 20]) : I < 48 ? (L = H ^ l ^ _, D = (3 * I + 5) % 16, v = [4, 11, 16, 23]) : (L = l ^ (H | ~_), D = 7 * I % 16, v = [6, 10, 15, 21]), L = L + f + r[I] + d[D], f = _, _ = l, l = H, H = H + (0, e.rotl)(L, v[I % 4]);
+      }
+      f = f + this.A | 0, H = H + this.B | 0, l = l + this.C | 0, _ = _ + this.D | 0, this.set(f, H, l, _);
+    }
+    roundClean() {
+      (0, e.clean)(d);
+    }
+    destroy() {
+      this.set(0, 0, 0, 0), (0, e.clean)(this.buffer);
+    }
+  }
+  K.MD5 = x, K.md5 = (0, e.createHasher)(() => new x());
+  const p = /* @__PURE__ */ Uint8Array.from([
+    7,
+    4,
+    13,
+    1,
+    10,
+    6,
+    15,
+    3,
+    12,
+    0,
+    9,
+    5,
+    2,
+    14,
+    11,
+    8
+  ]), b = Uint8Array.from(new Array(16).fill(0).map((B, a) => a)), U = b.map((B) => (9 * B + 5) % 16), w = /* @__PURE__ */ (() => {
+    const u = [[b], [U]];
+    for (let f = 0; f < 4; f++)
+      for (let H of u)
+        H.push(H[f].map((l) => p[l]));
+    return u;
+  })(), m = w[0], k = w[1], M = /* @__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((B) => Uint8Array.from(B)), P = /* @__PURE__ */ m.map((B, a) => B.map((u) => M[a][u])), R = /* @__PURE__ */ k.map((B, a) => B.map((u) => M[a][u])), V = /* @__PURE__ */ Uint32Array.from([
+    0,
+    1518500249,
+    1859775393,
+    2400959708,
+    2840853838
+  ]), T = /* @__PURE__ */ Uint32Array.from([
+    1352829926,
+    1548603684,
+    1836072691,
+    2053994217,
+    0
+  ]);
+  function g(B, a, u, f) {
+    return B === 0 ? a ^ u ^ f : B === 1 ? a & u | ~a & f : B === 2 ? (a | ~u) ^ f : B === 3 ? a & f | u & ~f : a ^ (u | ~f);
+  }
+  const S = /* @__PURE__ */ new Uint32Array(16);
+  class C extends t.HashMD {
+    constructor() {
+      super(64, 20, 8, !0), this.h0 = 1732584193, this.h1 = -271733879, this.h2 = -1732584194, this.h3 = 271733878, this.h4 = -1009589776;
+    }
+    get() {
+      const { h0: a, h1: u, h2: f, h3: H, h4: l } = this;
+      return [a, u, f, H, l];
+    }
+    set(a, u, f, H, l) {
+      this.h0 = a | 0, this.h1 = u | 0, this.h2 = f | 0, this.h3 = H | 0, this.h4 = l | 0;
+    }
+    process(a, u) {
+      for (let y = 0; y < 16; y++, u += 4)
+        S[y] = a.getUint32(u, !0);
+      let f = this.h0 | 0, H = f, l = this.h1 | 0, _ = l, I = this.h2 | 0, L = I, D = this.h3 | 0, v = D, c = this.h4 | 0, A = c;
+      for (let y = 0; y < 5; y++) {
+        const O = 4 - y, F = V[y], G = T[y], z = m[y], N = k[y], X = P[y], ot = R[y];
+        for (let J = 0; J < 16; J++) {
+          const $ = (0, e.rotl)(f + g(y, l, I, D) + S[z[J]] + F, X[J]) + c | 0;
+          f = c, c = D, D = (0, e.rotl)(I, 10) | 0, I = l, l = $;
+        }
+        for (let J = 0; J < 16; J++) {
+          const $ = (0, e.rotl)(H + g(O, _, L, v) + S[N[J]] + G, ot[J]) + A | 0;
+          H = A, A = v, v = (0, e.rotl)(L, 10) | 0, L = _, _ = $;
+        }
+      }
+      this.set(this.h1 + I + v | 0, this.h2 + D + A | 0, this.h3 + c + H | 0, this.h4 + f + _ | 0, this.h0 + l + L | 0);
+    }
+    roundClean() {
+      (0, e.clean)(S);
+    }
+    destroy() {
+      this.destroyed = !0, (0, e.clean)(this.buffer), this.set(0, 0, 0, 0, 0);
+    }
+  }
+  return K.RIPEMD160 = C, K.ripemd160 = (0, e.createHasher)(() => new C()), K;
+}
+var vt;
+function us() {
+  if (vt) return rt;
+  vt = 1, Object.defineProperty(rt, "__esModule", { value: !0 }), rt.ripemd160 = rt.RIPEMD160 = void 0;
+  const t = /* @__PURE__ */ Me();
+  return rt.RIPEMD160 = t.RIPEMD160, rt.ripemd160 = t.ripemd160, rt;
+}
+var Q = {}, Ft;
+function ds() {
+  if (Ft) return Q;
+  Ft = 1, Object.defineProperty(Q, "__esModule", { value: !0 }), Q.sha224 = Q.SHA224 = Q.sha256 = Q.SHA256 = void 0;
+  const t = /* @__PURE__ */ ne();
+  return Q.SHA256 = t.SHA256, Q.sha256 = t.sha256, Q.SHA224 = t.SHA224, Q.sha224 = t.sha224, Q;
+}
+var q = {}, Rt;
+function ls() {
+  if (Rt) return q;
+  Rt = 1, Object.defineProperty(q, "__esModule", { value: !0 }), q.sha512_256 = q.SHA512_256 = q.sha512_224 = q.SHA512_224 = q.sha384 = q.SHA384 = q.sha512 = q.SHA512 = void 0;
+  const t = /* @__PURE__ */ ne();
+  return q.SHA512 = t.SHA512, q.sha512 = t.sha512, q.SHA384 = t.SHA384, q.sha384 = t.sha384, q.SHA512_224 = t.SHA512_224, q.sha512_224 = t.sha512_224, q.SHA512_256 = t.SHA512_256, q.sha512_256 = t.sha512_256, q;
+}
+function Te(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function jt(t, e = "") {
+  if (!Number.isSafeInteger(t) || t < 0) {
+    const s = e && `"${e}" `;
+    throw new Error(`${s}expected integer >= 0, got ${t}`);
+  }
+}
+function Ht(t, e, s = "") {
+  const i = Te(t), o = t?.length, n = e !== void 0;
+  if (!i || n && o !== e) {
+    const r = s && `"${s}" `, h = n ? ` of length ${e}` : "", d = i ? `length=${o}` : `type=${typeof t}`;
+    throw new Error(r + "expected Uint8Array" + h + ", got " + d);
+  }
+  return t;
+}
+function Pt(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function ve(t, e) {
+  Ht(t, void 0, "digestInto() output");
+  const s = e.outputLen;
+  if (t.length < s)
+    throw new Error('"digestInto() output" expected to be of length >=' + s);
+}
+function Fe(t) {
+  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
+}
+function re(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+const Re = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function je(t) {
+  return t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255;
+}
+function Pe(t) {
+  for (let e = 0; e < t.length; e++)
+    t[e] = je(t[e]);
+  return t;
+}
+const Gt = Re ? (t) => t : Pe;
+function bs(...t) {
+  let e = 0;
+  for (let i = 0; i < t.length; i++) {
+    const o = t[i];
+    Ht(o), e += o.length;
+  }
+  const s = new Uint8Array(e);
+  for (let i = 0, o = 0; i < t.length; i++) {
+    const n = t[i];
+    s.set(n, o), o += n.length;
+  }
+  return s;
+}
+function Ge(t, e = {}) {
+  const s = (o, n) => t(n).update(o).digest(), i = t(void 0);
+  return s.outputLen = i.outputLen, s.blockLen = i.blockLen, s.create = (o) => t(o), Object.assign(s, e), Object.freeze(s);
+}
+function xs(t = 32) {
+  const e = typeof globalThis == "object" ? globalThis.crypto : null;
+  if (typeof e?.getRandomValues != "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return e.getRandomValues(new Uint8Array(t));
+}
+const ie = (t) => ({
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, t])
+}), xt = /* @__PURE__ */ BigInt(2 ** 32 - 1), qt = /* @__PURE__ */ BigInt(32);
+function qe(t, e = !1) {
+  return e ? { h: Number(t & xt), l: Number(t >> qt & xt) } : { h: Number(t >> qt & xt) | 0, l: Number(t & xt) | 0 };
+}
+function We(t, e = !1) {
+  const s = t.length;
+  let i = new Uint32Array(s), o = new Uint32Array(s);
+  for (let n = 0; n < s; n++) {
+    const { h: r, l: h } = qe(t[n], e);
+    [i[n], o[n]] = [r, h];
+  }
+  return [i, o];
+}
+const Ke = (t, e, s) => t << s | e >>> 32 - s, Ne = (t, e, s) => e << s | t >>> 32 - s, Xe = (t, e, s) => e << s - 32 | t >>> 64 - s, Je = (t, e, s) => t << s - 32 | e >>> 64 - s, Qe = BigInt(0), ut = BigInt(1), Ye = BigInt(2), Ze = BigInt(7), ze = BigInt(256), $e = BigInt(113), oe = [], ce = [], he = [];
+for (let t = 0, e = ut, s = 1, i = 0; t < 24; t++) {
+  [s, i] = [i, (2 * s + 3 * i) % 5], oe.push(2 * (5 * i + s)), ce.push((t + 1) * (t + 2) / 2 % 64);
+  let o = Qe;
+  for (let n = 0; n < 7; n++)
+    e = (e << ut ^ (e >> Ze) * $e) % ze, e & Ye && (o ^= ut << (ut << BigInt(n)) - ut);
+  he.push(o);
+}
+const ae = We(he, !0), ts = ae[0], es = ae[1], Wt = (t, e, s) => s > 32 ? Xe(t, e, s) : Ke(t, e, s), Kt = (t, e, s) => s > 32 ? Je(t, e, s) : Ne(t, e, s);
+function ss(t, e = 24) {
+  const s = new Uint32Array(10);
+  for (let i = 24 - e; i < 24; i++) {
+    for (let r = 0; r < 10; r++)
+      s[r] = t[r] ^ t[r + 10] ^ t[r + 20] ^ t[r + 30] ^ t[r + 40];
+    for (let r = 0; r < 10; r += 2) {
+      const h = (r + 8) % 10, d = (r + 2) % 10, x = s[d], p = s[d + 1], b = Wt(x, p, 1) ^ s[h], U = Kt(x, p, 1) ^ s[h + 1];
+      for (let w = 0; w < 50; w += 10)
+        t[r + w] ^= b, t[r + w + 1] ^= U;
+    }
+    let o = t[2], n = t[3];
+    for (let r = 0; r < 24; r++) {
+      const h = ce[r], d = Wt(o, n, h), x = Kt(o, n, h), p = oe[r];
+      o = t[p], n = t[p + 1], t[p] = d, t[p + 1] = x;
+    }
+    for (let r = 0; r < 50; r += 10) {
+      for (let h = 0; h < 10; h++)
+        s[h] = t[r + h];
+      for (let h = 0; h < 10; h++)
+        t[r + h] ^= ~s[(h + 2) % 10] & s[(h + 4) % 10];
+    }
+    t[0] ^= ts[i], t[1] ^= es[i];
+  }
+  re(s);
+}
+class Lt {
+  state;
+  pos = 0;
+  posOut = 0;
+  finished = !1;
+  state32;
+  destroyed = !1;
+  blockLen;
+  suffix;
+  outputLen;
+  enableXOF = !1;
+  rounds;
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(e, s, i, o = !1, n = 24) {
+    if (this.blockLen = e, this.suffix = s, this.outputLen = i, this.enableXOF = o, this.rounds = n, jt(i, "outputLen"), !(0 < e && e < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200), this.state32 = Fe(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    Gt(this.state32), ss(this.state32, this.rounds), Gt(this.state32), this.posOut = 0, this.pos = 0;
+  }
+  update(e) {
+    Pt(this), Ht(e);
+    const { blockLen: s, state: i } = this, o = e.length;
+    for (let n = 0; n < o; ) {
+      const r = Math.min(s - this.pos, o - n);
+      for (let h = 0; h < r; h++)
+        i[this.pos++] ^= e[n++];
+      this.pos === s && this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = !0;
+    const { state: e, suffix: s, pos: i, blockLen: o } = this;
+    e[i] ^= s, (s & 128) !== 0 && i === o - 1 && this.keccak(), e[o - 1] ^= 128, this.keccak();
+  }
+  writeInto(e) {
+    Pt(this, !1), Ht(e), this.finish();
+    const s = this.state, { blockLen: i } = this;
+    for (let o = 0, n = e.length; o < n; ) {
+      this.posOut >= i && this.keccak();
+      const r = Math.min(i - this.posOut, n - o);
+      e.set(s.subarray(this.posOut, this.posOut + r), o), this.posOut += r, o += r;
+    }
+    return e;
+  }
+  xofInto(e) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(e);
+  }
+  xof(e) {
+    return jt(e), this.xofInto(new Uint8Array(e));
+  }
+  digestInto(e) {
+    if (ve(e, this), this.finished)
+      throw new Error("digest() was already called");
+    return this.writeInto(e), this.destroy(), e;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = !0, re(this.state);
+  }
+  _cloneInto(e) {
+    const { blockLen: s, suffix: i, outputLen: o, rounds: n, enableXOF: r } = this;
+    return e ||= new Lt(s, i, o, r, n), e.state32.set(this.state32), e.pos = this.pos, e.posOut = this.posOut, e.finished = this.finished, e.rounds = n, e.suffix = i, e.outputLen = o, e.enableXOF = r, e.destroyed = this.destroyed, e;
+  }
+}
+const fe = (t, e, s, i = {}) => Ge((o = {}) => new Lt(e, t, o.dkLen === void 0 ? s : o.dkLen, !0), i), ps = /* @__PURE__ */ fe(31, 168, 16, /* @__PURE__ */ ie(11)), Hs = /* @__PURE__ */ fe(31, 136, 32, /* @__PURE__ */ ie(12));
+class ue extends Jt {
+  constructor(e, s) {
+    super(), this.finished = !1, this.destroyed = !1, be(e);
+    const i = wt(s);
+    if (this.iHash = e.create(), typeof this.iHash.update != "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
+    const o = this.blockLen, n = new Uint8Array(o);
+    n.set(i.length > o ? e.create().update(i).digest() : i);
+    for (let r = 0; r < n.length; r++)
+      n[r] ^= 54;
+    this.iHash.update(n), this.oHash = e.create();
+    for (let r = 0; r < n.length; r++)
+      n[r] ^= 106;
+    this.oHash.update(n), nt(n);
+  }
+  update(e) {
+    return pt(this), this.iHash.update(e), this;
+  }
+  digestInto(e) {
+    pt(this), ht(e, this.outputLen), this.finished = !0, this.iHash.digestInto(e), this.oHash.update(e), this.oHash.digestInto(e), this.destroy();
+  }
+  digest() {
+    const e = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(e), e;
+  }
+  _cloneInto(e) {
+    e || (e = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: s, iHash: i, finished: o, destroyed: n, blockLen: r, outputLen: h } = this;
+    return e = e, e.finished = o, e.destroyed = n, e.blockLen = r, e.outputLen = h, e.oHash = s._cloneInto(e.oHash), e.iHash = i._cloneInto(e.iHash), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const ns = (t, e, s) => new ue(t, e).update(s).digest();
+ns.create = (t, e) => new ue(t, e);
+var dt = {}, Nt;
+function As() {
+  if (Nt) return dt;
+  Nt = 1, Object.defineProperty(dt, "__esModule", { value: !0 }), dt.pbkdf2 = o, dt.pbkdf2Async = n;
+  const t = /* @__PURE__ */ Oe(), e = /* @__PURE__ */ lt();
+  function s(r, h, d, x) {
+    (0, e.ahash)(r);
+    const p = (0, e.checkOpts)({ dkLen: 32, asyncTick: 10 }, x), { c: b, dkLen: U, asyncTick: w } = p;
+    if ((0, e.anumber)(b), (0, e.anumber)(U), (0, e.anumber)(w), b < 1)
+      throw new Error("iterations (c) should be >= 1");
+    const m = (0, e.kdfInputToBytes)(h), k = (0, e.kdfInputToBytes)(d), M = new Uint8Array(U), P = t.hmac.create(r, m), R = P._cloneInto().update(k);
+    return { c: b, dkLen: U, asyncTick: w, DK: M, PRF: P, PRFSalt: R };
+  }
+  function i(r, h, d, x, p) {
+    return r.destroy(), h.destroy(), x && x.destroy(), (0, e.clean)(p), d;
+  }
+  function o(r, h, d, x) {
+    const { c: p, dkLen: b, DK: U, PRF: w, PRFSalt: m } = s(r, h, d, x);
+    let k;
+    const M = new Uint8Array(4), P = (0, e.createView)(M), R = new Uint8Array(w.outputLen);
+    for (let V = 1, T = 0; T < b; V++, T += w.outputLen) {
+      const g = U.subarray(T, T + w.outputLen);
+      P.setInt32(0, V, !1), (k = m._cloneInto(k)).update(M).digestInto(R), g.set(R.subarray(0, g.length));
+      for (let S = 1; S < p; S++) {
+        w._cloneInto(k).update(R).digestInto(R);
+        for (let C = 0; C < g.length; C++)
+          g[C] ^= R[C];
+      }
+    }
+    return i(w, m, U, k, R);
+  }
+  async function n(r, h, d, x) {
+    const { c: p, dkLen: b, asyncTick: U, DK: w, PRF: m, PRFSalt: k } = s(r, h, d, x);
+    let M;
+    const P = new Uint8Array(4), R = (0, e.createView)(P), V = new Uint8Array(m.outputLen);
+    for (let T = 1, g = 0; g < b; T++, g += m.outputLen) {
+      const S = w.subarray(g, g + m.outputLen);
+      R.setInt32(0, T, !1), (M = k._cloneInto(M)).update(P).digestInto(V), S.set(V.subarray(0, S.length)), await (0, e.asyncLoop)(p - 1, U, () => {
+        m._cloneInto(M).update(V).digestInto(V);
+        for (let C = 0; C < S.length; C++)
+          S[C] ^= V[C];
+      });
+    }
+    return i(m, k, w, M, V);
+  }
+  return dt;
+}
+export {
+  He as A,
+  ls as a,
+  ds as b,
+  lt as c,
+  us as d,
+  Oe as e,
+  as as f,
+  fs as g,
+  Ht as h,
+  xs as i,
+  bs as j,
+  Te as k,
+  ps as l,
+  Hs as m,
+  ne as n,
+  rs as o,
+  le as p,
+  is as q,
+  As as r,
+  hs as s,
+  ht as t,
+  os as u,
+  Bt as v,
+  be as w,
+  cs as x,
+  ns as y,
+  _e as z
+};