@prosopo/procaptcha-bundle 3.0.12 → 3.1.6

package/dist/bundle/nobleChunk-Bbltwf44.js

@@ -0,0 +1,2728 @@
+const kt = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+function ye(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function F(t) {
+  if (!Number.isSafeInteger(t) || t < 0)
+    throw new Error("positive integer expected, got " + t);
+}
+function et(t, ...e) {
+  if (!ye(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 $e(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  F(t.outputLen), F(t.blockLen);
+}
+function Nt(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 Ye(t, e) {
+  et(t);
+  const n = e.outputLen;
+  if (t.length < n)
+    throw new Error("digestInto() expects output buffer of length at least " + n);
+}
+function St(t) {
+  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
+}
+function rt(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function Wt(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function ot(t, e) {
+  return t << 32 - e | t >>> e;
+}
+function C(t, e) {
+  return t << e | t >>> 32 - e >>> 0;
+}
+const Xe = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function Ke(t) {
+  return t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255;
+}
+const ft = Xe ? (t) => t : (t) => Ke(t);
+function In(t) {
+  for (let e = 0; e < t.length; e++)
+    t[e] = Ke(t[e]);
+  return t;
+}
+const gt = Xe ? (t) => t : In, Pe = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Ln = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+function It(t) {
+  if (et(t), Pe)
+    return t.toHex();
+  let e = "";
+  for (let n = 0; n < t.length; n++)
+    e += Ln[t[n]];
+  return e;
+}
+const ct = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+function Ie(t) {
+  if (t >= ct._0 && t <= ct._9)
+    return t - ct._0;
+  if (t >= ct.A && t <= ct.F)
+    return t - (ct.A - 10);
+  if (t >= ct.a && t <= ct.f)
+    return t - (ct.a - 10);
+}
+function ge(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  if (Pe)
+    return Uint8Array.fromHex(t);
+  const e = t.length, n = e / 2;
+  if (e % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + e);
+  const r = new Uint8Array(n);
+  for (let i = 0, s = 0; i < n; i++, s += 2) {
+    const o = Ie(t.charCodeAt(s)), c = Ie(t.charCodeAt(s + 1));
+    if (o === void 0 || c === void 0) {
+      const a = t[s] + t[s + 1];
+      throw new Error('hex string expected, got non-hex character "' + a + '" at index ' + s);
+    }
+    r[i] = o * 16 + c;
+  }
+  return r;
+}
+function We(t) {
+  if (typeof t != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function Bt(t) {
+  return typeof t == "string" && (t = We(t)), et(t), t;
+}
+function Le(t) {
+  return typeof t == "string" && (t = We(t)), et(t), t;
+}
+function lt(...t) {
+  let e = 0;
+  for (let r = 0; r < t.length; r++) {
+    const i = t[r];
+    et(i), e += i.length;
+  }
+  const n = new Uint8Array(e);
+  for (let r = 0, i = 0; r < t.length; r++) {
+    const s = t[r];
+    n.set(s, i), i += s.length;
+  }
+  return n;
+}
+function Qe(t, e) {
+  if (e !== void 0 && {}.toString.call(e) !== "[object Object]")
+    throw new Error("options should be object or undefined");
+  return Object.assign(t, e);
+}
+class me {
+}
+function Je(t) {
+  const e = (r) => t().update(Bt(r)).digest(), n = t();
+  return e.outputLen = n.outputLen, e.blockLen = n.blockLen, e.create = () => t(), e;
+}
+function On(t) {
+  const e = (r, i) => t(i).update(Bt(r)).digest(), n = t({});
+  return e.outputLen = n.outputLen, e.blockLen = n.blockLen, e.create = (r) => t(r), e;
+}
+function Fe(t = 32) {
+  if (kt && typeof kt.getRandomValues == "function")
+    return kt.getRandomValues(new Uint8Array(t));
+  if (kt && typeof kt.randomBytes == "function")
+    return Uint8Array.from(kt.randomBytes(t));
+  throw new Error("crypto.getRandomValues must be defined");
+}
+function Hn(t, e, n, r) {
+  if (typeof t.setBigUint64 == "function")
+    return t.setBigUint64(e, n, r);
+  const i = BigInt(32), s = BigInt(4294967295), o = Number(n >> i & s), c = Number(n & s), a = r ? 4 : 0, l = r ? 0 : 4;
+  t.setUint32(e + a, o, r), t.setUint32(e + l, c, r);
+}
+function Rn(t, e, n) {
+  return t & e ^ ~t & n;
+}
+function kn(t, e, n) {
+  return t & e ^ t & n ^ e & n;
+}
+class tn extends me {
+  constructor(e, n, r, i) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = e, this.outputLen = n, this.padOffset = r, this.isLE = i, this.buffer = new Uint8Array(e), this.view = Wt(this.buffer);
+  }
+  update(e) {
+    Nt(this), e = Bt(e), et(e);
+    const { view: n, buffer: r, blockLen: i } = this, s = e.length;
+    for (let o = 0; o < s; ) {
+      const c = Math.min(i - this.pos, s - o);
+      if (c === i) {
+        const a = Wt(e);
+        for (; i <= s - o; o += i)
+          this.process(a, o);
+        continue;
+      }
+      r.set(e.subarray(o, o + c), this.pos), this.pos += c, o += c, this.pos === i && (this.process(n, 0), this.pos = 0);
+    }
+    return this.length += e.length, this.roundClean(), this;
+  }
+  digestInto(e) {
+    Nt(this), Ye(e, this), this.finished = !0;
+    const { buffer: n, view: r, blockLen: i, isLE: s } = this;
+    let { pos: o } = this;
+    n[o++] = 128, rt(this.buffer.subarray(o)), this.padOffset > i - o && (this.process(r, 0), o = 0);
+    for (let u = o; u < i; u++)
+      n[u] = 0;
+    Hn(r, i - 8, BigInt(this.length * 8), s), this.process(r, 0);
+    const c = Wt(e), a = this.outputLen;
+    if (a % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const l = a / 4, f = this.get();
+    if (l > f.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let u = 0; u < l; u++)
+      c.setUint32(4 * u, f[u], s);
+  }
+  digest() {
+    const { buffer: e, outputLen: n } = this;
+    this.digestInto(e);
+    const r = e.slice(0, n);
+    return this.destroy(), r;
+  }
+  _cloneInto(e) {
+    e || (e = new this.constructor()), e.set(...this.get());
+    const { blockLen: n, buffer: r, length: i, finished: s, destroyed: o, pos: c } = this;
+    return e.destroyed = o, e.finished = s, e.length = i, e.pos = c, i % n && e.buffer.set(r), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const ht = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+const W = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]), Xt = /* @__PURE__ */ BigInt(2 ** 32 - 1), Oe = /* @__PURE__ */ BigInt(32);
+function en(t, e = !1) {
+  return e ? { h: Number(t & Xt), l: Number(t >> Oe & Xt) } : { h: Number(t >> Oe & Xt) | 0, l: Number(t & Xt) | 0 };
+}
+function nn(t, e = !1) {
+  const n = t.length;
+  let r = new Uint32Array(n), i = new Uint32Array(n);
+  for (let s = 0; s < n; s++) {
+    const { h: o, l: c } = en(t[s], e);
+    [r[s], i[s]] = [o, c];
+  }
+  return [r, i];
+}
+const He = (t, e, n) => t >>> n, Re = (t, e, n) => t << 32 - n | e >>> n, mt = (t, e, n) => t >>> n | e << 32 - n, pt = (t, e, n) => t << 32 - n | e >>> n, zt = (t, e, n) => t << 64 - n | e >>> n - 32, Vt = (t, e, n) => t >>> n - 32 | e << 64 - n, Un = (t, e) => e, qn = (t, e) => t, Nn = (t, e, n) => t << n | e >>> 32 - n, Tn = (t, e, n) => e << n | t >>> 32 - n, Dn = (t, e, n) => e << n - 32 | t >>> 64 - n, Cn = (t, e, n) => t << n - 32 | e >>> 64 - n;
+function st(t, e, n, r) {
+  const i = (e >>> 0) + (r >>> 0);
+  return { h: t + n + (i / 2 ** 32 | 0) | 0, l: i | 0 };
+}
+const pe = (t, e, n) => (t >>> 0) + (e >>> 0) + (n >>> 0), Ee = (t, e, n, r) => e + n + r + (t / 2 ** 32 | 0) | 0, Zn = (t, e, n, r) => (t >>> 0) + (e >>> 0) + (n >>> 0) + (r >>> 0), Mn = (t, e, n, r, i) => e + n + r + i + (t / 2 ** 32 | 0) | 0, zn = (t, e, n, r, i) => (t >>> 0) + (e >>> 0) + (n >>> 0) + (r >>> 0) + (i >>> 0), Vn = (t, e, n, r, i, s) => e + n + r + i + s + (t / 2 ** 32 | 0) | 0, Gn = /* @__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
+]), dt = /* @__PURE__ */ new Uint32Array(64);
+class jn extends tn {
+  constructor(e = 32) {
+    super(64, e, 8, !1), this.A = ht[0] | 0, this.B = ht[1] | 0, this.C = ht[2] | 0, this.D = ht[3] | 0, this.E = ht[4] | 0, this.F = ht[5] | 0, this.G = ht[6] | 0, this.H = ht[7] | 0;
+  }
+  get() {
+    const { A: e, B: n, C: r, D: i, E: s, F: o, G: c, H: a } = this;
+    return [e, n, r, i, s, o, c, a];
+  }
+  // prettier-ignore
+  set(e, n, r, i, s, o, c, a) {
+    this.A = e | 0, this.B = n | 0, this.C = r | 0, this.D = i | 0, this.E = s | 0, this.F = o | 0, this.G = c | 0, this.H = a | 0;
+  }
+  process(e, n) {
+    for (let u = 0; u < 16; u++, n += 4)
+      dt[u] = e.getUint32(n, !1);
+    for (let u = 16; u < 64; u++) {
+      const b = dt[u - 15], h = dt[u - 2], E = ot(b, 7) ^ ot(b, 18) ^ b >>> 3, w = ot(h, 17) ^ ot(h, 19) ^ h >>> 10;
+      dt[u] = w + dt[u - 7] + E + dt[u - 16] | 0;
+    }
+    let { A: r, B: i, C: s, D: o, E: c, F: a, G: l, H: f } = this;
+    for (let u = 0; u < 64; u++) {
+      const b = ot(c, 6) ^ ot(c, 11) ^ ot(c, 25), h = f + b + Rn(c, a, l) + Gn[u] + dt[u] | 0, w = (ot(r, 2) ^ ot(r, 13) ^ ot(r, 22)) + kn(r, i, s) | 0;
+      f = l, l = a, a = c, c = o + h | 0, o = s, s = i, i = r, r = h + w | 0;
+    }
+    r = r + this.A | 0, i = i + this.B | 0, s = s + this.C | 0, o = o + this.D | 0, c = c + this.E | 0, a = a + this.F | 0, l = l + this.G | 0, f = f + this.H | 0, this.set(r, i, s, o, c, a, l, f);
+  }
+  roundClean() {
+    rt(dt);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), rt(this.buffer);
+  }
+}
+const rn = nn([
+  "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((t) => BigInt(t))), $n = rn[0], Yn = rn[1], bt = /* @__PURE__ */ new Uint32Array(80), xt = /* @__PURE__ */ new Uint32Array(80);
+class Xn extends tn {
+  constructor(e = 64) {
+    super(128, e, 16, !1), this.Ah = W[0] | 0, this.Al = W[1] | 0, this.Bh = W[2] | 0, this.Bl = W[3] | 0, this.Ch = W[4] | 0, this.Cl = W[5] | 0, this.Dh = W[6] | 0, this.Dl = W[7] | 0, this.Eh = W[8] | 0, this.El = W[9] | 0, this.Fh = W[10] | 0, this.Fl = W[11] | 0, this.Gh = W[12] | 0, this.Gl = W[13] | 0, this.Hh = W[14] | 0, this.Hl = W[15] | 0;
+  }
+  // prettier-ignore
+  get() {
+    const { Ah: e, Al: n, Bh: r, Bl: i, Ch: s, Cl: o, Dh: c, Dl: a, Eh: l, El: f, Fh: u, Fl: b, Gh: h, Gl: E, Hh: w, Hl: x } = this;
+    return [e, n, r, i, s, o, c, a, l, f, u, b, h, E, w, x];
+  }
+  // prettier-ignore
+  set(e, n, r, i, s, o, c, a, l, f, u, b, h, E, w, x) {
+    this.Ah = e | 0, this.Al = n | 0, this.Bh = r | 0, this.Bl = i | 0, this.Ch = s | 0, this.Cl = o | 0, this.Dh = c | 0, this.Dl = a | 0, this.Eh = l | 0, this.El = f | 0, this.Fh = u | 0, this.Fl = b | 0, this.Gh = h | 0, this.Gl = E | 0, this.Hh = w | 0, this.Hl = x | 0;
+  }
+  process(e, n) {
+    for (let L = 0; L < 16; L++, n += 4)
+      bt[L] = e.getUint32(n), xt[L] = e.getUint32(n += 4);
+    for (let L = 16; L < 80; L++) {
+      const T = bt[L - 15] | 0, m = xt[L - 15] | 0, H = mt(T, m, 1) ^ mt(T, m, 8) ^ He(T, m, 7), U = pt(T, m, 1) ^ pt(T, m, 8) ^ Re(T, m, 7), O = bt[L - 2] | 0, d = xt[L - 2] | 0, p = mt(O, d, 19) ^ zt(O, d, 61) ^ He(O, d, 6), y = pt(O, d, 19) ^ Vt(O, d, 61) ^ Re(O, d, 6), g = Zn(U, y, xt[L - 7], xt[L - 16]), B = Mn(g, H, p, bt[L - 7], bt[L - 16]);
+      bt[L] = B | 0, xt[L] = g | 0;
+    }
+    let { Ah: r, Al: i, Bh: s, Bl: o, Ch: c, Cl: a, Dh: l, Dl: f, Eh: u, El: b, Fh: h, Fl: E, Gh: w, Gl: x, Hh: _, Hl: R } = this;
+    for (let L = 0; L < 80; L++) {
+      const T = mt(u, b, 14) ^ mt(u, b, 18) ^ zt(u, b, 41), m = pt(u, b, 14) ^ pt(u, b, 18) ^ Vt(u, b, 41), H = u & h ^ ~u & w, U = b & E ^ ~b & x, O = zn(R, m, U, Yn[L], xt[L]), d = Vn(O, _, T, H, $n[L], bt[L]), p = O | 0, y = mt(r, i, 28) ^ zt(r, i, 34) ^ zt(r, i, 39), g = pt(r, i, 28) ^ Vt(r, i, 34) ^ Vt(r, i, 39), B = r & s ^ r & c ^ s & c, v = i & o ^ i & a ^ o & a;
+      _ = w | 0, R = x | 0, w = h | 0, x = E | 0, h = u | 0, E = b | 0, { h: u, l: b } = st(l | 0, f | 0, d | 0, p | 0), l = c | 0, f = a | 0, c = s | 0, a = o | 0, s = r | 0, o = i | 0;
+      const A = pe(p, g, v);
+      r = Ee(A, d, y, B), i = A | 0;
+    }
+    ({ h: r, l: i } = st(this.Ah | 0, this.Al | 0, r | 0, i | 0)), { h: s, l: o } = st(this.Bh | 0, this.Bl | 0, s | 0, o | 0), { h: c, l: a } = st(this.Ch | 0, this.Cl | 0, c | 0, a | 0), { h: l, l: f } = st(this.Dh | 0, this.Dl | 0, l | 0, f | 0), { h: u, l: b } = st(this.Eh | 0, this.El | 0, u | 0, b | 0), { h, l: E } = st(this.Fh | 0, this.Fl | 0, h | 0, E | 0), { h: w, l: x } = st(this.Gh | 0, this.Gl | 0, w | 0, x | 0), { h: _, l: R } = st(this.Hh | 0, this.Hl | 0, _ | 0, R | 0), this.set(r, i, s, o, c, a, l, f, u, b, h, E, w, x, _, R);
+  }
+  roundClean() {
+    rt(bt, xt);
+  }
+  destroy() {
+    rt(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+const Ft = /* @__PURE__ */ Je(() => new jn()), sn = /* @__PURE__ */ Je(() => new Xn()), ss = Ft, Kn = /* @__PURE__ */ Uint8Array.from([
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  14,
+  10,
+  4,
+  8,
+  9,
+  15,
+  13,
+  6,
+  1,
+  12,
+  0,
+  2,
+  11,
+  7,
+  5,
+  3,
+  11,
+  8,
+  12,
+  0,
+  5,
+  2,
+  15,
+  13,
+  10,
+  14,
+  3,
+  6,
+  7,
+  1,
+  9,
+  4,
+  7,
+  9,
+  3,
+  1,
+  13,
+  12,
+  11,
+  14,
+  2,
+  6,
+  5,
+  10,
+  4,
+  0,
+  15,
+  8,
+  9,
+  0,
+  5,
+  7,
+  2,
+  4,
+  10,
+  15,
+  14,
+  1,
+  11,
+  12,
+  6,
+  8,
+  3,
+  13,
+  2,
+  12,
+  6,
+  10,
+  0,
+  11,
+  8,
+  3,
+  4,
+  13,
+  7,
+  5,
+  15,
+  14,
+  1,
+  9,
+  12,
+  5,
+  1,
+  15,
+  14,
+  13,
+  4,
+  10,
+  0,
+  7,
+  6,
+  3,
+  9,
+  2,
+  8,
+  11,
+  13,
+  11,
+  7,
+  14,
+  12,
+  1,
+  3,
+  9,
+  5,
+  0,
+  15,
+  4,
+  8,
+  6,
+  2,
+  10,
+  6,
+  15,
+  14,
+  9,
+  11,
+  3,
+  0,
+  8,
+  12,
+  2,
+  13,
+  7,
+  1,
+  4,
+  10,
+  5,
+  10,
+  2,
+  8,
+  4,
+  7,
+  6,
+  1,
+  5,
+  15,
+  11,
+  9,
+  14,
+  3,
+  12,
+  13,
+  0,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  14,
+  10,
+  4,
+  8,
+  9,
+  15,
+  13,
+  6,
+  1,
+  12,
+  0,
+  2,
+  11,
+  7,
+  5,
+  3,
+  // Blake1, unused in others
+  11,
+  8,
+  12,
+  0,
+  5,
+  2,
+  15,
+  13,
+  10,
+  14,
+  3,
+  6,
+  7,
+  1,
+  9,
+  4,
+  7,
+  9,
+  3,
+  1,
+  13,
+  12,
+  11,
+  14,
+  2,
+  6,
+  5,
+  10,
+  4,
+  0,
+  15,
+  8,
+  9,
+  0,
+  5,
+  7,
+  2,
+  4,
+  10,
+  15,
+  14,
+  1,
+  11,
+  12,
+  6,
+  8,
+  3,
+  13,
+  2,
+  12,
+  6,
+  10,
+  0,
+  11,
+  8,
+  3,
+  4,
+  13,
+  7,
+  5,
+  15,
+  14,
+  1,
+  9
+]);
+const $ = /* @__PURE__ */ Uint32Array.from([
+  4089235720,
+  1779033703,
+  2227873595,
+  3144134277,
+  4271175723,
+  1013904242,
+  1595750129,
+  2773480762,
+  2917565137,
+  1359893119,
+  725511199,
+  2600822924,
+  4215389547,
+  528734635,
+  327033209,
+  1541459225
+]), S = /* @__PURE__ */ new Uint32Array(32);
+function wt(t, e, n, r, i, s) {
+  const o = i[s], c = i[s + 1];
+  let a = S[2 * t], l = S[2 * t + 1], f = S[2 * e], u = S[2 * e + 1], b = S[2 * n], h = S[2 * n + 1], E = S[2 * r], w = S[2 * r + 1], x = pe(a, f, o);
+  l = Ee(x, l, u, c), a = x | 0, { Dh: w, Dl: E } = { Dh: w ^ l, Dl: E ^ a }, { Dh: w, Dl: E } = { Dh: Un(w, E), Dl: qn(w) }, { h, l: b } = st(h, b, w, E), { Bh: u, Bl: f } = { Bh: u ^ h, Bl: f ^ b }, { Bh: u, Bl: f } = { Bh: mt(u, f, 24), Bl: pt(u, f, 24) }, S[2 * t] = a, S[2 * t + 1] = l, S[2 * e] = f, S[2 * e + 1] = u, S[2 * n] = b, S[2 * n + 1] = h, S[2 * r] = E, S[2 * r + 1] = w;
+}
+function yt(t, e, n, r, i, s) {
+  const o = i[s], c = i[s + 1];
+  let a = S[2 * t], l = S[2 * t + 1], f = S[2 * e], u = S[2 * e + 1], b = S[2 * n], h = S[2 * n + 1], E = S[2 * r], w = S[2 * r + 1], x = pe(a, f, o);
+  l = Ee(x, l, u, c), a = x | 0, { Dh: w, Dl: E } = { Dh: w ^ l, Dl: E ^ a }, { Dh: w, Dl: E } = { Dh: mt(w, E, 16), Dl: pt(w, E, 16) }, { h, l: b } = st(h, b, w, E), { Bh: u, Bl: f } = { Bh: u ^ h, Bl: f ^ b }, { Bh: u, Bl: f } = { Bh: zt(u, f, 63), Bl: Vt(u, f, 63) }, S[2 * t] = a, S[2 * t + 1] = l, S[2 * e] = f, S[2 * e + 1] = u, S[2 * n] = b, S[2 * n + 1] = h, S[2 * r] = E, S[2 * r + 1] = w;
+}
+function Pn(t, e = {}, n, r, i) {
+  if (F(n), t < 0 || t > n)
+    throw new Error("outputLen bigger than keyLen");
+  const { key: s, salt: o, personalization: c } = e;
+  if (s !== void 0 && (s.length < 1 || s.length > n))
+    throw new Error("key length must be undefined or 1.." + n);
+  if (o !== void 0 && o.length !== r)
+    throw new Error("salt must be undefined or " + r);
+  if (c !== void 0 && c.length !== i)
+    throw new Error("personalization must be undefined or " + i);
+}
+class Wn extends me {
+  constructor(e, n) {
+    super(), this.finished = !1, this.destroyed = !1, this.length = 0, this.pos = 0, F(e), F(n), this.blockLen = e, this.outputLen = n, this.buffer = new Uint8Array(e), this.buffer32 = St(this.buffer);
+  }
+  update(e) {
+    Nt(this), e = Bt(e), et(e);
+    const { blockLen: n, buffer: r, buffer32: i } = this, s = e.length, o = e.byteOffset, c = e.buffer;
+    for (let a = 0; a < s; ) {
+      this.pos === n && (gt(i), this.compress(i, 0, !1), gt(i), this.pos = 0);
+      const l = Math.min(n - this.pos, s - a), f = o + a;
+      if (l === n && !(f % 4) && a + l < s) {
+        const u = new Uint32Array(c, f, Math.floor((s - a) / 4));
+        gt(u);
+        for (let b = 0; a + n < s; b += i.length, a += n)
+          this.length += n, this.compress(u, b, !1);
+        gt(u);
+        continue;
+      }
+      r.set(e.subarray(a, a + l), this.pos), this.pos += l, this.length += l, a += l;
+    }
+    return this;
+  }
+  digestInto(e) {
+    Nt(this), Ye(e, this);
+    const { pos: n, buffer32: r } = this;
+    this.finished = !0, rt(this.buffer.subarray(n)), gt(r), this.compress(r, 0, !0), gt(r);
+    const i = St(e);
+    this.get().forEach((s, o) => i[o] = ft(s));
+  }
+  digest() {
+    const { buffer: e, outputLen: n } = this;
+    this.digestInto(e);
+    const r = e.slice(0, n);
+    return this.destroy(), r;
+  }
+  _cloneInto(e) {
+    const { buffer: n, length: r, finished: i, destroyed: s, outputLen: o, pos: c } = this;
+    return e || (e = new this.constructor({ dkLen: o })), e.set(...this.get()), e.buffer.set(n), e.destroyed = s, e.finished = i, e.length = r, e.pos = c, e.outputLen = o, e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+class Qn extends Wn {
+  constructor(e = {}) {
+    const n = e.dkLen === void 0 ? 64 : e.dkLen;
+    super(128, n), this.v0l = $[0] | 0, this.v0h = $[1] | 0, this.v1l = $[2] | 0, this.v1h = $[3] | 0, this.v2l = $[4] | 0, this.v2h = $[5] | 0, this.v3l = $[6] | 0, this.v3h = $[7] | 0, this.v4l = $[8] | 0, this.v4h = $[9] | 0, this.v5l = $[10] | 0, this.v5h = $[11] | 0, this.v6l = $[12] | 0, this.v6h = $[13] | 0, this.v7l = $[14] | 0, this.v7h = $[15] | 0, Pn(n, e, 64, 16, 16);
+    let { key: r, personalization: i, salt: s } = e, o = 0;
+    if (r !== void 0 && (r = Bt(r), o = r.length), this.v0l ^= this.outputLen | o << 8 | 65536 | 1 << 24, s !== void 0) {
+      s = Bt(s);
+      const c = St(s);
+      this.v4l ^= ft(c[0]), this.v4h ^= ft(c[1]), this.v5l ^= ft(c[2]), this.v5h ^= ft(c[3]);
+    }
+    if (i !== void 0) {
+      i = Bt(i);
+      const c = St(i);
+      this.v6l ^= ft(c[0]), this.v6h ^= ft(c[1]), this.v7l ^= ft(c[2]), this.v7h ^= ft(c[3]);
+    }
+    if (r !== void 0) {
+      const c = new Uint8Array(this.blockLen);
+      c.set(r), this.update(c);
+    }
+  }
+  // prettier-ignore
+  get() {
+    let { v0l: e, v0h: n, v1l: r, v1h: i, v2l: s, v2h: o, v3l: c, v3h: a, v4l: l, v4h: f, v5l: u, v5h: b, v6l: h, v6h: E, v7l: w, v7h: x } = this;
+    return [e, n, r, i, s, o, c, a, l, f, u, b, h, E, w, x];
+  }
+  // prettier-ignore
+  set(e, n, r, i, s, o, c, a, l, f, u, b, h, E, w, x) {
+    this.v0l = e | 0, this.v0h = n | 0, this.v1l = r | 0, this.v1h = i | 0, this.v2l = s | 0, this.v2h = o | 0, this.v3l = c | 0, this.v3h = a | 0, this.v4l = l | 0, this.v4h = f | 0, this.v5l = u | 0, this.v5h = b | 0, this.v6l = h | 0, this.v6h = E | 0, this.v7l = w | 0, this.v7h = x | 0;
+  }
+  compress(e, n, r) {
+    this.get().forEach((a, l) => S[l] = a), S.set($, 16);
+    let { h: i, l: s } = en(BigInt(this.length));
+    S[24] = $[8] ^ s, S[25] = $[9] ^ i, r && (S[28] = ~S[28], S[29] = ~S[29]);
+    let o = 0;
+    const c = Kn;
+    for (let a = 0; a < 12; a++)
+      wt(0, 4, 8, 12, e, n + 2 * c[o++]), yt(0, 4, 8, 12, e, n + 2 * c[o++]), wt(1, 5, 9, 13, e, n + 2 * c[o++]), yt(1, 5, 9, 13, e, n + 2 * c[o++]), wt(2, 6, 10, 14, e, n + 2 * c[o++]), yt(2, 6, 10, 14, e, n + 2 * c[o++]), wt(3, 7, 11, 15, e, n + 2 * c[o++]), yt(3, 7, 11, 15, e, n + 2 * c[o++]), wt(0, 5, 10, 15, e, n + 2 * c[o++]), yt(0, 5, 10, 15, e, n + 2 * c[o++]), wt(1, 6, 11, 12, e, n + 2 * c[o++]), yt(1, 6, 11, 12, e, n + 2 * c[o++]), wt(2, 7, 8, 13, e, n + 2 * c[o++]), yt(2, 7, 8, 13, e, n + 2 * c[o++]), wt(3, 4, 9, 14, e, n + 2 * c[o++]), yt(3, 4, 9, 14, e, n + 2 * c[o++]);
+    this.v0l ^= S[0] ^ S[16], this.v0h ^= S[1] ^ S[17], this.v1l ^= S[2] ^ S[18], this.v1h ^= S[3] ^ S[19], this.v2l ^= S[4] ^ S[20], this.v2h ^= S[5] ^ S[21], this.v3l ^= S[6] ^ S[22], this.v3h ^= S[7] ^ S[23], this.v4l ^= S[8] ^ S[24], this.v4h ^= S[9] ^ S[25], this.v5l ^= S[10] ^ S[26], this.v5h ^= S[11] ^ S[27], this.v6l ^= S[12] ^ S[28], this.v6h ^= S[13] ^ S[29], this.v7l ^= S[14] ^ S[30], this.v7h ^= S[15] ^ S[31], rt(S);
+  }
+  destroy() {
+    this.destroyed = !0, rt(this.buffer32), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+const Jn = /* @__PURE__ */ On((t) => new Qn(t));
+const os = Jn;
+class on extends me {
+  constructor(e, n) {
+    super(), this.finished = !1, this.destroyed = !1, $e(e);
+    const r = Bt(n);
+    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 i = this.blockLen, s = new Uint8Array(i);
+    s.set(r.length > i ? e.create().update(r).digest() : r);
+    for (let o = 0; o < s.length; o++)
+      s[o] ^= 54;
+    this.iHash.update(s), this.oHash = e.create();
+    for (let o = 0; o < s.length; o++)
+      s[o] ^= 106;
+    this.oHash.update(s), rt(s);
+  }
+  update(e) {
+    return Nt(this), this.iHash.update(e), this;
+  }
+  digestInto(e) {
+    Nt(this), et(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: n, iHash: r, finished: i, destroyed: s, blockLen: o, outputLen: c } = this;
+    return e = e, e.finished = i, e.destroyed = s, e.blockLen = o, e.outputLen = c, e.oHash = n._cloneInto(e.oHash), e.iHash = r._cloneInto(e.iHash), e;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}
+const Be = (t, e, n) => new on(t, e).update(n).digest();
+Be.create = (t, e) => new on(t, e);
+function Fn(t, e, n, r) {
+  $e(t);
+  const i = Qe({ dkLen: 32, asyncTick: 10 }, r), { c: s, dkLen: o, asyncTick: c } = i;
+  if (F(s), F(o), F(c), s < 1)
+    throw new Error("iterations (c) should be >= 1");
+  const a = Le(e), l = Le(n), f = new Uint8Array(o), u = Be.create(t, a), b = u._cloneInto().update(l);
+  return { c: s, dkLen: o, asyncTick: c, DK: f, PRF: u, PRFSalt: b };
+}
+function tr(t, e, n, r, i) {
+  return t.destroy(), e.destroy(), r && r.destroy(), rt(i), n;
+}
+function cn(t, e, n, r) {
+  const { c: i, dkLen: s, DK: o, PRF: c, PRFSalt: a } = Fn(t, e, n, r);
+  let l;
+  const f = new Uint8Array(4), u = Wt(f), b = new Uint8Array(c.outputLen);
+  for (let h = 1, E = 0; E < s; h++, E += c.outputLen) {
+    const w = o.subarray(E, E + c.outputLen);
+    u.setInt32(0, h, !1), (l = a._cloneInto(l)).update(f).digestInto(b), w.set(b.subarray(0, w.length));
+    for (let x = 1; x < i; x++) {
+      c._cloneInto(l).update(b).digestInto(b);
+      for (let _ = 0; _ < w.length; _++)
+        w[_] ^= b[_];
+    }
+  }
+  return tr(c, a, o, l, b);
+}
+function ke(t, e, n, r, i, s) {
+  let o = t[e++] ^ n[r++], c = t[e++] ^ n[r++], a = t[e++] ^ n[r++], l = t[e++] ^ n[r++], f = t[e++] ^ n[r++], u = t[e++] ^ n[r++], b = t[e++] ^ n[r++], h = t[e++] ^ n[r++], E = t[e++] ^ n[r++], w = t[e++] ^ n[r++], x = t[e++] ^ n[r++], _ = t[e++] ^ n[r++], R = t[e++] ^ n[r++], L = t[e++] ^ n[r++], T = t[e++] ^ n[r++], m = t[e++] ^ n[r++], H = o, U = c, O = a, d = l, p = f, y = u, g = b, B = h, v = E, A = w, I = x, q = _, k = R, Z = L, D = T, N = m;
+  for (let z = 0; z < 8; z += 2)
+    p ^= C(H + k | 0, 7), v ^= C(p + H | 0, 9), k ^= C(v + p | 0, 13), H ^= C(k + v | 0, 18), A ^= C(y + U | 0, 7), Z ^= C(A + y | 0, 9), U ^= C(Z + A | 0, 13), y ^= C(U + Z | 0, 18), D ^= C(I + g | 0, 7), O ^= C(D + I | 0, 9), g ^= C(O + D | 0, 13), I ^= C(g + O | 0, 18), d ^= C(N + q | 0, 7), B ^= C(d + N | 0, 9), q ^= C(B + d | 0, 13), N ^= C(q + B | 0, 18), U ^= C(H + d | 0, 7), O ^= C(U + H | 0, 9), d ^= C(O + U | 0, 13), H ^= C(d + O | 0, 18), g ^= C(y + p | 0, 7), B ^= C(g + y | 0, 9), p ^= C(B + g | 0, 13), y ^= C(p + B | 0, 18), q ^= C(I + A | 0, 7), v ^= C(q + I | 0, 9), A ^= C(v + q | 0, 13), I ^= C(A + v | 0, 18), k ^= C(N + D | 0, 7), Z ^= C(k + N | 0, 9), D ^= C(Z + k | 0, 13), N ^= C(D + Z | 0, 18);
+  i[s++] = o + H | 0, i[s++] = c + U | 0, i[s++] = a + O | 0, i[s++] = l + d | 0, i[s++] = f + p | 0, i[s++] = u + y | 0, i[s++] = b + g | 0, i[s++] = h + B | 0, i[s++] = E + v | 0, i[s++] = w + A | 0, i[s++] = x + I | 0, i[s++] = _ + q | 0, i[s++] = R + k | 0, i[s++] = L + Z | 0, i[s++] = T + D | 0, i[s++] = m + N | 0;
+}
+function se(t, e, n, r, i) {
+  let s = r + 0, o = r + 16 * i;
+  for (let c = 0; c < 16; c++)
+    n[o + c] = t[e + (2 * i - 1) * 16 + c];
+  for (let c = 0; c < i; c++, s += 16, e += 16)
+    ke(n, o, t, e, n, s), c > 0 && (o += 16), ke(n, s, t, e += 16, n, o);
+}
+function er(t, e, n) {
+  const r = Qe({
+    dkLen: 32,
+    asyncTick: 10,
+    maxmem: 1073742848
+  }, n), { N: i, r: s, p: o, dkLen: c, asyncTick: a, maxmem: l, onProgress: f } = r;
+  if (F(i), F(s), F(o), F(c), F(a), F(l), f !== void 0 && typeof f != "function")
+    throw new Error("progressCb should be function");
+  const u = 128 * s, b = u / 4, h = Math.pow(2, 32);
+  if (i <= 1 || (i & i - 1) !== 0 || i > h)
+    throw new Error("Scrypt: N must be larger than 1, a power of 2, and less than 2^32");
+  if (o < 0 || o > (h - 1) * 32 / u)
+    throw new Error("Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)");
+  if (c < 0 || c > (h - 1) * 32)
+    throw new Error("Scrypt: dkLen should be positive integer less than or equal to (2^32 - 1) * 32");
+  if (u * (i + o) > l)
+    throw new Error("Scrypt: memused is bigger than maxMem. Expected 128 * r * (N + p) > maxmem of " + l);
+  const w = cn(Ft, t, e, { c: 1, dkLen: u * o }), x = St(w), _ = St(new Uint8Array(u * i)), R = St(new Uint8Array(u));
+  let L = () => {
+  };
+  if (f) {
+    const T = 2 * i * o, m = Math.max(Math.floor(T / 1e4), 1);
+    let H = 0;
+    L = () => {
+      H++, f && (!(H % m) || H === T) && f(H / T);
+    };
+  }
+  return { N: i, r: s, p: o, dkLen: c, blockSize32: b, V: _, B32: x, B: w, tmp: R, blockMixCb: L, asyncTick: a };
+}
+function nr(t, e, n, r, i) {
+  const s = cn(Ft, t, n, { c: 1, dkLen: e });
+  return rt(n, r, i), s;
+}
+function is(t, e, n) {
+  const { N: r, r: i, p: s, dkLen: o, blockSize32: c, V: a, B32: l, B: f, tmp: u, blockMixCb: b } = er(t, e, n);
+  gt(l);
+  for (let h = 0; h < s; h++) {
+    const E = c * h;
+    for (let w = 0; w < c; w++)
+      a[w] = l[E + w];
+    for (let w = 0, x = 0; w < r - 1; w++)
+      se(a, x, a, x += c, i), b();
+    se(a, (r - 1) * c, l, E, i), b();
+    for (let w = 0; w < r; w++) {
+      const x = l[E + c - 16] % r;
+      for (let _ = 0; _ < c; _++)
+        u[_] = l[E + _] ^ a[x * c + _];
+      se(u, 0, l, E, i), b();
+    }
+  }
+  return gt(l), nr(t, o, f, a, u);
+}
+const _e = /* @__PURE__ */ BigInt(0), he = /* @__PURE__ */ BigInt(1);
+function Lt(t, e) {
+  if (typeof e != "boolean")
+    throw new Error(t + " boolean expected, got " + e);
+}
+function Kt(t) {
+  const e = t.toString(16);
+  return e.length & 1 ? "0" + e : e;
+}
+function fn(t) {
+  if (typeof t != "string")
+    throw new Error("hex string expected, got " + typeof t);
+  return t === "" ? _e : BigInt("0x" + t);
+}
+function te(t) {
+  return fn(It(t));
+}
+function Tt(t) {
+  return et(t), fn(It(Uint8Array.from(t).reverse()));
+}
+function Ae(t, e) {
+  return ge(t.toString(16).padStart(e * 2, "0"));
+}
+function Dt(t, e) {
+  return Ae(t, e).reverse();
+}
+function V(t, e, n) {
+  let r;
+  if (typeof e == "string")
+    try {
+      r = ge(e);
+    } catch (s) {
+      throw new Error(t + " must be hex string or Uint8Array, cause: " + s);
+    }
+  else if (ye(e))
+    r = Uint8Array.from(e);
+  else
+    throw new Error(t + " must be hex string or Uint8Array");
+  const i = r.length;
+  if (typeof n == "number" && i !== n)
+    throw new Error(t + " of length " + n + " expected, got " + i);
+  return r;
+}
+function rr(t, e) {
+  if (t.length !== e.length)
+    return !1;
+  let n = 0;
+  for (let r = 0; r < t.length; r++)
+    n |= t[r] ^ e[r];
+  return n === 0;
+}
+const oe = (t) => typeof t == "bigint" && _e <= t;
+function sr(t, e, n) {
+  return oe(t) && oe(e) && oe(n) && e <= t && t < n;
+}
+function qt(t, e, n, r) {
+  if (!sr(e, n, r))
+    throw new Error("expected valid " + t + ": " + n + " <= n < " + r + ", got " + e);
+}
+function or(t) {
+  let e;
+  for (e = 0; t > _e; t >>= he, e += 1)
+    ;
+  return e;
+}
+const ee = (t) => (he << BigInt(t)) - he;
+function ir(t, e, n) {
+  if (typeof t != "number" || t < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof e != "number" || e < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof n != "function")
+    throw new Error("hmacFn must be a function");
+  const r = (h) => new Uint8Array(h), i = (h) => Uint8Array.of(h);
+  let s = r(t), o = r(t), c = 0;
+  const a = () => {
+    s.fill(1), o.fill(0), c = 0;
+  }, l = (...h) => n(o, s, ...h), f = (h = r(0)) => {
+    o = l(i(0), h), s = l(), h.length !== 0 && (o = l(i(1), h), s = l());
+  }, u = () => {
+    if (c++ >= 1e3)
+      throw new Error("drbg: tried 1000 values");
+    let h = 0;
+    const E = [];
+    for (; h < e; ) {
+      s = l();
+      const w = s.slice();
+      E.push(w), h += s.length;
+    }
+    return lt(...E);
+  };
+  return (h, E) => {
+    a(), f(h);
+    let w;
+    for (; !(w = E(u())); )
+      f();
+    return a(), w;
+  };
+}
+function Yt(t, e, n = {}) {
+  if (!t || typeof t != "object")
+    throw new Error("expected valid options object");
+  function r(i, s, o) {
+    const c = t[i];
+    if (o && c === void 0)
+      return;
+    const a = typeof c;
+    if (a !== s || c === null)
+      throw new Error(`param "${i}" is invalid: expected ${s}, got ${a}`);
+  }
+  Object.entries(e).forEach(([i, s]) => r(i, s, !1)), Object.entries(n).forEach(([i, s]) => r(i, s, !0));
+}
+function Qt(t) {
+  const e = /* @__PURE__ */ new WeakMap();
+  return (n, ...r) => {
+    const i = e.get(n);
+    if (i !== void 0)
+      return i;
+    const s = t(n, ...r);
+    return e.set(n, s), s;
+  };
+}
+const tt = BigInt(0), K = BigInt(1), At = /* @__PURE__ */ BigInt(2), cr = /* @__PURE__ */ BigInt(3), an = /* @__PURE__ */ BigInt(4), ln = /* @__PURE__ */ BigInt(5), un = /* @__PURE__ */ BigInt(8);
+function j(t, e) {
+  const n = t % e;
+  return n >= tt ? n : e + n;
+}
+function G(t, e, n) {
+  let r = t;
+  for (; e-- > tt; )
+    r *= r, r %= n;
+  return r;
+}
+function Ue(t, e) {
+  if (t === tt)
+    throw new Error("invert: expected non-zero number");
+  if (e <= tt)
+    throw new Error("invert: expected positive modulus, got " + e);
+  let n = j(t, e), r = e, i = tt, s = K;
+  for (; n !== tt; ) {
+    const c = r / n, a = r % n, l = i - s * c;
+    r = n, n = a, i = s, s = l;
+  }
+  if (r !== K)
+    throw new Error("invert: does not exist");
+  return j(i, e);
+}
+function hn(t, e) {
+  const n = (t.ORDER + K) / an, r = t.pow(e, n);
+  if (!t.eql(t.sqr(r), e))
+    throw new Error("Cannot find square root");
+  return r;
+}
+function fr(t, e) {
+  const n = (t.ORDER - ln) / un, r = t.mul(e, At), i = t.pow(r, n), s = t.mul(e, i), o = t.mul(t.mul(s, At), i), c = t.mul(s, t.sub(o, t.ONE));
+  if (!t.eql(t.sqr(c), e))
+    throw new Error("Cannot find square root");
+  return c;
+}
+function ar(t) {
+  if (t < BigInt(3))
+    throw new Error("sqrt is not defined for small field");
+  let e = t - K, n = 0;
+  for (; e % At === tt; )
+    e /= At, n++;
+  let r = At;
+  const i = Ot(t);
+  for (; qe(i, r) === 1; )
+    if (r++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  if (n === 1)
+    return hn;
+  let s = i.pow(r, e);
+  const o = (e + K) / At;
+  return function(a, l) {
+    if (a.is0(l))
+      return l;
+    if (qe(a, l) !== 1)
+      throw new Error("Cannot find square root");
+    let f = n, u = a.mul(a.ONE, s), b = a.pow(l, e), h = a.pow(l, o);
+    for (; !a.eql(b, a.ONE); ) {
+      if (a.is0(b))
+        return a.ZERO;
+      let E = 1, w = a.sqr(b);
+      for (; !a.eql(w, a.ONE); )
+        if (E++, w = a.sqr(w), E === f)
+          throw new Error("Cannot find square root");
+      const x = K << BigInt(f - E - 1), _ = a.pow(u, x);
+      f = E, u = a.sqr(_), b = a.mul(b, u), h = a.mul(h, _);
+    }
+    return h;
+  };
+}
+function lr(t) {
+  return t % an === cr ? hn : t % un === ln ? fr : ar(t);
+}
+const Et = (t, e) => (j(t, e) & K) === K, ur = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function hr(t) {
+  const e = {
+    ORDER: "bigint",
+    MASK: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  }, n = ur.reduce((r, i) => (r[i] = "function", r), e);
+  return Yt(t, n), t;
+}
+function dr(t, e, n) {
+  if (n < tt)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (n === tt)
+    return t.ONE;
+  if (n === K)
+    return e;
+  let r = t.ONE, i = e;
+  for (; n > tt; )
+    n & K && (r = t.mul(r, i)), i = t.sqr(i), n >>= K;
+  return r;
+}
+function dn(t, e, n = !1) {
+  const r = new Array(e.length).fill(n ? t.ZERO : void 0), i = e.reduce((o, c, a) => t.is0(c) ? o : (r[a] = o, t.mul(o, c)), t.ONE), s = t.inv(i);
+  return e.reduceRight((o, c, a) => t.is0(c) ? o : (r[a] = t.mul(o, r[a]), t.mul(o, c)), s), r;
+}
+function qe(t, e) {
+  const n = (t.ORDER - K) / At, r = t.pow(e, n), i = t.eql(r, t.ONE), s = t.eql(r, t.ZERO), o = t.eql(r, t.neg(t.ONE));
+  if (!i && !s && !o)
+    throw new Error("invalid Legendre symbol result");
+  return i ? 1 : s ? 0 : -1;
+}
+function br(t, e) {
+  e !== void 0 && F(e);
+  const n = e !== void 0 ? e : t.toString(2).length, r = Math.ceil(n / 8);
+  return { nBitLength: n, nByteLength: r };
+}
+function Ot(t, e, n = !1, r = {}) {
+  if (t <= tt)
+    throw new Error("invalid field: expected ORDER > 0, got " + t);
+  let i, s;
+  if (typeof e == "object" && e != null) {
+    if (r.sqrt || n)
+      throw new Error("cannot specify opts in two arguments");
+    const f = e;
+    f.BITS && (i = f.BITS), f.sqrt && (s = f.sqrt), typeof f.isLE == "boolean" && (n = f.isLE);
+  } else
+    typeof e == "number" && (i = e), r.sqrt && (s = r.sqrt);
+  const { nBitLength: o, nByteLength: c } = br(t, i);
+  if (c > 2048)
+    throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+  let a;
+  const l = Object.freeze({
+    ORDER: t,
+    isLE: n,
+    BITS: o,
+    BYTES: c,
+    MASK: ee(o),
+    ZERO: tt,
+    ONE: K,
+    create: (f) => j(f, t),
+    isValid: (f) => {
+      if (typeof f != "bigint")
+        throw new Error("invalid field element: expected bigint, got " + typeof f);
+      return tt <= f && f < t;
+    },
+    is0: (f) => f === tt,
+    // is valid and invertible
+    isValidNot0: (f) => !l.is0(f) && l.isValid(f),
+    isOdd: (f) => (f & K) === K,
+    neg: (f) => j(-f, t),
+    eql: (f, u) => f === u,
+    sqr: (f) => j(f * f, t),
+    add: (f, u) => j(f + u, t),
+    sub: (f, u) => j(f - u, t),
+    mul: (f, u) => j(f * u, t),
+    pow: (f, u) => dr(l, f, u),
+    div: (f, u) => j(f * Ue(u, t), t),
+    // Same as above, but doesn't normalize
+    sqrN: (f) => f * f,
+    addN: (f, u) => f + u,
+    subN: (f, u) => f - u,
+    mulN: (f, u) => f * u,
+    inv: (f) => Ue(f, t),
+    sqrt: s || ((f) => (a || (a = lr(t)), a(l, f))),
+    toBytes: (f) => n ? Dt(f, c) : Ae(f, c),
+    fromBytes: (f) => {
+      if (f.length !== c)
+        throw new Error("Field.fromBytes: expected " + c + " bytes, got " + f.length);
+      return n ? Tt(f) : te(f);
+    },
+    // TODO: we don't need it here, move out to separate fn
+    invertBatch: (f) => dn(l, f),
+    // We can't move this out because Fp6, Fp12 implement it
+    // and it's unclear what to return in there.
+    cmov: (f, u, b) => b ? u : f
+  });
+  return Object.freeze(l);
+}
+function bn(t) {
+  if (typeof t != "bigint")
+    throw new Error("field order must be bigint");
+  const e = t.toString(2).length;
+  return Math.ceil(e / 8);
+}
+function xn(t) {
+  const e = bn(t);
+  return e + Math.ceil(e / 2);
+}
+function xr(t, e, n = !1) {
+  const r = t.length, i = bn(e), s = xn(e);
+  if (r < 16 || r < s || r > 1024)
+    throw new Error("expected " + s + "-1024 bytes of input, got " + r);
+  const o = n ? Tt(t) : te(t), c = j(o, e - K) + K;
+  return n ? Dt(c, i) : Ae(c, i);
+}
+const Ct = BigInt(0), vt = BigInt(1);
+function Gt(t, e) {
+  const n = e.negate();
+  return t ? n : e;
+}
+function wn(t, e, n) {
+  const r = e === "pz" ? (o) => o.pz : (o) => o.ez, i = dn(t.Fp, n.map(r));
+  return n.map((o, c) => o.toAffine(i[c])).map(t.fromAffine);
+}
+function yn(t, e) {
+  if (!Number.isSafeInteger(t) || t <= 0 || t > e)
+    throw new Error("invalid window size, expected [1.." + e + "], got W=" + t);
+}
+function ie(t, e) {
+  yn(t, e);
+  const n = Math.ceil(e / t) + 1, r = 2 ** (t - 1), i = 2 ** t, s = ee(t), o = BigInt(t);
+  return { windows: n, windowSize: r, mask: s, maxNumber: i, shiftBy: o };
+}
+function Ne(t, e, n) {
+  const { windowSize: r, mask: i, maxNumber: s, shiftBy: o } = n;
+  let c = Number(t & i), a = t >> o;
+  c > r && (c -= s, a += vt);
+  const l = e * r, f = l + Math.abs(c) - 1, u = c === 0, b = c < 0, h = e % 2 !== 0;
+  return { nextN: a, offset: f, isZero: u, isNeg: b, isNegF: h, offsetF: l };
+}
+function wr(t, e) {
+  if (!Array.isArray(t))
+    throw new Error("array expected");
+  t.forEach((n, r) => {
+    if (!(n instanceof e))
+      throw new Error("invalid point at index " + r);
+  });
+}
+function yr(t, e) {
+  if (!Array.isArray(t))
+    throw new Error("array of scalars expected");
+  t.forEach((n, r) => {
+    if (!e.isValid(n))
+      throw new Error("invalid scalar at index " + r);
+  });
+}
+const ce = /* @__PURE__ */ new WeakMap(), gn = /* @__PURE__ */ new WeakMap();
+function fe(t) {
+  return gn.get(t) || 1;
+}
+function Te(t) {
+  if (t !== Ct)
+    throw new Error("invalid wNAF");
+}
+function mn(t, e) {
+  return {
+    constTimeNegate: Gt,
+    hasPrecomputes(n) {
+      return fe(n) !== 1;
+    },
+    // non-const time multiplication ladder
+    unsafeLadder(n, r, i = t.ZERO) {
+      let s = n;
+      for (; r > Ct; )
+        r & vt && (i = i.add(s)), s = s.double(), r >>= vt;
+      return i;
+    },
+    /**
+     * Creates a wNAF precomputation window. Used for caching.
+     * Default window size is set by `utils.precompute()` and is equal to 8.
+     * Number of precomputed points depends on the curve size:
+     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+     * - 𝑊 is the window size
+     * - 𝑛 is the bitlength of the curve order.
+     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+     * @param elm Point instance
+     * @param W window size
+     * @returns precomputed point tables flattened to a single array
+     */
+    precomputeWindow(n, r) {
+      const { windows: i, windowSize: s } = ie(r, e), o = [];
+      let c = n, a = c;
+      for (let l = 0; l < i; l++) {
+        a = c, o.push(a);
+        for (let f = 1; f < s; f++)
+          a = a.add(c), o.push(a);
+        c = a.double();
+      }
+      return o;
+    },
+    /**
+     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+     * @param W window size
+     * @param precomputes precomputed tables
+     * @param n scalar (we don't check here, but should be less than curve order)
+     * @returns real and fake (for const-time) points
+     */
+    wNAF(n, r, i) {
+      let s = t.ZERO, o = t.BASE;
+      const c = ie(n, e);
+      for (let a = 0; a < c.windows; a++) {
+        const { nextN: l, offset: f, isZero: u, isNeg: b, isNegF: h, offsetF: E } = Ne(i, a, c);
+        i = l, u ? o = o.add(Gt(h, r[E])) : s = s.add(Gt(b, r[f]));
+      }
+      return Te(i), { p: s, f: o };
+    },
+    /**
+     * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+     * @param W window size
+     * @param precomputes precomputed tables
+     * @param n scalar (we don't check here, but should be less than curve order)
+     * @param acc accumulator point to add result of multiplication
+     * @returns point
+     */
+    wNAFUnsafe(n, r, i, s = t.ZERO) {
+      const o = ie(n, e);
+      for (let c = 0; c < o.windows && i !== Ct; c++) {
+        const { nextN: a, offset: l, isZero: f, isNeg: u } = Ne(i, c, o);
+        if (i = a, !f) {
+          const b = r[l];
+          s = s.add(u ? b.negate() : b);
+        }
+      }
+      return Te(i), s;
+    },
+    getPrecomputes(n, r, i) {
+      let s = ce.get(r);
+      return s || (s = this.precomputeWindow(r, n), n !== 1 && (typeof i == "function" && (s = i(s)), ce.set(r, s))), s;
+    },
+    wNAFCached(n, r, i) {
+      const s = fe(n);
+      return this.wNAF(s, this.getPrecomputes(s, n, i), r);
+    },
+    wNAFCachedUnsafe(n, r, i, s) {
+      const o = fe(n);
+      return o === 1 ? this.unsafeLadder(n, r, s) : this.wNAFUnsafe(o, this.getPrecomputes(o, n, i), r, s);
+    },
+    // We calculate precomputes for elliptic curve point multiplication
+    // using windowed method. This specifies window size and
+    // stores precomputed values. Usually only base point would be precomputed.
+    setWindowSize(n, r) {
+      yn(r, e), gn.set(n, r), ce.delete(n);
+    }
+  };
+}
+function gr(t, e, n, r) {
+  let i = e, s = t.ZERO, o = t.ZERO;
+  for (; n > Ct || r > Ct; )
+    n & vt && (s = s.add(i)), r & vt && (o = o.add(i)), i = i.double(), n >>= vt, r >>= vt;
+  return { p1: s, p2: o };
+}
+function ve(t, e, n, r) {
+  wr(n, t), yr(r, e);
+  const i = n.length, s = r.length;
+  if (i !== s)
+    throw new Error("arrays of points and scalars must have equal length");
+  const o = t.ZERO, c = or(BigInt(i));
+  let a = 1;
+  c > 12 ? a = c - 3 : c > 4 ? a = c - 2 : c > 0 && (a = 2);
+  const l = ee(a), f = new Array(Number(l) + 1).fill(o), u = Math.floor((e.BITS - 1) / a) * a;
+  let b = o;
+  for (let h = u; h >= 0; h -= a) {
+    f.fill(o);
+    for (let w = 0; w < s; w++) {
+      const x = r[w], _ = Number(x >> BigInt(h) & l);
+      f[_] = f[_].add(n[w]);
+    }
+    let E = o;
+    for (let w = f.length - 1, x = o; w > 0; w--)
+      x = x.add(f[w]), E = E.add(x);
+    if (b = b.add(E), h !== 0)
+      for (let w = 0; w < a; w++)
+        b = b.double();
+  }
+  return b;
+}
+function De(t, e) {
+  if (e) {
+    if (e.ORDER !== t)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    return hr(e), e;
+  } else
+    return Ot(t);
+}
+function pn(t, e, n = {}) {
+  if (!e || typeof e != "object")
+    throw new Error(`expected valid ${t} CURVE object`);
+  for (const c of ["p", "n", "h"]) {
+    const a = e[c];
+    if (!(typeof a == "bigint" && a > Ct))
+      throw new Error(`CURVE.${c} must be positive bigint`);
+  }
+  const r = De(e.p, n.Fp), i = De(e.n, n.Fn), o = ["Gx", "Gy", "a", t === "weierstrass" ? "b" : "d"];
+  for (const c of o)
+    if (!r.isValid(e[c]))
+      throw new Error(`CURVE.${c} must be valid field element of CURVE.Fp`);
+  return { Fp: r, Fn: i };
+}
+const it = BigInt(0), J = BigInt(1), ae = BigInt(2), mr = BigInt(8), pr = { zip215: !0 };
+function Er(t, e, n, r) {
+  const i = t.sqr(n), s = t.sqr(r), o = t.add(t.mul(e.a, i), s), c = t.add(t.ONE, t.mul(e.d, t.mul(i, s)));
+  return t.eql(o, c);
+}
+function Br(t, e = {}) {
+  const { Fp: n, Fn: r } = pn("edwards", t, e), { h: i, n: s } = t;
+  Yt(e, {}, { uvRatio: "function" });
+  const o = ae << BigInt(r.BYTES * 8) - J, c = (w) => n.create(w), a = e.uvRatio || ((w, x) => {
+    try {
+      return { isValid: !0, value: n.sqrt(n.div(w, x)) };
+    } catch {
+      return { isValid: !1, value: it };
+    }
+  });
+  if (!Er(n, t, t.Gx, t.Gy))
+    throw new Error("bad curve params: generator point");
+  function l(w, x, _ = !1) {
+    const R = _ ? J : it;
+    return qt("coordinate " + w, x, R, o), x;
+  }
+  function f(w) {
+    if (!(w instanceof h))
+      throw new Error("ExtendedPoint expected");
+  }
+  const u = Qt((w, x) => {
+    const { ex: _, ey: R, ez: L } = w, T = w.is0();
+    x == null && (x = T ? mr : n.inv(L));
+    const m = c(_ * x), H = c(R * x), U = c(L * x);
+    if (T)
+      return { x: it, y: J };
+    if (U !== J)
+      throw new Error("invZ was invalid");
+    return { x: m, y: H };
+  }), b = Qt((w) => {
+    const { a: x, d: _ } = t;
+    if (w.is0())
+      throw new Error("bad point: ZERO");
+    const { ex: R, ey: L, ez: T, et: m } = w, H = c(R * R), U = c(L * L), O = c(T * T), d = c(O * O), p = c(H * x), y = c(O * c(p + U)), g = c(d + c(_ * c(H * U)));
+    if (y !== g)
+      throw new Error("bad point: equation left != right (1)");
+    const B = c(R * L), v = c(T * m);
+    if (B !== v)
+      throw new Error("bad point: equation left != right (2)");
+    return !0;
+  });
+  class h {
+    constructor(x, _, R, L) {
+      this.ex = l("x", x), this.ey = l("y", _), this.ez = l("z", R, !0), this.et = l("t", L), Object.freeze(this);
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    static fromAffine(x) {
+      if (x instanceof h)
+        throw new Error("extended point not allowed");
+      const { x: _, y: R } = x || {};
+      return l("x", _), l("y", R), new h(_, R, J, c(_ * R));
+    }
+    static normalizeZ(x) {
+      return wn(h, "ez", x);
+    }
+    // Multiscalar Multiplication
+    static msm(x, _) {
+      return ve(h, r, x, _);
+    }
+    // "Private method", don't use it directly
+    _setWindowSize(x) {
+      this.precompute(x);
+    }
+    precompute(x = 8, _ = !0) {
+      return E.setWindowSize(this, x), _ || this.multiply(ae), this;
+    }
+    // Not required for fromHex(), which always creates valid points.
+    // Could be useful for fromAffine().
+    assertValidity() {
+      b(this);
+    }
+    // Compare one point to another.
+    equals(x) {
+      f(x);
+      const { ex: _, ey: R, ez: L } = this, { ex: T, ey: m, ez: H } = x, U = c(_ * H), O = c(T * L), d = c(R * H), p = c(m * L);
+      return U === O && d === p;
+    }
+    is0() {
+      return this.equals(h.ZERO);
+    }
+    negate() {
+      return new h(c(-this.ex), this.ey, this.ez, c(-this.et));
+    }
+    // Fast algo for doubling Extended Point.
+    // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd
+    // Cost: 4M + 4S + 1*a + 6add + 1*2.
+    double() {
+      const { a: x } = t, { ex: _, ey: R, ez: L } = this, T = c(_ * _), m = c(R * R), H = c(ae * c(L * L)), U = c(x * T), O = _ + R, d = c(c(O * O) - T - m), p = U + m, y = p - H, g = U - m, B = c(d * y), v = c(p * g), A = c(d * g), I = c(y * p);
+      return new h(B, v, I, A);
+    }
+    // Fast algo for adding 2 Extended Points.
+    // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd
+    // Cost: 9M + 1*a + 1*d + 7add.
+    add(x) {
+      f(x);
+      const { a: _, d: R } = t, { ex: L, ey: T, ez: m, et: H } = this, { ex: U, ey: O, ez: d, et: p } = x, y = c(L * U), g = c(T * O), B = c(H * R * p), v = c(m * d), A = c((L + T) * (U + O) - y - g), I = v - B, q = v + B, k = c(g - _ * y), Z = c(A * I), D = c(q * k), N = c(A * k), z = c(I * q);
+      return new h(Z, D, z, N);
+    }
+    subtract(x) {
+      return this.add(x.negate());
+    }
+    // Constant-time multiplication.
+    multiply(x) {
+      const _ = x;
+      qt("scalar", _, J, s);
+      const { p: R, f: L } = E.wNAFCached(this, _, h.normalizeZ);
+      return h.normalizeZ([R, L])[0];
+    }
+    // Non-constant-time multiplication. Uses double-and-add algorithm.
+    // It's faster, but should only be used when you don't care about
+    // an exposed private key e.g. sig verification.
+    // Does NOT allow scalars higher than CURVE.n.
+    // Accepts optional accumulator to merge with multiply (important for sparse scalars)
+    multiplyUnsafe(x, _ = h.ZERO) {
+      const R = x;
+      return qt("scalar", R, it, s), R === it ? h.ZERO : this.is0() || R === J ? this : E.wNAFCachedUnsafe(this, R, h.normalizeZ, _);
+    }
+    // Checks if point is of small order.
+    // If you add something to small order point, you will have "dirty"
+    // point with torsion component.
+    // Multiplies point by cofactor and checks if the result is 0.
+    isSmallOrder() {
+      return this.multiplyUnsafe(i).is0();
+    }
+    // Multiplies point by curve order and checks if the result is 0.
+    // Returns `false` is the point is dirty.
+    isTorsionFree() {
+      return E.wNAFCachedUnsafe(this, s).is0();
+    }
+    // Converts Extended point to default (x, y) coordinates.
+    // Can accept precomputed Z^-1 - for example, from invertBatch.
+    toAffine(x) {
+      return u(this, x);
+    }
+    clearCofactor() {
+      return i === J ? this : this.multiplyUnsafe(i);
+    }
+    static fromBytes(x, _ = !1) {
+      return et(x), this.fromHex(x, _);
+    }
+    // Converts hash string or Uint8Array to Point.
+    // Uses algo from RFC8032 5.1.3.
+    static fromHex(x, _ = !1) {
+      const { d: R, a: L } = t, T = n.BYTES;
+      x = V("pointHex", x, T), Lt("zip215", _);
+      const m = x.slice(), H = x[T - 1];
+      m[T - 1] = H & -129;
+      const U = Tt(m), O = _ ? o : n.ORDER;
+      qt("pointHex.y", U, it, O);
+      const d = c(U * U), p = c(d - J), y = c(R * d - L);
+      let { isValid: g, value: B } = a(p, y);
+      if (!g)
+        throw new Error("Point.fromHex: invalid y coordinate");
+      const v = (B & J) === J, A = (H & 128) !== 0;
+      if (!_ && B === it && A)
+        throw new Error("Point.fromHex: x=0 and x_0=1");
+      return A !== v && (B = c(-B)), h.fromAffine({ x: B, y: U });
+    }
+    static fromPrivateScalar(x) {
+      return h.BASE.multiply(x);
+    }
+    toBytes() {
+      const { x, y: _ } = this.toAffine(), R = Dt(_, n.BYTES);
+      return R[R.length - 1] |= x & J ? 128 : 0, R;
+    }
+    /** @deprecated use `toBytes` */
+    toRawBytes() {
+      return this.toBytes();
+    }
+    toHex() {
+      return It(this.toBytes());
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+  }
+  h.BASE = new h(t.Gx, t.Gy, J, c(t.Gx * t.Gy)), h.ZERO = new h(it, J, J, it), h.Fp = n, h.Fn = r;
+  const E = mn(h, r.BYTES * 8);
+  return h;
+}
+function _r(t, e) {
+  Yt(e, {
+    hash: "function"
+  }, {
+    adjustScalarBytes: "function",
+    randomBytes: "function",
+    domain: "function",
+    prehash: "function",
+    mapToCurve: "function"
+  });
+  const { prehash: n, hash: r } = e, { BASE: i, Fp: s, Fn: o } = t, c = o.ORDER, a = e.randomBytes || Fe, l = e.adjustScalarBytes || ((m) => m), f = e.domain || ((m, H, U) => {
+    if (Lt("phflag", U), H.length || U)
+      throw new Error("Contexts/pre-hash are not supported");
+    return m;
+  });
+  function u(m) {
+    return o.create(m);
+  }
+  function b(m) {
+    return u(Tt(m));
+  }
+  function h(m) {
+    const H = s.BYTES;
+    m = V("private key", m, H);
+    const U = V("hashed private key", r(m), 2 * H), O = l(U.slice(0, H)), d = U.slice(H, 2 * H), p = b(O);
+    return { head: O, prefix: d, scalar: p };
+  }
+  function E(m) {
+    const { head: H, prefix: U, scalar: O } = h(m), d = i.multiply(O), p = d.toBytes();
+    return { head: H, prefix: U, scalar: O, point: d, pointBytes: p };
+  }
+  function w(m) {
+    return E(m).pointBytes;
+  }
+  function x(m = Uint8Array.of(), ...H) {
+    const U = lt(...H);
+    return b(r(f(U, V("context", m), !!n)));
+  }
+  function _(m, H, U = {}) {
+    m = V("message", m), n && (m = n(m));
+    const { prefix: O, scalar: d, pointBytes: p } = E(H), y = x(U.context, O, m), g = i.multiply(y).toBytes(), B = x(U.context, g, p, m), v = u(y + B * d);
+    qt("signature.s", v, it, c);
+    const A = s.BYTES, I = lt(g, Dt(v, A));
+    return V("result", I, A * 2);
+  }
+  const R = pr;
+  function L(m, H, U, O = R) {
+    const { context: d, zip215: p } = O, y = s.BYTES;
+    m = V("signature", m, 2 * y), H = V("message", H), U = V("publicKey", U, y), p !== void 0 && Lt("zip215", p), n && (H = n(H));
+    const g = Tt(m.slice(y, 2 * y));
+    let B, v, A;
+    try {
+      B = t.fromHex(U, p), v = t.fromHex(m.slice(0, y), p), A = i.multiplyUnsafe(g);
+    } catch {
+      return !1;
+    }
+    if (!p && B.isSmallOrder())
+      return !1;
+    const I = x(d, v.toBytes(), B.toBytes(), H);
+    return v.add(B.multiplyUnsafe(I)).subtract(A).clearCofactor().is0();
+  }
+  return i.precompute(8), { getPublicKey: w, sign: _, verify: L, utils: {
+    getExtendedPublicKey: E,
+    /** ed25519 priv keys are uniform 32b. No need to check for modulo bias, like in secp256k1. */
+    randomPrivateKey: () => a(s.BYTES),
+    /**
+     * We're doing scalar multiplication (used in getPublicKey etc) with precomputed BASE_POINT
+     * values. This slows down first getPublicKey() by milliseconds (see Speed section),
+     * but allows to speed-up subsequent getPublicKey() calls up to 20x.
+     * @param windowSize 2, 4, 8, 16
+     */
+    precompute(m = 8, H = t.BASE) {
+      return H.precompute(m, !1);
+    }
+  }, Point: t };
+}
+function Ar(t) {
+  const e = {
+    a: t.a,
+    d: t.d,
+    p: t.Fp.ORDER,
+    n: t.n,
+    h: t.h,
+    Gx: t.Gx,
+    Gy: t.Gy
+  }, n = t.Fp, r = Ot(e.n, t.nBitLength, !0), i = { Fp: n, Fn: r, uvRatio: t.uvRatio }, s = {
+    hash: t.hash,
+    randomBytes: t.randomBytes,
+    adjustScalarBytes: t.adjustScalarBytes,
+    domain: t.domain,
+    prehash: t.prehash,
+    mapToCurve: t.mapToCurve
+  };
+  return { CURVE: e, curveOpts: i, eddsaOpts: s };
+}
+function vr(t, e) {
+  return Object.assign({}, e, { ExtendedPoint: e.Point, CURVE: t });
+}
+function Sr(t) {
+  const { CURVE: e, curveOpts: n, eddsaOpts: r } = Ar(t), i = Br(e, n), s = _r(i, r);
+  return vr(t, s);
+}
+const cs = BigInt(0), fs = BigInt(1), as = BigInt(2);
+const Ir = BigInt(0), ut = BigInt(1), Ce = BigInt(2), ls = BigInt(3), Lr = BigInt(5), Or = BigInt(8), ne = {
+  p: BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed"),
+  n: BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed"),
+  h: Or,
+  a: BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec"),
+  d: BigInt("0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3"),
+  Gx: BigInt("0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a"),
+  Gy: BigInt("0x6666666666666666666666666666666666666666666666666666666666666658")
+};
+function Hr(t) {
+  const e = BigInt(10), n = BigInt(20), r = BigInt(40), i = BigInt(80), s = ne.p, c = t * t % s * t % s, a = G(c, Ce, s) * c % s, l = G(a, ut, s) * t % s, f = G(l, Lr, s) * l % s, u = G(f, e, s) * f % s, b = G(u, n, s) * u % s, h = G(b, r, s) * b % s, E = G(h, i, s) * h % s, w = G(E, i, s) * h % s, x = G(w, e, s) * f % s;
+  return { pow_p_5_8: G(x, Ce, s) * t % s, b2: c };
+}
+function Rr(t) {
+  return t[0] &= 248, t[31] &= 127, t[31] |= 64, t;
+}
+const de = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
+function Se(t, e) {
+  const n = ne.p, r = j(e * e * e, n), i = j(r * r * e, n), s = Hr(t * i).pow_p_5_8;
+  let o = j(t * r * s, n);
+  const c = j(e * o * o, n), a = o, l = j(o * de, n), f = c === t, u = c === j(-t, n), b = c === j(-t * de, n);
+  return f && (o = a), (u || b) && (o = l), Et(o, n) && (o = j(-o, n)), { isValid: f || u, value: o };
+}
+const Ut = Ot(ne.p, void 0, !0), kr = {
+  ...ne,
+  Fp: Ut,
+  hash: sn,
+  adjustScalarBytes: Rr,
+  // dom2
+  // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.
+  // Constant-time, u/√v
+  uvRatio: Se
+}, nt = Sr(kr);
+function le(t) {
+  if (!(t instanceof Y))
+    throw new Error("RistrettoPoint expected");
+}
+const be = de, Ur = /* @__PURE__ */ BigInt("25063068953384623474111414158702152701244531502492656460079210482610430750235"), qr = /* @__PURE__ */ BigInt("54469307008909316920995813868745141605393597292927456921205312896311721017578"), Nr = /* @__PURE__ */ BigInt("1159843021668779879193775521855586647937357759715417654439879720876111806838"), Tr = /* @__PURE__ */ BigInt("40440834346308536858101042469323190826248399146238708352240133220865137265952"), Ze = (t) => Se(ut, t), Dr = /* @__PURE__ */ BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), ue = (t) => nt.CURVE.Fp.create(Tt(t) & Dr);
+function Me(t) {
+  const { d: e } = nt.CURVE, n = nt.CURVE.Fp.ORDER, r = nt.CURVE.Fp.create, i = r(be * t * t), s = r((i + ut) * Nr);
+  let o = BigInt(-1);
+  const c = r((o - e * i) * r(i + e));
+  let { isValid: a, value: l } = Se(s, c), f = r(l * t);
+  Et(f, n) || (f = r(-f)), a || (l = f), a || (o = i);
+  const u = r(o * (i - ut) * Tr - c), b = l * l, h = r((l + l) * c), E = r(u * Ur), w = r(ut - b), x = r(ut + b);
+  return new nt.Point(r(h * x), r(w * E), r(E * x), r(h * w));
+}
+class Y {
+  // Private property to discourage combining ExtendedPoint + RistrettoPoint
+  // Always use Ristretto encoding/decoding instead.
+  constructor(e) {
+    this.ep = e;
+  }
+  static fromAffine(e) {
+    return new Y(nt.Point.fromAffine(e));
+  }
+  /**
+   * Takes uniform output of 64-byte hash function like sha512 and converts it to `RistrettoPoint`.
+   * The hash-to-group operation applies Elligator twice and adds the results.
+   * **Note:** this is one-way map, there is no conversion from point to hash.
+   * Described in [RFC9380](https://www.rfc-editor.org/rfc/rfc9380#appendix-B) and on
+   * the [website](https://ristretto.group/formulas/elligator.html).
+   * @param hex 64-byte output of a hash function
+   */
+  static hashToCurve(e) {
+    e = V("ristrettoHash", e, 64);
+    const n = ue(e.slice(0, 32)), r = Me(n), i = ue(e.slice(32, 64)), s = Me(i);
+    return new Y(r.add(s));
+  }
+  static fromBytes(e) {
+    return et(e), this.fromHex(e);
+  }
+  /**
+   * Converts ristretto-encoded string to ristretto point.
+   * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-decode).
+   * @param hex Ristretto-encoded 32 bytes. Not every 32-byte string is valid ristretto encoding
+   */
+  static fromHex(e) {
+    e = V("ristrettoHex", e, 32);
+    const { a: n, d: r } = nt.CURVE, i = Ut.ORDER, s = Ut.create, o = "RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint", c = ue(e);
+    if (!rr(Dt(c, 32), e) || Et(c, i))
+      throw new Error(o);
+    const a = s(c * c), l = s(ut + n * a), f = s(ut - n * a), u = s(l * l), b = s(f * f), h = s(n * r * u - b), { isValid: E, value: w } = Ze(s(h * b)), x = s(w * f), _ = s(w * x * h);
+    let R = s((c + c) * x);
+    Et(R, i) && (R = s(-R));
+    const L = s(l * _), T = s(R * L);
+    if (!E || Et(T, i) || L === Ir)
+      throw new Error(o);
+    return new Y(new nt.Point(R, L, ut, T));
+  }
+  static msm(e, n) {
+    const r = Ot(nt.CURVE.n, nt.CURVE.nBitLength);
+    return ve(Y, r, e, n);
+  }
+  /**
+   * Encodes ristretto point to Uint8Array.
+   * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-encode).
+   */
+  toBytes() {
+    let { ex: e, ey: n, ez: r, et: i } = this.ep;
+    const s = Ut.ORDER, o = Ut.create, c = o(o(r + n) * o(r - n)), a = o(e * n), l = o(a * a), { value: f } = Ze(o(c * l)), u = o(f * c), b = o(f * a), h = o(u * b * i);
+    let E;
+    if (Et(i * h, s)) {
+      let x = o(n * be), _ = o(e * be);
+      e = x, n = _, E = o(u * qr);
+    } else
+      E = b;
+    Et(e * h, s) && (n = o(-n));
+    let w = o((r - n) * E);
+    return Et(w, s) && (w = o(-w)), Dt(w, 32);
+  }
+  /** @deprecated use `toBytes` */
+  toRawBytes() {
+    return this.toBytes();
+  }
+  toHex() {
+    return It(this.toBytes());
+  }
+  toString() {
+    return this.toHex();
+  }
+  /**
+   * Compares two Ristretto points.
+   * Described in [RFC9496](https://www.rfc-editor.org/rfc/rfc9496#name-equals).
+   */
+  equals(e) {
+    le(e);
+    const { ex: n, ey: r } = this.ep, { ex: i, ey: s } = e.ep, o = Ut.create, c = o(n * s) === o(r * i), a = o(r * s) === o(n * i);
+    return c || a;
+  }
+  add(e) {
+    return le(e), new Y(this.ep.add(e.ep));
+  }
+  subtract(e) {
+    return le(e), new Y(this.ep.subtract(e.ep));
+  }
+  multiply(e) {
+    return new Y(this.ep.multiply(e));
+  }
+  multiplyUnsafe(e) {
+    return new Y(this.ep.multiplyUnsafe(e));
+  }
+  double() {
+    return new Y(this.ep.double());
+  }
+  negate() {
+    return new Y(this.ep.negate());
+  }
+}
+const us = (Y.BASE || (Y.BASE = new Y(nt.Point.BASE)), Y.ZERO || (Y.ZERO = new Y(nt.Point.ZERO)), Y), Cr = BigInt(0), Mt = BigInt(1), Zr = BigInt(2), Mr = BigInt(7), zr = BigInt(256), Vr = BigInt(113), En = [], Bn = [], _n = [];
+for (let t = 0, e = Mt, n = 1, r = 0; t < 24; t++) {
+  [n, r] = [r, (2 * n + 3 * r) % 5], En.push(2 * (5 * r + n)), Bn.push((t + 1) * (t + 2) / 2 % 64);
+  let i = Cr;
+  for (let s = 0; s < 7; s++)
+    e = (e << Mt ^ (e >> Mr) * Vr) % zr, e & Zr && (i ^= Mt << (Mt << /* @__PURE__ */ BigInt(s)) - Mt);
+  _n.push(i);
+}
+const An = nn(_n, !0), Gr = An[0], jr = An[1], ze = (t, e, n) => n > 32 ? Dn(t, e, n) : Nn(t, e, n), Ve = (t, e, n) => n > 32 ? Cn(t, e, n) : Tn(t, e, n);
+function hs(t, e = 24) {
+  const n = new Uint32Array(10);
+  for (let r = 24 - e; r < 24; r++) {
+    for (let o = 0; o < 10; o++)
+      n[o] = t[o] ^ t[o + 10] ^ t[o + 20] ^ t[o + 30] ^ t[o + 40];
+    for (let o = 0; o < 10; o += 2) {
+      const c = (o + 8) % 10, a = (o + 2) % 10, l = n[a], f = n[a + 1], u = ze(l, f, 1) ^ n[c], b = Ve(l, f, 1) ^ n[c + 1];
+      for (let h = 0; h < 50; h += 10)
+        t[o + h] ^= u, t[o + h + 1] ^= b;
+    }
+    let i = t[2], s = t[3];
+    for (let o = 0; o < 24; o++) {
+      const c = Bn[o], a = ze(i, s, c), l = Ve(i, s, c), f = En[o];
+      i = t[f], s = t[f + 1], t[f] = a, t[f + 1] = l;
+    }
+    for (let o = 0; o < 50; o += 10) {
+      for (let c = 0; c < 10; c++)
+        n[c] = t[o + c];
+      for (let c = 0; c < 10; c++)
+        t[o + c] ^= ~n[(c + 2) % 10] & n[(c + 4) % 10];
+    }
+    t[0] ^= Gr[r], t[1] ^= jr[r];
+  }
+  rt(n);
+}
+const ds = sn;
+function Ge(t) {
+  t.lowS !== void 0 && Lt("lowS", t.lowS), t.prehash !== void 0 && Lt("prehash", t.prehash);
+}
+class $r extends Error {
+  constructor(e = "") {
+    super(e);
+  }
+}
+const at = {
+  // asn.1 DER encoding utils
+  Err: $r,
+  // Basic building block is TLV (Tag-Length-Value)
+  _tlv: {
+    encode: (t, e) => {
+      const { Err: n } = at;
+      if (t < 0 || t > 256)
+        throw new n("tlv.encode: wrong tag");
+      if (e.length & 1)
+        throw new n("tlv.encode: unpadded data");
+      const r = e.length / 2, i = Kt(r);
+      if (i.length / 2 & 128)
+        throw new n("tlv.encode: long form length too big");
+      const s = r > 127 ? Kt(i.length / 2 | 128) : "";
+      return Kt(t) + s + i + e;
+    },
+    // v - value, l - left bytes (unparsed)
+    decode(t, e) {
+      const { Err: n } = at;
+      let r = 0;
+      if (t < 0 || t > 256)
+        throw new n("tlv.encode: wrong tag");
+      if (e.length < 2 || e[r++] !== t)
+        throw new n("tlv.decode: wrong tlv");
+      const i = e[r++], s = !!(i & 128);
+      let o = 0;
+      if (!s)
+        o = i;
+      else {
+        const a = i & 127;
+        if (!a)
+          throw new n("tlv.decode(long): indefinite length not supported");
+        if (a > 4)
+          throw new n("tlv.decode(long): byte length is too big");
+        const l = e.subarray(r, r + a);
+        if (l.length !== a)
+          throw new n("tlv.decode: length bytes not complete");
+        if (l[0] === 0)
+          throw new n("tlv.decode(long): zero leftmost byte");
+        for (const f of l)
+          o = o << 8 | f;
+        if (r += a, o < 128)
+          throw new n("tlv.decode(long): not minimal encoding");
+      }
+      const c = e.subarray(r, r + o);
+      if (c.length !== o)
+        throw new n("tlv.decode: wrong value length");
+      return { v: c, l: e.subarray(r + o) };
+    }
+  },
+  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+  // since we always use positive integers here. It must always be empty:
+  // - add zero byte if exists
+  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+  _int: {
+    encode(t) {
+      const { Err: e } = at;
+      if (t < jt)
+        throw new e("integer: negative integers are not allowed");
+      let n = Kt(t);
+      if (Number.parseInt(n[0], 16) & 8 && (n = "00" + n), n.length & 1)
+        throw new e("unexpected DER parsing assertion: unpadded hex");
+      return n;
+    },
+    decode(t) {
+      const { Err: e } = at;
+      if (t[0] & 128)
+        throw new e("invalid signature integer: negative");
+      if (t[0] === 0 && !(t[1] & 128))
+        throw new e("invalid signature integer: unnecessary leading zero");
+      return te(t);
+    }
+  },
+  toSig(t) {
+    const { Err: e, _int: n, _tlv: r } = at, i = V("signature", t), { v: s, l: o } = r.decode(48, i);
+    if (o.length)
+      throw new e("invalid signature: left bytes after parsing");
+    const { v: c, l: a } = r.decode(2, s), { v: l, l: f } = r.decode(2, a);
+    if (f.length)
+      throw new e("invalid signature: left bytes after parsing");
+    return { r: n.decode(c), s: n.decode(l) };
+  },
+  hexFromSig(t) {
+    const { _tlv: e, _int: n } = at, r = e.encode(2, n.encode(t.r)), i = e.encode(2, n.encode(t.s)), s = r + i;
+    return e.encode(48, s);
+  }
+}, jt = BigInt(0), $t = BigInt(1), Yr = BigInt(2), Pt = BigInt(3), Xr = BigInt(4);
+function Kr(t, e, n) {
+  function r(i) {
+    const s = t.sqr(i), o = t.mul(s, i);
+    return t.add(t.add(o, t.mul(i, e)), n);
+  }
+  return r;
+}
+function vn(t, e, n) {
+  const { BYTES: r } = t;
+  function i(s) {
+    let o;
+    if (typeof s == "bigint")
+      o = s;
+    else {
+      let c = V("private key", s);
+      if (e) {
+        if (!e.includes(c.length * 2))
+          throw new Error("invalid private key");
+        const a = new Uint8Array(r);
+        a.set(c, a.length - c.length), c = a;
+      }
+      try {
+        o = t.fromBytes(c);
+      } catch {
+        throw new Error(`invalid private key: expected ui8a of size ${r}, got ${typeof s}`);
+      }
+    }
+    if (n && (o = t.create(o)), !t.isValidNot0(o))
+      throw new Error("invalid private key: out of range [1..N-1]");
+    return o;
+  }
+  return i;
+}
+function Pr(t, e = {}) {
+  const { Fp: n, Fn: r } = pn("weierstrass", t, e), { h: i, n: s } = t;
+  Yt(e, {}, {
+    allowInfinityPoint: "boolean",
+    clearCofactor: "function",
+    isTorsionFree: "function",
+    fromBytes: "function",
+    toBytes: "function",
+    endo: "object",
+    wrapPrivateKey: "boolean"
+  });
+  const { endo: o } = e;
+  if (o && (!n.is0(t.a) || typeof o.beta != "bigint" || typeof o.splitScalar != "function"))
+    throw new Error('invalid endo: expected "beta": bigint and "splitScalar": function');
+  function c() {
+    if (!n.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function a(O, d, p) {
+    const { x: y, y: g } = d.toAffine(), B = n.toBytes(y);
+    if (Lt("isCompressed", p), p) {
+      c();
+      const v = !n.isOdd(g);
+      return lt(Sn(v), B);
+    } else
+      return lt(Uint8Array.of(4), B, n.toBytes(g));
+  }
+  function l(O) {
+    et(O);
+    const d = n.BYTES, p = d + 1, y = 2 * d + 1, g = O.length, B = O[0], v = O.subarray(1);
+    if (g === p && (B === 2 || B === 3)) {
+      const A = n.fromBytes(v);
+      if (!n.isValid(A))
+        throw new Error("bad point: is not on curve, wrong x");
+      const I = b(A);
+      let q;
+      try {
+        q = n.sqrt(I);
+      } catch (D) {
+        const N = D instanceof Error ? ": " + D.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + N);
+      }
+      c();
+      const k = n.isOdd(q);
+      return (B & 1) === 1 !== k && (q = n.neg(q)), { x: A, y: q };
+    } else if (g === y && B === 4) {
+      const A = n.fromBytes(v.subarray(d * 0, d * 1)), I = n.fromBytes(v.subarray(d * 1, d * 2));
+      if (!h(A, I))
+        throw new Error("bad point: is not on curve");
+      return { x: A, y: I };
+    } else
+      throw new Error(`bad point: got length ${g}, expected compressed=${p} or uncompressed=${y}`);
+  }
+  const f = e.toBytes || a, u = e.fromBytes || l, b = Kr(n, t.a, t.b);
+  function h(O, d) {
+    const p = n.sqr(d), y = b(O);
+    return n.eql(p, y);
+  }
+  if (!h(t.Gx, t.Gy))
+    throw new Error("bad curve params: generator point");
+  const E = n.mul(n.pow(t.a, Pt), Xr), w = n.mul(n.sqr(t.b), BigInt(27));
+  if (n.is0(n.add(E, w)))
+    throw new Error("bad curve params: a or b");
+  function x(O, d, p = !1) {
+    if (!n.isValid(d) || p && n.is0(d))
+      throw new Error(`bad point coordinate ${O}`);
+    return d;
+  }
+  function _(O) {
+    if (!(O instanceof m))
+      throw new Error("ProjectivePoint expected");
+  }
+  const R = Qt((O, d) => {
+    const { px: p, py: y, pz: g } = O;
+    if (n.eql(g, n.ONE))
+      return { x: p, y };
+    const B = O.is0();
+    d == null && (d = B ? n.ONE : n.inv(g));
+    const v = n.mul(p, d), A = n.mul(y, d), I = n.mul(g, d);
+    if (B)
+      return { x: n.ZERO, y: n.ZERO };
+    if (!n.eql(I, n.ONE))
+      throw new Error("invZ was invalid");
+    return { x: v, y: A };
+  }), L = Qt((O) => {
+    if (O.is0()) {
+      if (e.allowInfinityPoint && !n.is0(O.py))
+        return;
+      throw new Error("bad point: ZERO");
+    }
+    const { x: d, y: p } = O.toAffine();
+    if (!n.isValid(d) || !n.isValid(p))
+      throw new Error("bad point: x or y not field elements");
+    if (!h(d, p))
+      throw new Error("bad point: equation left != right");
+    if (!O.isTorsionFree())
+      throw new Error("bad point: not in prime-order subgroup");
+    return !0;
+  });
+  function T(O, d, p, y, g) {
+    return p = new m(n.mul(p.px, O), p.py, p.pz), d = Gt(y, d), p = Gt(g, p), d.add(p);
+  }
+  class m {
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    constructor(d, p, y) {
+      this.px = x("x", d), this.py = x("y", p, !0), this.pz = x("z", y), Object.freeze(this);
+    }
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    static fromAffine(d) {
+      const { x: p, y } = d || {};
+      if (!d || !n.isValid(p) || !n.isValid(y))
+        throw new Error("invalid affine point");
+      if (d instanceof m)
+        throw new Error("projective point not allowed");
+      return n.is0(p) && n.is0(y) ? m.ZERO : new m(p, y, n.ONE);
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    static normalizeZ(d) {
+      return wn(m, "pz", d);
+    }
+    static fromBytes(d) {
+      return et(d), m.fromHex(d);
+    }
+    /** Converts hash string or Uint8Array to Point. */
+    static fromHex(d) {
+      const p = m.fromAffine(u(V("pointHex", d)));
+      return p.assertValidity(), p;
+    }
+    /** Multiplies generator point by privateKey. */
+    static fromPrivateKey(d) {
+      const p = vn(r, e.allowedPrivateKeyLengths, e.wrapPrivateKey);
+      return m.BASE.multiply(p(d));
+    }
+    /** Multiscalar Multiplication */
+    static msm(d, p) {
+      return ve(m, r, d, p);
+    }
+    /**
+     *
+     * @param windowSize
+     * @param isLazy true will defer table computation until the first multiplication
+     * @returns
+     */
+    precompute(d = 8, p = !0) {
+      return U.setWindowSize(this, d), p || this.multiply(Pt), this;
+    }
+    /** "Private method", don't use it directly */
+    _setWindowSize(d) {
+      this.precompute(d);
+    }
+    // TODO: return `this`
+    /** A point on curve is valid if it conforms to equation. */
+    assertValidity() {
+      L(this);
+    }
+    hasEvenY() {
+      const { y: d } = this.toAffine();
+      if (!n.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !n.isOdd(d);
+    }
+    /** Compare one point to another. */
+    equals(d) {
+      _(d);
+      const { px: p, py: y, pz: g } = this, { px: B, py: v, pz: A } = d, I = n.eql(n.mul(p, A), n.mul(B, g)), q = n.eql(n.mul(y, A), n.mul(v, g));
+      return I && q;
+    }
+    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
+    negate() {
+      return new m(this.px, n.neg(this.py), this.pz);
+    }
+    // Renes-Costello-Batina exception-free doubling formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 3
+    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+    double() {
+      const { a: d, b: p } = t, y = n.mul(p, Pt), { px: g, py: B, pz: v } = this;
+      let A = n.ZERO, I = n.ZERO, q = n.ZERO, k = n.mul(g, g), Z = n.mul(B, B), D = n.mul(v, v), N = n.mul(g, B);
+      return N = n.add(N, N), q = n.mul(g, v), q = n.add(q, q), A = n.mul(d, q), I = n.mul(y, D), I = n.add(A, I), A = n.sub(Z, I), I = n.add(Z, I), I = n.mul(A, I), A = n.mul(N, A), q = n.mul(y, q), D = n.mul(d, D), N = n.sub(k, D), N = n.mul(d, N), N = n.add(N, q), q = n.add(k, k), k = n.add(q, k), k = n.add(k, D), k = n.mul(k, N), I = n.add(I, k), D = n.mul(B, v), D = n.add(D, D), k = n.mul(D, N), A = n.sub(A, k), q = n.mul(D, Z), q = n.add(q, q), q = n.add(q, q), new m(A, I, q);
+    }
+    // Renes-Costello-Batina exception-free addition formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 1
+    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
+    add(d) {
+      _(d);
+      const { px: p, py: y, pz: g } = this, { px: B, py: v, pz: A } = d;
+      let I = n.ZERO, q = n.ZERO, k = n.ZERO;
+      const Z = t.a, D = n.mul(t.b, Pt);
+      let N = n.mul(p, B), z = n.mul(y, v), X = n.mul(g, A), P = n.add(p, y), M = n.add(B, v);
+      P = n.mul(P, M), M = n.add(N, z), P = n.sub(P, M), M = n.add(p, g);
+      let Q = n.add(B, A);
+      return M = n.mul(M, Q), Q = n.add(N, X), M = n.sub(M, Q), Q = n.add(y, g), I = n.add(v, A), Q = n.mul(Q, I), I = n.add(z, X), Q = n.sub(Q, I), k = n.mul(Z, M), I = n.mul(D, X), k = n.add(I, k), I = n.sub(z, k), k = n.add(z, k), q = n.mul(I, k), z = n.add(N, N), z = n.add(z, N), X = n.mul(Z, X), M = n.mul(D, M), z = n.add(z, X), X = n.sub(N, X), X = n.mul(Z, X), M = n.add(M, X), N = n.mul(z, M), q = n.add(q, N), N = n.mul(Q, M), I = n.mul(P, I), I = n.sub(I, N), N = n.mul(P, z), k = n.mul(Q, k), k = n.add(k, N), new m(I, q, k);
+    }
+    subtract(d) {
+      return this.add(d.negate());
+    }
+    is0() {
+      return this.equals(m.ZERO);
+    }
+    /**
+     * Constant time multiplication.
+     * Uses wNAF method. Windowed method may be 10% faster,
+     * but takes 2x longer to generate and consumes 2x memory.
+     * Uses precomputes when available.
+     * Uses endomorphism for Koblitz curves.
+     * @param scalar by which the point would be multiplied
+     * @returns New point
+     */
+    multiply(d) {
+      const { endo: p } = e;
+      if (!r.isValidNot0(d))
+        throw new Error("invalid scalar: out of range");
+      let y, g;
+      const B = (v) => U.wNAFCached(this, v, m.normalizeZ);
+      if (p) {
+        const { k1neg: v, k1: A, k2neg: I, k2: q } = p.splitScalar(d), { p: k, f: Z } = B(A), { p: D, f: N } = B(q);
+        g = Z.add(N), y = T(p.beta, k, D, v, I);
+      } else {
+        const { p: v, f: A } = B(d);
+        y = v, g = A;
+      }
+      return m.normalizeZ([y, g])[0];
+    }
+    /**
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about
+     * an exposed private key e.g. sig verification, which works over *public* keys.
+     */
+    multiplyUnsafe(d) {
+      const { endo: p } = e, y = this;
+      if (!r.isValid(d))
+        throw new Error("invalid scalar: out of range");
+      if (d === jt || y.is0())
+        return m.ZERO;
+      if (d === $t)
+        return y;
+      if (U.hasPrecomputes(this))
+        return this.multiply(d);
+      if (p) {
+        const { k1neg: g, k1: B, k2neg: v, k2: A } = p.splitScalar(d), { p1: I, p2: q } = gr(m, y, B, A);
+        return T(p.beta, I, q, g, v);
+      } else
+        return U.wNAFCachedUnsafe(y, d);
+    }
+    multiplyAndAddUnsafe(d, p, y) {
+      const g = this.multiplyUnsafe(p).add(d.multiplyUnsafe(y));
+      return g.is0() ? void 0 : g;
+    }
+    /**
+     * Converts Projective point to affine (x, y) coordinates.
+     * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+     */
+    toAffine(d) {
+      return R(this, d);
+    }
+    /**
+     * Checks whether Point is free of torsion elements (is in prime subgroup).
+     * Always torsion-free for cofactor=1 curves.
+     */
+    isTorsionFree() {
+      const { isTorsionFree: d } = e;
+      return i === $t ? !0 : d ? d(m, this) : U.wNAFCachedUnsafe(this, s).is0();
+    }
+    clearCofactor() {
+      const { clearCofactor: d } = e;
+      return i === $t ? this : d ? d(m, this) : this.multiplyUnsafe(i);
+    }
+    toBytes(d = !0) {
+      return Lt("isCompressed", d), this.assertValidity(), f(m, this, d);
+    }
+    /** @deprecated use `toBytes` */
+    toRawBytes(d = !0) {
+      return this.toBytes(d);
+    }
+    toHex(d = !0) {
+      return It(this.toBytes(d));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+  }
+  m.BASE = new m(t.Gx, t.Gy, n.ONE), m.ZERO = new m(n.ZERO, n.ONE, n.ZERO), m.Fp = n, m.Fn = r;
+  const H = r.BITS, U = mn(m, e.endo ? Math.ceil(H / 2) : H);
+  return m;
+}
+function Sn(t) {
+  return Uint8Array.of(t ? 2 : 3);
+}
+function Wr(t, e, n = {}) {
+  Yt(e, { hash: "function" }, {
+    hmac: "function",
+    lowS: "boolean",
+    randomBytes: "function",
+    bits2int: "function",
+    bits2int_modN: "function"
+  });
+  const r = e.randomBytes || Fe, i = e.hmac || ((y, ...g) => Be(e.hash, y, lt(...g))), { Fp: s, Fn: o } = t, { ORDER: c, BITS: a } = o;
+  function l(y) {
+    const g = c >> $t;
+    return y > g;
+  }
+  function f(y) {
+    return l(y) ? o.neg(y) : y;
+  }
+  function u(y, g) {
+    if (!o.isValidNot0(g))
+      throw new Error(`invalid signature ${y}: out of range 1..CURVE.n`);
+  }
+  class b {
+    constructor(g, B, v) {
+      u("r", g), u("s", B), this.r = g, this.s = B, v != null && (this.recovery = v), Object.freeze(this);
+    }
+    // pair (bytes of r, bytes of s)
+    static fromCompact(g) {
+      const B = o.BYTES, v = V("compactSignature", g, B * 2);
+      return new b(o.fromBytes(v.subarray(0, B)), o.fromBytes(v.subarray(B, B * 2)));
+    }
+    // DER encoded ECDSA signature
+    // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
+    static fromDER(g) {
+      const { r: B, s: v } = at.toSig(V("DER", g));
+      return new b(B, v);
+    }
+    /**
+     * @todo remove
+     * @deprecated
+     */
+    assertValidity() {
+    }
+    addRecoveryBit(g) {
+      return new b(this.r, this.s, g);
+    }
+    // ProjPointType<bigint>
+    recoverPublicKey(g) {
+      const B = s.ORDER, { r: v, s: A, recovery: I } = this;
+      if (I == null || ![0, 1, 2, 3].includes(I))
+        throw new Error("recovery id invalid");
+      if (c * Yr < B && I > 1)
+        throw new Error("recovery id is ambiguous for h>1 curve");
+      const k = I === 2 || I === 3 ? v + c : v;
+      if (!s.isValid(k))
+        throw new Error("recovery id 2 or 3 invalid");
+      const Z = s.toBytes(k), D = t.fromHex(lt(Sn((I & 1) === 0), Z)), N = o.inv(k), z = L(V("msgHash", g)), X = o.create(-z * N), P = o.create(A * N), M = t.BASE.multiplyUnsafe(X).add(D.multiplyUnsafe(P));
+      if (M.is0())
+        throw new Error("point at infinify");
+      return M.assertValidity(), M;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return l(this.s);
+    }
+    normalizeS() {
+      return this.hasHighS() ? new b(this.r, o.neg(this.s), this.recovery) : this;
+    }
+    toBytes(g) {
+      if (g === "compact")
+        return lt(o.toBytes(this.r), o.toBytes(this.s));
+      if (g === "der")
+        return ge(at.hexFromSig(this));
+      throw new Error("invalid format");
+    }
+    // DER-encoded
+    toDERRawBytes() {
+      return this.toBytes("der");
+    }
+    toDERHex() {
+      return It(this.toBytes("der"));
+    }
+    // padded bytes of r, then padded bytes of s
+    toCompactRawBytes() {
+      return this.toBytes("compact");
+    }
+    toCompactHex() {
+      return It(this.toBytes("compact"));
+    }
+  }
+  const h = vn(o, n.allowedPrivateKeyLengths, n.wrapPrivateKey), E = {
+    isValidPrivateKey(y) {
+      try {
+        return h(y), !0;
+      } catch {
+        return !1;
+      }
+    },
+    normPrivateKeyToScalar: h,
+    /**
+     * Produces cryptographically secure private key from random of size
+     * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
+     */
+    randomPrivateKey: () => {
+      const y = c;
+      return xr(r(xn(y)), y);
+    },
+    precompute(y = 8, g = t.BASE) {
+      return g.precompute(y, !1);
+    }
+  };
+  function w(y, g = !0) {
+    return t.fromPrivateKey(y).toBytes(g);
+  }
+  function x(y) {
+    if (typeof y == "bigint")
+      return !1;
+    if (y instanceof t)
+      return !0;
+    const B = V("key", y).length, v = s.BYTES, A = v + 1, I = 2 * v + 1;
+    if (!(n.allowedPrivateKeyLengths || o.BYTES === A))
+      return B === A || B === I;
+  }
+  function _(y, g, B = !0) {
+    if (x(y) === !0)
+      throw new Error("first arg must be private key");
+    if (x(g) === !1)
+      throw new Error("second arg must be public key");
+    return t.fromHex(g).multiply(h(y)).toBytes(B);
+  }
+  const R = e.bits2int || function(y) {
+    if (y.length > 8192)
+      throw new Error("input is too large");
+    const g = te(y), B = y.length * 8 - a;
+    return B > 0 ? g >> BigInt(B) : g;
+  }, L = e.bits2int_modN || function(y) {
+    return o.create(R(y));
+  }, T = ee(a);
+  function m(y) {
+    return qt("num < 2^" + a, y, jt, T), o.toBytes(y);
+  }
+  function H(y, g, B = U) {
+    if (["recovered", "canonical"].some((P) => P in B))
+      throw new Error("sign() legacy options not supported");
+    const { hash: v } = e;
+    let { lowS: A, prehash: I, extraEntropy: q } = B;
+    A == null && (A = !0), y = V("msgHash", y), Ge(B), I && (y = V("prehashed msgHash", v(y)));
+    const k = L(y), Z = h(g), D = [m(Z), m(k)];
+    if (q != null && q !== !1) {
+      const P = q === !0 ? r(s.BYTES) : q;
+      D.push(V("extraEntropy", P));
+    }
+    const N = lt(...D), z = k;
+    function X(P) {
+      const M = R(P);
+      if (!o.isValidNot0(M))
+        return;
+      const Q = o.inv(M), Zt = t.BASE.multiply(M).toAffine(), Ht = o.create(Zt.x);
+      if (Ht === jt)
+        return;
+      const _t = o.create(Q * o.create(z + Ht * Z));
+      if (_t === jt)
+        return;
+      let re = (Zt.x === Ht ? 0 : 2) | Number(Zt.y & $t), Rt = _t;
+      return A && l(_t) && (Rt = f(_t), re ^= 1), new b(Ht, Rt, re);
+    }
+    return { seed: N, k2sig: X };
+  }
+  const U = { lowS: e.lowS, prehash: !1 }, O = { lowS: e.lowS, prehash: !1 };
+  function d(y, g, B = U) {
+    const { seed: v, k2sig: A } = H(y, g, B);
+    return ir(e.hash.outputLen, o.BYTES, i)(v, A);
+  }
+  t.BASE.precompute(8);
+  function p(y, g, B, v = O) {
+    const A = y;
+    g = V("msgHash", g), B = V("publicKey", B), Ge(v);
+    const { lowS: I, prehash: q, format: k } = v;
+    if ("strict" in v)
+      throw new Error("options.strict was renamed to lowS");
+    if (k !== void 0 && !["compact", "der", "js"].includes(k))
+      throw new Error('format must be "compact", "der" or "js"');
+    const Z = typeof A == "string" || ye(A), D = !Z && !k && typeof A == "object" && A !== null && typeof A.r == "bigint" && typeof A.s == "bigint";
+    if (!Z && !D)
+      throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
+    let N, z;
+    try {
+      if (D)
+        if (k === void 0 || k === "js")
+          N = new b(A.r, A.s);
+        else
+          throw new Error("invalid format");
+      if (Z) {
+        try {
+          k !== "compact" && (N = b.fromDER(A));
+        } catch (Rt) {
+          if (!(Rt instanceof at.Err))
+            throw Rt;
+        }
+        !N && k !== "der" && (N = b.fromCompact(A));
+      }
+      z = t.fromHex(B);
+    } catch {
+      return !1;
+    }
+    if (!N || I && N.hasHighS())
+      return !1;
+    q && (g = e.hash(g));
+    const { r: X, s: P } = N, M = L(g), Q = o.inv(P), Zt = o.create(M * Q), Ht = o.create(X * Q), _t = t.BASE.multiplyUnsafe(Zt).add(z.multiplyUnsafe(Ht));
+    return _t.is0() ? !1 : o.create(_t.x) === X;
+  }
+  return Object.freeze({
+    getPublicKey: w,
+    getSharedSecret: _,
+    sign: d,
+    verify: p,
+    utils: E,
+    Point: t,
+    Signature: b
+  });
+}
+function Qr(t) {
+  const e = {
+    a: t.a,
+    b: t.b,
+    p: t.Fp.ORDER,
+    n: t.n,
+    h: t.h,
+    Gx: t.Gx,
+    Gy: t.Gy
+  }, n = t.Fp, r = Ot(e.n, t.nBitLength), i = {
+    Fp: n,
+    Fn: r,
+    allowedPrivateKeyLengths: t.allowedPrivateKeyLengths,
+    allowInfinityPoint: t.allowInfinityPoint,
+    endo: t.endo,
+    wrapPrivateKey: t.wrapPrivateKey,
+    isTorsionFree: t.isTorsionFree,
+    clearCofactor: t.clearCofactor,
+    fromBytes: t.fromBytes,
+    toBytes: t.toBytes
+  };
+  return { CURVE: e, curveOpts: i };
+}
+function Jr(t) {
+  const { CURVE: e, curveOpts: n } = Qr(t), r = {
+    hash: t.hash,
+    hmac: t.hmac,
+    randomBytes: t.randomBytes,
+    lowS: t.lowS,
+    bits2int: t.bits2int,
+    bits2int_modN: t.bits2int_modN
+  };
+  return { CURVE: e, curveOpts: n, ecdsaOpts: r };
+}
+function Fr(t, e) {
+  return Object.assign({}, e, {
+    ProjectivePoint: e.Point,
+    CURVE: t
+  });
+}
+function ts(t) {
+  const { CURVE: e, curveOpts: n, ecdsaOpts: r } = Jr(t), i = Pr(e, n), s = Wr(i, r, n);
+  return Fr(t, s);
+}
+function es(t, e) {
+  const n = (r) => ts({ ...t, hash: r });
+  return { ...n(e), create: n };
+}
+const Jt = {
+  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+  n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+  h: BigInt(1),
+  a: BigInt(0),
+  b: BigInt(7),
+  Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+  Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+};
+BigInt(0);
+const ns = BigInt(1), xe = BigInt(2), je = (t, e) => (t + e / xe) / e;
+function rs(t) {
+  const e = Jt.p, n = BigInt(3), r = BigInt(6), i = BigInt(11), s = BigInt(22), o = BigInt(23), c = BigInt(44), a = BigInt(88), l = t * t * t % e, f = l * l * t % e, u = G(f, n, e) * f % e, b = G(u, n, e) * f % e, h = G(b, xe, e) * l % e, E = G(h, i, e) * h % e, w = G(E, s, e) * E % e, x = G(w, c, e) * w % e, _ = G(x, a, e) * x % e, R = G(_, c, e) * w % e, L = G(R, n, e) * f % e, T = G(L, o, e) * E % e, m = G(T, r, e) * l % e, H = G(m, xe, e);
+  if (!we.eql(we.sqr(H), t))
+    throw new Error("Cannot find square root");
+  return H;
+}
+const we = Ot(Jt.p, void 0, void 0, { sqrt: rs }), bs = es({
+  ...Jt,
+  Fp: we,
+  lowS: !0,
+  // Allow only low-S signatures by default in sign() and verify()
+  endo: {
+    // Endomorphism, see above
+    beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+    splitScalar: (t) => {
+      const e = Jt.n, n = BigInt("0x3086d221a7d46bcde86c90e49284eb15"), r = -ns * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"), i = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), s = n, o = BigInt("0x100000000000000000000000000000000"), c = je(s * t, e), a = je(-r * t, e);
+      let l = j(t - c * n - a * i, e), f = j(-c * r - a * s, e);
+      const u = l > o, b = f > o;
+      if (u && (l = e - l), b && (f = e - f), l > o || f > o)
+        throw new Error("splitScalar: Endomorphism failed, k=" + t);
+      return { k1neg: u, k1: l, k2neg: b, k2: f };
+    }
+  }
+}, Ft);
+export {
+  us as R,
+  ds as a,
+  os as b,
+  lt as c,
+  Tt as d,
+  qt as e,
+  nt as f,
+  St as g,
+  ee as h,
+  ye as i,
+  ss as j,
+  hs as k,
+  bs as l,
+  j as m,
+  Dt as n,
+  cn as p,
+  Fe as r,
+  is as s,
+  We as u
+};