@btc-vision/transaction 1.8.7-beta.0 → 1.8.7

package/browser/noble-curves.js

@@ -1,119 +1,115 @@
-import { n as Dt, r as Bn } from "./rolldown-runtime.js";
-function Sn(t) {
+import { n as dt, r as Ze } from "./rolldown-runtime.js";
+function Ce(t) {
   return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in t && t.BYTES_PER_ELEMENT === 1;
 }
-function Pt(t, n = "") {
+function Et(t, e = "") {
   if (typeof t != "number") {
-    const e = n && `"${n}" `;
-    throw new TypeError(`${e}expected number, got ${typeof t}`);
+    const r = e && `"${e}" `;
+    throw new TypeError(`${r}expected number, got ${typeof t}`);
   }
   if (!Number.isSafeInteger(t) || t < 0) {
-    const e = n && `"${n}" `;
-    throw new RangeError(`${e}expected integer >= 0, got ${t}`);
+    const r = e && `"${e}" `;
+    throw new RangeError(`${r}expected integer >= 0, got ${t}`);
   }
 }
-function zt(t, n, e = "") {
-  const r = Sn(t), o = t?.length, i = n !== void 0;
-  if (!r || i && o !== n) {
-    const a = e && `"${e}" `, f = i ? ` of length ${n}` : "", l = r ? `length=${o}` : `type=${typeof t}`, g = a + "expected Uint8Array" + f + ", got " + l;
-    throw r ? new RangeError(g) : new TypeError(g);
+function mt(t, e, r = "") {
+  const n = Ce(t), o = t?.length, i = e !== void 0;
+  if (!n || i && o !== e) {
+    const c = r && `"${r}" `, s = i ? ` of length ${e}` : "", a = n ? `length=${o}` : `type=${typeof t}`, u = c + "expected Uint8Array" + s + ", got " + a;
+    throw n ? new RangeError(u) : new TypeError(u);
   }
   return t;
 }
-function An(t) {
+function ke(t) {
   if (typeof t != "function" || typeof t.create != "function") throw new TypeError("Hash must wrapped by utils.createHasher");
-  if (Pt(t.outputLen), Pt(t.blockLen), t.outputLen < 1) throw new Error('"outputLen" must be >= 1');
+  if (Et(t.outputLen), Et(t.blockLen), t.outputLen < 1) throw new Error('"outputLen" must be >= 1');
   if (t.blockLen < 1) throw new Error('"blockLen" must be >= 1');
 }
-function de(t, n = !0) {
+function Dt(t, e = !0) {
   if (t.destroyed) throw new Error("Hash instance has been destroyed");
-  if (n && t.finished) throw new Error("Hash#digest() has already been called");
+  if (e && t.finished) throw new Error("Hash#digest() has already been called");
 }
-function Rn(t, n) {
-  zt(t, void 0, "digestInto() output");
-  const e = n.outputLen;
-  if (t.length < e) throw new RangeError('"digestInto() output" expected to be of length >=' + e);
+function je(t, e) {
+  mt(t, void 0, "digestInto() output");
+  const r = e.outputLen;
+  if (t.length < r) throw new RangeError('"digestInto() output" expected to be of length >=' + r);
 }
-function Kt(...t) {
-  for (let n = 0; n < t.length; n++) t[n].fill(0);
+function Bt(...t) {
+  for (let e = 0; e < t.length; e++) t[e].fill(0);
 }
-function Be(t) {
+function Vt(t) {
   return new DataView(t.buffer, t.byteOffset, t.byteLength);
 }
-function vt(t, n) {
-  return t << 32 - n | t >>> n;
+function nt(t, e) {
+  return t << 32 - e | t >>> e;
 }
-function Ho(t, n) {
-  return t << n | t >>> 32 - n >>> 0;
+function vr(t, e) {
+  return t << e | t >>> 32 - e >>> 0;
 }
-function Ke(t) {
-  if (zt(t), Xe) return t.toHex();
-  let n = "";
-  for (let e = 0; e < t.length; e++) n += On[t[e]];
-  return n;
+function le(t) {
+  if (mt(t), he) return t.toHex();
+  let e = "";
+  for (let r = 0; r < t.length; r++) e += Ye[t[r]];
+  return e;
 }
-function sn(t) {
-  if (t >= xt._0 && t <= xt._9) return t - xt._0;
-  if (t >= xt.A && t <= xt.F) return t - (xt.A - 10);
-  if (t >= xt.a && t <= xt.f) return t - (xt.a - 10);
+function Ae(t) {
+  if (t >= rt._0 && t <= rt._9) return t - rt._0;
+  if (t >= rt.A && t <= rt.F) return t - (rt.A - 10);
+  if (t >= rt.a && t <= rt.f) return t - (rt.a - 10);
 }
-function _n(t) {
+function Ve(t) {
   if (typeof t != "string") throw new TypeError("hex string expected, got " + typeof t);
-  if (Xe) try {
+  if (he) try {
     return Uint8Array.fromHex(t);
   } catch (o) {
     throw o instanceof SyntaxError ? new RangeError(o.message) : o;
   }
-  const n = t.length, e = n / 2;
-  if (n % 2) throw new RangeError("hex string expected, got unpadded hex of length " + n);
-  const r = new Uint8Array(e);
-  for (let o = 0, i = 0; o < e; o++, i += 2) {
-    const a = sn(t.charCodeAt(i)), f = sn(t.charCodeAt(i + 1));
-    if (a === void 0 || f === void 0) {
-      const l = t[i] + t[i + 1];
-      throw new RangeError('hex string expected, got non-hex character "' + l + '" at index ' + i);
+  const e = t.length, r = e / 2;
+  if (e % 2) throw new RangeError("hex string expected, got unpadded hex of length " + e);
+  const n = new Uint8Array(r);
+  for (let o = 0, i = 0; o < r; o++, i += 2) {
+    const c = Ae(t.charCodeAt(i)), s = Ae(t.charCodeAt(i + 1));
+    if (c === void 0 || s === void 0) {
+      const a = t[i] + t[i + 1];
+      throw new RangeError('hex string expected, got non-hex character "' + a + '" at index ' + i);
     }
-    r[o] = a * 16 + f;
+    n[o] = c * 16 + s;
   }
-  return r;
-}
-function Nt(t) {
-  if (typeof t != "string") throw new TypeError("string expected");
-  return new Uint8Array(new TextEncoder().encode(t));
+  return n;
 }
-function br(...t) {
-  let n = 0;
-  for (let r = 0; r < t.length; r++) {
-    const o = t[r];
-    zt(o), n += o.length;
+function In(...t) {
+  let e = 0;
+  for (let n = 0; n < t.length; n++) {
+    const o = t[n];
+    mt(o), e += o.length;
   }
-  const e = new Uint8Array(n);
-  for (let r = 0, o = 0; r < t.length; r++) {
-    const i = t[r];
-    e.set(i, o), o += i.length;
+  const r = new Uint8Array(e);
+  for (let n = 0, o = 0; n < t.length; n++) {
+    const i = t[n];
+    r.set(i, o), o += i.length;
   }
-  return e;
+  return r;
 }
-function Yt(t, n = {}) {
-  const e = (o, i) => t(i).update(o).digest(), r = t(void 0);
-  return e.outputLen = r.outputLen, e.blockLen = r.blockLen, e.canXOF = r.canXOF, e.create = (o) => t(o), Object.assign(e, n), Object.freeze(e);
+function xt(t, e = {}) {
+  const r = (o, i) => t(i).update(o).digest(), n = t(void 0);
+  return r.outputLen = n.outputLen, r.blockLen = n.blockLen, r.canXOF = n.canXOF, r.create = (o) => t(o), Object.assign(r, e), Object.freeze(r);
 }
-function yr(t = 32) {
-  Pt(t, "bytesLength");
-  const n = typeof globalThis == "object" ? globalThis.crypto : null;
-  if (typeof n?.getRandomValues != "function") throw new Error("crypto.getRandomValues must be defined");
+function Fn(t = 32) {
+  Et(t, "bytesLength");
+  const e = typeof globalThis == "object" ? globalThis.crypto : null;
+  if (typeof e?.getRandomValues != "function") throw new Error("crypto.getRandomValues must be defined");
   if (t > 65536) throw new RangeError(`"bytesLength" expected <= 65536, got ${t}`);
-  return n.getRandomValues(new Uint8Array(t));
+  return e.getRandomValues(new Uint8Array(t));
 }
-var pr, Xe, On, xt, Lt, Qt = Dt((() => {
-  pr = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68, Xe = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", On = /* @__PURE__ */ Array.from({ length: 256 }, (t, n) => n.toString(16).padStart(2, "0")), xt = {
+var he, Ye, rt, gt, It = dt((() => {
+  he = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Ye = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0")), rt = {
     _0: 48,
     _9: 57,
     A: 65,
     F: 70,
     a: 97,
     f: 102
-  }, Lt = (t) => ({ oid: Uint8Array.from([
+  }, gt = (t) => ({ oid: Uint8Array.from([
     6,
     9,
     96,
@@ -126,11 +122,11 @@ var pr, Xe, On, xt, Lt, Qt = Dt((() => {
     2,
     t
   ]) });
-})), To = /* @__PURE__ */ Bn({
-  _HMAC: () => le,
-  hmac: () => We
-}), le, We, Er = Dt((() => {
-  Qt(), le = class {
+})), xr = /* @__PURE__ */ Ze({
+  _HMAC: () => Ut,
+  hmac: () => de
+}), Ut, de, Ln = dt((() => {
+  It(), Ut = class {
     oHash;
     iHash;
     blockLen;
@@ -138,23 +134,23 @@ var pr, Xe, On, xt, Lt, Qt = Dt((() => {
     canXOF = !1;
     finished = !1;
     destroyed = !1;
-    constructor(t, n) {
-      if (An(t), zt(n, void 0, "key"), this.iHash = t.create(), typeof this.iHash.update != "function") throw new Error("Expected instance of class which extends utils.Hash");
+    constructor(t, e) {
+      if (ke(t), mt(e, void 0, "key"), this.iHash = t.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 e = this.blockLen, r = new Uint8Array(e);
-      r.set(n.length > e ? t.create().update(n).digest() : n);
-      for (let o = 0; o < r.length; o++) r[o] ^= 54;
-      this.iHash.update(r), this.oHash = t.create();
-      for (let o = 0; o < r.length; o++) r[o] ^= 106;
-      this.oHash.update(r), Kt(r);
+      const r = this.blockLen, n = new Uint8Array(r);
+      n.set(e.length > r ? t.create().update(e).digest() : e);
+      for (let o = 0; o < n.length; o++) n[o] ^= 54;
+      this.iHash.update(n), this.oHash = t.create();
+      for (let o = 0; o < n.length; o++) n[o] ^= 106;
+      this.oHash.update(n), Bt(n);
     }
     update(t) {
-      return de(this), this.iHash.update(t), this;
+      return Dt(this), this.iHash.update(t), this;
     }
     digestInto(t) {
-      de(this), Rn(t, this), this.finished = !0;
-      const n = t.subarray(0, this.outputLen);
-      this.iHash.digestInto(n), this.oHash.update(n), this.oHash.digestInto(n), this.destroy();
+      Dt(this), je(t, this), this.finished = !0;
+      const e = t.subarray(0, this.outputLen);
+      this.iHash.digestInto(e), this.oHash.update(e), this.oHash.digestInto(e), this.destroy();
     }
     digest() {
       const t = new Uint8Array(this.oHash.outputLen);
@@ -162,8 +158,8 @@ var pr, Xe, On, xt, Lt, Qt = Dt((() => {
     }
     _cloneInto(t) {
       t ||= Object.create(Object.getPrototypeOf(this), {});
-      const { oHash: n, iHash: e, finished: r, destroyed: o, blockLen: i, outputLen: a } = this;
-      return t = t, t.finished = r, t.destroyed = o, t.blockLen = i, t.outputLen = a, t.oHash = n._cloneInto(t.oHash), t.iHash = e._cloneInto(t.iHash), t;
+      const { oHash: e, iHash: r, finished: n, destroyed: o, blockLen: i, outputLen: c } = this;
+      return t = t, t.finished = n, t.destroyed = o, t.blockLen = i, t.outputLen = c, t.oHash = e._cloneInto(t.oHash), t.iHash = r._cloneInto(t.iHash), t;
     }
     clone() {
       return this._cloneInto();
@@ -171,19 +167,19 @@ var pr, Xe, On, xt, Lt, Qt = Dt((() => {
     destroy() {
       this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
     }
-  }, We = /* @__PURE__ */ (() => {
-    const t = ((n, e, r) => new le(n, e).update(r).digest());
-    return t.create = (n, e) => new le(n, e), t;
+  }, de = /* @__PURE__ */ (() => {
+    const t = ((e, r, n) => new Ut(e, r).update(n).digest());
+    return t.create = (e, r) => new Ut(e, r), t;
   })();
 }));
-function vr(t, n, e) {
-  return t & n ^ ~t & e;
+function Nn(t, e, r) {
+  return t & e ^ ~t & r;
 }
-function xr(t, n, e) {
-  return t & n ^ t & e ^ n & e;
+function Tn(t, e, r) {
+  return t & e ^ t & r ^ e & r;
 }
-var Fe, Ht, Tt, lt, ut, Br = Dt((() => {
-  Qt(), Fe = class {
+var Wt, at, ut, M, G, Un = dt((() => {
+  It(), Wt = class {
     blockLen;
     outputLen;
     canXOF = !1;
@@ -195,51 +191,51 @@ var Fe, Ht, Tt, lt, ut, Br = Dt((() => {
     length = 0;
     pos = 0;
     destroyed = !1;
-    constructor(t, n, e, r) {
-      this.blockLen = t, this.outputLen = n, this.padOffset = e, this.isLE = r, this.buffer = new Uint8Array(t), this.view = Be(this.buffer);
+    constructor(t, e, r, n) {
+      this.blockLen = t, this.outputLen = e, this.padOffset = r, this.isLE = n, this.buffer = new Uint8Array(t), this.view = Vt(this.buffer);
     }
     update(t) {
-      de(this), zt(t);
-      const { view: n, buffer: e, blockLen: r } = this, o = t.length;
+      Dt(this), mt(t);
+      const { view: e, buffer: r, blockLen: n } = this, o = t.length;
       for (let i = 0; i < o; ) {
-        const a = Math.min(r - this.pos, o - i);
-        if (a === r) {
-          const f = Be(t);
-          for (; r <= o - i; i += r) this.process(f, i);
+        const c = Math.min(n - this.pos, o - i);
+        if (c === n) {
+          const s = Vt(t);
+          for (; n <= o - i; i += n) this.process(s, i);
           continue;
         }
-        e.set(t.subarray(i, i + a), this.pos), this.pos += a, i += a, this.pos === r && (this.process(n, 0), this.pos = 0);
+        r.set(t.subarray(i, i + c), this.pos), this.pos += c, i += c, this.pos === n && (this.process(e, 0), this.pos = 0);
       }
       return this.length += t.length, this.roundClean(), this;
     }
     digestInto(t) {
-      de(this), Rn(t, this), this.finished = !0;
-      const { buffer: n, view: e, blockLen: r, isLE: o } = this;
+      Dt(this), je(t, this), this.finished = !0;
+      const { buffer: e, view: r, blockLen: n, isLE: o } = this;
       let { pos: i } = this;
-      n[i++] = 128, Kt(this.buffer.subarray(i)), this.padOffset > r - i && (this.process(e, 0), i = 0);
-      for (let s = i; s < r; s++) n[s] = 0;
-      e.setBigUint64(r - 8, BigInt(this.length * 8), o), this.process(e, 0);
-      const a = Be(t), f = this.outputLen;
-      if (f % 4) throw new Error("_sha2: outputLen must be aligned to 32bit");
-      const l = f / 4, g = this.get();
-      if (l > g.length) throw new Error("_sha2: outputLen bigger than state");
-      for (let s = 0; s < l; s++) a.setUint32(4 * s, g[s], o);
+      e[i++] = 128, Bt(this.buffer.subarray(i)), this.padOffset > n - i && (this.process(r, 0), i = 0);
+      for (let f = i; f < n; f++) e[f] = 0;
+      r.setBigUint64(n - 8, BigInt(this.length * 8), o), this.process(r, 0);
+      const c = Vt(t), s = this.outputLen;
+      if (s % 4) throw new Error("_sha2: outputLen must be aligned to 32bit");
+      const a = s / 4, u = this.get();
+      if (a > u.length) throw new Error("_sha2: outputLen bigger than state");
+      for (let f = 0; f < a; f++) c.setUint32(4 * f, u[f], o);
     }
     digest() {
-      const { buffer: t, outputLen: n } = this;
+      const { buffer: t, outputLen: e } = this;
       this.digestInto(t);
-      const e = t.slice(0, n);
-      return this.destroy(), e;
+      const r = t.slice(0, e);
+      return this.destroy(), r;
     }
     _cloneInto(t) {
       t ||= new this.constructor(), t.set(...this.get());
-      const { blockLen: n, buffer: e, length: r, finished: o, destroyed: i, pos: a } = this;
-      return t.destroyed = i, t.finished = o, t.length = r, t.pos = a, r % n && t.buffer.set(e), t;
+      const { blockLen: e, buffer: r, length: n, finished: o, destroyed: i, pos: c } = this;
+      return t.destroyed = i, t.finished = o, t.length = n, t.pos = c, n % e && t.buffer.set(r), t;
     }
     clone() {
       return this._cloneInto();
     }
-  }, Ht = /* @__PURE__ */ Uint32Array.from([
+  }, at = /* @__PURE__ */ Uint32Array.from([
     1779033703,
     3144134277,
     1013904242,
@@ -248,7 +244,7 @@ var Fe, Ht, Tt, lt, ut, Br = Dt((() => {
     2600822924,
     528734635,
     1541459225
-  ]), Tt = /* @__PURE__ */ Uint32Array.from([
+  ]), ut = /* @__PURE__ */ Uint32Array.from([
     3238371032,
     914150663,
     812702999,
@@ -257,7 +253,7 @@ var Fe, Ht, Tt, lt, ut, Br = Dt((() => {
     1750603025,
     1694076839,
     3204075428
-  ]), lt = /* @__PURE__ */ Uint32Array.from([
+  ]), M = /* @__PURE__ */ Uint32Array.from([
     3418070365,
     3238371032,
     1654270250,
@@ -274,7 +270,7 @@ var Fe, Ht, Tt, lt, ut, Br = Dt((() => {
     1694076839,
     1203062813,
     3204075428
-  ]), ut = /* @__PURE__ */ Uint32Array.from([
+  ]), G = /* @__PURE__ */ Uint32Array.from([
     1779033703,
     4089235720,
     3144134277,
@@ -293,48 +289,48 @@ var Fe, Ht, Tt, lt, ut, Br = Dt((() => {
     327033209
   ]);
 }));
-function Sr(t, n = !1) {
-  return n ? {
-    h: Number(t & ee),
-    l: Number(t >> Ie & ee)
+function $n(t, e = !1) {
+  return e ? {
+    h: Number(t & St),
+    l: Number(t >> Qt & St)
   } : {
-    h: Number(t >> Ie & ee) | 0,
-    l: Number(t & ee) | 0
+    h: Number(t >> Qt & St) | 0,
+    l: Number(t & St) | 0
   };
 }
-function Ar(t, n = !1) {
-  const e = t.length;
-  let r = new Uint32Array(e), o = new Uint32Array(e);
-  for (let i = 0; i < e; i++) {
-    const { h: a, l: f } = Sr(t[i], n);
-    [r[i], o[i]] = [a, f];
+function Dn(t, e = !1) {
+  const r = t.length;
+  let n = new Uint32Array(r), o = new Uint32Array(r);
+  for (let i = 0; i < r; i++) {
+    const { h: c, l: s } = $n(t[i], e);
+    [n[i], o[i]] = [c, s];
   }
-  return [r, o];
+  return [n, o];
 }
-function At(t, n, e, r) {
-  const o = (n >>> 0) + (r >>> 0);
+function it(t, e, r, n) {
+  const o = (e >>> 0) + (n >>> 0);
   return {
-    h: t + e + (o / 2 ** 32 | 0) | 0,
+    h: t + r + (o / 2 ** 32 | 0) | 0,
     l: o | 0
   };
 }
-var ee, Ie, Ne, je, Ut, qt, ne, re, Hn, Tn, Fn, In, Nn, jn, Rr = Dt((() => {
-  ee = /* @__PURE__ */ BigInt(2 ** 32 - 1), Ie = /* @__PURE__ */ BigInt(32), Ne = (t, n, e) => t >>> e, je = (t, n, e) => t << 32 - e | n >>> e, Ut = (t, n, e) => t >>> e | n << 32 - e, qt = (t, n, e) => t << 32 - e | n >>> e, ne = (t, n, e) => t << 64 - e | n >>> e - 32, re = (t, n, e) => t >>> e - 32 | n << 64 - e, Hn = (t, n, e) => (t >>> 0) + (n >>> 0) + (e >>> 0), Tn = (t, n, e, r) => n + e + r + (t / 2 ** 32 | 0) | 0, Fn = (t, n, e, r) => (t >>> 0) + (n >>> 0) + (e >>> 0) + (r >>> 0), In = (t, n, e, r, o) => n + e + r + o + (t / 2 ** 32 | 0) | 0, Nn = (t, n, e, r, o) => (t >>> 0) + (n >>> 0) + (e >>> 0) + (r >>> 0) + (o >>> 0), jn = (t, n, e, r, o, i) => n + e + r + o + i + (t / 2 ** 32 | 0) | 0;
-})), Fo = /* @__PURE__ */ Bn({
-  _SHA224: () => Le,
-  _SHA256: () => De,
-  _SHA384: () => qe,
-  _SHA512: () => Ue,
-  _SHA512_224: () => Ce,
-  _SHA512_256: () => ke,
-  sha224: () => Dn,
-  sha256: () => jt,
-  sha384: () => Un,
-  sha512: () => Ln,
-  sha512_224: () => Cn,
-  sha512_256: () => qn
-}), cn, Rt, Se, De, Le, Ae, fn, an, _t, Ot, te, Ue, qe, ft, at, Ce, ke, jt, Dn, Ln, Un, qn, Cn, _r = Dt((() => {
-  Br(), Rr(), Qt(), cn = /* @__PURE__ */ Uint32Array.from([
+var St, Qt, Jt, Pt, bt, wt, _t, Ht, ze, Me, Ge, Ke, Xe, We, qn = dt((() => {
+  St = /* @__PURE__ */ BigInt(2 ** 32 - 1), Qt = /* @__PURE__ */ BigInt(32), Jt = (t, e, r) => t >>> r, Pt = (t, e, r) => t << 32 - r | e >>> r, bt = (t, e, r) => t >>> r | e << 32 - r, wt = (t, e, r) => t << 32 - r | e >>> r, _t = (t, e, r) => t << 64 - r | e >>> r - 32, Ht = (t, e, r) => t >>> r - 32 | e << 64 - r, ze = (t, e, r) => (t >>> 0) + (e >>> 0) + (r >>> 0), Me = (t, e, r, n) => e + r + n + (t / 2 ** 32 | 0) | 0, Ge = (t, e, r, n) => (t >>> 0) + (e >>> 0) + (r >>> 0) + (n >>> 0), Ke = (t, e, r, n, o) => e + r + n + o + (t / 2 ** 32 | 0) | 0, Xe = (t, e, r, n, o) => (t >>> 0) + (e >>> 0) + (r >>> 0) + (n >>> 0) + (o >>> 0), We = (t, e, r, n, o, i) => e + r + n + o + i + (t / 2 ** 32 | 0) | 0;
+})), Br = /* @__PURE__ */ Ze({
+  _SHA224: () => ee,
+  _SHA256: () => te,
+  _SHA384: () => re,
+  _SHA512: () => ne,
+  _SHA512_224: () => oe,
+  _SHA512_256: () => ie,
+  sha224: () => Qe,
+  sha256: () => ge,
+  sha384: () => Pe,
+  sha512: () => Je,
+  sha512_224: () => en,
+  sha512_256: () => tn
+}), Re, st, Yt, te, ee, zt, Se, _e, ct, ft, Rt, ne, re, Y, z, oe, ie, ge, Qe, Je, Pe, tn, en, Zn = dt((() => {
+  Un(), qn(), It(), Re = /* @__PURE__ */ Uint32Array.from([
     1116352408,
     1899447441,
     3049323471,
@@ -399,70 +395,70 @@ var ee, Ie, Ne, je, Ut, qt, ne, re, Hn, Tn, Fn, In, Nn, jn, Rr = Dt((() => {
     2756734187,
     3204031479,
     3329325298
-  ]), Rt = /* @__PURE__ */ new Uint32Array(64), Se = class extends Fe {
+  ]), st = /* @__PURE__ */ new Uint32Array(64), Yt = class extends Wt {
     constructor(t) {
       super(64, t, 8, !1);
     }
     get() {
-      const { A: t, B: n, C: e, D: r, E: o, F: i, G: a, H: f } = this;
+      const { A: t, B: e, C: r, D: n, E: o, F: i, G: c, H: s } = this;
       return [
         t,
-        n,
         e,
         r,
+        n,
         o,
         i,
-        a,
-        f
+        c,
+        s
       ];
     }
-    set(t, n, e, r, o, i, a, f) {
-      this.A = t | 0, this.B = n | 0, this.C = e | 0, this.D = r | 0, this.E = o | 0, this.F = i | 0, this.G = a | 0, this.H = f | 0;
+    set(t, e, r, n, o, i, c, s) {
+      this.A = t | 0, this.B = e | 0, this.C = r | 0, this.D = n | 0, this.E = o | 0, this.F = i | 0, this.G = c | 0, this.H = s | 0;
     }
-    process(t, n) {
-      for (let s = 0; s < 16; s++, n += 4) Rt[s] = t.getUint32(n, !1);
-      for (let s = 16; s < 64; s++) {
-        const u = Rt[s - 15], d = Rt[s - 2], h = vt(u, 7) ^ vt(u, 18) ^ u >>> 3;
-        Rt[s] = (vt(d, 17) ^ vt(d, 19) ^ d >>> 10) + Rt[s - 7] + h + Rt[s - 16] | 0;
+    process(t, e) {
+      for (let f = 0; f < 16; f++, e += 4) st[f] = t.getUint32(e, !1);
+      for (let f = 16; f < 64; f++) {
+        const g = st[f - 15], m = st[f - 2], w = nt(g, 7) ^ nt(g, 18) ^ g >>> 3;
+        st[f] = (nt(m, 17) ^ nt(m, 19) ^ m >>> 10) + st[f - 7] + w + st[f - 16] | 0;
       }
-      let { A: e, B: r, C: o, D: i, E: a, F: f, G: l, H: g } = this;
-      for (let s = 0; s < 64; s++) {
-        const u = vt(a, 6) ^ vt(a, 11) ^ vt(a, 25), d = g + u + vr(a, f, l) + cn[s] + Rt[s] | 0, h = (vt(e, 2) ^ vt(e, 13) ^ vt(e, 22)) + xr(e, r, o) | 0;
-        g = l, l = f, f = a, a = i + d | 0, i = o, o = r, r = e, e = d + h | 0;
+      let { A: r, B: n, C: o, D: i, E: c, F: s, G: a, H: u } = this;
+      for (let f = 0; f < 64; f++) {
+        const g = nt(c, 6) ^ nt(c, 11) ^ nt(c, 25), m = u + g + Nn(c, s, a) + Re[f] + st[f] | 0, w = (nt(r, 2) ^ nt(r, 13) ^ nt(r, 22)) + Tn(r, n, o) | 0;
+        u = a, a = s, s = c, c = i + m | 0, i = o, o = n, n = r, r = m + w | 0;
       }
-      e = e + this.A | 0, r = r + this.B | 0, o = o + this.C | 0, i = i + this.D | 0, a = a + this.E | 0, f = f + this.F | 0, l = l + this.G | 0, g = g + this.H | 0, this.set(e, r, o, i, a, f, l, g);
+      r = r + this.A | 0, n = n + this.B | 0, o = o + this.C | 0, i = i + this.D | 0, c = c + this.E | 0, s = s + this.F | 0, a = a + this.G | 0, u = u + this.H | 0, this.set(r, n, o, i, c, s, a, u);
     }
     roundClean() {
-      Kt(Rt);
+      Bt(st);
     }
     destroy() {
-      this.destroyed = !0, this.set(0, 0, 0, 0, 0, 0, 0, 0), Kt(this.buffer);
-    }
-  }, De = class extends Se {
-    A = Ht[0] | 0;
-    B = Ht[1] | 0;
-    C = Ht[2] | 0;
-    D = Ht[3] | 0;
-    E = Ht[4] | 0;
-    F = Ht[5] | 0;
-    G = Ht[6] | 0;
-    H = Ht[7] | 0;
+      this.destroyed = !0, this.set(0, 0, 0, 0, 0, 0, 0, 0), Bt(this.buffer);
+    }
+  }, te = class extends Yt {
+    A = at[0] | 0;
+    B = at[1] | 0;
+    C = at[2] | 0;
+    D = at[3] | 0;
+    E = at[4] | 0;
+    F = at[5] | 0;
+    G = at[6] | 0;
+    H = at[7] | 0;
     constructor() {
       super(32);
     }
-  }, Le = class extends Se {
-    A = Tt[0] | 0;
-    B = Tt[1] | 0;
-    C = Tt[2] | 0;
-    D = Tt[3] | 0;
-    E = Tt[4] | 0;
-    F = Tt[5] | 0;
-    G = Tt[6] | 0;
-    H = Tt[7] | 0;
+  }, ee = class extends Yt {
+    A = ut[0] | 0;
+    B = ut[1] | 0;
+    C = ut[2] | 0;
+    D = ut[3] | 0;
+    E = ut[4] | 0;
+    F = ut[5] | 0;
+    G = ut[6] | 0;
+    H = ut[7] | 0;
     constructor() {
       super(28);
     }
-  }, Ae = Ar([
+  }, zt = Dn([
     "0x428a2f98d728ae22",
     "0x7137449123ef65cd",
     "0xb5c0fbcfec4d3b2f",
@@ -543,97 +539,97 @@ var ee, Ie, Ne, je, Ut, qt, ne, re, Hn, Tn, Fn, In, Nn, jn, Rr = Dt((() => {
     "0x597f299cfc657e2a",
     "0x5fcb6fab3ad6faec",
     "0x6c44198c4a475817"
-  ].map((t) => BigInt(t))), fn = Ae[0], an = Ae[1], _t = /* @__PURE__ */ new Uint32Array(80), Ot = /* @__PURE__ */ new Uint32Array(80), te = class extends Fe {
+  ].map((t) => BigInt(t))), Se = zt[0], _e = zt[1], ct = /* @__PURE__ */ new Uint32Array(80), ft = /* @__PURE__ */ new Uint32Array(80), Rt = class extends Wt {
     constructor(t) {
       super(128, t, 16, !1);
     }
     get() {
-      const { Ah: t, Al: n, Bh: e, Bl: r, Ch: o, Cl: i, Dh: a, Dl: f, Eh: l, El: g, Fh: s, Fl: u, Gh: d, Gl: h, Hh: w, Hl: b } = this;
+      const { Ah: t, Al: e, Bh: r, Bl: n, Ch: o, Cl: i, Dh: c, Dl: s, Eh: a, El: u, Fh: f, Fl: g, Gh: m, Gl: w, Hh: A, Hl: _ } = this;
       return [
         t,
-        n,
         e,
         r,
+        n,
         o,
         i,
+        c,
+        s,
         a,
+        u,
         f,
-        l,
         g,
-        s,
-        u,
-        d,
-        h,
+        m,
         w,
-        b
+        A,
+        _
       ];
     }
-    set(t, n, e, r, o, i, a, f, l, g, s, u, d, h, w, b) {
-      this.Ah = t | 0, this.Al = n | 0, this.Bh = e | 0, this.Bl = r | 0, this.Ch = o | 0, this.Cl = i | 0, this.Dh = a | 0, this.Dl = f | 0, this.Eh = l | 0, this.El = g | 0, this.Fh = s | 0, this.Fl = u | 0, this.Gh = d | 0, this.Gl = h | 0, this.Hh = w | 0, this.Hl = b | 0;
+    set(t, e, r, n, o, i, c, s, a, u, f, g, m, w, A, _) {
+      this.Ah = t | 0, this.Al = e | 0, this.Bh = r | 0, this.Bl = n | 0, this.Ch = o | 0, this.Cl = i | 0, this.Dh = c | 0, this.Dl = s | 0, this.Eh = a | 0, this.El = u | 0, this.Fh = f | 0, this.Fl = g | 0, this.Gh = m | 0, this.Gl = w | 0, this.Hh = A | 0, this.Hl = _ | 0;
     }
-    process(t, n) {
-      for (let B = 0; B < 16; B++, n += 4)
-        _t[B] = t.getUint32(n), Ot[B] = t.getUint32(n += 4);
-      for (let B = 16; B < 80; B++) {
-        const C = _t[B - 15] | 0, O = Ot[B - 15] | 0, F = Ut(C, O, 1) ^ Ut(C, O, 8) ^ Ne(C, O, 7), z = qt(C, O, 1) ^ qt(C, O, 8) ^ je(C, O, 7), W = _t[B - 2] | 0, N = Ot[B - 2] | 0, V = Ut(W, N, 19) ^ ne(W, N, 61) ^ Ne(W, N, 6), K = qt(W, N, 19) ^ re(W, N, 61) ^ je(W, N, 6), M = Fn(z, K, Ot[B - 7], Ot[B - 16]);
-        _t[B] = In(M, F, V, _t[B - 7], _t[B - 16]) | 0, Ot[B] = M | 0;
+    process(t, e) {
+      for (let x = 0; x < 16; x++, e += 4)
+        ct[x] = t.getUint32(e), ft[x] = t.getUint32(e += 4);
+      for (let x = 16; x < 80; x++) {
+        const q = ct[x - 15] | 0, Z = ft[x - 15] | 0, T = bt(q, Z, 1) ^ bt(q, Z, 8) ^ Jt(q, Z, 7), Q = wt(q, Z, 1) ^ wt(q, Z, 8) ^ Pt(q, Z, 7), $ = ct[x - 2] | 0, R = ft[x - 2] | 0, C = bt($, R, 19) ^ _t($, R, 61) ^ Jt($, R, 6), X = wt($, R, 19) ^ Ht($, R, 61) ^ Pt($, R, 6), F = Ge(Q, X, ft[x - 7], ft[x - 16]);
+        ct[x] = Ke(F, T, C, ct[x - 7], ct[x - 16]) | 0, ft[x] = F | 0;
       }
-      let { Ah: e, Al: r, Bh: o, Bl: i, Ch: a, Cl: f, Dh: l, Dl: g, Eh: s, El: u, Fh: d, Fl: h, Gh: w, Gl: b, Hh: E, Hl: T } = this;
-      for (let B = 0; B < 80; B++) {
-        const C = Ut(s, u, 14) ^ Ut(s, u, 18) ^ ne(s, u, 41), O = qt(s, u, 14) ^ qt(s, u, 18) ^ re(s, u, 41), F = s & d ^ ~s & w, z = u & h ^ ~u & b, W = Nn(T, O, z, an[B], Ot[B]), N = jn(W, E, C, F, fn[B], _t[B]), V = W | 0, K = Ut(e, r, 28) ^ ne(e, r, 34) ^ ne(e, r, 39), M = qt(e, r, 28) ^ re(e, r, 34) ^ re(e, r, 39), v = e & o ^ e & a ^ o & a, H = r & i ^ r & f ^ i & f;
-        E = w | 0, T = b | 0, w = d | 0, b = h | 0, d = s | 0, h = u | 0, { h: s, l: u } = At(l | 0, g | 0, N | 0, V | 0), l = a | 0, g = f | 0, a = o | 0, f = i | 0, o = e | 0, i = r | 0;
-        const U = Hn(V, M, H);
-        e = Tn(U, N, K, v), r = U | 0;
+      let { Ah: r, Al: n, Bh: o, Bl: i, Ch: c, Cl: s, Dh: a, Dl: u, Eh: f, El: g, Fh: m, Fl: w, Gh: A, Gl: _, Hh: H, Hl: O } = this;
+      for (let x = 0; x < 80; x++) {
+        const q = bt(f, g, 14) ^ bt(f, g, 18) ^ _t(f, g, 41), Z = wt(f, g, 14) ^ wt(f, g, 18) ^ Ht(f, g, 41), T = f & m ^ ~f & A, Q = g & w ^ ~g & _, $ = Xe(O, Z, Q, _e[x], ft[x]), R = We($, H, q, T, Se[x], ct[x]), C = $ | 0, X = bt(r, n, 28) ^ _t(r, n, 34) ^ _t(r, n, 39), F = wt(r, n, 28) ^ Ht(r, n, 34) ^ Ht(r, n, 39), h = r & o ^ r & c ^ o & c, y = n & i ^ n & s ^ i & s;
+        H = A | 0, O = _ | 0, A = m | 0, _ = w | 0, m = f | 0, w = g | 0, { h: f, l: g } = it(a | 0, u | 0, R | 0, C | 0), a = c | 0, u = s | 0, c = o | 0, s = i | 0, o = r | 0, i = n | 0;
+        const B = ze(C, F, y);
+        r = Me(B, R, X, h), n = B | 0;
       }
-      ({ h: e, l: r } = At(this.Ah | 0, this.Al | 0, e | 0, r | 0)), { h: o, l: i } = At(this.Bh | 0, this.Bl | 0, o | 0, i | 0), { h: a, l: f } = At(this.Ch | 0, this.Cl | 0, a | 0, f | 0), { h: l, l: g } = At(this.Dh | 0, this.Dl | 0, l | 0, g | 0), { h: s, l: u } = At(this.Eh | 0, this.El | 0, s | 0, u | 0), { h: d, l: h } = At(this.Fh | 0, this.Fl | 0, d | 0, h | 0), { h: w, l: b } = At(this.Gh | 0, this.Gl | 0, w | 0, b | 0), { h: E, l: T } = At(this.Hh | 0, this.Hl | 0, E | 0, T | 0), this.set(e, r, o, i, a, f, l, g, s, u, d, h, w, b, E, T);
+      ({ h: r, l: n } = it(this.Ah | 0, this.Al | 0, r | 0, n | 0)), { h: o, l: i } = it(this.Bh | 0, this.Bl | 0, o | 0, i | 0), { h: c, l: s } = it(this.Ch | 0, this.Cl | 0, c | 0, s | 0), { h: a, l: u } = it(this.Dh | 0, this.Dl | 0, a | 0, u | 0), { h: f, l: g } = it(this.Eh | 0, this.El | 0, f | 0, g | 0), { h: m, l: w } = it(this.Fh | 0, this.Fl | 0, m | 0, w | 0), { h: A, l: _ } = it(this.Gh | 0, this.Gl | 0, A | 0, _ | 0), { h: H, l: O } = it(this.Hh | 0, this.Hl | 0, H | 0, O | 0), this.set(r, n, o, i, c, s, a, u, f, g, m, w, A, _, H, O);
     }
     roundClean() {
-      Kt(_t, Ot);
+      Bt(ct, ft);
     }
     destroy() {
-      this.destroyed = !0, Kt(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-    }
-  }, Ue = class extends te {
-    Ah = ut[0] | 0;
-    Al = ut[1] | 0;
-    Bh = ut[2] | 0;
-    Bl = ut[3] | 0;
-    Ch = ut[4] | 0;
-    Cl = ut[5] | 0;
-    Dh = ut[6] | 0;
-    Dl = ut[7] | 0;
-    Eh = ut[8] | 0;
-    El = ut[9] | 0;
-    Fh = ut[10] | 0;
-    Fl = ut[11] | 0;
-    Gh = ut[12] | 0;
-    Gl = ut[13] | 0;
-    Hh = ut[14] | 0;
-    Hl = ut[15] | 0;
+      this.destroyed = !0, Bt(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    }
+  }, ne = class extends Rt {
+    Ah = G[0] | 0;
+    Al = G[1] | 0;
+    Bh = G[2] | 0;
+    Bl = G[3] | 0;
+    Ch = G[4] | 0;
+    Cl = G[5] | 0;
+    Dh = G[6] | 0;
+    Dl = G[7] | 0;
+    Eh = G[8] | 0;
+    El = G[9] | 0;
+    Fh = G[10] | 0;
+    Fl = G[11] | 0;
+    Gh = G[12] | 0;
+    Gl = G[13] | 0;
+    Hh = G[14] | 0;
+    Hl = G[15] | 0;
     constructor() {
       super(64);
     }
-  }, qe = class extends te {
-    Ah = lt[0] | 0;
-    Al = lt[1] | 0;
-    Bh = lt[2] | 0;
-    Bl = lt[3] | 0;
-    Ch = lt[4] | 0;
-    Cl = lt[5] | 0;
-    Dh = lt[6] | 0;
-    Dl = lt[7] | 0;
-    Eh = lt[8] | 0;
-    El = lt[9] | 0;
-    Fh = lt[10] | 0;
-    Fl = lt[11] | 0;
-    Gh = lt[12] | 0;
-    Gl = lt[13] | 0;
-    Hh = lt[14] | 0;
-    Hl = lt[15] | 0;
+  }, re = class extends Rt {
+    Ah = M[0] | 0;
+    Al = M[1] | 0;
+    Bh = M[2] | 0;
+    Bl = M[3] | 0;
+    Ch = M[4] | 0;
+    Cl = M[5] | 0;
+    Dh = M[6] | 0;
+    Dl = M[7] | 0;
+    Eh = M[8] | 0;
+    El = M[9] | 0;
+    Fh = M[10] | 0;
+    Fl = M[11] | 0;
+    Gh = M[12] | 0;
+    Gl = M[13] | 0;
+    Hh = M[14] | 0;
+    Hl = M[15] | 0;
     constructor() {
       super(48);
     }
-  }, ft = /* @__PURE__ */ Uint32Array.from([
+  }, Y = /* @__PURE__ */ Uint32Array.from([
     2352822216,
     424955298,
     1944164710,
@@ -650,7 +646,7 @@ var ee, Ie, Ne, je, Ut, qt, ne, re, Hn, Tn, Fn, In, Nn, jn, Rr = Dt((() => {
     1780299464,
     286451373,
     2446758561
-  ]), at = /* @__PURE__ */ Uint32Array.from([
+  ]), z = /* @__PURE__ */ Uint32Array.from([
     573645204,
     4230739756,
     2673172387,
@@ -667,111 +663,111 @@ var ee, Ie, Ne, je, Ut, qt, ne, re, Hn, Tn, Fn, In, Nn, jn, Rr = Dt((() => {
     746961066,
     246885852,
     2177182882
-  ]), Ce = class extends te {
-    Ah = ft[0] | 0;
-    Al = ft[1] | 0;
-    Bh = ft[2] | 0;
-    Bl = ft[3] | 0;
-    Ch = ft[4] | 0;
-    Cl = ft[5] | 0;
-    Dh = ft[6] | 0;
-    Dl = ft[7] | 0;
-    Eh = ft[8] | 0;
-    El = ft[9] | 0;
-    Fh = ft[10] | 0;
-    Fl = ft[11] | 0;
-    Gh = ft[12] | 0;
-    Gl = ft[13] | 0;
-    Hh = ft[14] | 0;
-    Hl = ft[15] | 0;
+  ]), oe = class extends Rt {
+    Ah = Y[0] | 0;
+    Al = Y[1] | 0;
+    Bh = Y[2] | 0;
+    Bl = Y[3] | 0;
+    Ch = Y[4] | 0;
+    Cl = Y[5] | 0;
+    Dh = Y[6] | 0;
+    Dl = Y[7] | 0;
+    Eh = Y[8] | 0;
+    El = Y[9] | 0;
+    Fh = Y[10] | 0;
+    Fl = Y[11] | 0;
+    Gh = Y[12] | 0;
+    Gl = Y[13] | 0;
+    Hh = Y[14] | 0;
+    Hl = Y[15] | 0;
     constructor() {
       super(28);
     }
-  }, ke = class extends te {
-    Ah = at[0] | 0;
-    Al = at[1] | 0;
-    Bh = at[2] | 0;
-    Bl = at[3] | 0;
-    Ch = at[4] | 0;
-    Cl = at[5] | 0;
-    Dh = at[6] | 0;
-    Dl = at[7] | 0;
-    Eh = at[8] | 0;
-    El = at[9] | 0;
-    Fh = at[10] | 0;
-    Fl = at[11] | 0;
-    Gh = at[12] | 0;
-    Gl = at[13] | 0;
-    Hh = at[14] | 0;
-    Hl = at[15] | 0;
+  }, ie = class extends Rt {
+    Ah = z[0] | 0;
+    Al = z[1] | 0;
+    Bh = z[2] | 0;
+    Bl = z[3] | 0;
+    Ch = z[4] | 0;
+    Cl = z[5] | 0;
+    Dh = z[6] | 0;
+    Dl = z[7] | 0;
+    Eh = z[8] | 0;
+    El = z[9] | 0;
+    Fh = z[10] | 0;
+    Fl = z[11] | 0;
+    Gh = z[12] | 0;
+    Gl = z[13] | 0;
+    Hh = z[14] | 0;
+    Hl = z[15] | 0;
     constructor() {
       super(32);
     }
-  }, jt = /* @__PURE__ */ Yt(() => new De(), /* @__PURE__ */ Lt(1)), Dn = /* @__PURE__ */ Yt(() => new Le(), /* @__PURE__ */ Lt(4)), Ln = /* @__PURE__ */ Yt(() => new Ue(), /* @__PURE__ */ Lt(3)), Un = /* @__PURE__ */ Yt(() => new qe(), /* @__PURE__ */ Lt(2)), qn = /* @__PURE__ */ Yt(() => new ke(), /* @__PURE__ */ Lt(6)), Cn = /* @__PURE__ */ Yt(() => new Ce(), /* @__PURE__ */ Lt(5));
+  }, ge = /* @__PURE__ */ xt(() => new te(), /* @__PURE__ */ gt(1)), Qe = /* @__PURE__ */ xt(() => new ee(), /* @__PURE__ */ gt(4)), Je = /* @__PURE__ */ xt(() => new ne(), /* @__PURE__ */ gt(3)), Pe = /* @__PURE__ */ xt(() => new re(), /* @__PURE__ */ gt(2)), tn = /* @__PURE__ */ xt(() => new ie(), /* @__PURE__ */ gt(6)), en = /* @__PURE__ */ xt(() => new oe(), /* @__PURE__ */ gt(5));
 }));
-function Or(t) {
+function Cn(t) {
   return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
 }
-function Io(t, n = "") {
+function Ar(t, e = "") {
   if (!Number.isSafeInteger(t) || t < 0) {
-    const e = n && `"${n}" `;
-    throw new Error(`${e}expected integer >= 0, got ${t}`);
+    const r = e && `"${e}" `;
+    throw new Error(`${r}expected integer >= 0, got ${t}`);
   }
 }
-function kn(t, n, e = "") {
-  const r = Or(t), o = t?.length, i = n !== void 0;
-  if (!r || i && o !== n) {
-    const a = e && `"${e}" `, f = i ? ` of length ${n}` : "", l = r ? `length=${o}` : `type=${typeof t}`;
-    throw new Error(a + "expected Uint8Array" + f + ", got " + l);
+function nn(t, e, r = "") {
+  const n = Cn(t), o = t?.length, i = e !== void 0;
+  if (!n || i && o !== e) {
+    const c = r && `"${r}" `, s = i ? ` of length ${e}` : "", a = n ? `length=${o}` : `type=${typeof t}`;
+    throw new Error(c + "expected Uint8Array" + s + ", got " + a);
   }
   return t;
 }
-function No(t, n = !0) {
+function Rr(t, e = !0) {
   if (t.destroyed) throw new Error("Hash instance has been destroyed");
-  if (n && t.finished) throw new Error("Hash#digest() has already been called");
+  if (e && t.finished) throw new Error("Hash#digest() has already been called");
 }
-function jo(t, n) {
-  kn(t, void 0, "digestInto() output");
-  const e = n.outputLen;
-  if (t.length < e) throw new Error('"digestInto() output" expected to be of length >=' + e);
+function Sr(t, e) {
+  nn(t, void 0, "digestInto() output");
+  const r = e.outputLen;
+  if (t.length < r) throw new Error('"digestInto() output" expected to be of length >=' + r);
 }
-function Do(t) {
+function _r(t) {
   return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
 }
-function Lo(...t) {
-  for (let n = 0; n < t.length; n++) t[n].fill(0);
+function Hr(...t) {
+  for (let e = 0; e < t.length; e++) t[e].fill(0);
 }
-function Hr(t) {
+function kn(t) {
   return t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255;
 }
-function Tr(t) {
-  for (let n = 0; n < t.length; n++) t[n] = Hr(t[n]);
+function jn(t) {
+  for (let e = 0; e < t.length; e++) t[e] = kn(t[e]);
   return t;
 }
-function Uo(...t) {
-  let n = 0;
-  for (let r = 0; r < t.length; r++) {
-    const o = t[r];
-    kn(o), n += o.length;
+function Or(...t) {
+  let e = 0;
+  for (let n = 0; n < t.length; n++) {
+    const o = t[n];
+    nn(o), e += o.length;
   }
-  const e = new Uint8Array(n);
-  for (let r = 0, o = 0; r < t.length; r++) {
-    const i = t[r];
-    e.set(i, o), o += i.length;
+  const r = new Uint8Array(e);
+  for (let n = 0, o = 0; n < t.length; n++) {
+    const i = t[n];
+    r.set(i, o), o += i.length;
   }
-  return e;
+  return r;
 }
-function qo(t, n = {}) {
-  const e = (o, i) => t(i).update(o).digest(), r = t(void 0);
-  return e.outputLen = r.outputLen, e.blockLen = r.blockLen, e.create = (o) => t(o), Object.assign(e, n), Object.freeze(e);
+function Ir(t, e = {}) {
+  const r = (o, i) => t(i).update(o).digest(), n = t(void 0);
+  return r.outputLen = n.outputLen, r.blockLen = n.blockLen, r.create = (o) => t(o), Object.assign(r, e), Object.freeze(r);
 }
-function Co(t = 32) {
-  const n = typeof globalThis == "object" ? globalThis.crypto : null;
-  if (typeof n?.getRandomValues != "function") throw new Error("crypto.getRandomValues must be defined");
-  return n.getRandomValues(new Uint8Array(t));
+function Fr(t = 32) {
+  const e = typeof globalThis == "object" ? globalThis.crypto : null;
+  if (typeof e?.getRandomValues != "function") throw new Error("crypto.getRandomValues must be defined");
+  return e.getRandomValues(new Uint8Array(t));
 }
-var ln, Fr, Ir, Nr, jr = Dt((() => {
-  ln = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68, Fr = ln ? (t) => t : Tr, Ir = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Nr = (t) => ({ oid: Uint8Array.from([
+var He, Vn, Yn, zn = dt((() => {
+  He = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68, Vn = He ? (t) => t : jn, Yn = (t) => ({ oid: Uint8Array.from([
     6,
     9,
     96,
@@ -785,258 +781,250 @@ var ln, Fr, Ir, Nr, jr = Dt((() => {
     t
   ]) });
 }));
-function ko(t, n = "") {
+function Lr(t, e = "") {
   if (typeof t != "boolean") {
-    const e = n && `"${n}" `;
-    throw new Error(e + "expected boolean, got type=" + typeof t);
+    const r = e && `"${e}" `;
+    throw new Error(r + "expected boolean, got type=" + typeof t);
   }
   return t;
 }
-var $o = Dt((() => {
-  jr();
+var Nr = dt((() => {
+  zn();
 }));
-function Qe(t) {
+function be(t) {
   if (!Number.isSafeInteger(t) || t < 0 || t > 4294967295) throw new Error("wrong u32 integer:" + t);
   return t;
 }
-function $n(t) {
-  return Qe(t), (t & t - 1) === 0 && t !== 0;
+function rn(t) {
+  return be(t), (t & t - 1) === 0 && t !== 0;
 }
-function Dr(t, n) {
-  Qe(t);
-  let e = 0;
-  for (let r = 0; r < n; r++, t >>>= 1) e = e << 1 | t & 1;
-  return e;
+function Mn(t, e) {
+  be(t);
+  let r = 0;
+  for (let n = 0; n < e; n++, t >>>= 1) r = r << 1 | t & 1;
+  return r;
 }
-function Zn(t) {
-  return Qe(t), 31 - Math.clz32(t);
+function on(t) {
+  return be(t), 31 - Math.clz32(t);
 }
-function un(t) {
-  const n = t.length;
-  if (n < 2 || !$n(n)) throw new Error("n must be a power of 2 and greater than 1. Got " + n);
-  const e = Zn(n);
-  for (let r = 0; r < n; r++) {
-    const o = Dr(r, e);
-    if (r < o) {
-      const i = t[r];
-      t[r] = t[o], t[o] = i;
+function Oe(t) {
+  const e = t.length;
+  if (e < 2 || !rn(e)) throw new Error("n must be a power of 2 and greater than 1. Got " + e);
+  const r = on(e);
+  for (let n = 0; n < e; n++) {
+    const o = Mn(n, r);
+    if (n < o) {
+      const i = t[n];
+      t[n] = t[o], t[o] = i;
     }
   }
   return t;
 }
-var Lr, Zo = Dt((() => {
-  Lr = (t, n) => {
-    const { N: e, roots: r, dit: o, invertButterflies: i = !1, skipStages: a = 0, brp: f = !0 } = n, l = Zn(e);
-    if (!$n(e)) throw new Error("FFT: Polynomial size should be power of two");
-    const g = o !== i;
-    return (s) => {
-      if (s.length !== e) throw new Error("FFT: wrong Polynomial length");
-      o && f && un(s);
-      for (let u = 0, d = 1; u < l - a; u++) {
-        const h = o ? u + 1 + a : l - u, w = 1 << h, b = w >> 1, E = e >> h;
-        for (let T = 0; T < e; T += w) for (let B = 0, C = d++; B < b; B++) {
-          const O = i ? o ? e - C : C : B * E, F = T + B, z = T + B + b, W = r[O], N = s[z], V = s[F];
-          if (g) {
-            const K = t.mul(N, W);
-            s[F] = t.add(V, K), s[z] = t.sub(V, K);
-          } else i ? (s[F] = t.add(N, V), s[z] = t.mul(t.sub(N, V), W)) : (s[F] = t.add(V, N), s[z] = t.mul(t.sub(V, N), W));
+var Gn, Tr = dt((() => {
+  Gn = (t, e) => {
+    const { N: r, roots: n, dit: o, invertButterflies: i = !1, skipStages: c = 0, brp: s = !0 } = e, a = on(r);
+    if (!rn(r)) throw new Error("FFT: Polynomial size should be power of two");
+    const u = o !== i;
+    return (f) => {
+      if (f.length !== r) throw new Error("FFT: wrong Polynomial length");
+      o && s && Oe(f);
+      for (let g = 0, m = 1; g < a - c; g++) {
+        const w = o ? g + 1 + c : a - g, A = 1 << w, _ = A >> 1, H = r >> w;
+        for (let O = 0; O < r; O += A) for (let x = 0, q = m++; x < _; x++) {
+          const Z = i ? o ? r - q : q : x * H, T = O + x, Q = O + x + _, $ = n[Z], R = f[Q], C = f[T];
+          if (u) {
+            const X = t.mul(R, $);
+            f[T] = t.add(C, X), f[Q] = t.sub(C, X);
+          } else i ? (f[T] = t.add(R, C), f[Q] = t.mul(t.sub(R, C), $)) : (f[T] = t.add(C, R), f[Q] = t.mul(t.sub(C, R), $));
         }
       }
-      return !o && f && un(s), s;
+      return !o && s && Oe(f), f;
     };
   };
 }));
-_r();
-Qt();
-var st = (t, n, e) => zt(t, n, e), Vn = Pt, Ct = Ke, Q = (...t) => br(...t), he = (t) => _n(t), oe = Sn, wt = (t) => yr(t), me = /* @__PURE__ */ BigInt(0), $e = /* @__PURE__ */ BigInt(1);
-function ie(t, n = "") {
+Zn();
+It();
+var W = (t, e, r) => mt(t, e, r), sn = Et, cn = le, lt = (...t) => In(...t), se = (t) => Ve(t), fn = Ce, an = (t) => Fn(t), qt = /* @__PURE__ */ BigInt(0), ce = /* @__PURE__ */ BigInt(1);
+function Ot(t, e = "") {
   if (typeof t != "boolean") {
-    const e = n && `"${n}" `;
-    throw new TypeError(e + "expected boolean, got type=" + typeof t);
+    const r = e && `"${e}" `;
+    throw new TypeError(r + "expected boolean, got type=" + typeof t);
   }
   return t;
 }
-function Je(t) {
+function we(t) {
   if (typeof t == "bigint") {
-    if (!ue(t)) throw new RangeError("positive bigint expected, got " + t);
-  } else Vn(t);
+    if (!$t(t)) throw new RangeError("positive bigint expected, got " + t);
+  } else sn(t);
   return t;
 }
-function Ft(t, n = "") {
+function fe(t, e = "") {
   if (typeof t != "number") {
-    const e = n && `"${n}" `;
-    throw new TypeError(e + "expected number, got type=" + typeof t);
+    const r = e && `"${e}" `;
+    throw new TypeError(r + "expected number, got type=" + typeof t);
   }
   if (!Number.isSafeInteger(t)) {
-    const e = n && `"${n}" `;
-    throw new RangeError(e + "expected safe integer, got " + t);
+    const r = e && `"${e}" `;
+    throw new RangeError(r + "expected safe integer, got " + t);
   }
 }
-function ce(t) {
-  const n = Je(t).toString(16);
-  return n.length & 1 ? "0" + n : n;
+function Nt(t) {
+  const e = we(t).toString(16);
+  return e.length & 1 ? "0" + e : e;
 }
-function Pn(t) {
+function un(t) {
   if (typeof t != "string") throw new TypeError("hex string expected, got " + typeof t);
-  return t === "" ? me : BigInt("0x" + t);
-}
-function St(t) {
-  return Pn(Ke(t));
+  return t === "" ? qt : BigInt("0x" + t);
 }
-function ge(t) {
-  return Pn(Ke(Ze(zt(t)).reverse()));
+function Ct(t) {
+  return un(le(t));
 }
-function tn(t, n) {
-  if (Pt(n), n === 0) throw new RangeError("zero length");
-  t = Je(t);
-  const e = t.toString(16);
-  if (e.length > n * 2) throw new RangeError("number too large");
-  return _n(e.padStart(n * 2, "0"));
+function ln(t) {
+  return un(le(Kn(mt(t)).reverse()));
 }
-function zn(t, n) {
-  return tn(t, n).reverse();
+function pe(t, e) {
+  if (Et(e), e === 0) throw new RangeError("zero length");
+  t = we(t);
+  const r = t.toString(16);
+  if (r.length > e * 2) throw new RangeError("number too large");
+  return Ve(r.padStart(e * 2, "0"));
 }
-function Ze(t) {
-  return Uint8Array.from(st(t));
+function hn(t, e) {
+  return pe(t, e).reverse();
 }
-function be(t) {
-  if (typeof t != "string") throw new TypeError("ascii string expected, got " + typeof t);
-  return Uint8Array.from(t, (n, e) => {
-    const r = n.charCodeAt(0);
-    if (n.length !== 1 || r > 127) throw new RangeError(`string contains non-ASCII character "${t[e]}" with code ${r} at position ${e}`);
-    return r;
-  });
+function Kn(t) {
+  return Uint8Array.from(W(t));
 }
-var ue = (t) => typeof t == "bigint" && me <= t;
-function Ur(t, n, e) {
-  return ue(t) && ue(n) && ue(e) && n <= t && t < e;
+var $t = (t) => typeof t == "bigint" && qt <= t;
+function Xn(t, e, r) {
+  return $t(t) && $t(e) && $t(r) && e <= t && t < r;
 }
-function Mn(t, n, e, r) {
-  if (!Ur(n, e, r)) throw new RangeError("expected valid " + t + ": " + e + " <= n < " + r + ", got " + n);
+function dn(t, e, r, n) {
+  if (!Xn(e, r, n)) throw new RangeError("expected valid " + t + ": " + r + " <= n < " + n + ", got " + e);
 }
 function ye(t) {
-  if (t < me) throw new Error("expected non-negative bigint, got " + t);
-  let n;
-  for (n = 0; t > me; t >>= $e, n += 1) ;
-  return n;
+  if (t < qt) throw new Error("expected non-negative bigint, got " + t);
+  let e;
+  for (e = 0; t > qt; t >>= ce, e += 1) ;
+  return e;
 }
-var pe = (t) => ($e << BigInt(t)) - $e;
-function qr(t, n, e) {
-  if (Pt(t, "hashLen"), Pt(n, "qByteLen"), typeof e != "function") throw new TypeError("hmacFn must be a function");
-  const r = (E) => new Uint8Array(E), o = Uint8Array.of(), i = Uint8Array.of(0), a = Uint8Array.of(1), f = 1e3;
-  let l = r(t), g = r(t), s = 0;
-  const u = () => {
-    l.fill(1), g.fill(0), s = 0;
-  }, d = (...E) => e(g, Q(l, ...E)), h = (E = o) => {
-    g = d(i, E), l = d(), E.length !== 0 && (g = d(a, E), l = d());
-  }, w = () => {
-    if (s++ >= f) throw new Error("drbg: tried max amount of iterations");
-    let E = 0;
-    const T = [];
-    for (; E < n; ) {
-      l = d();
-      const B = l.slice();
-      T.push(B), E += l.length;
-    }
-    return Q(...T);
+var Ee = (t) => (ce << BigInt(t)) - ce;
+function Wn(t, e, r) {
+  if (Et(t, "hashLen"), Et(e, "qByteLen"), typeof r != "function") throw new TypeError("hmacFn must be a function");
+  const n = (H) => new Uint8Array(H), o = Uint8Array.of(), i = Uint8Array.of(0), c = Uint8Array.of(1), s = 1e3;
+  let a = n(t), u = n(t), f = 0;
+  const g = () => {
+    a.fill(1), u.fill(0), f = 0;
+  }, m = (...H) => r(u, lt(a, ...H)), w = (H = o) => {
+    u = m(i, H), a = m(), H.length !== 0 && (u = m(c, H), a = m());
+  }, A = () => {
+    if (f++ >= s) throw new Error("drbg: tried max amount of iterations");
+    let H = 0;
+    const O = [];
+    for (; H < e; ) {
+      a = m();
+      const x = a.slice();
+      O.push(x), H += a.length;
+    }
+    return lt(...O);
   };
-  return (E, T) => {
-    u(), h(E);
-    let B;
-    for (; (B = T(w())) === void 0; ) h();
-    return u(), B;
+  return (H, O) => {
+    g(), w(H);
+    let x;
+    for (; (x = O(A())) === void 0; ) w();
+    return g(), x;
   };
 }
-function Mt(t, n = {}, e = {}) {
+function kt(t, e = {}, r = {}) {
   if (Object.prototype.toString.call(t) !== "[object Object]") throw new TypeError("expected valid options object");
-  function r(i, a, f) {
-    if (!f && a !== "function" && !Object.hasOwn(t, i)) throw new TypeError(`param "${i}" is invalid: expected own property`);
-    const l = t[i];
-    if (f && l === void 0) return;
-    const g = typeof l;
-    if (g !== a || l === null) throw new TypeError(`param "${i}" is invalid: expected ${a}, got ${g}`);
-  }
-  const o = (i, a) => Object.entries(i).forEach(([f, l]) => r(f, l, a));
-  o(n, !1), o(e, !0);
-}
-var dt = /* @__PURE__ */ BigInt(0), ot = /* @__PURE__ */ BigInt(1), $t = /* @__PURE__ */ BigInt(2), Gn = /* @__PURE__ */ BigInt(3), Yn = /* @__PURE__ */ BigInt(4), Kn = /* @__PURE__ */ BigInt(5), Cr = /* @__PURE__ */ BigInt(7), Xn = /* @__PURE__ */ BigInt(8), kr = /* @__PURE__ */ BigInt(9), Wn = /* @__PURE__ */ BigInt(16);
-function bt(t, n) {
-  if (n <= dt) throw new Error("mod: expected positive modulus, got " + n);
-  const e = t % n;
-  return e >= dt ? e : n + e;
-}
-function gt(t, n, e) {
-  if (n < dt) throw new Error("pow2: expected non-negative exponent, got " + n);
-  let r = t;
-  for (; n-- > dt; )
-    r *= r, r %= e;
-  return r;
+  function n(i, c, s) {
+    if (!s && c !== "function" && !Object.hasOwn(t, i)) throw new TypeError(`param "${i}" is invalid: expected own property`);
+    const a = t[i];
+    if (s && a === void 0) return;
+    const u = typeof a;
+    if (u !== c || a === null) throw new TypeError(`param "${i}" is invalid: expected ${c}, got ${u}`);
+  }
+  const o = (i, c) => Object.entries(i).forEach(([s, a]) => n(s, a, c));
+  o(e, !1), o(r, !0);
+}
+var K = /* @__PURE__ */ BigInt(0), D = /* @__PURE__ */ BigInt(1), pt = /* @__PURE__ */ BigInt(2), gn = /* @__PURE__ */ BigInt(3), bn = /* @__PURE__ */ BigInt(4), wn = /* @__PURE__ */ BigInt(5), Qn = /* @__PURE__ */ BigInt(7), pn = /* @__PURE__ */ BigInt(8), Jn = /* @__PURE__ */ BigInt(9), yn = /* @__PURE__ */ BigInt(16);
+function tt(t, e) {
+  if (e <= K) throw new Error("mod: expected positive modulus, got " + e);
+  const r = t % e;
+  return r >= K ? r : e + r;
+}
+function P(t, e, r) {
+  if (e < K) throw new Error("pow2: expected non-negative exponent, got " + e);
+  let n = t;
+  for (; e-- > K; )
+    n *= n, n %= r;
+  return n;
 }
-function dn(t, n) {
-  if (t === dt) throw new Error("invert: expected non-zero number");
-  if (n <= dt) throw new Error("invert: expected positive modulus, got " + n);
-  let e = bt(t, n), r = n, o = dt, i = ot, a = ot, f = dt;
-  for (; e !== dt; ) {
-    const l = r / e, g = r - e * l, s = o - a * l, u = i - f * l;
-    r = e, e = g, o = a, i = f, a = s, f = u;
-  }
-  if (r !== ot) throw new Error("invert: does not exist");
-  return bt(o, n);
-}
-function en(t, n, e) {
-  const r = t;
-  if (!r.eql(r.sqr(n), e)) throw new Error("Cannot find square root");
-}
-function Qn(t, n) {
-  const e = t, r = (e.ORDER + ot) / Yn, o = e.pow(n, r);
-  return en(e, o, n), o;
-}
-function $r(t, n) {
-  const e = t, r = (e.ORDER - Kn) / Xn, o = e.mul(n, $t), i = e.pow(o, r), a = e.mul(n, i), f = e.mul(e.mul(a, $t), i), l = e.mul(a, e.sub(f, e.ONE));
-  return en(e, l, n), l;
-}
-function Zr(t) {
-  const n = ve(t), e = Jn(t), r = e(n, n.neg(n.ONE)), o = e(n, r), i = e(n, n.neg(r)), a = (t + Cr) / Wn;
-  return ((f, l) => {
-    const g = f;
-    let s = g.pow(l, a), u = g.mul(s, r);
-    const d = g.mul(s, o), h = g.mul(s, i), w = g.eql(g.sqr(u), l), b = g.eql(g.sqr(d), l);
-    s = g.cmov(s, u, w), u = g.cmov(h, d, b);
-    const E = g.eql(g.sqr(u), l), T = g.cmov(s, u, E);
-    return en(g, T, l), T;
+function Ie(t, e) {
+  if (t === K) throw new Error("invert: expected non-zero number");
+  if (e <= K) throw new Error("invert: expected positive modulus, got " + e);
+  let r = tt(t, e), n = e, o = K, i = D, c = D, s = K;
+  for (; r !== K; ) {
+    const a = n / r, u = n - r * a, f = o - c * a, g = i - s * a;
+    n = r, r = u, o = c, i = s, c = f, s = g;
+  }
+  if (n !== D) throw new Error("invert: does not exist");
+  return tt(o, e);
+}
+function me(t, e, r) {
+  const n = t;
+  if (!n.eql(n.sqr(e), r)) throw new Error("Cannot find square root");
+}
+function En(t, e) {
+  const r = t, n = (r.ORDER + D) / bn, o = r.pow(e, n);
+  return me(r, o, e), o;
+}
+function Pn(t, e) {
+  const r = t, n = (r.ORDER - wn) / pn, o = r.mul(e, pt), i = r.pow(o, n), c = r.mul(e, i), s = r.mul(r.mul(c, pt), i), a = r.mul(c, r.sub(s, r.ONE));
+  return me(r, a, e), a;
+}
+function tr(t) {
+  const e = jt(t), r = mn(t), n = r(e, e.neg(e.ONE)), o = r(e, n), i = r(e, e.neg(n)), c = (t + Qn) / yn;
+  return ((s, a) => {
+    const u = s;
+    let f = u.pow(a, c), g = u.mul(f, n);
+    const m = u.mul(f, o), w = u.mul(f, i), A = u.eql(u.sqr(g), a), _ = u.eql(u.sqr(m), a);
+    f = u.cmov(f, g, A), g = u.cmov(w, m, _);
+    const H = u.eql(u.sqr(g), a), O = u.cmov(f, g, H);
+    return me(u, O, a), O;
   });
 }
-function Jn(t) {
-  if (t < Gn) throw new Error("sqrt is not defined for small field");
-  let n = t - ot, e = 0;
-  for (; n % $t === dt; )
-    n /= $t, e++;
-  let r = $t;
-  const o = ve(t);
-  for (; Ve(o, r) === 1; ) if (r++ > 1e3) throw new Error("Cannot find square root: probably non-prime P");
-  if (e === 1) return Qn;
-  let i = o.pow(r, n);
-  const a = (n + ot) / $t;
-  return function(l, g) {
-    const s = l;
-    if (s.is0(g)) return g;
-    if (Ve(s, g) !== 1) throw new Error("Cannot find square root");
-    let u = e, d = s.mul(s.ONE, i), h = s.pow(g, n), w = s.pow(g, a);
-    for (; !s.eql(h, s.ONE); ) {
-      if (s.is0(h)) return s.ZERO;
-      let b = 1, E = s.sqr(h);
-      for (; !s.eql(E, s.ONE); )
-        if (b++, E = s.sqr(E), b === u) throw new Error("Cannot find square root");
-      const T = ot << BigInt(u - b - 1), B = s.pow(d, T);
-      u = b, d = s.sqr(B), h = s.mul(h, d), w = s.mul(w, B);
-    }
-    return w;
+function mn(t) {
+  if (t < gn) throw new Error("sqrt is not defined for small field");
+  let e = t - D, r = 0;
+  for (; e % pt === K; )
+    e /= pt, r++;
+  let n = pt;
+  const o = jt(t);
+  for (; Fe(o, n) === 1; ) if (n++ > 1e3) throw new Error("Cannot find square root: probably non-prime P");
+  if (r === 1) return En;
+  let i = o.pow(n, e);
+  const c = (e + D) / pt;
+  return function(a, u) {
+    const f = a;
+    if (f.is0(u)) return u;
+    if (Fe(f, u) !== 1) throw new Error("Cannot find square root");
+    let g = r, m = f.mul(f.ONE, i), w = f.pow(u, e), A = f.pow(u, c);
+    for (; !f.eql(w, f.ONE); ) {
+      if (f.is0(w)) return f.ZERO;
+      let _ = 1, H = f.sqr(w);
+      for (; !f.eql(H, f.ONE); )
+        if (_++, H = f.sqr(H), _ === g) throw new Error("Cannot find square root");
+      const O = D << BigInt(g - _ - 1), x = f.pow(m, O);
+      g = _, m = f.sqr(x), w = f.mul(w, m), A = f.mul(A, x);
+    }
+    return A;
   };
 }
-function Vr(t) {
-  return t % Yn === Gn ? Qn : t % Xn === Kn ? $r : t % Wn === kr ? Zr(t) : Jn(t);
+function er(t) {
+  return t % bn === gn ? En : t % pn === wn ? Pn : t % yn === Jn ? tr(t) : mn(t);
 }
-var Pr = [
+var nr = [
   "create",
   "isValid",
   "is0",
@@ -1055,1088 +1043,347 @@ var Pr = [
   "mulN",
   "sqrN"
 ];
-function se(t) {
-  if (Mt(t, Pr.reduce((n, e) => (n[e] = "function", n), {
+function rr(t) {
+  if (kt(t, nr.reduce((e, r) => (e[r] = "function", e), {
     ORDER: "bigint",
     BYTES: "number",
     BITS: "number"
-  })), Ft(t.BYTES, "BYTES"), Ft(t.BITS, "BITS"), t.BYTES < 1 || t.BITS < 1) throw new Error("invalid field: expected BYTES/BITS > 0");
-  if (t.ORDER <= ot) throw new Error("invalid field: expected ORDER > 1, got " + t.ORDER);
+  })), fe(t.BYTES, "BYTES"), fe(t.BITS, "BITS"), t.BYTES < 1 || t.BITS < 1) throw new Error("invalid field: expected BYTES/BITS > 0");
+  if (t.ORDER <= D) throw new Error("invalid field: expected ORDER > 1, got " + t.ORDER);
   return t;
 }
-function zr(t, n, e) {
-  const r = t;
-  if (e < dt) throw new Error("invalid exponent, negatives unsupported");
-  if (e === dt) return r.ONE;
-  if (e === ot) return n;
-  let o = r.ONE, i = n;
-  for (; e > dt; )
-    e & ot && (o = r.mul(o, i)), i = r.sqr(i), e >>= ot;
+function or(t, e, r) {
+  const n = t;
+  if (r < K) throw new Error("invalid exponent, negatives unsupported");
+  if (r === K) return n.ONE;
+  if (r === D) return e;
+  let o = n.ONE, i = e;
+  for (; r > K; )
+    r & D && (o = n.mul(o, i)), i = n.sqr(i), r >>= D;
   return o;
 }
-function Ee(t, n, e = !1) {
-  const r = t, o = new Array(n.length).fill(e ? r.ZERO : void 0), i = n.reduce((f, l, g) => r.is0(l) ? f : (o[g] = f, r.mul(f, l)), r.ONE), a = r.inv(i);
-  return n.reduceRight((f, l, g) => r.is0(l) ? f : (o[g] = r.mul(f, o[g]), r.mul(f, l)), a), o;
-}
-function Ve(t, n) {
-  const e = t, r = (e.ORDER - ot) / $t, o = e.pow(n, r), i = e.eql(o, e.ONE), a = e.eql(o, e.ZERO), f = e.eql(o, e.neg(e.ONE));
-  if (!i && !a && !f) throw new Error("invalid Legendre symbol result");
-  return i ? 1 : a ? 0 : -1;
-}
-function hn(t, n) {
-  return Ve(t, n) !== -1;
-}
-function Mr(t, n) {
-  if (n !== void 0 && Vn(n), t <= dt) throw new Error("invalid n length: expected positive n, got " + t);
-  if (n !== void 0 && n < 1) throw new Error("invalid n length: expected positive bit length, got " + n);
-  const e = ye(t);
-  if (n !== void 0 && n < e) throw new Error(`invalid n length: expected bit length (${e}) >= n.length (${n})`);
-  const r = n !== void 0 ? n : e;
+function vn(t, e, r = !1) {
+  const n = t, o = new Array(e.length).fill(r ? n.ZERO : void 0), i = e.reduce((s, a, u) => n.is0(a) ? s : (o[u] = s, n.mul(s, a)), n.ONE), c = n.inv(i);
+  return e.reduceRight((s, a, u) => n.is0(a) ? s : (o[u] = n.mul(s, o[u]), n.mul(s, a)), c), o;
+}
+function Fe(t, e) {
+  const r = t, n = (r.ORDER - D) / pt, o = r.pow(e, n), i = r.eql(o, r.ONE), c = r.eql(o, r.ZERO), s = r.eql(o, r.neg(r.ONE));
+  if (!i && !c && !s) throw new Error("invalid Legendre symbol result");
+  return i ? 1 : c ? 0 : -1;
+}
+function ir(t, e) {
+  if (e !== void 0 && sn(e), t <= K) throw new Error("invalid n length: expected positive n, got " + t);
+  if (e !== void 0 && e < 1) throw new Error("invalid n length: expected positive bit length, got " + e);
+  const r = ye(t);
+  if (e !== void 0 && e < r) throw new Error(`invalid n length: expected bit length (${r}) >= n.length (${e})`);
+  const n = e !== void 0 ? e : r;
   return {
-    nBitLength: r,
-    nByteLength: Math.ceil(r / 8)
+    nBitLength: n,
+    nByteLength: Math.ceil(n / 8)
   };
 }
-var mn = /* @__PURE__ */ new WeakMap(), tr = class {
+var Le = /* @__PURE__ */ new WeakMap(), xn = class {
   ORDER;
   BITS;
   BYTES;
   isLE;
-  ZERO = dt;
-  ONE = ot;
+  ZERO = K;
+  ONE = D;
   _lengths;
   _mod;
-  constructor(t, n = {}) {
-    if (t <= ot) throw new Error("invalid field: expected ORDER > 1, got " + t);
-    let e;
-    this.isLE = !1, n != null && typeof n == "object" && (typeof n.BITS == "number" && (e = n.BITS), typeof n.sqrt == "function" && Object.defineProperty(this, "sqrt", {
-      value: n.sqrt,
+  constructor(t, e = {}) {
+    if (t <= D) throw new Error("invalid field: expected ORDER > 1, got " + t);
+    let r;
+    this.isLE = !1, e != null && typeof e == "object" && (typeof e.BITS == "number" && (r = e.BITS), typeof e.sqrt == "function" && Object.defineProperty(this, "sqrt", {
+      value: e.sqrt,
       enumerable: !0
-    }), typeof n.isLE == "boolean" && (this.isLE = n.isLE), n.allowedLengths && (this._lengths = Object.freeze(n.allowedLengths.slice())), typeof n.modFromBytes == "boolean" && (this._mod = n.modFromBytes));
-    const { nBitLength: r, nByteLength: o } = Mr(t, e);
+    }), typeof e.isLE == "boolean" && (this.isLE = e.isLE), e.allowedLengths && (this._lengths = Object.freeze(e.allowedLengths.slice())), typeof e.modFromBytes == "boolean" && (this._mod = e.modFromBytes));
+    const { nBitLength: n, nByteLength: o } = ir(t, r);
     if (o > 2048) throw new Error("invalid field: expected ORDER of <= 2048 bytes");
-    this.ORDER = t, this.BITS = r, this.BYTES = o, Object.freeze(this);
+    this.ORDER = t, this.BITS = n, this.BYTES = o, Object.freeze(this);
   }
   create(t) {
-    return bt(t, this.ORDER);
+    return tt(t, this.ORDER);
   }
   isValid(t) {
     if (typeof t != "bigint") throw new TypeError("invalid field element: expected bigint, got " + typeof t);
-    return dt <= t && t < this.ORDER;
+    return K <= t && t < this.ORDER;
   }
   is0(t) {
-    return t === dt;
+    return t === K;
   }
   isValidNot0(t) {
     return !this.is0(t) && this.isValid(t);
   }
   isOdd(t) {
-    return (t & ot) === ot;
+    return (t & D) === D;
   }
   neg(t) {
-    return bt(-t, this.ORDER);
+    return tt(-t, this.ORDER);
   }
-  eql(t, n) {
-    return t === n;
+  eql(t, e) {
+    return t === e;
   }
   sqr(t) {
-    return bt(t * t, this.ORDER);
+    return tt(t * t, this.ORDER);
   }
-  add(t, n) {
-    return bt(t + n, this.ORDER);
+  add(t, e) {
+    return tt(t + e, this.ORDER);
   }
-  sub(t, n) {
-    return bt(t - n, this.ORDER);
+  sub(t, e) {
+    return tt(t - e, this.ORDER);
   }
-  mul(t, n) {
-    return bt(t * n, this.ORDER);
+  mul(t, e) {
+    return tt(t * e, this.ORDER);
   }
-  pow(t, n) {
-    return zr(this, t, n);
+  pow(t, e) {
+    return or(this, t, e);
   }
-  div(t, n) {
-    return bt(t * dn(n, this.ORDER), this.ORDER);
+  div(t, e) {
+    return tt(t * Ie(e, this.ORDER), this.ORDER);
   }
   sqrN(t) {
     return t * t;
   }
-  addN(t, n) {
-    return t + n;
+  addN(t, e) {
+    return t + e;
   }
-  subN(t, n) {
-    return t - n;
+  subN(t, e) {
+    return t - e;
   }
-  mulN(t, n) {
-    return t * n;
+  mulN(t, e) {
+    return t * e;
   }
   inv(t) {
-    return dn(t, this.ORDER);
+    return Ie(t, this.ORDER);
   }
   sqrt(t) {
-    let n = mn.get(this);
-    return n || mn.set(this, n = Vr(this.ORDER)), n(this, t);
+    let e = Le.get(this);
+    return e || Le.set(this, e = er(this.ORDER)), e(this, t);
   }
   toBytes(t) {
-    return this.isLE ? zn(t, this.BYTES) : tn(t, this.BYTES);
-  }
-  fromBytes(t, n = !1) {
-    st(t);
-    const { _lengths: e, BYTES: r, isLE: o, ORDER: i, _mod: a } = this;
-    if (e) {
-      if (t.length < 1 || !e.includes(t.length) || t.length > r) throw new Error("Field.fromBytes: expected " + e + " bytes, got " + t.length);
-      const l = new Uint8Array(r);
-      l.set(t, o ? 0 : l.length - t.length), t = l;
-    }
-    if (t.length !== r) throw new Error("Field.fromBytes: expected " + r + " bytes, got " + t.length);
-    let f = o ? ge(t) : St(t);
-    if (a && (f = bt(f, i)), !n && !this.isValid(f))
+    return this.isLE ? hn(t, this.BYTES) : pe(t, this.BYTES);
+  }
+  fromBytes(t, e = !1) {
+    W(t);
+    const { _lengths: r, BYTES: n, isLE: o, ORDER: i, _mod: c } = this;
+    if (r) {
+      if (t.length < 1 || !r.includes(t.length) || t.length > n) throw new Error("Field.fromBytes: expected " + r + " bytes, got " + t.length);
+      const a = new Uint8Array(n);
+      a.set(t, o ? 0 : a.length - t.length), t = a;
+    }
+    if (t.length !== n) throw new Error("Field.fromBytes: expected " + n + " bytes, got " + t.length);
+    let s = o ? ln(t) : Ct(t);
+    if (c && (s = tt(s, i)), !e && !this.isValid(s))
       throw new Error("invalid field element: outside of range 0..ORDER");
-    return f;
+    return s;
   }
   invertBatch(t) {
-    return Ee(this, t);
+    return vn(this, t);
   }
-  cmov(t, n, e) {
-    return ie(e, "condition"), e ? n : t;
+  cmov(t, e, r) {
+    return Ot(r, "condition"), r ? e : t;
   }
 };
-Object.freeze(tr.prototype);
-function ve(t, n = {}) {
-  return new tr(t, n);
+Object.freeze(xn.prototype);
+function jt(t, e = {}) {
+  return new xn(t, e);
 }
-function er(t) {
+function Bn(t) {
   if (typeof t != "bigint") throw new Error("field order must be bigint");
-  if (t <= ot) throw new Error("field order must be greater than 1");
-  const n = ye(t - ot);
-  return Math.ceil(n / 8);
-}
-function nn(t) {
-  const n = er(t);
-  return n + Math.ceil(n / 2);
-}
-function nr(t, n, e = !1) {
-  st(t);
-  const r = t.length, o = er(n), i = Math.max(nn(n), 16);
-  if (r < i || r > 1024) throw new Error("expected " + i + "-1024 bytes of input, got " + r);
-  const a = bt(e ? ge(t) : St(t), n - ot) + ot;
-  return e ? zn(a, o) : tn(a, o);
-}
-var Wt = /* @__PURE__ */ BigInt(0), Zt = /* @__PURE__ */ BigInt(1);
-function Gr(t) {
-  const n = t;
-  if (typeof n != "function") throw new TypeError("Point must be a constructor");
-  Mt({
-    Fp: n.Fp,
-    Fn: n.Fn,
-    fromAffine: n.fromAffine,
-    fromBytes: n.fromBytes,
-    fromHex: n.fromHex
-  }, {
-    Fp: "object",
-    Fn: "object",
-    fromAffine: "function",
-    fromBytes: "function",
-    fromHex: "function"
-  }), se(n.Fp), se(n.Fn);
-}
-function we(t, n) {
-  const e = n.negate();
-  return t ? e : n;
-}
-function gn(t, n) {
-  const e = Ee(t.Fp, n.map((r) => r.Z));
-  return n.map((r, o) => t.fromAffine(r.toAffine(e[o])));
-}
-function rr(t, n) {
-  if (!Number.isSafeInteger(t) || t <= 0 || t > n) throw new Error("invalid window size, expected [1.." + n + "], got W=" + t);
+  if (t <= D) throw new Error("field order must be greater than 1");
+  const e = ye(t - D);
+  return Math.ceil(e / 8);
 }
-function Re(t, n) {
-  rr(t, n);
-  const e = Math.ceil(n / t) + 1, r = 2 ** (t - 1), o = 2 ** t;
+function An(t) {
+  const e = Bn(t);
+  return e + Math.ceil(e / 2);
+}
+function sr(t, e, r = !1) {
+  W(t);
+  const n = t.length, o = Bn(e), i = Math.max(An(e), 16);
+  if (n < i || n > 1024) throw new Error("expected " + i + "-1024 bytes of input, got " + n);
+  const c = tt(r ? ln(t) : Ct(t), e - D) + D;
+  return r ? hn(c, o) : pe(c, o);
+}
+var At = /* @__PURE__ */ BigInt(0), yt = /* @__PURE__ */ BigInt(1);
+function Zt(t, e) {
+  const r = e.negate();
+  return t ? r : e;
+}
+function Ne(t, e) {
+  const r = vn(t.Fp, e.map((n) => n.Z));
+  return e.map((n, o) => t.fromAffine(n.toAffine(r[o])));
+}
+function Rn(t, e) {
+  if (!Number.isSafeInteger(t) || t <= 0 || t > e) throw new Error("invalid window size, expected [1.." + e + "], got W=" + t);
+}
+function Mt(t, e) {
+  Rn(t, e);
+  const r = Math.ceil(e / t) + 1, n = 2 ** (t - 1), o = 2 ** t;
   return {
-    windows: e,
-    windowSize: r,
-    mask: pe(t),
+    windows: r,
+    windowSize: n,
+    mask: Ee(t),
     maxNumber: o,
     shiftBy: BigInt(t)
   };
 }
-function wn(t, n, e) {
-  const { windowSize: r, mask: o, maxNumber: i, shiftBy: a } = e;
-  let f = Number(t & o), l = t >> a;
-  f > r && (f -= i, l += Zt);
-  const g = n * r, s = g + Math.abs(f) - 1, u = f === 0, d = f < 0, h = n % 2 !== 0;
+function Te(t, e, r) {
+  const { windowSize: n, mask: o, maxNumber: i, shiftBy: c } = r;
+  let s = Number(t & o), a = t >> c;
+  s > n && (s -= i, a += yt);
+  const u = e * n, f = u + Math.abs(s) - 1, g = s === 0, m = s < 0, w = e % 2 !== 0;
   return {
-    nextN: l,
-    offset: s,
-    isZero: u,
-    isNeg: d,
-    isNegF: h,
-    offsetF: g
+    nextN: a,
+    offset: f,
+    isZero: g,
+    isNeg: m,
+    isNegF: w,
+    offsetF: u
   };
 }
-function Yr(t, n) {
-  if (!Array.isArray(t)) throw new Error("array expected");
-  t.forEach((e, r) => {
-    if (!(e instanceof n)) throw new Error("invalid point at index " + r);
-  });
+var Gt = /* @__PURE__ */ new WeakMap(), Sn = /* @__PURE__ */ new WeakMap();
+function Kt(t) {
+  return Sn.get(t) || 1;
 }
-function Kr(t, n) {
-  if (!Array.isArray(t)) throw new Error("array of scalars expected");
-  t.forEach((e, r) => {
-    if (!n.isValid(e)) throw new Error("invalid scalar at index " + r);
-  });
+function Ue(t) {
+  if (t !== At) throw new Error("invalid wNAF");
 }
-var _e = /* @__PURE__ */ new WeakMap(), or = /* @__PURE__ */ new WeakMap();
-function Oe(t) {
-  return or.get(t) || 1;
-}
-function bn(t) {
-  if (t !== Wt) throw new Error("invalid wNAF");
-}
-var Xr = class {
+var cr = class {
   BASE;
   ZERO;
   Fn;
   bits;
-  constructor(t, n) {
-    this.BASE = t.BASE, this.ZERO = t.ZERO, this.Fn = t.Fn, this.bits = n;
-  }
-  _unsafeLadder(t, n, e = this.ZERO) {
-    let r = t;
-    for (; n > Wt; )
-      n & Zt && (e = e.add(r)), r = r.double(), n >>= Zt;
-    return e;
-  }
-  precomputeWindow(t, n) {
-    const { windows: e, windowSize: r } = Re(n, this.bits), o = [];
-    let i = t, a = i;
-    for (let f = 0; f < e; f++) {
-      a = i, o.push(a);
-      for (let l = 1; l < r; l++)
-        a = a.add(i), o.push(a);
-      i = a.double();
+  constructor(t, e) {
+    this.BASE = t.BASE, this.ZERO = t.ZERO, this.Fn = t.Fn, this.bits = e;
+  }
+  _unsafeLadder(t, e, r = this.ZERO) {
+    let n = t;
+    for (; e > At; )
+      e & yt && (r = r.add(n)), n = n.double(), e >>= yt;
+    return r;
+  }
+  precomputeWindow(t, e) {
+    const { windows: r, windowSize: n } = Mt(e, this.bits), o = [];
+    let i = t, c = i;
+    for (let s = 0; s < r; s++) {
+      c = i, o.push(c);
+      for (let a = 1; a < n; a++)
+        c = c.add(i), o.push(c);
+      i = c.double();
     }
     return o;
   }
-  wNAF(t, n, e) {
-    if (!this.Fn.isValid(e)) throw new Error("invalid scalar");
-    let r = this.ZERO, o = this.BASE;
-    const i = Re(t, this.bits);
-    for (let a = 0; a < i.windows; a++) {
-      const { nextN: f, offset: l, isZero: g, isNeg: s, isNegF: u, offsetF: d } = wn(e, a, i);
-      e = f, g ? o = o.add(we(u, n[d])) : r = r.add(we(s, n[l]));
+  wNAF(t, e, r) {
+    if (!this.Fn.isValid(r)) throw new Error("invalid scalar");
+    let n = this.ZERO, o = this.BASE;
+    const i = Mt(t, this.bits);
+    for (let c = 0; c < i.windows; c++) {
+      const { nextN: s, offset: a, isZero: u, isNeg: f, isNegF: g, offsetF: m } = Te(r, c, i);
+      r = s, u ? o = o.add(Zt(g, e[m])) : n = n.add(Zt(f, e[a]));
     }
-    return bn(e), {
-      p: r,
+    return Ue(r), {
+      p: n,
       f: o
     };
   }
-  wNAFUnsafe(t, n, e, r = this.ZERO) {
-    const o = Re(t, this.bits);
-    for (let i = 0; i < o.windows && e !== Wt; i++) {
-      const { nextN: a, offset: f, isZero: l, isNeg: g } = wn(e, i, o);
-      if (e = a, !l) {
-        const s = n[f];
-        r = r.add(g ? s.negate() : s);
+  wNAFUnsafe(t, e, r, n = this.ZERO) {
+    const o = Mt(t, this.bits);
+    for (let i = 0; i < o.windows && r !== At; i++) {
+      const { nextN: c, offset: s, isZero: a, isNeg: u } = Te(r, i, o);
+      if (r = c, !a) {
+        const f = e[s];
+        n = n.add(u ? f.negate() : f);
       }
     }
-    return bn(e), r;
+    return Ue(r), n;
   }
-  getPrecomputes(t, n, e) {
-    let r = _e.get(n);
-    return r || (r = this.precomputeWindow(n, t), t !== 1 && (typeof e == "function" && (r = e(r)), _e.set(n, r))), r;
+  getPrecomputes(t, e, r) {
+    let n = Gt.get(e);
+    return n || (n = this.precomputeWindow(e, t), t !== 1 && (typeof r == "function" && (n = r(n)), Gt.set(e, n))), n;
   }
-  cached(t, n, e) {
-    const r = Oe(t);
-    return this.wNAF(r, this.getPrecomputes(r, t, e), n);
+  cached(t, e, r) {
+    const n = Kt(t);
+    return this.wNAF(n, this.getPrecomputes(n, t, r), e);
   }
-  unsafe(t, n, e, r) {
-    const o = Oe(t);
-    return o === 1 ? this._unsafeLadder(t, n, r) : this.wNAFUnsafe(o, this.getPrecomputes(o, t, e), n, r);
+  unsafe(t, e, r, n) {
+    const o = Kt(t);
+    return o === 1 ? this._unsafeLadder(t, e, n) : this.wNAFUnsafe(o, this.getPrecomputes(o, t, r), e, n);
   }
-  createCache(t, n) {
-    rr(n, this.bits), or.set(t, n), _e.delete(t);
+  createCache(t, e) {
+    Rn(e, this.bits), Sn.set(t, e), Gt.delete(t);
   }
   hasCache(t) {
-    return Oe(t) !== 1;
+    return Kt(t) !== 1;
   }
 };
-function Wr(t, n, e, r) {
-  let o = n, i = t.ZERO, a = t.ZERO;
-  for (; e > Wt || r > Wt; )
-    e & Zt && (i = i.add(o)), r & Zt && (a = a.add(o)), o = o.double(), e >>= Zt, r >>= Zt;
+function fr(t, e, r, n) {
+  let o = e, i = t.ZERO, c = t.ZERO;
+  for (; r > At || n > At; )
+    r & yt && (i = i.add(o)), n & yt && (c = c.add(o)), o = o.double(), r >>= yt, n >>= yt;
   return {
     p1: i,
-    p2: a
+    p2: c
   };
 }
-function Qr(t, n, e) {
-  const r = t.Fn;
-  Yr(n, t), Kr(e, r);
-  const o = n.length, i = e.length;
-  if (o !== i) throw new Error("arrays of points and scalars must have equal length");
-  const a = t.ZERO, f = ye(BigInt(o));
-  let l = 1;
-  f > 12 ? l = f - 3 : f > 4 ? l = f - 2 : f > 0 && (l = 2);
-  const g = pe(l), s = new Array(Number(g) + 1).fill(a), u = Math.floor((r.BITS - 1) / l) * l;
-  let d = a;
-  for (let h = u; h >= 0; h -= l) {
-    s.fill(a);
-    for (let b = 0; b < i; b++) {
-      const E = e[b], T = Number(E >> BigInt(h) & g);
-      s[T] = s[T].add(n[b]);
-    }
-    let w = a;
-    for (let b = s.length - 1, E = a; b > 0; b--)
-      E = E.add(s[b]), w = w.add(E);
-    if (d = d.add(w), h !== 0) for (let b = 0; b < l; b++) d = d.double();
-  }
-  return d;
-}
-function yn(t, n, e) {
-  if (n) {
-    if (n.ORDER !== t) throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
-    return se(n), n;
-  } else return ve(t, { isLE: e });
-}
-function Jr(t, n, e = {}, r) {
-  if (r === void 0 && (r = t === "edwards"), !n || typeof n != "object") throw new Error(`expected valid ${t} CURVE object`);
-  for (const f of [
+function $e(t, e, r) {
+  if (e) {
+    if (e.ORDER !== t) throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    return rr(e), e;
+  } else return jt(t, { isLE: r });
+}
+function ar(t, e, r = {}, n) {
+  if (n === void 0 && (n = t === "edwards"), !e || typeof e != "object") throw new Error(`expected valid ${t} CURVE object`);
+  for (const s of [
     "p",
     "n",
     "h"
   ]) {
-    const l = n[f];
-    if (!(typeof l == "bigint" && l > Wt)) throw new Error(`CURVE.${f} must be positive bigint`);
+    const a = e[s];
+    if (!(typeof a == "bigint" && a > At)) throw new Error(`CURVE.${s} must be positive bigint`);
   }
-  const o = yn(n.p, e.Fp, r), i = yn(n.n, e.Fn, r), a = [
+  const o = $e(e.p, r.Fp, n), i = $e(e.n, r.Fn, n), c = [
     "Gx",
     "Gy",
     "a",
     t === "weierstrass" ? "b" : "d"
   ];
-  for (const f of a) if (!o.isValid(n[f])) throw new Error(`CURVE.${f} must be valid field element of CURVE.Fp`);
-  return n = Object.freeze(Object.assign({}, n)), {
-    CURVE: n,
+  for (const s of c) if (!o.isValid(e[s])) throw new Error(`CURVE.${s} must be valid field element of CURVE.Fp`);
+  return e = Object.freeze(Object.assign({}, e)), {
+    CURVE: e,
     Fp: o,
     Fn: i
   };
 }
-function to(t, n) {
-  return function(r) {
-    const o = t(r);
+function ur(t, e) {
+  return function(n) {
+    const o = t(n);
     return {
       secretKey: o,
-      publicKey: n(o)
-    };
-  };
-}
-function ir(t) {
-  if (!Number.isSafeInteger(t) || t < 0 || t > 4294967295) throw new Error("wrong u32 integer:" + t);
-  return t;
-}
-function eo(t) {
-  if (ir(t), t <= 1) return 1;
-  if (t > 2147483648) throw new Error("nextPowerOfTwo overflow: result does not fit u32");
-  return 1 << Pe(t - 1) + 1 >>> 0;
-}
-function Pe(t) {
-  return ir(t), 31 - Math.clz32(t);
-}
-function no(t, n, e, r, o) {
-  const i = t, a = e || ((s, u) => new Array(s).fill(u ?? i.ZERO)), f = (s) => {
-    if (Array.isArray(s)) return !0;
-    if (!ArrayBuffer.isView(s)) return !1;
-    const u = s;
-    return typeof u.length == "number" && typeof u.slice == "function" && typeof u[Symbol.iterator] == "function";
-  }, l = (...s) => {
-    if (!s.length) return 0;
-    for (const d of s) if (!f(d)) throw new Error("poly: not polynomial: " + d);
-    const u = s[0].length;
-    for (let d = 1; d < s.length; d++) if (s[d].length !== u) throw new Error(`poly: mismatched lengths ${u} vs ${s[d].length}`);
-    if (o !== void 0 && u !== o) throw new Error(`poly: expected fixed length ${o}, got ${u}`);
-    return u;
-  };
-  function g(s, u, d = !1) {
-    const h = Pe(u), w = d ? n.brp(h) : n.roots(h);
-    for (let b = 0; b < u; b++) if (i.eql(s, w[b])) return b;
-    return -1;
-  }
-  return {
-    roots: n,
-    create: a,
-    length: o,
-    extend: (s, u) => {
-      l(s);
-      const d = a(u, i.ZERO);
-      for (let h = 0; h < Math.min(s.length, u); h++) d[h] = s[h];
-      return d;
-    },
-    degree: (s) => {
-      l(s);
-      for (let u = s.length - 1; u >= 0; u--) if (!i.is0(s[u])) return u;
-      return -1;
-    },
-    add: (s, u) => {
-      const d = l(s, u), h = a(d);
-      for (let w = 0; w < d; w++) h[w] = i.add(s[w], u[w]);
-      return h;
-    },
-    sub: (s, u) => {
-      const d = l(s, u), h = a(d);
-      for (let w = 0; w < d; w++) h[w] = i.sub(s[w], u[w]);
-      return h;
-    },
-    dot: (s, u) => {
-      const d = l(s, u), h = a(d);
-      for (let w = 0; w < d; w++) h[w] = i.mul(s[w], u[w]);
-      return h;
-    },
-    mul: (s, u) => {
-      if (f(u)) {
-        const d = l(s, u);
-        if (r) {
-          const h = r.direct(s, !1, !0), w = r.direct(u, !1, !0);
-          for (let b = 0; b < h.length; b++) h[b] = i.mul(h[b], w[b]);
-          return r.inverse(h, !0, !1);
-        } else {
-          const h = a(d);
-          for (let w = 0; w < d; w++) for (let b = 0; b < d; b++) {
-            const E = (w + b) % d;
-            h[E] = i.add(h[E], i.mul(s[w], u[b]));
-          }
-          return h;
-        }
-      } else {
-        const d = a(l(s));
-        for (let h = 0; h < d.length; h++) d[h] = i.mul(s[h], u);
-        return d;
-      }
-    },
-    convolve(s, u) {
-      const d = eo(s.length + u.length - 1);
-      return this.mul(this.extend(s, d), this.extend(u, d));
-    },
-    shift(s, u) {
-      const d = a(l(s));
-      d[0] = s[0];
-      for (let h = 1, w = i.ONE; h < s.length; h++)
-        w = i.mul(w, u), d[h] = i.mul(s[h], w);
-      return d;
-    },
-    clone: (s) => {
-      l(s);
-      const u = a(s.length);
-      for (let d = 0; d < s.length; d++) u[d] = s[d];
-      return u;
-    },
-    eval: (s, u) => {
-      l(s, u);
-      let d = i.ZERO;
-      for (let h = 0; h < s.length; h++) d = i.add(d, i.mul(s[h], u[h]));
-      return d;
-    },
-    monomial: {
-      basis: (s, u) => {
-        const d = a(u);
-        let h = i.ONE;
-        for (let w = 0; w < u; w++)
-          d[w] = h, h = i.mul(h, s);
-        return d;
-      },
-      eval: (s, u) => {
-        l(s);
-        let d = i.ZERO;
-        for (let h = s.length - 1; h >= 0; h--) d = i.add(i.mul(d, u), s[h]);
-        return d;
-      }
-    },
-    lagrange: {
-      basis: (s, u, d = !1, h) => {
-        const w = Pe(u), b = h || (d ? n.brp(w) : n.roots(w)), E = a(u), T = g(s, u, d);
-        if (T !== -1)
-          return E[T] = i.ONE, E;
-        const B = i.pow(s, BigInt(u)), C = i.mul(i.sub(B, i.ONE), i.inv(BigInt(u))), O = a(u);
-        for (let z = 0; z < u; z++) O[z] = i.sub(s, b[z]);
-        const F = i.invertBatch(O);
-        for (let z = 0; z < u; z++) E[z] = i.mul(C, i.mul(b[z], F[z]));
-        return E;
-      },
-      eval(s, u, d = !1) {
-        l(s);
-        const h = g(u, s.length, d);
-        if (h !== -1) return s[h];
-        const w = this.basis(u, s.length, d);
-        let b = i.ZERO;
-        for (let E = 0; E < s.length; E++) i.is0(s[E]) || (b = i.add(b, i.mul(s[E], w[E])));
-        return b;
-      }
-    },
-    vanishing(s) {
-      l(s);
-      const u = a(s.length + 1, i.ZERO);
-      u[0] = i.ONE;
-      for (const d of s) {
-        const h = i.neg(d);
-        for (let w = u.length - 1; w > 0; w--) u[w] = i.add(i.mul(u[w], h), u[w - 1]);
-        u[0] = i.mul(u[0], h);
-      }
-      return u;
-    }
-  };
-}
-var ro = St;
-function kt(t, n) {
-  if (Ft(t), Ft(n), n < 0 || n > 4) throw new Error("invalid I2OSP length: " + n);
-  if (t < 0 || t > 2 ** (8 * n) - 1) throw new Error("invalid I2OSP input: " + t);
-  const e = Array.from({ length: n }).fill(0);
-  for (let r = n - 1; r >= 0; r--)
-    e[r] = t & 255, t >>>= 8;
-  return new Uint8Array(e);
-}
-function oo(t, n) {
-  const e = new Uint8Array(t.length);
-  for (let r = 0; r < t.length; r++) e[r] = t[r] ^ n[r];
-  return e;
-}
-function sr(t) {
-  if (!oe(t) && typeof t != "string") throw new Error("DST must be Uint8Array or ascii string");
-  const n = typeof t == "string" ? be(t) : t;
-  if (n.length === 0) throw new Error("DST must be non-empty");
-  return n;
-}
-function io(t, n, e, r) {
-  st(t), Ft(e), n = sr(n), n.length > 255 && (n = r(Q(be("H2C-OVERSIZE-DST-"), n)));
-  const { outputLen: o, blockLen: i } = r, a = Math.ceil(e / o);
-  if (e > 65535 || a > 255) throw new Error("expand_message_xmd: invalid lenInBytes");
-  const f = Q(n, kt(n.length, 1)), l = new Uint8Array(i), g = kt(e, 2), s = new Array(a), u = r(Q(l, t, g, kt(0, 1), f));
-  s[0] = r(Q(u, kt(1, 1), f));
-  for (let d = 1; d < a; d++) s[d] = r(Q(oo(u, s[d - 1]), kt(d + 1, 1), f));
-  return Q(...s).slice(0, e);
-}
-function so(t, n, e, r, o) {
-  if (st(t), Ft(e), n = sr(n), n.length > 255) {
-    const i = Math.ceil(2 * r / 8);
-    n = o.create({ dkLen: i }).update(be("H2C-OVERSIZE-DST-")).update(n).digest();
-  }
-  if (e > 65535 || n.length > 255) throw new Error("expand_message_xof: invalid lenInBytes");
-  return o.create({ dkLen: e }).update(t).update(kt(e, 2)).update(n).update(kt(n.length, 1)).digest();
-}
-function He(t, n, e) {
-  Mt(e, {
-    p: "bigint",
-    m: "number",
-    k: "number",
-    hash: "function"
-  });
-  const { p: r, k: o, m: i, hash: a, expand: f, DST: l } = e;
-  if (Ft(a.outputLen, "valid hash"), st(t), Ft(n), n < 1) throw new Error("hash_to_field: expected count >= 1");
-  if (i < 1) throw new Error("hash_to_field: expected m >= 1");
-  const g = r.toString(2).length, s = Math.ceil((g + o) / 8), u = n * i * s;
-  let d;
-  if (f === "xmd") d = io(t, l, u, a);
-  else if (f === "xof") d = so(t, l, u, o, a);
-  else if (f === "_internal_pass") d = t;
-  else throw new Error('expand must be "xmd" or "xof"');
-  const h = new Array(n);
-  for (let w = 0; w < n; w++) {
-    const b = new Array(i);
-    for (let E = 0; E < i; E++) {
-      const T = s * (E + w * i);
-      b[E] = bt(ro(d.subarray(T, T + s)), r);
-    }
-    h[w] = b;
-  }
-  return h;
-}
-function co(t, n) {
-  const e = n.map((r) => Array.from(r).reverse());
-  return (r, o) => {
-    const [i, a, f, l] = e.map((u) => u.reduce((d, h) => t.add(t.mul(d, r), h))), [g, s] = Ee(t, [a, l], !0);
-    return r = t.mul(i, g), o = t.mul(o, t.mul(f, s)), {
-      x: r,
-      y: o
+      publicKey: e(o)
     };
   };
 }
-var fo = "HashToScalar-";
-function ao(t, n, e) {
-  if (typeof n != "function") throw new Error("mapToCurve() must be defined");
-  const r = (f) => Object.freeze({
-    ...f,
-    DST: oe(f.DST) ? Ze(f.DST) : f.DST,
-    ...f.encodeDST === void 0 ? {} : { encodeDST: oe(f.encodeDST) ? Ze(f.encodeDST) : f.encodeDST }
-  }), o = r(e);
-  function i(f) {
-    return t.fromAffine(n(f));
-  }
-  function a(f) {
-    const l = f.clearCofactor();
-    return l.equals(t.ZERO) ? t.ZERO : (l.assertValidity(), l);
-  }
-  return Object.freeze({
-    get defaults() {
-      return r(o);
-    },
-    Point: t,
-    hashToCurve(f, l) {
-      const g = He(f, 2, Object.assign({}, o, l)), s = i(g[0]), u = i(g[1]);
-      return a(s.add(u));
-    },
-    encodeToCurve(f, l) {
-      const g = o.encodeDST ? { DST: o.encodeDST } : {};
-      return a(i(He(f, 1, Object.assign({}, o, g, l))[0]));
-    },
-    mapToCurve(f) {
-      if (o.m === 1) {
-        if (typeof f != "bigint") throw new Error("expected bigint (m=1)");
-        return a(i([f]));
-      }
-      if (!Array.isArray(f)) throw new Error("expected array of bigints");
-      for (const l of f) if (typeof l != "bigint") throw new Error("expected array of bigints");
-      return a(i(f));
-    },
-    hashToScalar(f, l) {
-      const g = t.Fn.ORDER;
-      return He(f, 1, Object.assign({}, o, {
-        p: g,
-        m: 1,
-        DST: fo
-      }, l))[0][0];
-    }
-  });
-}
-Qt();
-var fe = (t) => {
-  if (!Number.isSafeInteger(t.min) || !Number.isSafeInteger(t.max)) throw new Error("Wrong signers info: min=" + t.min + " max=" + t.max);
-  if (t.min < 2 || t.max < 2 || t.min > t.max) throw new Error("Wrong signers info: min=" + t.min + " max=" + t.max);
-}, pn = (t, n) => {
-  if (n < t.min || n > t.max) throw new Error("Wrong number of commitments=" + n);
-}, ae = class extends Error {
-  cheaters;
-  constructor(t, n) {
-    super(t), this.cheaters = n;
-  }
-};
-function cr(t) {
-  Mt(t, {
-    name: "string",
-    hash: "function"
-  }, {
-    hashToScalar: "function",
-    validatePoint: "function",
-    parsePublicKey: "function",
-    adjustScalar: "function",
-    adjustPoint: "function",
-    challenge: "function",
-    adjustNonces: "function",
-    adjustSecret: "function",
-    adjustPublic: "function",
-    adjustGroupCommitmentShare: "function",
-    adjustDKG: "function"
-  }), Gr(t.Point);
-  const { Point: n } = t, e = t.Fn === void 0 ? n.Fn : t.Fn, r = t.hash, o = t.hashToScalar === void 0 ? (c, m = { DST: new Uint8Array() }) => {
-    const y = r(Q(m.DST, c));
-    return e.create(e.isLE ? ge(y) : St(y));
-  } : t.hashToScalar, i = Nt(t.H1 !== void 0 ? t.H1 : t.name + "rho"), a = Nt(t.H2 !== void 0 ? t.H2 : t.name + "chal"), f = Nt(t.H3 !== void 0 ? t.H3 : t.name + "nonce"), l = Nt(t.H4 !== void 0 ? t.H4 : t.name + "msg"), g = Nt(t.H5 !== void 0 ? t.H5 : t.name + "com"), s = Nt(t.HDKG !== void 0 ? t.HDKG : t.name + "dkg"), u = Nt(t.HID !== void 0 ? t.HID : t.name + "id"), d = (c) => o(c, { DST: i }), h = (c) => o(c, { DST: a }), w = (c) => o(c, { DST: f }), b = (c) => r(Q(l, c)), E = (c) => r(Q(g, c)), T = (c) => o(c, { DST: s }), B = (c) => o(c, { DST: u }), C = (c = wt) => {
-    const m = nr(c(nn(e.ORDER)), e.ORDER, e.isLE);
-    return e.isLE ? ge(m) : St(m);
-  }, O = (c) => c.toBytes(), F = (c) => {
-    const m = n.fromBytes(c);
-    return t.validatePoint && t.validatePoint(m), m;
-  }, z = (c, m) => ({
-    identifier: c,
-    hiding: O(n.BASE.multiply(e.fromBytes(m.hiding))),
-    binding: O(n.BASE.multiply(e.fromBytes(m.binding)))
-  }), W = t.adjustPoint === void 0 ? (c) => c : t.adjustPoint, N = (c) => {
-    if (!e.isValid(c) || e.is0(c)) throw new Error("Invalid identifier " + c);
-    return c;
-  }, V = (c) => Ct(e.toBytes(N(c))), K = (c) => {
-    const m = N(e.fromBytes(he(c)));
-    if (V(m) !== c) throw new Error("expected canonical identifier hex");
-    return m;
-  }, M = {
-    encode: (c, m) => {
-      let y = Q(O(c), e.toBytes(m));
-      return t.adjustTx && (y = t.adjustTx.encode(y)), y;
-    },
-    decode: (c) => (t.adjustTx && (c = t.adjustTx.decode(c)), {
-      R: F(c.subarray(0, -e.BYTES)),
-      z: e.fromBytes(c.subarray(-e.BYTES))
-    })
-  }, v = (c = wt) => {
-    let m = C(c);
-    t.adjustScalar && (m = t.adjustScalar(m));
-    let y = n.BASE.multiply(m);
-    return {
-      scalar: m,
-      point: y
-    };
-  }, H = "roots are unavailable in FROST polynomial mode", U = no(e, {
-    info: {
-      G: e.ZERO,
-      oddFactor: e.ZERO,
-      powerOfTwo: 0
-    },
-    roots() {
-      throw new Error(H);
-    },
-    brp() {
-      throw new Error(H);
-    },
-    inverse() {
-      throw new Error(H);
-    },
-    omega() {
-      throw new Error(H);
-    },
-    clear() {
-    }
-  }), S = (c, m) => Qr(n, c, m), p = (c, m) => {
-    if (!m.length) throw new Error("empty coefficients");
-    return U.monomial.eval(m, c);
-  }, R = (c, m) => {
-    const y = "invalid parameters";
-    if (!c.some((L) => e.eql(L, m))) throw new Error(y);
-    const x = new Set(c);
-    if (x.size !== c.length) throw new Error(y);
-    if (!x.has(m)) throw new Error(y);
-    let A = e.ONE, j = e.ONE;
-    for (const L of c)
-      e.eql(L, m) || (A = e.mul(A, L), j = e.mul(j, e.sub(L, m)));
-    return e.div(A, j);
-  }, I = (c, m) => S(m, U.monomial.basis(c, m.length)), _ = (c, m, y, x = wt) => {
-    fe(c);
-    const A = m === void 0 ? C(x) : e.fromBytes(m);
-    if (!y) {
-      y = [];
-      for (let L = 0; L < c.min - 1; L++) y.push(C(x));
-    }
-    if (y.length !== c.min - 1) throw new Error("wrong coefficients length");
-    const j = [A, ...y];
-    return {
-      coefficients: j,
-      commitment: j.map((L) => n.BASE.multiply(L)),
-      secret: A
-    };
-  }, D = {
-    challenge: (c, m, y) => T(Q(e.toBytes(c), O(m), O(y))),
-    compute(c, m, y, x = wt) {
-      if (m.length < 1) throw new Error("coefficients should have at least one element");
-      const { point: A, scalar: j } = v(x), L = y[0], P = this.challenge(c, L, A), k = e.add(j, e.mul(m[0], P));
-      return M.encode(A, k);
-    },
-    validate(c, m, y) {
-      if (m.length < 1) throw new Error("commitment should have at least one element");
-      const { R: x, z: A } = M.decode(y), j = F(m[0]), L = this.challenge(c, j, x);
-      if (!x.equals(n.BASE.multiply(A).subtract(j.multiply(L)))) throw new Error("invalid proof of knowledge");
-    }
-  }, q = {
-    challenge: (c, m, y) => t.challenge ? t.challenge(c, m, y) : h(Q(O(c), O(m), y)),
-    sign(c, m, y = wt) {
-      const { point: x, scalar: A } = v(y), j = n.BASE.multiply(m), L = this.challenge(x, j, c);
-      return [x, e.add(A, e.mul(L, m))];
-    },
-    verify(c, m, y, x) {
-      t.adjustPoint && (x = t.adjustPoint(x)), t.adjustPoint && (m = t.adjustPoint(m));
-      const A = this.challenge(m, x, c), j = n.BASE.multiply(y), L = x.multiply(A);
-      let P = j.subtract(L).subtract(m);
-      return P.clearCofactor && (P = P.clearCofactor()), n.ZERO.equals(P);
-    }
-  }, X = (c, m, y) => {
-    if (!n.BASE.multiply(y).equals(I(c, m))) throw new Error("invalid secret share");
-  }, Y = {
-    fromNumber(c) {
-      if (!Number.isSafeInteger(c)) throw new Error("expected safe interger");
-      return V(BigInt(c));
-    },
-    derive(c) {
-      if (typeof c != "string") throw new Error("wrong identifier string: " + c);
-      return V(B(Nt(c)));
-    }
-  }, Z = (c, m = wt) => w(Q(m(32), e.toBytes(c))), nt = (c, m, y) => {
-    const x = m.map((tt) => [
-      tt.identifier,
-      K(tt.identifier),
-      F(tt.hiding),
-      F(tt.binding)
-    ]);
-    x.sort((tt, ht) => tt[1] < ht[1] ? -1 : tt[1] > ht[1] ? 1 : 0);
-    const A = [];
-    for (const [tt, ht, $, et] of x) A.push(e.toBytes(ht), O($), O(et));
-    const j = E(Q(...A)), L = Q(O(c), b(y), j), P = {};
-    for (const [tt, ht] of x) P[tt] = d(Q(L, e.toBytes(ht)));
-    const k = [], G = [];
-    for (const [tt, ht, $, et] of x) {
-      if (n.ZERO.equals($) || n.ZERO.equals(et)) throw new Error("infinity commitment");
-      k.push($, et), G.push(e.ONE, P[tt]);
-    }
-    const mt = S(k, G);
-    return {
-      identifiers: x.map((tt) => tt[1]),
-      groupCommitment: mt,
-      bindingFactors: P
-    };
-  }, rt = (c, m, y, x) => {
-    const A = W(F(c)), j = K(x), { identifiers: L, groupCommitment: P, bindingFactors: k } = nt(A, m, y), G = k[x];
-    return {
-      lambda: R(L, j),
-      challenge: q.challenge(P, A, y),
-      bindingFactor: G,
-      groupCommitment: P
-    };
-  };
-  Object.freeze(Y);
-  const it = {
-    Identifier: Y,
-    DKG: Object.freeze({
-      round1: (c, m, y, x = wt) => {
-        fe(m);
-        const A = K(c), { coefficients: j, commitment: L } = _(m, y, void 0, x), P = D.compute(A, j, L, x), k = L.map(O);
-        return {
-          public: {
-            identifier: V(A),
-            commitment: k,
-            proofOfKnowledge: P
-          },
-          secret: {
-            identifier: A,
-            coefficients: j,
-            commitment: L.map(O),
-            signers: {
-              min: m.min,
-              max: m.max
-            },
-            step: 1
-          }
-        };
-      },
-      round2: (c, m) => {
-        if (m.length !== c.signers.max - 1) throw new Error("wrong number of round1 packages");
-        if (!c.coefficients || c.step === 3) throw new Error("round3 package used in round2");
-        const y = {};
-        for (const x of m) {
-          if (x.commitment.length !== c.signers.min) throw new Error("wrong number of commitments");
-          const A = K(x.identifier);
-          if (A === c.identifier) throw new Error("duplicate id=" + V(A));
-          D.validate(A, x.commitment, x.proofOfKnowledge);
-          for (const L of x.commitment) F(L);
-          if (y[x.identifier]) throw new Error("Duplicate id=" + A);
-          const j = e.toBytes(p(A, c.coefficients));
-          y[x.identifier] = {
-            identifier: V(c.identifier),
-            signingShare: j
-          };
-        }
-        return c.step = 2, y;
-      },
-      round3: (c, m, y) => {
-        if (m.length !== c.signers.max - 1) throw new Error("wrong length of round1 packages");
-        if (!c.coefficients || c.step !== 2) throw new Error("round2 package used in round3");
-        if (y.length !== m.length) throw new Error("wrong length of round2 packages");
-        const x = {};
-        for (const $ of m) {
-          if (!$.identifier || !$.commitment) throw new Error("wrong round1 share");
-          x[$.identifier] = { ...$ };
-        }
-        for (const $ of y) {
-          if (!$.identifier || !$.signingShare) throw new Error("wrong round2 share");
-          if (!x[$.identifier]) throw new Error("round1 share for " + $.identifier + " is missing");
-          x[$.identifier].signingShare = $.signingShare;
-        }
-        if (Object.keys(x).length !== m.length) throw new Error("mismatch identifiers between rounds");
-        let A = e.ZERO;
-        if (c.commitment.length !== c.signers.min) throw new Error("wrong commitments length");
-        const j = c.commitment.map(F), L = p(c.identifier, c.coefficients);
-        X(c.identifier, j, L);
-        const P = j.map(O), k = { [V(c.identifier)]: P };
-        for (const $ in x) {
-          const et = x[$];
-          if (!et.signingShare || !et.commitment) throw new Error("mismatch identifiers");
-          const pt = K($), Gt = e.fromBytes(et.signingShare), xe = et.commitment.map(F);
-          X(c.identifier, xe, Gt), A = e.add(A, Gt);
-          const Jt = V(pt);
-          if (k[Jt]) throw new Error("duplicated id=" + Jt);
-          k[Jt] = et.commitment;
-        }
-        A = e.add(A, L);
-        const G = new Array(c.signers.min).fill(n.ZERO);
-        for (const $ in k) {
-          const et = k[$];
-          if (et.length !== c.signers.min) throw new Error("wrong commitments length");
-          for (let pt = 0; pt < et.length; pt++) G[pt] = G[pt].add(F(et[pt]));
-        }
-        const mt = G.map(O), tt = {};
-        for (const $ in k) tt[$] = O(I(K($), G));
-        let ht = {
-          public: {
-            signers: {
-              min: c.signers.min,
-              max: c.signers.max
-            },
-            commitments: mt,
-            verifyingShares: Object.fromEntries(Object.entries(tt).map(([$, et]) => [$, et.slice()]))
-          },
-          secret: {
-            identifier: V(c.identifier),
-            signingShare: e.toBytes(A)
-          }
-        };
-        t.adjustDKG && (ht = t.adjustDKG(ht));
-        for (let $ = 0; $ < c.coefficients.length; $++) c.coefficients[$] -= c.coefficients[$];
-        return delete c.coefficients, c.step = 3, ht;
-      },
-      clean(c) {
-        if (c.identifier -= c.identifier, c.coefficients) for (let m = 0; m < c.coefficients.length; m++) c.coefficients[m] -= c.coefficients[m];
-        c.step = 3;
-      }
-    }),
-    trustedDealer(c, m, y, x = wt) {
-      if (fe(c), m === void 0) {
-        m = [];
-        for (let G = 1; G <= c.max; G++) m.push(Y.fromNumber(G));
-      } else if (!Array.isArray(m) || m.length !== c.max) throw new Error("identifiers should be array of " + c.max);
-      const A = {};
-      for (const G of m) {
-        const mt = K(G);
-        if (G in A) throw new Error("duplicated id=" + G);
-        A[G] = mt;
-      }
-      const j = _(c, y, void 0, x), L = j.commitment.map(O), P = {}, k = {};
-      for (const G of m) {
-        const mt = p(A[G], j.coefficients);
-        k[G] = O(n.BASE.multiply(mt)), P[G] = {
-          identifier: G,
-          signingShare: e.toBytes(mt)
-        };
-      }
-      return {
-        public: {
-          signers: {
-            min: c.min,
-            max: c.max
-          },
-          commitments: L,
-          verifyingShares: k
-        },
-        secretShares: P
-      };
-    },
-    validateSecret(c, m) {
-      X(K(c.identifier), m.commitments.map(F), e.fromBytes(c.signingShare));
-    },
-    commit(c, m = wt) {
-      const y = e.fromBytes(c.signingShare), x = Z(y, m), A = Z(y, m), j = {
-        hiding: e.toBytes(x),
-        binding: e.toBytes(A)
-      };
-      return {
-        nonces: j,
-        commitments: z(c.identifier, j)
-      };
-    },
-    signShare(c, m, y, x, A) {
-      pn(m.signers, x.length);
-      const j = e.fromBytes(y.hiding), L = e.fromBytes(y.binding);
-      if (e.is0(j) || e.is0(L)) throw new Error("signing nonces already used");
-      const P = {
-        identifier: c.identifier,
-        hiding: O(n.BASE.multiply(j)),
-        binding: O(n.BASE.multiply(L))
-      }, k = x.find((wr) => wr.identifier === c.identifier);
-      if (!k) throw new Error("missing signer commitment");
-      if (Ct(k.hiding) !== Ct(P.hiding) || Ct(k.binding) !== Ct(P.binding)) throw new Error("incorrect signer commitment");
-      t.adjustSecret && (c = t.adjustSecret(c, m)), t.adjustPublic && (m = t.adjustPublic(m));
-      const G = e.fromBytes(c.signingShare), { lambda: mt, challenge: tt, bindingFactor: ht, groupCommitment: $ } = rt(m.commitments[0], x, A, c.identifier), et = t.adjustNonces ? t.adjustNonces($, y) : y, pt = t.adjustNonces ? e.fromBytes(et.hiding) : j, Gt = t.adjustNonces ? e.fromBytes(et.binding) : L, xe = e.mul(e.mul(mt, G), tt), Jt = e.mul(Gt, ht), gr = e.toBytes(e.add(e.add(pt, Jt), xe));
-      return y.hiding.fill(0), y.binding.fill(0), gr;
-    },
-    verifyShare(c, m, y, x, A) {
-      t.adjustPublic && (c = t.adjustPublic(c));
-      const j = m.find((Gt) => Gt.identifier === x);
-      if (!j) throw new Error("cannot find identifier commitment");
-      const L = F(c.verifyingShares[x]), P = F(j.hiding), k = F(j.binding), { lambda: G, challenge: mt, bindingFactor: tt, groupCommitment: ht } = rt(c.commitments[0], m, y, x);
-      let $ = P.add(k.multiply(tt));
-      t.adjustGroupCommitmentShare && ($ = t.adjustGroupCommitmentShare(ht, $));
-      const et = n.BASE.multiply(e.fromBytes(A)), pt = $.add(L.multiply(e.mul(mt, G)));
-      return et.equals(pt);
-    },
-    aggregate(c, m, y, x) {
-      t.adjustPublic && (c = t.adjustPublic(c));
-      try {
-        pn(c.signers, m.length);
-      } catch {
-        throw new ae("aggregation failed", []);
-      }
-      const A = m.map((k) => k.identifier);
-      if (A.length !== Object.keys(x).length) throw new ae("aggregation failed", []);
-      for (const k of A) if (!(k in x) || !(k in c.verifyingShares)) throw new ae("aggregation failed", []);
-      const j = F(c.commitments[0]), { groupCommitment: L } = nt(j, m, y);
-      let P = e.ZERO;
-      for (const k of A) P = e.add(P, e.fromBytes(x[k]));
-      if (!q.verify(y, L, P, j)) {
-        const k = [];
-        for (const G of A) this.verifyShare(c, m, y, G, x[G]) || k.push(G);
-        throw new ae("aggregation failed", k);
-      }
-      return M.encode(L, P);
-    },
-    sign(c, m) {
-      let y = e.fromBytes(m);
-      t.adjustScalar && (y = t.adjustScalar(y));
-      const [x, A] = q.sign(c, y);
-      return M.encode(x, A);
-    },
-    verify(c, m, y) {
-      const x = t.parsePublicKey ? t.parsePublicKey(y) : F(y), { R: A, z: j } = M.decode(c);
-      return q.verify(m, A, j, x);
-    },
-    combineSecret(c, m) {
-      if (fe(m), !Array.isArray(c) || c.length < m.min) throw new Error("wrong secret shares array");
-      const y = [], x = {};
-      for (const L of c) {
-        const P = K(L.identifier), k = V(P);
-        if (x[k]) throw new Error("duplicated id=" + k);
-        x[k] = !0, y.push([P, e.fromBytes(L.signingShare)]);
-      }
-      const A = y.map(([L]) => L);
-      let j = e.ZERO;
-      for (const [L, P] of y) j = e.add(j, e.mul(P, R(A, L)));
-      return e.toBytes(j);
-    },
-    utils: Object.freeze({
-      Fn: e,
-      randomScalar: (c = wt) => e.toBytes(v(c).scalar),
-      generateSecretPolynomial: (c, m, y, x) => {
-        const A = _(c, m, y, x);
-        return {
-          ...A,
-          commitment: A.commitment.map(O)
-        };
-      }
-    })
-  };
-  return Object.freeze(it);
-}
-Er();
-Qt();
-var En = (t, n) => (t + (t >= 0 ? n : -n) / Bt) / n;
-function lo(t, n, e) {
-  Mn("scalar", t, yt, e);
-  const [[r, o], [i, a]] = n, f = En(a * t, e), l = En(-o * t, e);
-  let g = t - f * r - l * i, s = -f * o - l * a;
-  const u = g < yt, d = s < yt;
-  u && (g = -g), d && (s = -s);
-  const h = pe(Math.ceil(ye(e) / 2)) + ct;
-  if (g < yt || g >= h || s < yt || s >= h) throw new Error("splitScalar (endomorphism): failed for k");
+Ln();
+It();
+var De = (t, e) => (t + (t >= 0 ? e : -e) / _n) / e;
+function lr(t, e, r) {
+  dn("scalar", t, ot, r);
+  const [[n, o], [i, c]] = e, s = De(c * t, r), a = De(-o * t, r);
+  let u = t - s * n - a * i, f = -s * o - a * c;
+  const g = u < ot, m = f < ot;
+  g && (u = -u), m && (f = -f);
+  const w = Ee(Math.ceil(ye(r) / 2)) + ht;
+  if (u < ot || u >= w || f < ot || f >= w) throw new Error("splitScalar (endomorphism): failed for k");
   return {
-    k1neg: u,
-    k1: g,
-    k2neg: d,
-    k2: s
+    k1neg: g,
+    k1: u,
+    k2neg: m,
+    k2: f
   };
 }
-function ze(t) {
+function ae(t) {
   if (![
     "compact",
     "recovered",
@@ -2144,96 +1391,96 @@ function ze(t) {
   ].includes(t)) throw new Error('Signature format must be "compact", "recovered", or "der"');
   return t;
 }
-function Te(t, n) {
-  Mt(t);
-  const e = {};
-  for (let r of Object.keys(n)) e[r] = t[r] === void 0 ? n[r] : t[r];
-  return ie(e.lowS, "lowS"), ie(e.prehash, "prehash"), e.format !== void 0 && ze(e.format), e;
+function Xt(t, e) {
+  kt(t);
+  const r = {};
+  for (let n of Object.keys(e)) r[n] = t[n] === void 0 ? e[n] : t[n];
+  return Ot(r.lowS, "lowS"), Ot(r.prehash, "prehash"), r.format !== void 0 && ae(r.format), r;
 }
-var uo = class extends Error {
+var hr = class extends Error {
   constructor(t = "") {
     super(t);
   }
-}, Et = {
-  Err: uo,
+}, et = {
+  Err: hr,
   _tlv: {
-    encode: (t, n) => {
-      const { Err: e } = Et;
-      if (Ft(t, "tag"), t < 0 || t > 255) throw new e("tlv.encode: wrong tag");
-      if (typeof n != "string") throw new TypeError('"data" expected string, got type=' + typeof n);
-      if (n.length & 1) throw new e("tlv.encode: unpadded data");
-      const r = n.length / 2, o = ce(r);
-      if (o.length / 2 & 128) throw new e("tlv.encode: long form length too big");
-      const i = r > 127 ? ce(o.length / 2 | 128) : "";
-      return ce(t) + i + o + n;
+    encode: (t, e) => {
+      const { Err: r } = et;
+      if (fe(t, "tag"), t < 0 || t > 255) throw new r("tlv.encode: wrong tag");
+      if (typeof e != "string") throw new TypeError('"data" expected string, got type=' + typeof e);
+      if (e.length & 1) throw new r("tlv.encode: unpadded data");
+      const n = e.length / 2, o = Nt(n);
+      if (o.length / 2 & 128) throw new r("tlv.encode: long form length too big");
+      const i = n > 127 ? Nt(o.length / 2 | 128) : "";
+      return Nt(t) + i + o + e;
     },
-    decode(t, n) {
-      const { Err: e } = Et;
-      n = st(n, void 0, "DER data");
-      let r = 0;
-      if (t < 0 || t > 255) throw new e("tlv.encode: wrong tag");
-      if (n.length < 2 || n[r++] !== t) throw new e("tlv.decode: wrong tlv");
-      const o = n[r++], i = !!(o & 128);
-      let a = 0;
-      if (!i) a = o;
+    decode(t, e) {
+      const { Err: r } = et;
+      e = W(e, void 0, "DER data");
+      let n = 0;
+      if (t < 0 || t > 255) throw new r("tlv.encode: wrong tag");
+      if (e.length < 2 || e[n++] !== t) throw new r("tlv.decode: wrong tlv");
+      const o = e[n++], i = !!(o & 128);
+      let c = 0;
+      if (!i) c = o;
       else {
-        const l = o & 127;
-        if (!l) throw new e("tlv.decode(long): indefinite length not supported");
-        if (l > 4) throw new e("tlv.decode(long): byte length is too big");
-        const g = n.subarray(r, r + l);
-        if (g.length !== l) throw new e("tlv.decode: length bytes not complete");
-        if (g[0] === 0) throw new e("tlv.decode(long): zero leftmost byte");
-        for (const s of g) a = a << 8 | s;
-        if (r += l, a < 128) throw new e("tlv.decode(long): not minimal encoding");
+        const a = o & 127;
+        if (!a) throw new r("tlv.decode(long): indefinite length not supported");
+        if (a > 4) throw new r("tlv.decode(long): byte length is too big");
+        const u = e.subarray(n, n + a);
+        if (u.length !== a) throw new r("tlv.decode: length bytes not complete");
+        if (u[0] === 0) throw new r("tlv.decode(long): zero leftmost byte");
+        for (const f of u) c = c << 8 | f;
+        if (n += a, c < 128) throw new r("tlv.decode(long): not minimal encoding");
       }
-      const f = n.subarray(r, r + a);
-      if (f.length !== a) throw new e("tlv.decode: wrong value length");
+      const s = e.subarray(n, n + c);
+      if (s.length !== c) throw new r("tlv.decode: wrong value length");
       return {
-        v: f,
-        l: n.subarray(r + a)
+        v: s,
+        l: e.subarray(n + c)
       };
     }
   },
   _int: {
     encode(t) {
-      const { Err: n } = Et;
-      if (Je(t), t < yt) throw new n("integer: negative integers are not allowed");
-      let e = ce(t);
-      if (Number.parseInt(e[0], 16) & 8 && (e = "00" + e), e.length & 1) throw new n("unexpected DER parsing assertion: unpadded hex");
-      return e;
+      const { Err: e } = et;
+      if (we(t), t < ot) throw new e("integer: negative integers are not allowed");
+      let r = Nt(t);
+      if (Number.parseInt(r[0], 16) & 8 && (r = "00" + r), r.length & 1) throw new e("unexpected DER parsing assertion: unpadded hex");
+      return r;
     },
     decode(t) {
-      const { Err: n } = Et;
-      if (t.length < 1) throw new n("invalid signature integer: empty");
-      if (t[0] & 128) throw new n("invalid signature integer: negative");
-      if (t.length > 1 && t[0] === 0 && !(t[1] & 128)) throw new n("invalid signature integer: unnecessary leading zero");
-      return St(t);
+      const { Err: e } = et;
+      if (t.length < 1) throw new e("invalid signature integer: empty");
+      if (t[0] & 128) throw new e("invalid signature integer: negative");
+      if (t.length > 1 && t[0] === 0 && !(t[1] & 128)) throw new e("invalid signature integer: unnecessary leading zero");
+      return Ct(t);
     }
   },
   toSig(t) {
-    const { Err: n, _int: e, _tlv: r } = Et, o = st(t, void 0, "signature"), { v: i, l: a } = r.decode(48, o);
-    if (a.length) throw new n("invalid signature: left bytes after parsing");
-    const { v: f, l } = r.decode(2, i), { v: g, l: s } = r.decode(2, l);
-    if (s.length) throw new n("invalid signature: left bytes after parsing");
+    const { Err: e, _int: r, _tlv: n } = et, o = W(t, void 0, "signature"), { v: i, l: c } = n.decode(48, o);
+    if (c.length) throw new e("invalid signature: left bytes after parsing");
+    const { v: s, l: a } = n.decode(2, i), { v: u, l: f } = n.decode(2, a);
+    if (f.length) throw new e("invalid signature: left bytes after parsing");
     return {
-      r: e.decode(f),
-      s: e.decode(g)
+      r: r.decode(s),
+      s: r.decode(u)
     };
   },
   hexFromSig(t) {
-    const { _tlv: n, _int: e } = Et, r = n.encode(2, e.encode(t.r)) + n.encode(2, e.encode(t.s));
-    return n.encode(48, r);
+    const { _tlv: e, _int: r } = et, n = e.encode(2, r.encode(t.r)) + e.encode(2, r.encode(t.s));
+    return e.encode(48, n);
   }
 };
-Object.freeze(Et._tlv);
-Object.freeze(Et._int);
-Object.freeze(Et);
-var yt = /* @__PURE__ */ BigInt(0), ct = /* @__PURE__ */ BigInt(1), Bt = /* @__PURE__ */ BigInt(2), Xt = /* @__PURE__ */ BigInt(3), Me = /* @__PURE__ */ BigInt(4);
-function ho(t, n = {}) {
-  const e = Jr("weierstrass", t, n), r = e.Fp, o = e.Fn;
-  let i = e.CURVE;
-  const { h: a, n: f } = i;
-  Mt(n, {}, {
+Object.freeze(et._tlv);
+Object.freeze(et._int);
+Object.freeze(et);
+var ot = /* @__PURE__ */ BigInt(0), ht = /* @__PURE__ */ BigInt(1), _n = /* @__PURE__ */ BigInt(2), Tt = /* @__PURE__ */ BigInt(3), dr = /* @__PURE__ */ BigInt(4);
+function gr(t, e = {}) {
+  const r = ar("weierstrass", t, e), n = r.Fp, o = r.Fn;
+  let i = r.CURVE;
+  const { h: c, n: s } = i;
+  kt(e, {}, {
     allowInfinityPoint: "boolean",
     clearCofactor: "function",
     isTorsionFree: "function",
@@ -2241,103 +1488,103 @@ function ho(t, n = {}) {
     toBytes: "function",
     endo: "object"
   });
-  const { endo: l, allowInfinityPoint: g } = n;
-  if (l && (!r.is0(i.a) || typeof l.beta != "bigint" || !Array.isArray(l.basises)))
+  const { endo: a, allowInfinityPoint: u } = e;
+  if (a && (!n.is0(i.a) || typeof a.beta != "bigint" || !Array.isArray(a.basises)))
     throw new Error('invalid endo: expected "beta": bigint and "basises": array');
-  const s = ar(r, o);
-  function u() {
-    if (!r.isOdd) throw new Error("compression is not supported: Field does not have .isOdd()");
-  }
-  function d(M, v, H) {
-    if (g && v.is0()) return Uint8Array.of(0);
-    const { x: U, y: S } = v.toAffine(), p = r.toBytes(U);
-    return ie(H, "isCompressed"), H ? (u(), Q(fr(!r.isOdd(S)), p)) : Q(Uint8Array.of(4), p, r.toBytes(S));
-  }
-  function h(M) {
-    st(M, void 0, "Point");
-    const { publicKey: v, publicKeyUncompressed: H } = s, U = M.length, S = M[0], p = M.subarray(1);
-    if (g && U === 1 && S === 0) return {
-      x: r.ZERO,
-      y: r.ZERO
+  const f = On(n, o);
+  function g() {
+    if (!n.isOdd) throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function m(F, h, y) {
+    if (u && h.is0()) return Uint8Array.of(0);
+    const { x: B, y: d } = h.toAffine(), l = n.toBytes(B);
+    return Ot(y, "isCompressed"), y ? (g(), lt(Hn(!n.isOdd(d)), l)) : lt(Uint8Array.of(4), l, n.toBytes(d));
+  }
+  function w(F) {
+    W(F, void 0, "Point");
+    const { publicKey: h, publicKeyUncompressed: y } = f, B = F.length, d = F[0], l = F.subarray(1);
+    if (u && B === 1 && d === 0) return {
+      x: n.ZERO,
+      y: n.ZERO
     };
-    if (U === v && (S === 2 || S === 3)) {
-      const R = r.fromBytes(p);
-      if (!r.isValid(R)) throw new Error("bad point: is not on curve, wrong x");
-      const I = E(R);
-      let _;
+    if (B === h && (d === 2 || d === 3)) {
+      const b = n.fromBytes(l);
+      if (!n.isValid(b)) throw new Error("bad point: is not on curve, wrong x");
+      const E = H(b);
+      let p;
       try {
-        _ = r.sqrt(I);
-      } catch (q) {
-        const X = q instanceof Error ? ": " + q.message : "";
-        throw new Error("bad point: is not on curve, sqrt error" + X);
+        p = n.sqrt(E);
+      } catch (S) {
+        const N = S instanceof Error ? ": " + S.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + N);
       }
-      u();
-      const D = r.isOdd(_);
-      return (S & 1) === 1 !== D && (_ = r.neg(_)), {
-        x: R,
-        y: _
+      g();
+      const v = n.isOdd(p);
+      return (d & 1) === 1 !== v && (p = n.neg(p)), {
+        x: b,
+        y: p
       };
-    } else if (U === H && S === 4) {
-      const R = r.BYTES, I = r.fromBytes(p.subarray(0, R)), _ = r.fromBytes(p.subarray(R, R * 2));
-      if (!T(I, _)) throw new Error("bad point: is not on curve");
+    } else if (B === y && d === 4) {
+      const b = n.BYTES, E = n.fromBytes(l.subarray(0, b)), p = n.fromBytes(l.subarray(b, b * 2));
+      if (!O(E, p)) throw new Error("bad point: is not on curve");
       return {
-        x: I,
-        y: _
+        x: E,
+        y: p
       };
-    } else throw new Error(`bad point: got length ${U}, expected compressed=${v} or uncompressed=${H}`);
-  }
-  const w = n.toBytes === void 0 ? d : n.toBytes, b = n.fromBytes === void 0 ? h : n.fromBytes;
-  function E(M) {
-    const v = r.sqr(M), H = r.mul(v, M);
-    return r.add(r.add(H, r.mul(M, i.a)), i.b);
-  }
-  function T(M, v) {
-    const H = r.sqr(v), U = E(M);
-    return r.eql(H, U);
-  }
-  if (!T(i.Gx, i.Gy)) throw new Error("bad curve params: generator point");
-  const B = r.mul(r.pow(i.a, Xt), Me), C = r.mul(r.sqr(i.b), BigInt(27));
-  if (r.is0(r.add(B, C))) throw new Error("bad curve params: a or b");
-  function O(M, v, H = !1) {
-    if (!r.isValid(v) || H && r.is0(v)) throw new Error(`bad point coordinate ${M}`);
-    return v;
-  }
-  function F(M) {
-    if (!(M instanceof N)) throw new Error("Weierstrass Point expected");
-  }
-  function z(M) {
-    if (!l || !l.basises) throw new Error("no endo");
-    return lo(M, l.basises, o.ORDER);
-  }
-  function W(M, v, H, U, S) {
-    return H = new N(r.mul(H.X, M), H.Y, H.Z), v = we(U, v), H = we(S, H), v.add(H);
-  }
-  class N {
-    static BASE = new N(i.Gx, i.Gy, r.ONE);
-    static ZERO = new N(r.ZERO, r.ONE, r.ZERO);
-    static Fp = r;
+    } else throw new Error(`bad point: got length ${B}, expected compressed=${h} or uncompressed=${y}`);
+  }
+  const A = e.toBytes === void 0 ? m : e.toBytes, _ = e.fromBytes === void 0 ? w : e.fromBytes;
+  function H(F) {
+    const h = n.sqr(F), y = n.mul(h, F);
+    return n.add(n.add(y, n.mul(F, i.a)), i.b);
+  }
+  function O(F, h) {
+    const y = n.sqr(h), B = H(F);
+    return n.eql(y, B);
+  }
+  if (!O(i.Gx, i.Gy)) throw new Error("bad curve params: generator point");
+  const x = n.mul(n.pow(i.a, Tt), dr), q = n.mul(n.sqr(i.b), BigInt(27));
+  if (n.is0(n.add(x, q))) throw new Error("bad curve params: a or b");
+  function Z(F, h, y = !1) {
+    if (!n.isValid(h) || y && n.is0(h)) throw new Error(`bad point coordinate ${F}`);
+    return h;
+  }
+  function T(F) {
+    if (!(F instanceof R)) throw new Error("Weierstrass Point expected");
+  }
+  function Q(F) {
+    if (!a || !a.basises) throw new Error("no endo");
+    return lr(F, a.basises, o.ORDER);
+  }
+  function $(F, h, y, B, d) {
+    return y = new R(n.mul(y.X, F), y.Y, y.Z), h = Zt(B, h), y = Zt(d, y), h.add(y);
+  }
+  class R {
+    static BASE = new R(i.Gx, i.Gy, n.ONE);
+    static ZERO = new R(n.ZERO, n.ONE, n.ZERO);
+    static Fp = n;
     static Fn = o;
     X;
     Y;
     Z;
-    constructor(v, H, U) {
-      this.X = O("x", v), this.Y = O("y", H, !0), this.Z = O("z", U), Object.freeze(this);
+    constructor(h, y, B) {
+      this.X = Z("x", h), this.Y = Z("y", y, !0), this.Z = Z("z", B), Object.freeze(this);
     }
     static CURVE() {
       return i;
     }
-    static fromAffine(v) {
-      const { x: H, y: U } = v || {};
-      if (!v || !r.isValid(H) || !r.isValid(U)) throw new Error("invalid affine point");
-      if (v instanceof N) throw new Error("projective point not allowed");
-      return r.is0(H) && r.is0(U) ? N.ZERO : new N(H, U, r.ONE);
+    static fromAffine(h) {
+      const { x: y, y: B } = h || {};
+      if (!h || !n.isValid(y) || !n.isValid(B)) throw new Error("invalid affine point");
+      if (h instanceof R) throw new Error("projective point not allowed");
+      return n.is0(y) && n.is0(B) ? R.ZERO : new R(y, B, n.ONE);
     }
-    static fromBytes(v) {
-      const H = N.fromAffine(b(st(v, void 0, "point")));
-      return H.assertValidity(), H;
+    static fromBytes(h) {
+      const y = R.fromAffine(_(W(h, void 0, "point")));
+      return y.assertValidity(), y;
     }
-    static fromHex(v) {
-      return N.fromBytes(he(v));
+    static fromHex(h) {
+      return R.fromBytes(se(h));
     }
     get x() {
       return this.toAffine().x;
@@ -2345,420 +1592,354 @@ function ho(t, n = {}) {
     get y() {
       return this.toAffine().y;
     }
-    precompute(v = 8, H = !0) {
-      return K.createCache(this, v), H || this.multiply(Xt), this;
+    precompute(h = 8, y = !0) {
+      return X.createCache(this, h), y || this.multiply(Tt), this;
     }
     assertValidity() {
-      const v = this;
-      if (v.is0()) {
-        if (n.allowInfinityPoint && r.is0(v.X) && r.eql(v.Y, r.ONE) && r.is0(v.Z)) return;
+      const h = this;
+      if (h.is0()) {
+        if (e.allowInfinityPoint && n.is0(h.X) && n.eql(h.Y, n.ONE) && n.is0(h.Z)) return;
         throw new Error("bad point: ZERO");
       }
-      const { x: H, y: U } = v.toAffine();
-      if (!r.isValid(H) || !r.isValid(U)) throw new Error("bad point: x or y not field elements");
-      if (!T(H, U)) throw new Error("bad point: equation left != right");
-      if (!v.isTorsionFree()) throw new Error("bad point: not in prime-order subgroup");
+      const { x: y, y: B } = h.toAffine();
+      if (!n.isValid(y) || !n.isValid(B)) throw new Error("bad point: x or y not field elements");
+      if (!O(y, B)) throw new Error("bad point: equation left != right");
+      if (!h.isTorsionFree()) throw new Error("bad point: not in prime-order subgroup");
     }
     hasEvenY() {
-      const { y: v } = this.toAffine();
-      if (!r.isOdd) throw new Error("Field doesn't support isOdd");
-      return !r.isOdd(v);
+      const { y: h } = this.toAffine();
+      if (!n.isOdd) throw new Error("Field doesn't support isOdd");
+      return !n.isOdd(h);
     }
-    equals(v) {
-      F(v);
-      const { X: H, Y: U, Z: S } = this, { X: p, Y: R, Z: I } = v, _ = r.eql(r.mul(H, I), r.mul(p, S)), D = r.eql(r.mul(U, I), r.mul(R, S));
-      return _ && D;
+    equals(h) {
+      T(h);
+      const { X: y, Y: B, Z: d } = this, { X: l, Y: b, Z: E } = h, p = n.eql(n.mul(y, E), n.mul(l, d)), v = n.eql(n.mul(B, E), n.mul(b, d));
+      return p && v;
     }
     negate() {
-      return new N(this.X, r.neg(this.Y), this.Z);
+      return new R(this.X, n.neg(this.Y), this.Z);
     }
     double() {
-      const { a: v, b: H } = i, U = r.mul(H, Xt), { X: S, Y: p, Z: R } = this;
-      let I = r.ZERO, _ = r.ZERO, D = r.ZERO, q = r.mul(S, S), X = r.mul(p, p), Y = r.mul(R, R), Z = r.mul(S, p);
-      return Z = r.add(Z, Z), D = r.mul(S, R), D = r.add(D, D), I = r.mul(v, D), _ = r.mul(U, Y), _ = r.add(I, _), I = r.sub(X, _), _ = r.add(X, _), _ = r.mul(I, _), I = r.mul(Z, I), D = r.mul(U, D), Y = r.mul(v, Y), Z = r.sub(q, Y), Z = r.mul(v, Z), Z = r.add(Z, D), D = r.add(q, q), q = r.add(D, q), q = r.add(q, Y), q = r.mul(q, Z), _ = r.add(_, q), Y = r.mul(p, R), Y = r.add(Y, Y), q = r.mul(Y, Z), I = r.sub(I, q), D = r.mul(Y, X), D = r.add(D, D), D = r.add(D, D), new N(I, _, D);
-    }
-    add(v) {
-      F(v);
-      const { X: H, Y: U, Z: S } = this, { X: p, Y: R, Z: I } = v;
-      let _ = r.ZERO, D = r.ZERO, q = r.ZERO;
-      const X = i.a, Y = r.mul(i.b, Xt);
-      let Z = r.mul(H, p), nt = r.mul(U, R), rt = r.mul(S, I), it = r.add(H, U), c = r.add(p, R);
-      it = r.mul(it, c), c = r.add(Z, nt), it = r.sub(it, c), c = r.add(H, S);
-      let m = r.add(p, I);
-      return c = r.mul(c, m), m = r.add(Z, rt), c = r.sub(c, m), m = r.add(U, S), _ = r.add(R, I), m = r.mul(m, _), _ = r.add(nt, rt), m = r.sub(m, _), q = r.mul(X, c), _ = r.mul(Y, rt), q = r.add(_, q), _ = r.sub(nt, q), q = r.add(nt, q), D = r.mul(_, q), nt = r.add(Z, Z), nt = r.add(nt, Z), rt = r.mul(X, rt), c = r.mul(Y, c), nt = r.add(nt, rt), rt = r.sub(Z, rt), rt = r.mul(X, rt), c = r.add(c, rt), Z = r.mul(nt, c), D = r.add(D, Z), Z = r.mul(m, c), _ = r.mul(it, _), _ = r.sub(_, Z), Z = r.mul(it, nt), q = r.mul(m, q), q = r.add(q, Z), new N(_, D, q);
-    }
-    subtract(v) {
-      return F(v), this.add(v.negate());
+      const { a: h, b: y } = i, B = n.mul(y, Tt), { X: d, Y: l, Z: b } = this;
+      let E = n.ZERO, p = n.ZERO, v = n.ZERO, S = n.mul(d, d), N = n.mul(l, l), L = n.mul(b, b), I = n.mul(d, l);
+      return I = n.add(I, I), v = n.mul(d, b), v = n.add(v, v), E = n.mul(h, v), p = n.mul(B, L), p = n.add(E, p), E = n.sub(N, p), p = n.add(N, p), p = n.mul(E, p), E = n.mul(I, E), v = n.mul(B, v), L = n.mul(h, L), I = n.sub(S, L), I = n.mul(h, I), I = n.add(I, v), v = n.add(S, S), S = n.add(v, S), S = n.add(S, L), S = n.mul(S, I), p = n.add(p, S), L = n.mul(l, b), L = n.add(L, L), S = n.mul(L, I), E = n.sub(E, S), v = n.mul(L, N), v = n.add(v, v), v = n.add(v, v), new R(E, p, v);
+    }
+    add(h) {
+      T(h);
+      const { X: y, Y: B, Z: d } = this, { X: l, Y: b, Z: E } = h;
+      let p = n.ZERO, v = n.ZERO, S = n.ZERO;
+      const N = i.a, L = n.mul(i.b, Tt);
+      let I = n.mul(y, l), k = n.mul(B, b), j = n.mul(d, E), V = n.add(y, B), U = n.add(l, b);
+      V = n.mul(V, U), U = n.add(I, k), V = n.sub(V, U), U = n.add(y, d);
+      let J = n.add(l, E);
+      return U = n.mul(U, J), J = n.add(I, j), U = n.sub(U, J), J = n.add(B, d), p = n.add(b, E), J = n.mul(J, p), p = n.add(k, j), J = n.sub(J, p), S = n.mul(N, U), p = n.mul(L, j), S = n.add(p, S), p = n.sub(k, S), S = n.add(k, S), v = n.mul(p, S), k = n.add(I, I), k = n.add(k, I), j = n.mul(N, j), U = n.mul(L, U), k = n.add(k, j), j = n.sub(I, j), j = n.mul(N, j), U = n.add(U, j), I = n.mul(k, U), v = n.add(v, I), I = n.mul(J, U), p = n.mul(V, p), p = n.sub(p, I), I = n.mul(V, k), S = n.mul(J, S), S = n.add(S, I), new R(p, v, S);
+    }
+    subtract(h) {
+      return T(h), this.add(h.negate());
     }
     is0() {
-      return this.equals(N.ZERO);
-    }
-    multiply(v) {
-      const { endo: H } = n;
-      if (!o.isValidNot0(v)) throw new RangeError("invalid scalar: out of range");
-      let U, S;
-      const p = (R) => K.cached(this, R, (I) => gn(N, I));
-      if (H) {
-        const { k1neg: R, k1: I, k2neg: _, k2: D } = z(v), { p: q, f: X } = p(I), { p: Y, f: Z } = p(D);
-        S = X.add(Z), U = W(H.beta, q, Y, R, _);
+      return this.equals(R.ZERO);
+    }
+    multiply(h) {
+      const { endo: y } = e;
+      if (!o.isValidNot0(h)) throw new RangeError("invalid scalar: out of range");
+      let B, d;
+      const l = (b) => X.cached(this, b, (E) => Ne(R, E));
+      if (y) {
+        const { k1neg: b, k1: E, k2neg: p, k2: v } = Q(h), { p: S, f: N } = l(E), { p: L, f: I } = l(v);
+        d = N.add(I), B = $(y.beta, S, L, b, p);
       } else {
-        const { p: R, f: I } = p(v);
-        U = R, S = I;
+        const { p: b, f: E } = l(h);
+        B = b, d = E;
       }
-      return gn(N, [U, S])[0];
-    }
-    multiplyUnsafe(v) {
-      const { endo: H } = n, U = this, S = v;
-      if (!o.isValid(S)) throw new RangeError("invalid scalar: out of range");
-      if (S === yt || U.is0()) return N.ZERO;
-      if (S === ct) return U;
-      if (K.hasCache(this)) return this.multiply(S);
-      if (H) {
-        const { k1neg: p, k1: R, k2neg: I, k2: _ } = z(S), { p1: D, p2: q } = Wr(N, U, R, _);
-        return W(H.beta, D, q, p, I);
-      } else return K.unsafe(U, S);
-    }
-    toAffine(v) {
-      const H = this;
-      let U = v;
-      const { X: S, Y: p, Z: R } = H;
-      if (r.eql(R, r.ONE)) return {
-        x: S,
-        y: p
+      return Ne(R, [B, d])[0];
+    }
+    multiplyUnsafe(h) {
+      const { endo: y } = e, B = this, d = h;
+      if (!o.isValid(d)) throw new RangeError("invalid scalar: out of range");
+      if (d === ot || B.is0()) return R.ZERO;
+      if (d === ht) return B;
+      if (X.hasCache(this)) return this.multiply(d);
+      if (y) {
+        const { k1neg: l, k1: b, k2neg: E, k2: p } = Q(d), { p1: v, p2: S } = fr(R, B, b, p);
+        return $(y.beta, v, S, l, E);
+      } else return X.unsafe(B, d);
+    }
+    toAffine(h) {
+      const y = this;
+      let B = h;
+      const { X: d, Y: l, Z: b } = y;
+      if (n.eql(b, n.ONE)) return {
+        x: d,
+        y: l
       };
-      const I = H.is0();
-      U == null && (U = I ? r.ONE : r.inv(R));
-      const _ = r.mul(S, U), D = r.mul(p, U), q = r.mul(R, U);
-      if (I) return {
-        x: r.ZERO,
-        y: r.ZERO
+      const E = y.is0();
+      B == null && (B = E ? n.ONE : n.inv(b));
+      const p = n.mul(d, B), v = n.mul(l, B), S = n.mul(b, B);
+      if (E) return {
+        x: n.ZERO,
+        y: n.ZERO
       };
-      if (!r.eql(q, r.ONE)) throw new Error("invZ was invalid");
+      if (!n.eql(S, n.ONE)) throw new Error("invZ was invalid");
       return {
-        x: _,
-        y: D
+        x: p,
+        y: v
       };
     }
     isTorsionFree() {
-      const { isTorsionFree: v } = n;
-      return a === ct ? !0 : v ? v(N, this) : K.unsafe(this, f).is0();
+      const { isTorsionFree: h } = e;
+      return c === ht ? !0 : h ? h(R, this) : X.unsafe(this, s).is0();
     }
     clearCofactor() {
-      const { clearCofactor: v } = n;
-      return a === ct ? this : v ? v(N, this) : this.multiplyUnsafe(a);
+      const { clearCofactor: h } = e;
+      return c === ht ? this : h ? h(R, this) : this.multiplyUnsafe(c);
     }
     isSmallOrder() {
-      return a === ct ? this.is0() : this.clearCofactor().is0();
+      return c === ht ? this.is0() : this.clearCofactor().is0();
     }
-    toBytes(v = !0) {
-      return ie(v, "isCompressed"), this.assertValidity(), w(N, this, v);
+    toBytes(h = !0) {
+      return Ot(h, "isCompressed"), this.assertValidity(), A(R, this, h);
     }
-    toHex(v = !0) {
-      return Ct(this.toBytes(v));
+    toHex(h = !0) {
+      return cn(this.toBytes(h));
     }
     toString() {
       return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
     }
   }
-  const V = o.BITS, K = new Xr(N, n.endo ? Math.ceil(V / 2) : V);
-  return V >= 8 && N.BASE.precompute(8), Object.freeze(N.prototype), Object.freeze(N), N;
+  const C = o.BITS, X = new cr(R, e.endo ? Math.ceil(C / 2) : C);
+  return C >= 8 && R.BASE.precompute(8), Object.freeze(R.prototype), Object.freeze(R), R;
 }
-function fr(t) {
+function Hn(t) {
   return Uint8Array.of(t ? 2 : 3);
 }
-function mo(t, n) {
-  const e = se(t), r = e.ORDER;
-  let o = yt;
-  for (let b = r - ct; b % Bt === yt; b /= Bt) o += ct;
-  const i = o, a = Bt << i - ct - ct, f = a * Bt, l = (r - ct) / f, g = (l - ct) / Bt, s = f - ct, u = a, d = e.pow(n, l), h = e.pow(n, (l + ct) / Bt);
-  let w = (b, E) => {
-    let T = d, B = e.pow(E, s), C = e.sqr(B);
-    C = e.mul(C, E);
-    let O = e.mul(b, C);
-    O = e.pow(O, g), O = e.mul(O, B), B = e.mul(O, E), C = e.mul(O, b);
-    let F = e.mul(C, B);
-    O = e.pow(F, u);
-    let z = e.eql(O, e.ONE);
-    B = e.mul(C, h), O = e.mul(F, T), C = e.cmov(B, C, z), F = e.cmov(O, F, z);
-    for (let W = i; W > ct; W--) {
-      let N = W - Bt;
-      N = Bt << N - ct;
-      let V = e.pow(F, N);
-      const K = e.eql(V, e.ONE);
-      B = e.mul(C, T), T = e.mul(T, T), V = e.mul(F, T), C = e.cmov(B, C, K), F = e.cmov(V, F, K);
-    }
-    return {
-      isValid: !e.is0(E) && (z || e.is0(b)),
-      value: C
-    };
-  };
-  if (e.ORDER % Me === Xt) {
-    const b = (e.ORDER - Xt) / Me, E = e.sqrt(e.neg(n));
-    w = (T, B) => {
-      let C = e.sqr(B);
-      const O = e.mul(T, B);
-      C = e.mul(C, O);
-      let F = e.pow(C, b);
-      F = e.mul(F, O);
-      const z = e.mul(F, E), W = e.mul(e.sqr(F), B), N = e.eql(W, T);
-      let V = e.cmov(z, F, N);
-      return {
-        isValid: !e.is0(B) && N,
-        value: V
-      };
-    };
-  }
-  return w;
-}
-function go(t, n) {
-  const e = se(t), { A: r, B: o, Z: i } = n;
-  if (!e.isValidNot0(r) || !e.isValidNot0(o) || !e.isValid(i)) throw new Error("mapToCurveSimpleSWU: invalid opts");
-  if (e.eql(i, e.neg(e.ONE)) || hn(e, i)) throw new Error("mapToCurveSimpleSWU: invalid opts");
-  const a = e.mul(o, e.inv(e.mul(i, r)));
-  if (!hn(e, e.add(e.add(e.mul(e.sqr(a), a), e.mul(r, a)), o))) throw new Error("mapToCurveSimpleSWU: invalid opts");
-  const f = mo(e, i);
-  if (!e.isOdd) throw new Error("Field does not have .isOdd()");
-  return (l) => {
-    let g, s, u, d, h, w, b, E;
-    g = e.sqr(l), g = e.mul(g, i), s = e.sqr(g), s = e.add(s, g), u = e.add(s, e.ONE), u = e.mul(u, o), d = e.cmov(i, e.neg(s), !e.eql(s, e.ZERO)), d = e.mul(d, r), s = e.sqr(u), w = e.sqr(d), h = e.mul(w, r), s = e.add(s, h), s = e.mul(s, u), w = e.mul(w, d), h = e.mul(w, o), s = e.add(s, h), b = e.mul(g, u);
-    const { isValid: T, value: B } = f(s, w);
-    E = e.mul(g, l), E = e.mul(E, B), b = e.cmov(b, u, T), E = e.cmov(E, B, T);
-    const C = e.isOdd(l) === e.isOdd(E);
-    E = e.cmov(e.neg(E), E, C);
-    const O = Ee(e, [d], !0)[0];
-    return b = e.mul(b, O), {
-      x: b,
-      y: E
-    };
-  };
-}
-function ar(t, n) {
+function On(t, e) {
   return {
-    secretKey: n.BYTES,
+    secretKey: e.BYTES,
     publicKey: 1 + t.BYTES,
     publicKeyUncompressed: 1 + 2 * t.BYTES,
     publicKeyHasPrefix: !0,
-    signature: 2 * n.BYTES
+    signature: 2 * e.BYTES
   };
 }
-function wo(t, n = {}) {
-  const { Fn: e } = t, r = n.randomBytes === void 0 ? wt : n.randomBytes, o = Object.assign(ar(t.Fp, e), { seed: Math.max(nn(e.ORDER), 16) });
-  function i(h) {
+function br(t, e = {}) {
+  const { Fn: r } = t, n = e.randomBytes === void 0 ? an : e.randomBytes, o = Object.assign(On(t.Fp, r), { seed: Math.max(An(r.ORDER), 16) });
+  function i(w) {
     try {
-      const w = e.fromBytes(h);
-      return e.isValidNot0(w);
+      const A = r.fromBytes(w);
+      return r.isValidNot0(A);
     } catch {
       return !1;
     }
   }
-  function a(h, w) {
-    const { publicKey: b, publicKeyUncompressed: E } = o;
+  function c(w, A) {
+    const { publicKey: _, publicKeyUncompressed: H } = o;
     try {
-      const T = h.length;
-      return w === !0 && T !== b || w === !1 && T !== E ? !1 : !!t.fromBytes(h);
+      const O = w.length;
+      return A === !0 && O !== _ || A === !1 && O !== H ? !1 : !!t.fromBytes(w);
     } catch {
       return !1;
     }
   }
-  function f(h) {
-    return h = h === void 0 ? r(o.seed) : h, nr(st(h, o.seed, "seed"), e.ORDER);
+  function s(w) {
+    return w = w === void 0 ? n(o.seed) : w, sr(W(w, o.seed, "seed"), r.ORDER);
   }
-  function l(h, w = !0) {
-    return t.BASE.multiply(e.fromBytes(h)).toBytes(w);
+  function a(w, A = !0) {
+    return t.BASE.multiply(r.fromBytes(w)).toBytes(A);
   }
-  function g(h) {
-    const { secretKey: w, publicKey: b, publicKeyUncompressed: E } = o, T = e._lengths;
-    if (!oe(h)) return;
-    const B = st(h, void 0, "key").length, C = B === b || B === E, O = B === w || !!T?.includes(B);
-    if (!(C && O))
-      return C;
+  function u(w) {
+    const { secretKey: A, publicKey: _, publicKeyUncompressed: H } = o, O = r._lengths;
+    if (!fn(w)) return;
+    const x = W(w, void 0, "key").length, q = x === _ || x === H, Z = x === A || !!O?.includes(x);
+    if (!(q && Z))
+      return q;
   }
-  function s(h, w, b = !0) {
-    if (g(h) === !0) throw new Error("first arg must be private key");
-    if (g(w) === !1) throw new Error("second arg must be public key");
-    const E = e.fromBytes(h);
-    return t.fromBytes(w).multiply(E).toBytes(b);
+  function f(w, A, _ = !0) {
+    if (u(w) === !0) throw new Error("first arg must be private key");
+    if (u(A) === !1) throw new Error("second arg must be public key");
+    const H = r.fromBytes(w);
+    return t.fromBytes(A).multiply(H).toBytes(_);
   }
-  const u = {
+  const g = {
     isValidSecretKey: i,
-    isValidPublicKey: a,
-    randomSecretKey: f
-  }, d = to(f, l);
-  return Object.freeze(u), Object.freeze(o), Object.freeze({
-    getPublicKey: l,
-    getSharedSecret: s,
-    keygen: d,
+    isValidPublicKey: c,
+    randomSecretKey: s
+  }, m = ur(s, a);
+  return Object.freeze(g), Object.freeze(o), Object.freeze({
+    getPublicKey: a,
+    getSharedSecret: f,
+    keygen: m,
     Point: t,
-    utils: u,
+    utils: g,
     lengths: o
   });
 }
-function bo(t, n, e = {}) {
-  const r = n;
-  An(r), Mt(e, {}, {
+function wr(t, e, r = {}) {
+  const n = e;
+  ke(n), kt(r, {}, {
     hmac: "function",
     lowS: "boolean",
     randomBytes: "function",
     bits2int: "function",
     bits2int_modN: "function"
-  }), e = Object.assign({}, e);
-  const o = e.randomBytes === void 0 ? wt : e.randomBytes, i = e.hmac === void 0 ? (S, p) => We(r, S, p) : e.hmac, { Fp: a, Fn: f } = t, { ORDER: l, BITS: g } = f, { keygen: s, getPublicKey: u, getSharedSecret: d, utils: h, lengths: w } = wo(t, e), b = {
+  }), r = Object.assign({}, r);
+  const o = r.randomBytes === void 0 ? an : r.randomBytes, i = r.hmac === void 0 ? (d, l) => de(n, d, l) : r.hmac, { Fp: c, Fn: s } = t, { ORDER: a, BITS: u } = s, { keygen: f, getPublicKey: g, getSharedSecret: m, utils: w, lengths: A } = br(t, r), _ = {
     prehash: !0,
-    lowS: typeof e.lowS == "boolean" ? e.lowS : !0,
+    lowS: typeof r.lowS == "boolean" ? r.lowS : !0,
     format: "compact",
     extraEntropy: !1
-  }, E = l * Bt + ct < a.ORDER;
-  function T(S) {
-    return S > l >> ct;
+  }, H = a * _n + ht < c.ORDER;
+  function O(d) {
+    return d > a >> ht;
   }
-  function B(S, p) {
-    if (!f.isValidNot0(p)) throw new Error(`invalid signature ${S}: out of range 1..Point.Fn.ORDER`);
-    return p;
+  function x(d, l) {
+    if (!s.isValidNot0(l)) throw new Error(`invalid signature ${d}: out of range 1..Point.Fn.ORDER`);
+    return l;
   }
-  function C() {
-    if (E) throw new Error('"recovered" sig type is not supported for cofactor >2 curves');
+  function q() {
+    if (H) throw new Error('"recovered" sig type is not supported for cofactor >2 curves');
   }
-  function O(S, p) {
-    ze(p);
-    const R = w.signature;
-    return st(S, p === "compact" ? R : p === "recovered" ? R + 1 : void 0);
+  function Z(d, l) {
+    ae(l);
+    const b = A.signature;
+    return W(d, l === "compact" ? b : l === "recovered" ? b + 1 : void 0);
   }
-  class F {
+  class T {
     r;
     s;
     recovery;
-    constructor(p, R, I) {
-      if (this.r = B("r", p), this.s = B("s", R), I != null) {
-        if (C(), ![
+    constructor(l, b, E) {
+      if (this.r = x("r", l), this.s = x("s", b), E != null) {
+        if (q(), ![
           0,
           1,
           2,
           3
-        ].includes(I)) throw new Error("invalid recovery id");
-        this.recovery = I;
+        ].includes(E)) throw new Error("invalid recovery id");
+        this.recovery = E;
       }
       Object.freeze(this);
     }
-    static fromBytes(p, R = b.format) {
-      O(p, R);
-      let I;
-      if (R === "der") {
-        const { r: X, s: Y } = Et.toSig(st(p));
-        return new F(X, Y);
+    static fromBytes(l, b = _.format) {
+      Z(l, b);
+      let E;
+      if (b === "der") {
+        const { r: N, s: L } = et.toSig(W(l));
+        return new T(N, L);
       }
-      R === "recovered" && (I = p[0], R = "compact", p = p.subarray(1));
-      const _ = w.signature / 2, D = p.subarray(0, _), q = p.subarray(_, _ * 2);
-      return new F(f.fromBytes(D), f.fromBytes(q), I);
+      b === "recovered" && (E = l[0], b = "compact", l = l.subarray(1));
+      const p = A.signature / 2, v = l.subarray(0, p), S = l.subarray(p, p * 2);
+      return new T(s.fromBytes(v), s.fromBytes(S), E);
     }
-    static fromHex(p, R) {
-      return this.fromBytes(he(p), R);
+    static fromHex(l, b) {
+      return this.fromBytes(se(l), b);
     }
     assertRecovery() {
-      const { recovery: p } = this;
-      if (p == null) throw new Error("invalid recovery id: must be present");
-      return p;
+      const { recovery: l } = this;
+      if (l == null) throw new Error("invalid recovery id: must be present");
+      return l;
     }
-    addRecoveryBit(p) {
-      return new F(this.r, this.s, p);
+    addRecoveryBit(l) {
+      return new T(this.r, this.s, l);
     }
-    recoverPublicKey(p) {
-      const { r: R, s: I } = this, _ = this.assertRecovery(), D = _ === 2 || _ === 3 ? R + l : R;
-      if (!a.isValid(D)) throw new Error("invalid recovery id: sig.r+curve.n != R.x");
-      const q = a.toBytes(D), X = t.fromBytes(Q(fr((_ & 1) === 0), q)), Y = f.inv(D), Z = W(st(p, void 0, "msgHash")), nt = f.create(-Z * Y), rt = f.create(I * Y), it = t.BASE.multiplyUnsafe(nt).add(X.multiplyUnsafe(rt));
-      if (it.is0()) throw new Error("invalid recovery: point at infinify");
-      return it.assertValidity(), it;
+    recoverPublicKey(l) {
+      const { r: b, s: E } = this, p = this.assertRecovery(), v = p === 2 || p === 3 ? b + a : b;
+      if (!c.isValid(v)) throw new Error("invalid recovery id: sig.r+curve.n != R.x");
+      const S = c.toBytes(v), N = t.fromBytes(lt(Hn((p & 1) === 0), S)), L = s.inv(v), I = $(W(l, void 0, "msgHash")), k = s.create(-I * L), j = s.create(E * L), V = t.BASE.multiplyUnsafe(k).add(N.multiplyUnsafe(j));
+      if (V.is0()) throw new Error("invalid recovery: point at infinify");
+      return V.assertValidity(), V;
     }
     hasHighS() {
-      return T(this.s);
-    }
-    toBytes(p = b.format) {
-      if (ze(p), p === "der") return he(Et.hexFromSig(this));
-      const { r: R, s: I } = this, _ = f.toBytes(R), D = f.toBytes(I);
-      return p === "recovered" ? (C(), Q(Uint8Array.of(this.assertRecovery()), _, D)) : Q(_, D);
-    }
-    toHex(p) {
-      return Ct(this.toBytes(p));
-    }
-  }
-  Object.freeze(F.prototype), Object.freeze(F);
-  const z = e.bits2int === void 0 ? function(p) {
-    if (p.length > 8192) throw new Error("input is too large");
-    const R = St(p), I = p.length * 8 - g;
-    return I > 0 ? R >> BigInt(I) : R;
-  } : e.bits2int, W = e.bits2int_modN === void 0 ? function(p) {
-    return f.create(z(p));
-  } : e.bits2int_modN, N = pe(g);
-  function V(S) {
-    return Mn("num < 2^" + g, S, yt, N), f.toBytes(S);
-  }
-  function K(S, p) {
-    return st(S, void 0, "message"), p ? st(r(S), void 0, "prehashed message") : S;
-  }
-  function M(S, p, R) {
-    const { lowS: I, prehash: _, extraEntropy: D } = Te(R, b);
-    S = K(S, _);
-    const q = W(S), X = f.fromBytes(p);
-    if (!f.isValidNot0(X)) throw new Error("invalid private key");
-    const Y = [V(X), V(q)];
-    if (D != null && D !== !1) {
-      const it = D === !0 ? o(w.secretKey) : D;
-      Y.push(st(it, void 0, "extraEntropy"));
-    }
-    const Z = Q(...Y), nt = q;
-    function rt(it) {
-      const c = z(it);
-      if (!f.isValidNot0(c)) return;
-      const m = f.inv(c), y = t.BASE.multiply(c).toAffine(), x = f.create(y.x);
-      if (x === yt) return;
-      const A = f.create(m * f.create(nt + x * X));
-      if (A === yt) return;
-      let j = (y.x === x ? 0 : 2) | Number(y.y & ct), L = A;
-      return I && T(A) && (L = f.neg(A), j ^= 1), new F(x, L, E ? void 0 : j);
+      return O(this.s);
+    }
+    toBytes(l = _.format) {
+      if (ae(l), l === "der") return se(et.hexFromSig(this));
+      const { r: b, s: E } = this, p = s.toBytes(b), v = s.toBytes(E);
+      return l === "recovered" ? (q(), lt(Uint8Array.of(this.assertRecovery()), p, v)) : lt(p, v);
+    }
+    toHex(l) {
+      return cn(this.toBytes(l));
+    }
+  }
+  Object.freeze(T.prototype), Object.freeze(T);
+  const Q = r.bits2int === void 0 ? function(l) {
+    if (l.length > 8192) throw new Error("input is too large");
+    const b = Ct(l), E = l.length * 8 - u;
+    return E > 0 ? b >> BigInt(E) : b;
+  } : r.bits2int, $ = r.bits2int_modN === void 0 ? function(l) {
+    return s.create(Q(l));
+  } : r.bits2int_modN, R = Ee(u);
+  function C(d) {
+    return dn("num < 2^" + u, d, ot, R), s.toBytes(d);
+  }
+  function X(d, l) {
+    return W(d, void 0, "message"), l ? W(n(d), void 0, "prehashed message") : d;
+  }
+  function F(d, l, b) {
+    const { lowS: E, prehash: p, extraEntropy: v } = Xt(b, _);
+    d = X(d, p);
+    const S = $(d), N = s.fromBytes(l);
+    if (!s.isValidNot0(N)) throw new Error("invalid private key");
+    const L = [C(N), C(S)];
+    if (v != null && v !== !1) {
+      const V = v === !0 ? o(A.secretKey) : v;
+      L.push(W(V, void 0, "extraEntropy"));
+    }
+    const I = lt(...L), k = S;
+    function j(V) {
+      const U = Q(V);
+      if (!s.isValidNot0(U)) return;
+      const J = s.inv(U), vt = t.BASE.multiply(U).toAffine(), Ft = s.create(vt.x);
+      if (Ft === ot) return;
+      const Lt = s.create(J * s.create(k + Ft * N));
+      if (Lt === ot) return;
+      let xe = (vt.x === Ft ? 0 : 2) | Number(vt.y & ht), Be = Lt;
+      return E && O(Lt) && (Be = s.neg(Lt), xe ^= 1), new T(Ft, Be, H ? void 0 : xe);
     }
     return {
-      seed: Z,
-      k2sig: rt
+      seed: I,
+      k2sig: j
     };
   }
-  function v(S, p, R = {}) {
-    const { seed: I, k2sig: _ } = M(S, p, R);
-    return qr(r.outputLen, f.BYTES, i)(I, _).toBytes(R.format);
+  function h(d, l, b = {}) {
+    const { seed: E, k2sig: p } = F(d, l, b);
+    return Wn(n.outputLen, s.BYTES, i)(E, p).toBytes(b.format);
   }
-  function H(S, p, R, I = {}) {
-    const { lowS: _, prehash: D, format: q } = Te(I, b);
-    if (R = st(R, void 0, "publicKey"), p = K(p, D), !oe(S)) {
-      const X = S instanceof F ? ", use sig.toBytes()" : "";
-      throw new Error("verify expects Uint8Array signature" + X);
+  function y(d, l, b, E = {}) {
+    const { lowS: p, prehash: v, format: S } = Xt(E, _);
+    if (b = W(b, void 0, "publicKey"), l = X(l, v), !fn(d)) {
+      const N = d instanceof T ? ", use sig.toBytes()" : "";
+      throw new Error("verify expects Uint8Array signature" + N);
     }
-    O(S, q);
+    Z(d, S);
     try {
-      const X = F.fromBytes(S, q), Y = t.fromBytes(R);
-      if (_ && X.hasHighS()) return !1;
-      const { r: Z, s: nt } = X, rt = W(p), it = f.inv(nt), c = f.create(rt * it), m = f.create(Z * it), y = t.BASE.multiplyUnsafe(c).add(Y.multiplyUnsafe(m));
-      return y.is0() ? !1 : f.create(y.x) === Z;
+      const N = T.fromBytes(d, S), L = t.fromBytes(b);
+      if (p && N.hasHighS()) return !1;
+      const { r: I, s: k } = N, j = $(l), V = s.inv(k), U = s.create(j * V), J = s.create(I * V), vt = t.BASE.multiplyUnsafe(U).add(L.multiplyUnsafe(J));
+      return vt.is0() ? !1 : s.create(vt.x) === I;
     } catch {
       return !1;
     }
   }
-  function U(S, p, R = {}) {
-    const { prehash: I } = Te(R, b);
-    return p = K(p, I), F.fromBytes(S, "recovered").recoverPublicKey(p).toBytes();
+  function B(d, l, b = {}) {
+    const { prehash: E } = Xt(b, _);
+    return l = X(l, E), T.fromBytes(d, "recovered").recoverPublicKey(l).toBytes();
   }
   return Object.freeze({
-    keygen: s,
-    getPublicKey: u,
-    getSharedSecret: d,
-    utils: h,
-    lengths: w,
+    keygen: f,
+    getPublicKey: g,
+    getSharedSecret: m,
+    utils: w,
+    lengths: A,
     Point: t,
-    sign: v,
-    verify: H,
-    recoverPublicKey: U,
-    Signature: F,
-    hash: r
+    sign: h,
+    verify: y,
+    recoverPublicKey: B,
+    Signature: T,
+    hash: n
   });
 }
-var rn = {
+var ve = {
   p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
   n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
   h: BigInt(1),
@@ -2766,209 +1947,55 @@ var rn = {
   b: BigInt(7),
   Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
   Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
-}, yo = {
+}, pr = {
   beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
   basises: [[BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")], [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]]
-}, lr = /* @__PURE__ */ BigInt(0), Ge = /* @__PURE__ */ BigInt(2);
-function po(t) {
-  const n = rn.p, e = BigInt(3), r = BigInt(6), o = BigInt(11), i = BigInt(22), a = BigInt(23), f = BigInt(44), l = BigInt(88), g = t * t * t % n, s = g * g * t % n, u = gt(gt(gt(s, e, n) * s % n, e, n) * s % n, Ge, n) * g % n, d = gt(u, o, n) * u % n, h = gt(d, i, n) * d % n, w = gt(h, f, n) * h % n, b = gt(gt(gt(gt(gt(gt(w, l, n) * w % n, f, n) * h % n, e, n) * s % n, a, n) * d % n, r, n) * g % n, Ge, n);
-  if (!It.eql(It.sqr(b), t)) throw new Error("Cannot find square root");
-  return b;
-}
-var It = ve(rn.p, { sqrt: po }), J = /* @__PURE__ */ ho(rn, {
-  Fp: It,
-  endo: yo
-}), Vo = /* @__PURE__ */ bo(J, jt), vn = {};
-function ur(t, ...n) {
-  let e = vn[t];
-  if (e === void 0) {
-    const r = jt(be(t));
-    e = Q(r, r), vn[t] = e;
-  }
-  return jt(Q(e, ...n));
-}
-var Ye = (t) => t.toBytes(!0).slice(1), Vt = (t) => t % Ge === lr;
-function Eo(t) {
-  const n = It;
-  if (!n.isValidNot0(t)) throw new Error("invalid x: Fail if x ≥ p");
-  const e = n.create(t * t), r = n.create(e * t + BigInt(7));
-  let o = n.sqrt(r);
-  Vt(o) || (o = n.neg(o));
-  const i = J.fromAffine({
-    x: t,
-    y: o
-  });
-  return i.assertValidity(), i;
-}
-var vo = St;
-function xo(...t) {
-  return J.Fn.create(vo(ur("BIP0340/challenge", ...t)));
-}
-var Bo = co(It, [
-  [
-    "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
-    "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
-    "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
-    "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
-  ],
-  [
-    "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
-    "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
-    "0x0000000000000000000000000000000000000000000000000000000000000001"
-  ],
-  [
-    "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
-    "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
-    "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
-    "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
-  ],
-  [
-    "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
-    "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
-    "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
-    "0x0000000000000000000000000000000000000000000000000000000000000001"
-  ]
-].map((t) => t.map((n) => BigInt(n)))), xn, So = () => xn || (xn = go(It, {
-  A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
-  B: BigInt("1771"),
-  Z: It.create(BigInt("-11"))
-})), dr = ao(J, (t) => {
-  const { x: n, y: e } = So()(It.create(t[0]));
-  return Bo(n, e);
-}, {
-  DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
-  encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
-  p: It.ORDER,
-  m: 1,
-  k: 128,
-  expand: "xmd",
-  hash: jt
-}), Po = cr({
-  name: "FROST-secp256k1-SHA256-v1",
-  Point: J,
-  hashToScalar: dr.hashToScalar,
-  hash: jt
-});
-function hr(t, n) {
-  if (n === void 0) return lr;
-  const e = St(ur("TapTweak", Ye(t), n));
-  if (!J.Fn.isValid(e)) throw new Error("invalid TapTweak hash");
-  return e;
-}
-function on(t) {
-  return Vt(J.fromBytes(t.commitments[0]).y) ? t : {
-    signers: {
-      min: t.signers.min,
-      max: t.signers.max
-    },
-    commitments: t.commitments.map((n) => J.fromBytes(n).negate().toBytes()),
-    verifyingShares: Object.fromEntries(Object.entries(t.verifyingShares).map(([n, e]) => [n, J.fromBytes(e).negate().toBytes()]))
-  };
-}
-function mr(t, n) {
-  if (Vt(J.fromBytes(n.commitments[0]).y)) return t;
-  const e = J.Fn;
-  return {
-    ...t,
-    signingShare: e.toBytes(e.neg(e.fromBytes(t.signingShare)))
-  };
-}
-function Ao(t, n) {
-  if (Vt(t.y)) return n;
-  const e = J.Fn;
-  return {
-    binding: e.toBytes(e.neg(e.fromBytes(n.binding))),
-    hiding: e.toBytes(e.neg(e.fromBytes(n.hiding)))
-  };
-}
-function Ro(t, n, e) {
-  const r = J.Fn, o = mr(t, n), i = on(n), a = hr(J.fromBytes(i.commitments[0]), e), f = r.toBytes(r.add(r.fromBytes(o.signingShare), a));
-  return {
-    identifier: o.identifier,
-    signingShare: f
-  };
-}
-function _o(t, n) {
-  const e = on(t), r = hr(J.fromBytes(e.commitments[0]), n), o = J.BASE.multiply(r), i = e.commitments.map((f, l) => (l === 0 ? J.fromBytes(f).add(o) : J.fromBytes(f)).toBytes()), a = {};
-  for (const f in e.verifyingShares) a[f] = J.fromBytes(e.verifyingShares[f]).add(o).toBytes();
-  return {
-    signers: {
-      min: e.signers.min,
-      max: e.signers.max
-    },
-    commitments: i,
-    verifyingShares: a
-  };
-}
-var zo = cr({
-  name: "FROST-secp256k1-SHA256-TR-v1",
-  Point: J,
-  hashToScalar: dr.hashToScalar,
-  hash: jt,
-  parsePublicKey(t) {
-    if (t.length === 32) return Eo(St(t));
-    if (t.length === 33) return J.fromBytes(t);
-    throw new Error(`expected x-only or compressed public key, got length=${t.length}`);
-  },
-  adjustScalar(t) {
-    return Vt(J.BASE.multiply(t).y) ? t : J.Fn.neg(t);
-  },
-  adjustPoint: (t) => Vt(t.y) ? t : t.negate(),
-  challenge(t, n, e) {
-    return xo(Ye(t), Ye(n), e);
-  },
-  adjustNonces: Ao,
-  adjustGroupCommitmentShare: (t, n) => Vt(t.y) ? n : n.negate(),
-  adjustPublic: on,
-  adjustSecret: mr,
-  adjustTx: {
-    encode: (t) => t.subarray(1),
-    decode: (t) => Q(Uint8Array.of(2), t)
-  },
-  adjustDKG: (t) => {
-    const n = new Uint8Array(0);
-    return {
-      public: _o(t.public, n),
-      secret: Ro(t.secret, t.public, n)
-    };
-  }
-});
+}, qe = /* @__PURE__ */ BigInt(2);
+function yr(t) {
+  const e = ve.p, r = BigInt(3), n = BigInt(6), o = BigInt(11), i = BigInt(22), c = BigInt(23), s = BigInt(44), a = BigInt(88), u = t * t * t % e, f = u * u * t % e, g = P(P(P(f, r, e) * f % e, r, e) * f % e, qe, e) * u % e, m = P(g, o, e) * g % e, w = P(m, i, e) * m % e, A = P(w, s, e) * w % e, _ = P(P(P(P(P(P(A, a, e) * A % e, s, e) * w % e, r, e) * f % e, c, e) * m % e, n, e) * u % e, qe, e);
+  if (!ue.eql(ue.sqr(_), t)) throw new Error("Cannot find square root");
+  return _;
+}
+var ue = jt(ve.p, { sqrt: yr }), Er = /* @__PURE__ */ gr(ve, {
+  Fp: ue,
+  endo: pr
+}), Ur = /* @__PURE__ */ wr(Er, ge);
 export {
-  xr as A,
-  Do as C,
-  Ln as D,
-  Fo as E,
-  Yt as F,
-  Qt as I,
-  Ho as L,
-  To as M,
-  Er as N,
-  vr as O,
-  Kt as P,
-  Fr as S,
-  jt as T,
-  qo as _,
-  wt as a,
-  Nr as b,
-  Dr as c,
-  kn as d,
-  No as f,
-  Uo as g,
-  Lo as h,
-  Q as i,
-  Br as j,
-  Fe as k,
-  ko as l,
-  jo as m,
-  bt as n,
-  Lr as o,
-  Io as p,
-  St as r,
-  Zo as s,
-  Vo as t,
-  $o as u,
-  jr as v,
-  _r as w,
-  Co as x,
-  Or as y
+  Tn as A,
+  _r as C,
+  Je as D,
+  Br as E,
+  xt as F,
+  It as I,
+  vr as L,
+  xr as M,
+  Ln as N,
+  Nn as O,
+  Bt as P,
+  Vn as S,
+  ge as T,
+  Ir as _,
+  an as a,
+  Yn as b,
+  Mn as c,
+  nn as d,
+  Rr as f,
+  Or as g,
+  Hr as h,
+  lt as i,
+  Un as j,
+  Wt as k,
+  Lr as l,
+  Sr as m,
+  tt as n,
+  Gn as o,
+  Ar as p,
+  Ct as r,
+  Tr as s,
+  Ur as t,
+  Nr as u,
+  zn as v,
+  Zn as w,
+  Fr as x,
+  Cn as y
 };