@btc-vision/transaction 1.8.6 → 1.8.7

package/browser/noble-curves.js

@@ -1,114 +1,115 @@
-import { n as Bt, r as je } from "./rolldown-runtime.js";
-function Kt(t) {
-  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+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 xt(t, e = "") {
+function Et(t, e = "") {
+  if (typeof t != "number") {
+    const r = e && `"${e}" `;
+    throw new TypeError(`${r}expected number, got ${typeof t}`);
+  }
   if (!Number.isSafeInteger(t) || t < 0) {
     const r = e && `"${e}" `;
-    throw new Error(`${r}expected integer >= 0, got ${t}`);
+    throw new RangeError(`${r}expected integer >= 0, got ${t}`);
   }
 }
-function C(t, e, r = "") {
-  const n = Kt(t), o = t?.length, s = e !== void 0;
-  if (!n || s && o !== e) {
-    const i = r && `"${r}" `, c = s ? ` of length ${e}` : "", f = n ? `length=${o}` : `type=${typeof t}`;
-    throw new Error(i + "expected Uint8Array" + c + ", got " + f);
+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 Ye(t) {
-  if (typeof t != "function" || typeof t.create != "function") throw new Error("Hash must wrapped by utils.createHasher");
-  xt(t.outputLen), xt(t.blockLen);
+function ke(t) {
+  if (typeof t != "function" || typeof t.create != "function") throw new TypeError("Hash must wrapped by utils.createHasher");
+  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 Vt(t, e = !0) {
+function Dt(t, e = !0) {
   if (t.destroyed) throw new Error("Hash instance has been destroyed");
   if (e && t.finished) throw new Error("Hash#digest() has already been called");
 }
-function Rn(t, e) {
-  C(t, void 0, "digestInto() output");
+function je(t, e) {
+  mt(t, void 0, "digestInto() output");
   const r = e.outputLen;
-  if (t.length < r) throw new Error('"digestInto() output" expected to be of length >=' + r);
+  if (t.length < r) throw new RangeError('"digestInto() output" expected to be of length >=' + r);
 }
-function Hr(t) {
-  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
-}
-function At(...t) {
+function Bt(...t) {
   for (let e = 0; e < t.length; e++) t[e].fill(0);
 }
-function ee(t) {
+function Vt(t) {
   return new DataView(t.buffer, t.byteOffset, t.byteLength);
 }
-function st(t, e) {
+function nt(t, e) {
   return t << 32 - e | t >>> e;
 }
-function Ir(t, e) {
+function vr(t, e) {
   return t << e | t >>> 32 - e >>> 0;
 }
-function On(t) {
-  return t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255;
-}
-function Hn(t) {
-  for (let e = 0; e < t.length; e++) t[e] = On(t[e]);
-  return t;
-}
-function Xt(t) {
-  if (C(t), pe) return t.toHex();
+function le(t) {
+  if (mt(t), he) return t.toHex();
   let e = "";
-  for (let r = 0; r < t.length; r++) e += Ke[t[r]];
+  for (let r = 0; r < t.length; r++) e += Ye[t[r]];
   return e;
 }
-function Oe(t) {
-  if (t >= it._0 && t <= it._9) return t - it._0;
-  if (t >= it.A && t <= it.F) return t - (it.A - 10);
-  if (t >= it.a && t <= it.f) return t - (it.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 Mt(t) {
-  if (typeof t != "string") throw new Error("hex string expected, got " + typeof t);
-  if (pe) return Uint8Array.fromHex(t);
+function Ve(t) {
+  if (typeof t != "string") throw new TypeError("hex string expected, got " + typeof t);
+  if (he) try {
+    return Uint8Array.fromHex(t);
+  } catch (o) {
+    throw o instanceof SyntaxError ? new RangeError(o.message) : o;
+  }
   const e = t.length, r = e / 2;
-  if (e % 2) throw new Error("hex string expected, got unpadded hex of length " + e);
+  if (e % 2) throw new RangeError("hex string expected, got unpadded hex of length " + e);
   const n = new Uint8Array(r);
-  for (let o = 0, s = 0; o < r; o++, s += 2) {
-    const i = Oe(t.charCodeAt(s)), c = Oe(t.charCodeAt(s + 1));
-    if (i === void 0 || c === void 0) {
-      const f = t[s] + t[s + 1];
-      throw new Error('hex string expected, got non-hex character "' + f + '" at index ' + s);
+  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);
     }
-    n[o] = i * 16 + c;
+    n[o] = c * 16 + s;
   }
   return n;
 }
-function P(...t) {
+function In(...t) {
   let e = 0;
   for (let n = 0; n < t.length; n++) {
     const o = t[n];
-    C(o), e += o.length;
+    mt(o), e += o.length;
   }
   const r = new Uint8Array(e);
   for (let n = 0, o = 0; n < t.length; n++) {
-    const s = t[n];
-    r.set(s, o), o += s.length;
+    const i = t[n];
+    r.set(i, o), o += i.length;
   }
   return r;
 }
-function _t(t, e = {}) {
-  const r = (o, s) => t(s).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 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 Ge(t = 32) {
+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 e.getRandomValues(new Uint8Array(t));
 }
-var He, In, pe, Ke, it, mt, Nt = Bt((() => {
-  He = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68, In = He ? (t) => t : Hn, pe = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Ke = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0")), it = {
+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
-  }, mt = (t) => ({ oid: Uint8Array.from([
+  }, gt = (t) => ({ oid: Uint8Array.from([
     6,
     9,
     96,
@@ -121,32 +122,35 @@ var He, In, pe, Ke, it, mt, Nt = Bt((() => {
     2,
     t
   ]) });
-})), Lr = /* @__PURE__ */ je({
-  _HMAC: () => kt,
-  hmac: () => $t
-}), kt, $t, Ln = Bt((() => {
-  Nt(), kt = class {
+})), xr = /* @__PURE__ */ Ze({
+  _HMAC: () => Ut,
+  hmac: () => de
+}), Ut, de, Ln = dt((() => {
+  It(), Ut = class {
     oHash;
     iHash;
     blockLen;
     outputLen;
+    canXOF = !1;
     finished = !1;
     destroyed = !1;
     constructor(t, e) {
-      if (Ye(t), C(e, void 0, "key"), this.iHash = t.create(), typeof this.iHash.update != "function") throw new Error("Expected instance of class which extends utils.Hash");
+      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 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), At(n);
+      this.oHash.update(n), Bt(n);
     }
     update(t) {
-      return Vt(this), this.iHash.update(t), this;
+      return Dt(this), this.iHash.update(t), this;
     }
     digestInto(t) {
-      Vt(this), C(t, this.outputLen, "output"), this.finished = !0, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), 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);
@@ -154,8 +158,8 @@ var He, In, pe, Ke, it, mt, Nt = Bt((() => {
     }
     _cloneInto(t) {
       t ||= Object.create(Object.getPrototypeOf(this), {});
-      const { oHash: e, iHash: r, finished: n, destroyed: o, blockLen: s, outputLen: i } = this;
-      return t = t, t.finished = n, t.destroyed = o, t.blockLen = s, t.outputLen = i, t.oHash = e._cloneInto(t.oHash), t.iHash = r._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();
@@ -163,18 +167,22 @@ var He, In, pe, Ke, it, mt, Nt = Bt((() => {
     destroy() {
       this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
     }
-  }, $t = (t, e, r) => new kt(t, e).update(r).digest(), $t.create = (t, e) => new kt(t, e);
+  }, 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 qn(t, e, r) {
+function Nn(t, e, r) {
   return t & e ^ ~t & r;
 }
-function Un(t, e, r) {
+function Tn(t, e, r) {
   return t & e ^ t & r ^ e & r;
 }
-var ae, dt, ht, K, X, Nn = Bt((() => {
-  Nt(), ae = class {
+var Wt, at, ut, M, G, Un = dt((() => {
+  It(), Wt = class {
     blockLen;
     outputLen;
+    canXOF = !1;
     padOffset;
     isLE;
     buffer;
@@ -184,34 +192,34 @@ var ae, dt, ht, K, X, Nn = Bt((() => {
     pos = 0;
     destroyed = !1;
     constructor(t, e, r, n) {
-      this.blockLen = t, this.outputLen = e, this.padOffset = r, this.isLE = n, this.buffer = new Uint8Array(t), this.view = ee(this.buffer);
+      this.blockLen = t, this.outputLen = e, this.padOffset = r, this.isLE = n, this.buffer = new Uint8Array(t), this.view = Vt(this.buffer);
     }
     update(t) {
-      Vt(this), C(t);
+      Dt(this), mt(t);
       const { view: e, buffer: r, blockLen: n } = this, o = t.length;
-      for (let s = 0; s < o; ) {
-        const i = Math.min(n - this.pos, o - s);
-        if (i === n) {
-          const c = ee(t);
-          for (; n <= o - s; s += n) this.process(c, s);
+      for (let i = 0; i < o; ) {
+        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;
         }
-        r.set(t.subarray(s, s + i), this.pos), this.pos += i, s += i, this.pos === n && (this.process(e, 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) {
-      Vt(this), Rn(t, this), this.finished = !0;
+      Dt(this), je(t, this), this.finished = !0;
       const { buffer: e, view: r, blockLen: n, isLE: o } = this;
-      let { pos: s } = this;
-      e[s++] = 128, At(this.buffer.subarray(s)), this.padOffset > n - s && (this.process(r, 0), s = 0);
-      for (let a = s; a < n; a++) e[a] = 0;
+      let { pos: i } = this;
+      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 i = ee(t), c = this.outputLen;
-      if (c % 4) throw new Error("_sha2: outputLen must be aligned to 32bit");
-      const f = c / 4, l = this.get();
-      if (f > l.length) throw new Error("_sha2: outputLen bigger than state");
-      for (let a = 0; a < f; a++) i.setUint32(4 * a, l[a], o);
+      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: e } = this;
@@ -221,13 +229,13 @@ var ae, dt, ht, K, X, Nn = Bt((() => {
     }
     _cloneInto(t) {
       t ||= new this.constructor(), t.set(...this.get());
-      const { blockLen: e, buffer: r, length: n, finished: o, destroyed: s, pos: i } = this;
-      return t.destroyed = s, t.finished = o, t.length = n, t.pos = i, n % e && t.buffer.set(r), 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();
     }
-  }, dt = /* @__PURE__ */ Uint32Array.from([
+  }, at = /* @__PURE__ */ Uint32Array.from([
     1779033703,
     3144134277,
     1013904242,
@@ -236,7 +244,7 @@ var ae, dt, ht, K, X, Nn = Bt((() => {
     2600822924,
     528734635,
     1541459225
-  ]), ht = /* @__PURE__ */ Uint32Array.from([
+  ]), ut = /* @__PURE__ */ Uint32Array.from([
     3238371032,
     914150663,
     812702999,
@@ -245,7 +253,7 @@ var ae, dt, ht, K, X, Nn = Bt((() => {
     1750603025,
     1694076839,
     3204075428
-  ]), K = /* @__PURE__ */ Uint32Array.from([
+  ]), M = /* @__PURE__ */ Uint32Array.from([
     3418070365,
     3238371032,
     1654270250,
@@ -262,7 +270,7 @@ var ae, dt, ht, K, X, Nn = Bt((() => {
     1694076839,
     1203062813,
     3204075428
-  ]), X = /* @__PURE__ */ Uint32Array.from([
+  ]), G = /* @__PURE__ */ Uint32Array.from([
     1779033703,
     4089235720,
     3144134277,
@@ -281,48 +289,48 @@ var ae, dt, ht, K, X, Nn = Bt((() => {
     327033209
   ]);
 }));
-function Dn(t, e = !1) {
+function $n(t, e = !1) {
   return e ? {
-    h: Number(t & It),
-    l: Number(t >> le & It)
+    h: Number(t & St),
+    l: Number(t >> Qt & St)
   } : {
-    h: Number(t >> le & It) | 0,
-    l: Number(t & It) | 0
+    h: Number(t >> Qt & St) | 0,
+    l: Number(t & St) | 0
   };
 }
-function Cn(t, e = !1) {
+function Dn(t, e = !1) {
   const r = t.length;
   let n = new Uint32Array(r), o = new Uint32Array(r);
-  for (let s = 0; s < r; s++) {
-    const { h: i, l: c } = Dn(t[s], e);
-    [n[s], o[s]] = [i, c];
+  for (let i = 0; i < r; i++) {
+    const { h: c, l: s } = $n(t[i], e);
+    [n[i], o[i]] = [c, s];
   }
   return [n, o];
 }
-function ft(t, e, r, n) {
+function it(t, e, r, n) {
   const o = (e >>> 0) + (n >>> 0);
   return {
     h: t + r + (o / 2 ** 32 | 0) | 0,
     l: o | 0
   };
 }
-var It, le, ue, de, yt, Et, Lt, qt, Zn, kn, Tn, Vn, Xe, ze, We, Qe, Je, Pe, Mn = Bt((() => {
-  It = /* @__PURE__ */ BigInt(2 ** 32 - 1), le = /* @__PURE__ */ BigInt(32), ue = (t, e, r) => t >>> r, de = (t, e, r) => t << 32 - r | e >>> r, yt = (t, e, r) => t >>> r | e << 32 - r, Et = (t, e, r) => t << 32 - r | e >>> r, Lt = (t, e, r) => t << 64 - r | e >>> r - 32, qt = (t, e, r) => t >>> r - 32 | e << 64 - r, Zn = (t, e, r) => t << r | e >>> 32 - r, kn = (t, e, r) => e << r | t >>> 32 - r, Tn = (t, e, r) => e << r - 32 | t >>> 64 - r, Vn = (t, e, r) => t << r - 32 | e >>> 64 - r, Xe = (t, e, r) => (t >>> 0) + (e >>> 0) + (r >>> 0), ze = (t, e, r, n) => e + r + n + (t / 2 ** 32 | 0) | 0, We = (t, e, r, n) => (t >>> 0) + (e >>> 0) + (r >>> 0) + (n >>> 0), Qe = (t, e, r, n, o) => e + r + n + o + (t / 2 ** 32 | 0) | 0, Je = (t, e, r, n, o) => (t >>> 0) + (e >>> 0) + (r >>> 0) + (n >>> 0) + (o >>> 0), Pe = (t, e, r, n, o, s) => e + r + n + o + s + (t / 2 ** 32 | 0) | 0;
-})), qr = /* @__PURE__ */ je({
-  _SHA224: () => be,
-  _SHA256: () => he,
-  _SHA384: () => ge,
-  _SHA512: () => we,
-  _SHA512_224: () => me,
-  _SHA512_256: () => ye,
-  sha224: () => Fe,
-  sha256: () => zt,
-  sha384: () => en,
-  sha512: () => tn,
-  sha512_224: () => rn,
-  sha512_256: () => nn
-}), Ie, at, ne, he, be, re, Le, qe, lt, ut, Ht, we, ge, Y, G, me, ye, zt, Fe, tn, en, nn, rn, $n = Bt((() => {
-  Nn(), Mn(), Nt(), Ie = /* @__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,
@@ -387,70 +395,70 @@ var It, le, ue, de, yt, Et, Lt, qt, Zn, kn, Tn, Vn, Xe, ze, We, Qe, Je, Pe, Mn =
     2756734187,
     3204031479,
     3329325298
-  ]), at = /* @__PURE__ */ new Uint32Array(64), ne = class extends ae {
+  ]), st = /* @__PURE__ */ new Uint32Array(64), Yt = class extends Wt {
     constructor(t) {
       super(64, t, 8, !1);
     }
     get() {
-      const { A: t, B: e, C: r, D: n, E: o, F: s, G: i, H: c } = this;
+      const { A: t, B: e, C: r, D: n, E: o, F: i, G: c, H: s } = this;
       return [
         t,
         e,
         r,
         n,
         o,
-        s,
         i,
-        c
+        c,
+        s
       ];
     }
-    set(t, e, r, n, o, s, i, c) {
-      this.A = t | 0, this.B = e | 0, this.C = r | 0, this.D = n | 0, this.E = o | 0, this.F = s | 0, this.G = i | 0, this.H = c | 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, e) {
-      for (let a = 0; a < 16; a++, e += 4) at[a] = t.getUint32(e, !1);
-      for (let a = 16; a < 64; a++) {
-        const g = at[a - 15], b = at[a - 2], w = st(g, 7) ^ st(g, 18) ^ g >>> 3;
-        at[a] = (st(b, 17) ^ st(b, 19) ^ b >>> 10) + at[a - 7] + w + at[a - 16] | 0;
+      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: r, B: n, C: o, D: s, E: i, F: c, G: f, H: l } = this;
-      for (let a = 0; a < 64; a++) {
-        const g = st(i, 6) ^ st(i, 11) ^ st(i, 25), b = l + g + qn(i, c, f) + Ie[a] + at[a] | 0, w = (st(r, 2) ^ st(r, 13) ^ st(r, 22)) + Un(r, n, o) | 0;
-        l = f, f = c, c = i, i = s + b | 0, s = o, o = n, n = r, r = b + w | 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;
       }
-      r = r + this.A | 0, n = n + this.B | 0, o = o + this.C | 0, s = s + this.D | 0, i = i + this.E | 0, c = c + this.F | 0, f = f + this.G | 0, l = l + this.H | 0, this.set(r, n, o, s, i, c, f, l);
+      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() {
-      At(at);
+      Bt(st);
     }
     destroy() {
-      this.set(0, 0, 0, 0, 0, 0, 0, 0), At(this.buffer);
-    }
-  }, he = class extends ne {
-    A = dt[0] | 0;
-    B = dt[1] | 0;
-    C = dt[2] | 0;
-    D = dt[3] | 0;
-    E = dt[4] | 0;
-    F = dt[5] | 0;
-    G = dt[6] | 0;
-    H = dt[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);
     }
-  }, be = class extends ne {
-    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;
+  }, 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);
     }
-  }, re = Cn([
+  }, zt = Dn([
     "0x428a2f98d728ae22",
     "0x7137449123ef65cd",
     "0xb5c0fbcfec4d3b2f",
@@ -531,93 +539,93 @@ var It, le, ue, de, yt, Et, Lt, qt, Zn, kn, Tn, Vn, Xe, ze, We, Qe, Je, Pe, Mn =
     "0x597f299cfc657e2a",
     "0x5fcb6fab3ad6faec",
     "0x6c44198c4a475817"
-  ].map((t) => BigInt(t))), Le = re[0], qe = re[1], lt = /* @__PURE__ */ new Uint32Array(80), ut = /* @__PURE__ */ new Uint32Array(80), Ht = class extends ae {
+  ].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: e, Bh: r, Bl: n, Ch: o, Cl: s, Dh: i, Dl: c, Eh: f, El: l, Fh: a, Fl: g, Gh: b, Gl: w, Hh: m, Hl: x } = 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,
         e,
         r,
         n,
         o,
-        s,
         i,
         c,
-        f,
-        l,
+        s,
         a,
+        u,
+        f,
         g,
-        b,
-        w,
         m,
-        x
+        w,
+        A,
+        _
       ];
     }
-    set(t, e, r, n, o, s, i, c, f, l, a, g, b, w, m, x) {
-      this.Ah = t | 0, this.Al = e | 0, this.Bh = r | 0, this.Bl = n | 0, this.Ch = o | 0, this.Cl = s | 0, this.Dh = i | 0, this.Dl = c | 0, this.Eh = f | 0, this.El = l | 0, this.Fh = a | 0, this.Fl = g | 0, this.Gh = b | 0, this.Gl = w | 0, this.Hh = m | 0, this.Hl = x | 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, e) {
-      for (let E = 0; E < 16; E++, e += 4)
-        lt[E] = t.getUint32(e), ut[E] = t.getUint32(e += 4);
-      for (let E = 16; E < 80; E++) {
-        const L = lt[E - 15] | 0, I = ut[E - 15] | 0, V = yt(L, I, 1) ^ yt(L, I, 8) ^ ue(L, I, 7), M = Et(L, I, 1) ^ Et(L, I, 8) ^ de(L, I, 7), D = lt[E - 2] | 0, N = ut[E - 2] | 0, O = yt(D, N, 19) ^ Lt(D, N, 61) ^ ue(D, N, 6), nt = Et(D, N, 19) ^ qt(D, N, 61) ^ de(D, N, 6), F = We(M, nt, ut[E - 7], ut[E - 16]);
-        lt[E] = Qe(F, V, O, lt[E - 7], lt[E - 16]) | 0, ut[E] = F | 0;
+      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: r, Al: n, Bh: o, Bl: s, Ch: i, Cl: c, Dh: f, Dl: l, Eh: a, El: g, Fh: b, Fl: w, Gh: m, Gl: x, Hh: v, Hl: B } = this;
-      for (let E = 0; E < 80; E++) {
-        const L = yt(a, g, 14) ^ yt(a, g, 18) ^ Lt(a, g, 41), I = Et(a, g, 14) ^ Et(a, g, 18) ^ qt(a, g, 41), V = a & b ^ ~a & m, M = g & w ^ ~g & x, D = Je(B, I, M, qe[E], ut[E]), N = Pe(D, v, L, V, Le[E], lt[E]), O = D | 0, nt = yt(r, n, 28) ^ Lt(r, n, 34) ^ Lt(r, n, 39), F = Et(r, n, 28) ^ qt(r, n, 34) ^ qt(r, n, 39), U = r & o ^ r & i ^ o & i, h = n & s ^ n & c ^ s & c;
-        v = m | 0, B = x | 0, m = b | 0, x = w | 0, b = a | 0, w = g | 0, { h: a, l: g } = ft(f | 0, l | 0, N | 0, O | 0), f = i | 0, l = c | 0, i = o | 0, c = s | 0, o = r | 0, s = n | 0;
-        const d = Xe(O, F, h);
-        r = ze(d, N, nt, U), n = d | 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: r, l: n } = ft(this.Ah | 0, this.Al | 0, r | 0, n | 0)), { h: o, l: s } = ft(this.Bh | 0, this.Bl | 0, o | 0, s | 0), { h: i, l: c } = ft(this.Ch | 0, this.Cl | 0, i | 0, c | 0), { h: f, l } = ft(this.Dh | 0, this.Dl | 0, f | 0, l | 0), { h: a, l: g } = ft(this.Eh | 0, this.El | 0, a | 0, g | 0), { h: b, l: w } = ft(this.Fh | 0, this.Fl | 0, b | 0, w | 0), { h: m, l: x } = ft(this.Gh | 0, this.Gl | 0, m | 0, x | 0), { h: v, l: B } = ft(this.Hh | 0, this.Hl | 0, v | 0, B | 0), this.set(r, n, o, s, i, c, f, l, a, g, b, w, m, x, v, B);
+      ({ 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() {
-      At(lt, ut);
+      Bt(ct, ft);
     }
     destroy() {
-      At(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-    }
-  }, we = class extends Ht {
-    Ah = X[0] | 0;
-    Al = X[1] | 0;
-    Bh = X[2] | 0;
-    Bl = X[3] | 0;
-    Ch = X[4] | 0;
-    Cl = X[5] | 0;
-    Dh = X[6] | 0;
-    Dl = X[7] | 0;
-    Eh = X[8] | 0;
-    El = X[9] | 0;
-    Fh = X[10] | 0;
-    Fl = X[11] | 0;
-    Gh = X[12] | 0;
-    Gl = X[13] | 0;
-    Hh = X[14] | 0;
-    Hl = X[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);
     }
-  }, ge = class extends Ht {
-    Ah = K[0] | 0;
-    Al = K[1] | 0;
-    Bh = K[2] | 0;
-    Bl = K[3] | 0;
-    Ch = K[4] | 0;
-    Cl = K[5] | 0;
-    Dh = K[6] | 0;
-    Dl = K[7] | 0;
-    Eh = K[8] | 0;
-    El = K[9] | 0;
-    Fh = K[10] | 0;
-    Fl = K[11] | 0;
-    Gh = K[12] | 0;
-    Gl = K[13] | 0;
-    Hh = K[14] | 0;
-    Hl = K[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);
     }
@@ -638,7 +646,7 @@ var It, le, ue, de, yt, Et, Lt, qt, Zn, kn, Tn, Vn, Xe, ze, We, Qe, Je, Pe, Mn =
     1780299464,
     286451373,
     2446758561
-  ]), G = /* @__PURE__ */ Uint32Array.from([
+  ]), z = /* @__PURE__ */ Uint32Array.from([
     573645204,
     4230739756,
     2673172387,
@@ -655,7 +663,7 @@ var It, le, ue, de, yt, Et, Lt, qt, Zn, kn, Tn, Vn, Xe, ze, We, Qe, Je, Pe, Mn =
     746961066,
     246885852,
     2177182882
-  ]), me = class extends Ht {
+  ]), oe = class extends Rt {
     Ah = Y[0] | 0;
     Al = Y[1] | 0;
     Bh = Y[2] | 0;
@@ -675,265 +683,348 @@ var It, le, ue, de, yt, Et, Lt, qt, Zn, kn, Tn, Vn, Xe, ze, We, Qe, Je, Pe, Mn =
     constructor() {
       super(28);
     }
-  }, ye = class extends Ht {
-    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;
+  }, 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);
     }
-  }, zt = /* @__PURE__ */ _t(() => new he(), /* @__PURE__ */ mt(1)), Fe = /* @__PURE__ */ _t(() => new be(), /* @__PURE__ */ mt(4)), tn = /* @__PURE__ */ _t(() => new we(), /* @__PURE__ */ mt(3)), en = /* @__PURE__ */ _t(() => new ge(), /* @__PURE__ */ mt(2)), nn = /* @__PURE__ */ _t(() => new ye(), /* @__PURE__ */ mt(6)), rn = /* @__PURE__ */ _t(() => new me(), /* @__PURE__ */ mt(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 jt(t, e = "") {
-  if (typeof t != "boolean") {
-    const r = e && `"${e}" `;
-    throw new Error(r + "expected boolean, got type=" + typeof t);
-  }
-  return t;
-}
-function on(t) {
-  if (typeof t == "bigint") {
-    if (!Ut(t)) throw new Error("positive bigint expected, got " + t);
-  } else xt(t);
-  return t;
+function Cn(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
 }
-function Rt(t, e = "") {
-  if (!Number.isSafeInteger(t)) {
+function Ar(t, e = "") {
+  if (!Number.isSafeInteger(t) || t < 0) {
     const r = e && `"${e}" `;
-    throw new Error(r + "expected safe integer, got type=" + typeof t);
+    throw new Error(`${r}expected integer >= 0, got ${t}`);
   }
 }
-function Zt(t) {
-  const e = on(t).toString(16);
-  return e.length & 1 ? "0" + e : e;
+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 sn(t) {
-  if (typeof t != "string") throw new Error("hex string expected, got " + typeof t);
-  return t === "" ? Yt : BigInt("0x" + t);
+function Rr(t, e = !0) {
+  if (t.destroyed) throw new Error("Hash instance has been destroyed");
+  if (e && t.finished) throw new Error("Hash#digest() has already been called");
 }
-function Dt(t) {
-  return sn(Xt(t));
+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 cn(t) {
-  return sn(Xt(jn(C(t)).reverse()));
+function _r(t) {
+  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
 }
-function xe(t, e) {
-  xt(e), t = on(t);
-  const r = Mt(t.toString(16).padStart(e * 2, "0"));
-  if (r.length !== e) throw new Error("number too large");
-  return r;
+function Hr(...t) {
+  for (let e = 0; e < t.length; e++) t[e].fill(0);
 }
-function fn(t, e) {
-  return xe(t, e).reverse();
+function kn(t) {
+  return t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255;
 }
 function jn(t) {
-  return Uint8Array.from(t);
-}
-function Wt(t) {
-  return Uint8Array.from(t, (e, r) => {
-    const n = e.charCodeAt(0);
-    if (e.length !== 1 || n > 127) throw new Error(`string contains non-ASCII character "${t[r]}" with code ${n} at position ${r}`);
-    return n;
-  });
-}
-function Yn(t, e, r) {
-  return Ut(t) && Ut(e) && Ut(r) && e <= t && t < r;
+  for (let e = 0; e < t.length; e++) t[e] = kn(t[e]);
+  return t;
 }
-function Gn(t, e, r, n) {
-  if (!Yn(e, r, n)) throw new Error("expected valid " + t + ": " + r + " <= n < " + n + ", got " + e);
+function Or(...t) {
+  let e = 0;
+  for (let n = 0; n < t.length; n++) {
+    const o = t[n];
+    nn(o), e += o.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 r;
 }
-function Kn(t) {
-  let e;
-  for (e = 0; t > Yt; t >>= Tt, e += 1) ;
-  return 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 Xn(t, e, r) {
-  if (xt(t, "hashLen"), xt(e, "qByteLen"), typeof r != "function") throw new Error("hmacFn must be a function");
-  const n = (v) => new Uint8Array(v), o = Uint8Array.of(), s = Uint8Array.of(0), i = Uint8Array.of(1), c = 1e3;
-  let f = n(t), l = n(t), a = 0;
-  const g = () => {
-    f.fill(1), l.fill(0), a = 0;
-  }, b = (...v) => r(l, P(f, ...v)), w = (v = o) => {
-    l = b(s, v), f = b(), v.length !== 0 && (l = b(i, v), f = b());
-  }, m = () => {
-    if (a++ >= c) throw new Error("drbg: tried max amount of iterations");
-    let v = 0;
-    const B = [];
-    for (; v < e; ) {
-      f = b();
-      const E = f.slice();
-      B.push(E), v += f.length;
-    }
-    return P(...B);
-  };
-  return (v, B) => {
-    g(), w(v);
-    let E;
-    for (; !(E = B(m())); ) w();
-    return g(), E;
-  };
+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));
 }
-function Qt(t, e = {}, r = {}) {
-  if (!t || typeof t != "object") throw new Error("expected valid options object");
-  function n(s, i, c) {
-    const f = t[s];
-    if (c && f === void 0) return;
-    const l = typeof f;
-    if (l !== i || f === null) throw new Error(`param "${s}" is invalid: expected ${i}, got ${l}`);
+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,
+    134,
+    72,
+    1,
+    101,
+    3,
+    4,
+    2,
+    t
+  ]) });
+}));
+function Lr(t, e = "") {
+  if (typeof t != "boolean") {
+    const r = e && `"${e}" `;
+    throw new Error(r + "expected boolean, got type=" + typeof t);
   }
-  const o = (s, i) => Object.entries(s).forEach(([c, f]) => n(c, f, i));
-  o(e, !1), o(r, !0);
-}
-function Ue(t) {
-  const e = /* @__PURE__ */ new WeakMap();
-  return (r, ...n) => {
-    const o = e.get(r);
-    if (o !== void 0) return o;
-    const s = t(r, ...n);
-    return e.set(r, s), s;
-  };
+  return t;
 }
-var Yt, Tt, Ut, Jt, Pt = Bt((() => {
-  Nt(), Yt = /* @__PURE__ */ BigInt(0), Tt = /* @__PURE__ */ BigInt(1), Ut = (t) => typeof t == "bigint" && Yt <= t, Jt = (t) => (Tt << BigInt(t)) - Tt;
+var Nr = dt((() => {
+  zn();
 }));
-function Be(t) {
+function be(t) {
   if (!Number.isSafeInteger(t) || t < 0 || t > 4294967295) throw new Error("wrong u32 integer:" + t);
   return t;
 }
-function an(t) {
-  return Be(t), (t & t - 1) === 0 && t !== 0;
+function rn(t) {
+  return be(t), (t & t - 1) === 0 && t !== 0;
 }
-function zn(t, e) {
-  Be(t);
+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 ln(t) {
-  return Be(t), 31 - Math.clz32(t);
+function on(t) {
+  return be(t), 31 - Math.clz32(t);
 }
-function Ne(t) {
+function Oe(t) {
   const e = t.length;
-  if (e < 2 || !an(e)) throw new Error("n must be a power of 2 and greater than 1. Got " + e);
-  const r = ln(e);
+  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 = zn(n, r);
+    const o = Mn(n, r);
     if (n < o) {
-      const s = t[n];
-      t[n] = t[o], t[o] = s;
+      const i = t[n];
+      t[n] = t[o], t[o] = i;
     }
   }
   return t;
 }
-var Wn, Ur = Bt((() => {
-  Wn = (t, e) => {
-    const { N: r, roots: n, dit: o, invertButterflies: s = !1, skipStages: i = 0, brp: c = !0 } = e, f = ln(r);
-    if (!an(r)) throw new Error("FFT: Polynomial size should be power of two");
-    const l = o !== s;
-    return (a) => {
-      if (a.length !== r) throw new Error("FFT: wrong Polynomial length");
-      o && c && Ne(a);
-      for (let g = 0, b = 1; g < f - i; g++) {
-        const w = o ? g + 1 + i : f - g, m = 1 << w, x = m >> 1, v = r >> w;
-        for (let B = 0; B < r; B += m) for (let E = 0, L = b++; E < x; E++) {
-          const I = s ? o ? r - L : L : E * v, V = B + E, M = B + E + x, D = n[I], N = a[M], O = a[V];
-          if (l) {
-            const nt = t.mul(N, D);
-            a[V] = t.add(O, nt), a[M] = t.sub(O, nt);
-          } else s ? (a[V] = t.add(N, O), a[M] = t.mul(t.sub(N, O), D)) : (a[V] = t.add(O, N), a[M] = t.mul(t.sub(O, N), D));
+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 && c && Ne(a), a;
+      return !o && s && Oe(f), f;
     };
   };
 }));
-Pt();
-var J = /* @__PURE__ */ BigInt(0), W = /* @__PURE__ */ BigInt(1), vt = /* @__PURE__ */ BigInt(2), un = /* @__PURE__ */ BigInt(3), dn = /* @__PURE__ */ BigInt(4), hn = /* @__PURE__ */ BigInt(5), Qn = /* @__PURE__ */ BigInt(7), bn = /* @__PURE__ */ BigInt(8), Jn = /* @__PURE__ */ BigInt(9), wn = /* @__PURE__ */ BigInt(16);
-function et(t, e) {
+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 r = e && `"${e}" `;
+    throw new TypeError(r + "expected boolean, got type=" + typeof t);
+  }
+  return t;
+}
+function we(t) {
+  if (typeof t == "bigint") {
+    if (!$t(t)) throw new RangeError("positive bigint expected, got " + t);
+  } else sn(t);
+  return t;
+}
+function fe(t, e = "") {
+  if (typeof t != "number") {
+    const r = e && `"${e}" `;
+    throw new TypeError(r + "expected number, got type=" + typeof t);
+  }
+  if (!Number.isSafeInteger(t)) {
+    const r = e && `"${e}" `;
+    throw new RangeError(r + "expected safe integer, got " + t);
+  }
+}
+function Nt(t) {
+  const e = we(t).toString(16);
+  return e.length & 1 ? "0" + e : e;
+}
+function un(t) {
+  if (typeof t != "string") throw new TypeError("hex string expected, got " + typeof t);
+  return t === "" ? qt : BigInt("0x" + t);
+}
+function Ct(t) {
+  return un(le(t));
+}
+function ln(t) {
+  return un(le(Kn(mt(t)).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 hn(t, e) {
+  return pe(t, e).reverse();
+}
+function Kn(t) {
+  return Uint8Array.from(W(t));
+}
+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 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 < qt) throw new Error("expected non-negative bigint, got " + t);
+  let e;
+  for (e = 0; t > qt; t >>= ce, e += 1) ;
+  return e;
+}
+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 (H, O) => {
+    g(), w(H);
+    let x;
+    for (; (x = O(A())) === void 0; ) w();
+    return g(), x;
+  };
+}
+function kt(t, e = {}, r = {}) {
+  if (Object.prototype.toString.call(t) !== "[object Object]") throw new TypeError("expected valid options object");
+  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 >= J ? r : e + r;
+  return r >= K ? r : e + r;
 }
-function tt(t, 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-- > J; )
+  for (; e-- > K; )
     n *= n, n %= r;
   return n;
 }
-function De(t, e) {
-  if (t === J) throw new Error("invert: expected non-zero number");
-  if (e <= J) throw new Error("invert: expected positive modulus, got " + e);
-  let r = et(t, e), n = e, o = J, s = W, i = W, c = J;
-  for (; r !== J; ) {
-    const f = n / r, l = n % r, a = o - i * f, g = s - c * f;
-    n = r, r = l, o = i, s = c, i = a, c = g;
+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 !== W) throw new Error("invert: does not exist");
-  return et(o, e);
+  if (n !== D) throw new Error("invert: does not exist");
+  return tt(o, e);
 }
-function _e(t, e, r) {
-  if (!t.eql(t.sqr(e), r)) throw new Error("Cannot find square root");
+function me(t, e, r) {
+  const n = t;
+  if (!n.eql(n.sqr(e), r)) throw new Error("Cannot find square root");
 }
-function gn(t, e) {
-  const r = (t.ORDER + W) / dn, n = t.pow(e, r);
-  return _e(t, n, e), n;
+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.ORDER - hn) / bn, n = t.mul(e, vt), o = t.pow(n, r), s = t.mul(e, o), i = t.mul(t.mul(s, vt), o), c = t.mul(s, t.sub(i, t.ONE));
-  return _e(t, c, e), c;
-}
-function Fn(t) {
-  const e = te(t), r = mn(t), n = r(e, e.neg(e.ONE)), o = r(e, n), s = r(e, e.neg(n)), i = (t + Qn) / wn;
-  return (c, f) => {
-    let l = c.pow(f, i), a = c.mul(l, n);
-    const g = c.mul(l, o), b = c.mul(l, s), w = c.eql(c.sqr(a), f), m = c.eql(c.sqr(g), f);
-    l = c.cmov(l, a, w), a = c.cmov(b, g, m);
-    const x = c.eql(c.sqr(a), f), v = c.cmov(l, a, x);
-    return _e(c, v, f), v;
-  };
+  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 mn(t) {
-  if (t < un) throw new Error("sqrt is not defined for small field");
-  let e = t - W, r = 0;
-  for (; e % vt === J; )
-    e /= vt, r++;
-  let n = vt;
-  const o = te(t);
-  for (; Ce(o, n) === 1; ) if (n++ > 1e3) throw new Error("Cannot find square root: probably non-prime P");
-  if (r === 1) return gn;
-  let s = o.pow(n, e);
-  const i = (e + W) / vt;
-  return function(f, l) {
-    if (f.is0(l)) return l;
-    if (Ce(f, l) !== 1) throw new Error("Cannot find square root");
-    let a = r, g = f.mul(f.ONE, s), b = f.pow(l, e), w = f.pow(l, i);
-    for (; !f.eql(b, f.ONE); ) {
-      if (f.is0(b)) return f.ZERO;
-      let m = 1, x = f.sqr(b);
-      for (; !f.eql(x, f.ONE); )
-        if (m++, x = f.sqr(x), m === a) throw new Error("Cannot find square root");
-      const v = W << BigInt(a - m - 1), B = f.pow(g, v);
-      a = m, g = f.sqr(B), b = f.mul(b, g), w = f.mul(w, B);
-    }
-    return w;
+  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 tr(t) {
-  return t % dn === un ? gn : t % bn === hn ? Pn : t % wn === Jn ? Fn(t) : mn(t);
+function er(t) {
+  return t % bn === gn ? En : t % pn === wn ? Pn : t % yn === Jn ? tr(t) : mn(t);
 }
-var er = [
+var nr = [
   "create",
   "isValid",
   "is0",
@@ -952,96 +1043,104 @@ var er = [
   "mulN",
   "sqrN"
 ];
-function yn(t) {
-  return Qt(t, er.reduce((e, r) => (e[r] = "function", e), {
+function rr(t) {
+  if (kt(t, nr.reduce((e, r) => (e[r] = "function", e), {
     ORDER: "bigint",
     BYTES: "number",
     BITS: "number"
-  })), t;
-}
-function nr(t, e, r) {
-  if (r < J) throw new Error("invalid exponent, negatives unsupported");
-  if (r === J) return t.ONE;
-  if (r === W) return e;
-  let n = t.ONE, o = e;
-  for (; r > J; )
-    r & W && (n = t.mul(n, o)), o = t.sqr(o), r >>= W;
-  return n;
-}
-function Ft(t, e, r = !1) {
-  const n = new Array(e.length).fill(r ? t.ZERO : void 0), o = e.reduce((i, c, f) => t.is0(c) ? i : (n[f] = i, t.mul(i, c)), t.ONE), s = t.inv(o);
-  return e.reduceRight((i, c, f) => t.is0(c) ? i : (n[f] = t.mul(i, n[f]), t.mul(i, c)), s), n;
-}
-function Ce(t, e) {
-  const r = (t.ORDER - W) / vt, n = t.pow(e, r), o = t.eql(n, t.ONE), s = t.eql(n, t.ZERO), i = t.eql(n, t.neg(t.ONE));
-  if (!o && !s && !i) throw new Error("invalid Legendre symbol result");
-  return o ? 1 : s ? 0 : -1;
+  })), 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 rr(t, e) {
-  e !== void 0 && xt(e);
-  const r = e !== void 0 ? e : t.toString(2).length;
+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 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 or = class {
+var Le = /* @__PURE__ */ new WeakMap(), xn = class {
   ORDER;
   BITS;
   BYTES;
   isLE;
-  ZERO = J;
-  ONE = W;
+  ZERO = K;
+  ONE = D;
   _lengths;
-  _sqrt;
   _mod;
   constructor(t, e = {}) {
-    if (t <= J) throw new Error("invalid field: expected ORDER > 0, got " + t);
+    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" && (this.sqrt = e.sqrt), typeof e.isLE == "boolean" && (this.isLE = e.isLE), e.allowedLengths && (this._lengths = e.allowedLengths?.slice()), typeof e.modFromBytes == "boolean" && (this._mod = e.modFromBytes));
-    const { nBitLength: n, nByteLength: o } = rr(t, 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 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 = n, this.BYTES = o, this._sqrt = void 0, Object.preventExtensions(this);
+    this.ORDER = t, this.BITS = n, this.BYTES = o, Object.freeze(this);
   }
   create(t) {
-    return et(t, this.ORDER);
+    return tt(t, this.ORDER);
   }
   isValid(t) {
-    if (typeof t != "bigint") throw new Error("invalid field element: expected bigint, got " + typeof t);
-    return J <= t && t < this.ORDER;
+    if (typeof t != "bigint") throw new TypeError("invalid field element: expected bigint, got " + typeof t);
+    return K <= t && t < this.ORDER;
   }
   is0(t) {
-    return t === J;
+    return t === K;
   }
   isValidNot0(t) {
     return !this.is0(t) && this.isValid(t);
   }
   isOdd(t) {
-    return (t & W) === W;
+    return (t & D) === D;
   }
   neg(t) {
-    return et(-t, this.ORDER);
+    return tt(-t, this.ORDER);
   }
   eql(t, e) {
     return t === e;
   }
   sqr(t) {
-    return et(t * t, this.ORDER);
+    return tt(t * t, this.ORDER);
   }
   add(t, e) {
-    return et(t + e, this.ORDER);
+    return tt(t + e, this.ORDER);
   }
   sub(t, e) {
-    return et(t - e, this.ORDER);
+    return tt(t - e, this.ORDER);
   }
   mul(t, e) {
-    return et(t * e, this.ORDER);
+    return tt(t * e, this.ORDER);
   }
   pow(t, e) {
-    return nr(this, t, e);
+    return or(this, t, e);
   }
   div(t, e) {
-    return et(t * De(e, this.ORDER), this.ORDER);
+    return tt(t * Ie(e, this.ORDER), this.ORDER);
   }
   sqrN(t) {
     return t * t;
@@ -1056,100 +1155,102 @@ var or = class {
     return t * e;
   }
   inv(t) {
-    return De(t, this.ORDER);
+    return Ie(t, this.ORDER);
   }
   sqrt(t) {
-    return this._sqrt || (this._sqrt = tr(this.ORDER)), this._sqrt(this, t);
+    let e = Le.get(this);
+    return e || Le.set(this, e = er(this.ORDER)), e(this, t);
   }
   toBytes(t) {
-    return this.isLE ? fn(t, this.BYTES) : xe(t, this.BYTES);
+    return this.isLE ? hn(t, this.BYTES) : pe(t, this.BYTES);
   }
   fromBytes(t, e = !1) {
-    C(t);
-    const { _lengths: r, BYTES: n, isLE: o, ORDER: s, _mod: i } = this;
+    W(t);
+    const { _lengths: r, BYTES: n, isLE: o, ORDER: i, _mod: c } = this;
     if (r) {
-      if (!r.includes(t.length) || t.length > n) throw new Error("Field.fromBytes: expected " + r + " bytes, got " + t.length);
-      const f = new Uint8Array(n);
-      f.set(t, o ? 0 : f.length - t.length), t = f;
+      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 c = o ? cn(t) : Dt(t);
-    if (i && (c = et(c, s)), !e && !this.isValid(c))
+    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 c;
+    return s;
   }
   invertBatch(t) {
-    return Ft(this, t);
+    return vn(this, t);
   }
   cmov(t, e, r) {
-    return r ? e : t;
+    return Ot(r, "condition"), r ? e : t;
   }
 };
-function te(t, e = {}) {
-  return new or(t, e);
+Object.freeze(xn.prototype);
+function jt(t, e = {}) {
+  return new xn(t, e);
 }
-function En(t) {
+function Bn(t) {
   if (typeof t != "bigint") throw new Error("field order must be bigint");
-  const e = t.toString(2).length;
+  if (t <= D) throw new Error("field order must be greater than 1");
+  const e = ye(t - D);
   return Math.ceil(e / 8);
 }
-function vn(t) {
-  const e = En(t);
+function An(t) {
+  const e = Bn(t);
   return e + Math.ceil(e / 2);
 }
 function sr(t, e, r = !1) {
-  C(t);
-  const n = t.length, o = En(e), s = vn(e);
-  if (n < 16 || n < s || n > 1024) throw new Error("expected " + s + "-1024 bytes of input, got " + n);
-  const i = et(r ? cn(t) : Dt(t), e - W) + W;
-  return r ? fn(i, o) : xe(i, o);
-}
-Pt();
-var Ot = /* @__PURE__ */ BigInt(0), pt = /* @__PURE__ */ BigInt(1);
-function Gt(t, e) {
+  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 Ze(t, e) {
-  const r = Ft(t.Fp, e.map((n) => n.Z));
+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 pn(t, e) {
+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 oe(t, e) {
-  pn(t, e);
+function Mt(t, e) {
+  Rn(t, e);
   const r = Math.ceil(e / t) + 1, n = 2 ** (t - 1), o = 2 ** t;
   return {
     windows: r,
     windowSize: n,
-    mask: Jt(t),
+    mask: Ee(t),
     maxNumber: o,
     shiftBy: BigInt(t)
   };
 }
-function ke(t, e, r) {
-  const { windowSize: n, mask: o, maxNumber: s, shiftBy: i } = r;
-  let c = Number(t & o), f = t >> i;
-  c > n && (c -= s, f += pt);
-  const l = e * n, a = l + Math.abs(c) - 1, g = c === 0, b = c < 0, w = e % 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: f,
-    offset: a,
+    nextN: a,
+    offset: f,
     isZero: g,
-    isNeg: b,
+    isNeg: m,
     isNegF: w,
-    offsetF: l
+    offsetF: u
   };
 }
-var se = /* @__PURE__ */ new WeakMap(), xn = /* @__PURE__ */ new WeakMap();
-function ie(t) {
-  return xn.get(t) || 1;
+var Gt = /* @__PURE__ */ new WeakMap(), Sn = /* @__PURE__ */ new WeakMap();
+function Kt(t) {
+  return Sn.get(t) || 1;
 }
-function Te(t) {
-  if (t !== Ot) throw new Error("invalid wNAF");
+function Ue(t) {
+  if (t !== At) throw new Error("invalid wNAF");
 }
-var ir = class {
+var cr = class {
   BASE;
   ZERO;
   Fn;
@@ -1159,103 +1260,103 @@ var ir = class {
   }
   _unsafeLadder(t, e, r = this.ZERO) {
     let n = t;
-    for (; e > Ot; )
-      e & pt && (r = r.add(n)), n = n.double(), e >>= pt;
+    for (; e > At; )
+      e & yt && (r = r.add(n)), n = n.double(), e >>= yt;
     return r;
   }
   precomputeWindow(t, e) {
-    const { windows: r, windowSize: n } = oe(e, this.bits), o = [];
-    let s = t, i = s;
-    for (let c = 0; c < r; c++) {
-      i = s, o.push(i);
-      for (let f = 1; f < n; f++)
-        i = i.add(s), o.push(i);
-      s = i.double();
+    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, e, r) {
     if (!this.Fn.isValid(r)) throw new Error("invalid scalar");
     let n = this.ZERO, o = this.BASE;
-    const s = oe(t, this.bits);
-    for (let i = 0; i < s.windows; i++) {
-      const { nextN: c, offset: f, isZero: l, isNeg: a, isNegF: g, offsetF: b } = ke(r, i, s);
-      r = c, l ? o = o.add(Gt(g, e[b])) : n = n.add(Gt(a, e[f]));
+    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 Te(r), {
+    return Ue(r), {
       p: n,
       f: o
     };
   }
   wNAFUnsafe(t, e, r, n = this.ZERO) {
-    const o = oe(t, this.bits);
-    for (let s = 0; s < o.windows && r !== Ot; s++) {
-      const { nextN: i, offset: c, isZero: f, isNeg: l } = ke(r, s, o);
-      if (r = i, !f) {
-        const a = e[c];
-        n = n.add(l ? a.negate() : a);
+    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 Te(r), n;
+    return Ue(r), n;
   }
   getPrecomputes(t, e, r) {
-    let n = se.get(e);
-    return n || (n = this.precomputeWindow(e, t), t !== 1 && (typeof r == "function" && (n = r(n)), se.set(e, n))), n;
+    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, e, r) {
-    const n = ie(t);
+    const n = Kt(t);
     return this.wNAF(n, this.getPrecomputes(n, t, r), e);
   }
   unsafe(t, e, r, n) {
-    const o = ie(t);
+    const o = Kt(t);
     return o === 1 ? this._unsafeLadder(t, e, n) : this.wNAFUnsafe(o, this.getPrecomputes(o, t, r), e, n);
   }
   createCache(t, e) {
-    pn(e, this.bits), xn.set(t, e), se.delete(t);
+    Rn(e, this.bits), Sn.set(t, e), Gt.delete(t);
   }
   hasCache(t) {
-    return ie(t) !== 1;
+    return Kt(t) !== 1;
   }
 };
-function cr(t, e, r, n) {
-  let o = e, s = t.ZERO, i = t.ZERO;
-  for (; r > Ot || n > Ot; )
-    r & pt && (s = s.add(o)), n & pt && (i = i.add(o)), o = o.double(), r >>= pt, n >>= pt;
+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: s,
-    p2: i
+    p1: i,
+    p2: c
   };
 }
-function Ve(t, e, r) {
+function $e(t, e, r) {
   if (e) {
     if (e.ORDER !== t) throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
-    return yn(e), e;
-  } else return te(t, { isLE: r });
+    return rr(e), e;
+  } else return jt(t, { isLE: r });
 }
-function fr(t, e, r = {}, n) {
+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 c of [
+  for (const s of [
     "p",
     "n",
     "h"
   ]) {
-    const f = e[c];
-    if (!(typeof f == "bigint" && f > Ot)) throw new Error(`CURVE.${c} 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 = Ve(e.p, r.Fp, n), s = Ve(e.n, r.Fn, n), i = [
+  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 c of i) if (!o.isValid(e[c])) throw new Error(`CURVE.${c} must be valid field element of CURVE.Fp`);
+  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: s
+    Fn: i
   };
 }
-function ar(t, e) {
+function ur(t, e) {
   return function(n) {
     const o = t(n);
     return {
@@ -1264,136 +1365,25 @@ function ar(t, e) {
     };
   };
 }
-Pt();
-var lr = Dt;
-function bt(t, e) {
-  if (Rt(t), Rt(e), t < 0 || t >= 1 << 8 * e) throw new Error("invalid I2OSP input: " + t);
-  const r = Array.from({ length: e }).fill(0);
-  for (let n = e - 1; n >= 0; n--)
-    r[n] = t & 255, t >>>= 8;
-  return new Uint8Array(r);
-}
-function ur(t, e) {
-  const r = new Uint8Array(t.length);
-  for (let n = 0; n < t.length; n++) r[n] = t[n] ^ e[n];
-  return r;
-}
-function Bn(t) {
-  if (!Kt(t) && typeof t != "string") throw new Error("DST must be Uint8Array or ascii string");
-  return typeof t == "string" ? Wt(t) : t;
-}
-function dr(t, e, r, n) {
-  C(t), Rt(r), e = Bn(e), e.length > 255 && (e = n(P(Wt("H2C-OVERSIZE-DST-"), e)));
-  const { outputLen: o, blockLen: s } = n, i = Math.ceil(r / o);
-  if (r > 65535 || i > 255) throw new Error("expand_message_xmd: invalid lenInBytes");
-  const c = P(e, bt(e.length, 1)), f = bt(0, s), l = bt(r, 2), a = new Array(i), g = n(P(f, t, l, bt(0, 1), c));
-  a[0] = n(P(g, bt(1, 1), c));
-  for (let b = 1; b <= i; b++) a[b] = n(P(ur(g, a[b - 1]), bt(b + 1, 1), c));
-  return P(...a).slice(0, r);
-}
-function hr(t, e, r, n, o) {
-  if (C(t), Rt(r), e = Bn(e), e.length > 255) {
-    const s = Math.ceil(2 * n / 8);
-    e = o.create({ dkLen: s }).update(Wt("H2C-OVERSIZE-DST-")).update(e).digest();
-  }
-  if (r > 65535 || e.length > 255) throw new Error("expand_message_xof: invalid lenInBytes");
-  return o.create({ dkLen: r }).update(t).update(bt(r, 2)).update(e).update(bt(e.length, 1)).digest();
-}
-function ce(t, e, r) {
-  Qt(r, {
-    p: "bigint",
-    m: "number",
-    k: "number",
-    hash: "function"
-  });
-  const { p: n, k: o, m: s, hash: i, expand: c, DST: f } = r;
-  Rt(i.outputLen, "valid hash"), C(t), Rt(e);
-  const l = n.toString(2).length, a = Math.ceil((l + o) / 8), g = e * s * a;
-  let b;
-  if (c === "xmd") b = dr(t, f, g, i);
-  else if (c === "xof") b = hr(t, f, g, o, i);
-  else if (c === "_internal_pass") b = t;
-  else throw new Error('expand must be "xmd" or "xof"');
-  const w = new Array(e);
-  for (let m = 0; m < e; m++) {
-    const x = new Array(s);
-    for (let v = 0; v < s; v++) {
-      const B = a * (v + m * s);
-      x[v] = et(lr(b.subarray(B, B + a)), n);
-    }
-    w[m] = x;
-  }
-  return w;
-}
-function br(t, e) {
-  const r = e.map((n) => Array.from(n).reverse());
-  return (n, o) => {
-    const [s, i, c, f] = r.map((g) => g.reduce((b, w) => t.add(t.mul(b, n), w))), [l, a] = Ft(t, [i, f], !0);
-    return n = t.mul(s, l), o = t.mul(o, t.mul(c, a)), {
-      x: n,
-      y: o
-    };
-  };
-}
-var wr = Wt("HashToScalar-");
-function gr(t, e, r) {
-  if (typeof e != "function") throw new Error("mapToCurve() must be defined");
-  function n(s) {
-    return t.fromAffine(e(s));
-  }
-  function o(s) {
-    const i = s.clearCofactor();
-    return i.equals(t.ZERO) ? t.ZERO : (i.assertValidity(), i);
-  }
-  return {
-    defaults: Object.freeze(r),
-    Point: t,
-    hashToCurve(s, i) {
-      const c = ce(s, 2, Object.assign({}, r, i)), f = n(c[0]), l = n(c[1]);
-      return o(f.add(l));
-    },
-    encodeToCurve(s, i) {
-      const c = r.encodeDST ? { DST: r.encodeDST } : {};
-      return o(n(ce(s, 1, Object.assign({}, r, c, i))[0]));
-    },
-    mapToCurve(s) {
-      if (r.m === 1) {
-        if (typeof s != "bigint") throw new Error("expected bigint (m=1)");
-        return o(n([s]));
-      }
-      if (!Array.isArray(s)) throw new Error("expected array of bigints");
-      for (const i of s) if (typeof i != "bigint") throw new Error("expected array of bigints");
-      return o(n(s));
-    },
-    hashToScalar(s, i) {
-      const c = t.Fn.ORDER;
-      return ce(s, 1, Object.assign({}, r, {
-        p: c,
-        m: 1,
-        DST: wr
-      }, i))[0][0];
-    }
-  };
-}
 Ln();
-Nt();
-Pt();
-var Me = (t, e) => (t + (t >= 0 ? e : -e) / ct) / e;
-function mr(t, e, r) {
-  const [[n, o], [s, i]] = e, c = Me(i * t, r), f = Me(-o * t, r);
-  let l = t - c * n - f * s, a = -c * o - f * i;
-  const g = l < rt, b = a < rt;
-  g && (l = -l), b && (a = -a);
-  const w = Jt(Math.ceil(Kn(r) / 2)) + z;
-  if (l < rt || l >= w || a < rt || a >= w) throw new Error("splitScalar (endomorphism): failed, k=" + t);
+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: g,
-    k1: l,
-    k2neg: b,
-    k2: a
+    k1: u,
+    k2neg: m,
+    k2: f
   };
 }
-function Ee(t) {
+function ae(t) {
   if (![
     "compact",
     "recovered",
@@ -1401,88 +1391,96 @@ function Ee(t) {
   ].includes(t)) throw new Error('Signature format must be "compact", "recovered", or "der"');
   return t;
 }
-function fe(t, 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 jt(r.lowS, "lowS"), jt(r.prehash, "prehash"), r.format !== void 0 && Ee(r.format), r;
+  return Ot(r.lowS, "lowS"), Ot(r.prehash, "prehash"), r.format !== void 0 && ae(r.format), r;
 }
-var yr = class extends Error {
+var hr = class extends Error {
   constructor(t = "") {
     super(t);
   }
-}, wt = {
-  Err: yr,
+}, et = {
+  Err: hr,
   _tlv: {
     encode: (t, e) => {
-      const { Err: r } = wt;
-      if (t < 0 || t > 256) throw new r("tlv.encode: wrong tag");
+      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 = Zt(n);
+      const n = e.length / 2, o = Nt(n);
       if (o.length / 2 & 128) throw new r("tlv.encode: long form length too big");
-      const s = n > 127 ? Zt(o.length / 2 | 128) : "";
-      return Zt(t) + s + o + e;
+      const i = n > 127 ? Nt(o.length / 2 | 128) : "";
+      return Nt(t) + i + o + e;
     },
     decode(t, e) {
-      const { Err: r } = wt;
+      const { Err: r } = et;
+      e = W(e, void 0, "DER data");
       let n = 0;
-      if (t < 0 || t > 256) throw new r("tlv.encode: wrong tag");
+      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++], s = !!(o & 128);
-      let i = 0;
-      if (!s) i = o;
+      const o = e[n++], i = !!(o & 128);
+      let c = 0;
+      if (!i) c = o;
       else {
-        const f = o & 127;
-        if (!f) throw new r("tlv.decode(long): indefinite length not supported");
-        if (f > 4) throw new r("tlv.decode(long): byte length is too big");
-        const l = e.subarray(n, n + f);
-        if (l.length !== f) throw new r("tlv.decode: length bytes not complete");
-        if (l[0] === 0) throw new r("tlv.decode(long): zero leftmost byte");
-        for (const a of l) i = i << 8 | a;
-        if (n += f, i < 128) throw new r("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 c = e.subarray(n, n + i);
-      if (c.length !== i) throw new r("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: c,
-        l: e.subarray(n + i)
+        v: s,
+        l: e.subarray(n + c)
       };
     }
   },
   _int: {
     encode(t) {
-      const { Err: e } = wt;
-      if (t < rt) throw new e("integer: negative integers are not allowed");
-      let r = Zt(t);
+      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: e } = wt;
+      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[0] === 0 && !(t[1] & 128)) throw new e("invalid signature integer: unnecessary leading zero");
-      return Dt(t);
+      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: e, _int: r, _tlv: n } = wt, o = C(t, void 0, "signature"), { v: s, l: i } = n.decode(48, o);
-    if (i.length) throw new e("invalid signature: left bytes after parsing");
-    const { v: c, l: f } = n.decode(2, s), { v: l, l: a } = n.decode(2, f);
-    if (a.length) throw new e("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: r.decode(c),
-      s: r.decode(l)
+      r: r.decode(s),
+      s: r.decode(u)
     };
   },
   hexFromSig(t) {
-    const { _tlv: e, _int: r } = wt, n = e.encode(2, r.encode(t.r)) + e.encode(2, r.encode(t.s));
+    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);
   }
-}, rt = BigInt(0), z = BigInt(1), ct = BigInt(2), St = BigInt(3), ve = BigInt(4);
-function Er(t, e = {}) {
-  const r = fr("weierstrass", t, e), { Fp: n, Fn: o } = r;
-  let s = r.CURVE;
-  const { h: i, n: c } = s;
-  Qt(e, {}, {
+};
+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",
@@ -1490,127 +1488,103 @@ function Er(t, e = {}) {
     toBytes: "function",
     endo: "object"
   });
-  const { endo: f } = e;
-  if (f && (!n.is0(s.a) || typeof f.beta != "bigint" || !Array.isArray(f.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 l = An(n, o);
-  function a() {
+  const f = On(n, o);
+  function g() {
     if (!n.isOdd) throw new Error("compression is not supported: Field does not have .isOdd()");
   }
-  function g(U, h, d) {
-    const { x: u, y } = h.toAffine(), _ = n.toBytes(u);
-    return jt(d, "isCompressed"), d ? (a(), P(_n(!n.isOdd(y)), _)) : P(Uint8Array.of(4), _, n.toBytes(y));
-  }
-  function b(U) {
-    C(U, void 0, "Point");
-    const { publicKey: h, publicKeyUncompressed: d } = l, u = U.length, y = U[0], _ = U.subarray(1);
-    if (u === h && (y === 2 || y === 3)) {
-      const S = n.fromBytes(_);
-      if (!n.isValid(S)) throw new Error("bad point: is not on curve, wrong x");
-      const A = x(S);
+  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 (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 {
-        p = n.sqrt(A);
-      } catch (H) {
-        const $ = H instanceof Error ? ": " + H.message : "";
-        throw new Error("bad point: is not on curve, sqrt error" + $);
+        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);
       }
-      a();
-      const R = n.isOdd(p);
-      return (y & 1) === 1 !== R && (p = n.neg(p)), {
-        x: S,
+      g();
+      const v = n.isOdd(p);
+      return (d & 1) === 1 !== v && (p = n.neg(p)), {
+        x: b,
         y: p
       };
-    } else if (u === d && y === 4) {
-      const S = n.BYTES, A = n.fromBytes(_.subarray(0, S)), p = n.fromBytes(_.subarray(S, S * 2));
-      if (!v(A, p)) 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: A,
+        x: E,
         y: p
       };
-    } else throw new Error(`bad point: got length ${u}, expected compressed=${h} or uncompressed=${d}`);
-  }
-  const w = e.toBytes || g, m = e.fromBytes || b;
-  function x(U) {
-    const h = n.sqr(U), d = n.mul(h, U);
-    return n.add(n.add(d, n.mul(U, s.a)), s.b);
-  }
-  function v(U, h) {
-    const d = n.sqr(h), u = x(U);
-    return n.eql(d, u);
-  }
-  if (!v(s.Gx, s.Gy)) throw new Error("bad curve params: generator point");
-  const B = n.mul(n.pow(s.a, St), ve), E = n.mul(n.sqr(s.b), BigInt(27));
-  if (n.is0(n.add(B, E))) throw new Error("bad curve params: a or b");
-  function L(U, h, d = !1) {
-    if (!n.isValid(h) || d && n.is0(h)) throw new Error(`bad point coordinate ${U}`);
+    } 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 I(U) {
-    if (!(U instanceof O)) throw new Error("Weierstrass Point expected");
+  function T(F) {
+    if (!(F instanceof R)) throw new Error("Weierstrass Point expected");
   }
-  function V(U) {
-    if (!f || !f.basises) throw new Error("no endo");
-    return mr(U, f.basises, o.ORDER);
+  function Q(F) {
+    if (!a || !a.basises) throw new Error("no endo");
+    return lr(F, a.basises, o.ORDER);
   }
-  const M = Ue((U, h) => {
-    const { X: d, Y: u, Z: y } = U;
-    if (n.eql(y, n.ONE)) return {
-      x: d,
-      y: u
-    };
-    const _ = U.is0();
-    h == null && (h = _ ? n.ONE : n.inv(y));
-    const S = n.mul(d, h), A = n.mul(u, h), p = n.mul(y, h);
-    if (_) return {
-      x: n.ZERO,
-      y: n.ZERO
-    };
-    if (!n.eql(p, n.ONE)) throw new Error("invZ was invalid");
-    return {
-      x: S,
-      y: A
-    };
-  }), D = Ue((U) => {
-    if (U.is0()) {
-      if (e.allowInfinityPoint && !n.is0(U.Y)) return;
-      throw new Error("bad point: ZERO");
-    }
-    const { x: h, y: d } = U.toAffine();
-    if (!n.isValid(h) || !n.isValid(d)) throw new Error("bad point: x or y not field elements");
-    if (!v(h, d)) throw new Error("bad point: equation left != right");
-    if (!U.isTorsionFree()) throw new Error("bad point: not in prime-order subgroup");
-    return !0;
-  });
-  function N(U, h, d, u, y) {
-    return d = new O(n.mul(d.X, U), d.Y, d.Z), h = Gt(u, h), d = Gt(y, d), h.add(d);
+  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 O {
-    static BASE = new O(s.Gx, s.Gy, n.ONE);
-    static ZERO = new O(n.ZERO, n.ONE, n.ZERO);
+  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(h, d, u) {
-      this.X = L("x", h), this.Y = L("y", d, !0), this.Z = L("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 s;
+      return i;
     }
     static fromAffine(h) {
-      const { x: d, y: u } = h || {};
-      if (!h || !n.isValid(d) || !n.isValid(u)) throw new Error("invalid affine point");
-      if (h instanceof O) throw new Error("projective point not allowed");
-      return n.is0(d) && n.is0(u) ? O.ZERO : new O(d, u, n.ONE);
+      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(h) {
-      const d = O.fromAffine(m(C(h, void 0, "point")));
-      return d.assertValidity(), d;
+      const y = R.fromAffine(_(W(h, void 0, "point")));
+      return y.assertValidity(), y;
     }
     static fromHex(h) {
-      return O.fromBytes(Mt(h));
+      return R.fromBytes(se(h));
     }
     get x() {
       return this.toAffine().x;
@@ -1618,11 +1592,19 @@ function Er(t, e = {}) {
     get y() {
       return this.toAffine().y;
     }
-    precompute(h = 8, d = !0) {
-      return F.createCache(this, h), d || this.multiply(St), this;
+    precompute(h = 8, y = !0) {
+      return X.createCache(this, h), y || this.multiply(Tt), this;
     }
     assertValidity() {
-      D(this);
+      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: 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: h } = this.toAffine();
@@ -1630,153 +1612,108 @@ function Er(t, e = {}) {
       return !n.isOdd(h);
     }
     equals(h) {
-      I(h);
-      const { X: d, Y: u, Z: y } = this, { X: _, Y: S, Z: A } = h, p = n.eql(n.mul(d, A), n.mul(_, y)), R = n.eql(n.mul(u, A), n.mul(S, y));
-      return p && R;
+      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 O(this.X, n.neg(this.Y), this.Z);
+      return new R(this.X, n.neg(this.Y), this.Z);
     }
     double() {
-      const { a: h, b: d } = s, u = n.mul(d, St), { X: y, Y: _, Z: S } = this;
-      let A = n.ZERO, p = n.ZERO, R = n.ZERO, H = n.mul(y, y), $ = n.mul(_, _), Z = n.mul(S, S), q = n.mul(y, _);
-      return q = n.add(q, q), R = n.mul(y, S), R = n.add(R, R), A = n.mul(h, R), p = n.mul(u, Z), p = n.add(A, p), A = n.sub($, p), p = n.add($, p), p = n.mul(A, p), A = n.mul(q, A), R = n.mul(u, R), Z = n.mul(h, Z), q = n.sub(H, Z), q = n.mul(h, q), q = n.add(q, R), R = n.add(H, H), H = n.add(R, H), H = n.add(H, Z), H = n.mul(H, q), p = n.add(p, H), Z = n.mul(_, S), Z = n.add(Z, Z), H = n.mul(Z, q), A = n.sub(A, H), R = n.mul(Z, $), R = n.add(R, R), R = n.add(R, R), new O(A, p, R);
+      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) {
-      I(h);
-      const { X: d, Y: u, Z: y } = this, { X: _, Y: S, Z: A } = h;
-      let p = n.ZERO, R = n.ZERO, H = n.ZERO;
-      const $ = s.a, Z = n.mul(s.b, St);
-      let q = n.mul(d, _), k = n.mul(u, S), j = n.mul(y, A), ot = n.add(d, u), T = n.add(_, S);
-      ot = n.mul(ot, T), T = n.add(q, k), ot = n.sub(ot, T), T = n.add(d, y);
-      let Q = n.add(_, A);
-      return T = n.mul(T, Q), Q = n.add(q, j), T = n.sub(T, Q), Q = n.add(u, y), p = n.add(S, A), Q = n.mul(Q, p), p = n.add(k, j), Q = n.sub(Q, p), H = n.mul($, T), p = n.mul(Z, j), H = n.add(p, H), p = n.sub(k, H), H = n.add(k, H), R = n.mul(p, H), k = n.add(q, q), k = n.add(k, q), j = n.mul($, j), T = n.mul(Z, T), k = n.add(k, j), j = n.sub(q, j), j = n.mul($, j), T = n.add(T, j), q = n.mul(k, T), R = n.add(R, q), q = n.mul(Q, T), p = n.mul(ot, p), p = n.sub(p, q), q = n.mul(ot, k), H = n.mul(Q, H), H = n.add(H, q), new O(p, R, 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 this.add(h.negate());
+      return T(h), this.add(h.negate());
     }
     is0() {
-      return this.equals(O.ZERO);
+      return this.equals(R.ZERO);
     }
     multiply(h) {
-      const { endo: d } = e;
-      if (!o.isValidNot0(h)) throw new Error("invalid scalar: out of range");
-      let u, y;
-      const _ = (S) => F.cached(this, S, (A) => Ze(O, A));
-      if (d) {
-        const { k1neg: S, k1: A, k2neg: p, k2: R } = V(h), { p: H, f: $ } = _(A), { p: Z, f: q } = _(R);
-        y = $.add(q), u = N(d.beta, H, Z, S, p);
+      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: S, f: A } = _(h);
-        u = S, y = A;
+        const { p: b, f: E } = l(h);
+        B = b, d = E;
       }
-      return Ze(O, [u, y])[0];
+      return Ne(R, [B, d])[0];
     }
     multiplyUnsafe(h) {
-      const { endo: d } = e, u = this;
-      if (!o.isValid(h)) throw new Error("invalid scalar: out of range");
-      if (h === rt || u.is0()) return O.ZERO;
-      if (h === z) return u;
-      if (F.hasCache(this)) return this.multiply(h);
-      if (d) {
-        const { k1neg: y, k1: _, k2neg: S, k2: A } = V(h), { p1: p, p2: R } = cr(O, u, _, A);
-        return N(d.beta, p, R, y, S);
-      } else return F.unsafe(u, 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) {
-      return M(this, 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 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 (!n.eql(S, n.ONE)) throw new Error("invZ was invalid");
+      return {
+        x: p,
+        y: v
+      };
     }
     isTorsionFree() {
       const { isTorsionFree: h } = e;
-      return i === z ? !0 : h ? h(O, this) : F.unsafe(this, c).is0();
+      return c === ht ? !0 : h ? h(R, this) : X.unsafe(this, s).is0();
     }
     clearCofactor() {
       const { clearCofactor: h } = e;
-      return i === z ? this : h ? h(O, this) : this.multiplyUnsafe(i);
+      return c === ht ? this : h ? h(R, this) : this.multiplyUnsafe(c);
     }
     isSmallOrder() {
-      return this.multiplyUnsafe(i).is0();
+      return c === ht ? this.is0() : this.clearCofactor().is0();
     }
     toBytes(h = !0) {
-      return jt(h, "isCompressed"), this.assertValidity(), w(O, this, h);
+      return Ot(h, "isCompressed"), this.assertValidity(), A(R, this, h);
     }
     toHex(h = !0) {
-      return Xt(this.toBytes(h));
+      return cn(this.toBytes(h));
     }
     toString() {
       return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
     }
   }
-  const nt = o.BITS, F = new ir(O, e.endo ? Math.ceil(nt / 2) : nt);
-  return O.BASE.precompute(8), O;
+  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 _n(t) {
+function Hn(t) {
   return Uint8Array.of(t ? 2 : 3);
 }
-function vr(t, e) {
-  const r = t.ORDER;
-  let n = rt;
-  for (let m = r - z; m % ct === rt; m /= ct) n += z;
-  const o = n, s = ct << o - z - z, i = s * ct, c = (r - z) / i, f = (c - z) / ct, l = i - z, a = s, g = t.pow(e, c), b = t.pow(e, (c + z) / ct);
-  let w = (m, x) => {
-    let v = g, B = t.pow(x, l), E = t.sqr(B);
-    E = t.mul(E, x);
-    let L = t.mul(m, E);
-    L = t.pow(L, f), L = t.mul(L, B), B = t.mul(L, x), E = t.mul(L, m);
-    let I = t.mul(E, B);
-    L = t.pow(I, a);
-    let V = t.eql(L, t.ONE);
-    B = t.mul(E, b), L = t.mul(I, v), E = t.cmov(B, E, V), I = t.cmov(L, I, V);
-    for (let M = o; M > z; M--) {
-      let D = M - ct;
-      D = ct << D - z;
-      let N = t.pow(I, D);
-      const O = t.eql(N, t.ONE);
-      B = t.mul(E, v), v = t.mul(v, v), N = t.mul(I, v), E = t.cmov(B, E, O), I = t.cmov(N, I, O);
-    }
-    return {
-      isValid: V,
-      value: E
-    };
-  };
-  if (t.ORDER % ve === St) {
-    const m = (t.ORDER - St) / ve, x = t.sqrt(t.neg(e));
-    w = (v, B) => {
-      let E = t.sqr(B);
-      const L = t.mul(v, B);
-      E = t.mul(E, L);
-      let I = t.pow(E, m);
-      I = t.mul(I, L);
-      const V = t.mul(I, x), M = t.mul(t.sqr(I), B), D = t.eql(M, v);
-      return {
-        isValid: D,
-        value: t.cmov(V, I, D)
-      };
-    };
-  }
-  return w;
-}
-function pr(t, e) {
-  yn(t);
-  const { A: r, B: n, Z: o } = e;
-  if (!t.isValid(r) || !t.isValid(n) || !t.isValid(o)) throw new Error("mapToCurveSimpleSWU: invalid opts");
-  const s = vr(t, o);
-  if (!t.isOdd) throw new Error("Field does not have .isOdd()");
-  return (i) => {
-    let c, f, l, a, g, b, w, m;
-    c = t.sqr(i), c = t.mul(c, o), f = t.sqr(c), f = t.add(f, c), l = t.add(f, t.ONE), l = t.mul(l, n), a = t.cmov(o, t.neg(f), !t.eql(f, t.ZERO)), a = t.mul(a, r), f = t.sqr(l), b = t.sqr(a), g = t.mul(b, r), f = t.add(f, g), f = t.mul(f, l), b = t.mul(b, a), g = t.mul(b, n), f = t.add(f, g), w = t.mul(c, l);
-    const { isValid: x, value: v } = s(f, b);
-    m = t.mul(c, i), m = t.mul(m, v), w = t.cmov(w, l, x), m = t.cmov(m, v, x);
-    const B = t.isOdd(i) === t.isOdd(m);
-    m = t.cmov(t.neg(m), m, B);
-    const E = Ft(t, [a], !0)[0];
-    return w = t.mul(w, E), {
-      x: w,
-      y: m
-    };
-  };
-}
-function An(t, e) {
+function On(t, e) {
   return {
     secretKey: e.BYTES,
     publicKey: 1 + t.BYTES,
@@ -1785,222 +1722,224 @@ function An(t, e) {
     signature: 2 * e.BYTES
   };
 }
-function xr(t, e = {}) {
-  const { Fn: r } = t, n = e.randomBytes || Ge, o = Object.assign(An(t.Fp, r), { seed: vn(r.ORDER) });
-  function s(w) {
+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 m = r.fromBytes(w);
-      return r.isValidNot0(m);
+      const A = r.fromBytes(w);
+      return r.isValidNot0(A);
     } catch {
       return !1;
     }
   }
-  function i(w, m) {
-    const { publicKey: x, publicKeyUncompressed: v } = o;
+  function c(w, A) {
+    const { publicKey: _, publicKeyUncompressed: H } = o;
     try {
-      const B = w.length;
-      return m === !0 && B !== x || m === !1 && B !== v ? !1 : !!t.fromBytes(w);
+      const O = w.length;
+      return A === !0 && O !== _ || A === !1 && O !== H ? !1 : !!t.fromBytes(w);
     } catch {
       return !1;
     }
   }
-  function c(w = n(o.seed)) {
-    return sr(C(w, o.seed, "seed"), r.ORDER);
+  function s(w) {
+    return w = w === void 0 ? n(o.seed) : w, sr(W(w, o.seed, "seed"), r.ORDER);
   }
-  function f(w, m = !0) {
-    return t.BASE.multiply(r.fromBytes(w)).toBytes(m);
+  function a(w, A = !0) {
+    return t.BASE.multiply(r.fromBytes(w)).toBytes(A);
   }
-  function l(w) {
-    const { secretKey: m, publicKey: x, publicKeyUncompressed: v } = o;
-    if (!Kt(w) || "_lengths" in r && r._lengths || m === x) return;
-    const B = C(w, void 0, "key").length;
-    return B === x || B === v;
+  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 a(w, m, x = !0) {
-    if (l(w) === !0) throw new Error("first arg must be private key");
-    if (l(m) === !1) throw new Error("second arg must be public key");
-    const v = r.fromBytes(w);
-    return t.fromBytes(m).multiply(v).toBytes(x);
+  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 g = {
-    isValidSecretKey: s,
-    isValidPublicKey: i,
-    randomSecretKey: c
-  }, b = ar(c, f);
-  return Object.freeze({
-    getPublicKey: f,
-    getSharedSecret: a,
-    keygen: b,
+    isValidSecretKey: i,
+    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: g,
     lengths: o
   });
 }
-function Br(t, e, r = {}) {
-  Ye(e), Qt(r, {}, {
+function wr(t, e, r = {}) {
+  const n = e;
+  ke(n), kt(r, {}, {
     hmac: "function",
     lowS: "boolean",
     randomBytes: "function",
     bits2int: "function",
     bits2int_modN: "function"
   }), r = Object.assign({}, r);
-  const n = r.randomBytes || Ge, o = r.hmac || ((d, u) => $t(e, d, u)), { Fp: s, Fn: i } = t, { ORDER: c, BITS: f } = i, { keygen: l, getPublicKey: a, getSharedSecret: g, utils: b, lengths: w } = xr(t, r), m = {
+  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 r.lowS == "boolean" ? r.lowS : !0,
     format: "compact",
     extraEntropy: !1
-  }, x = c * ct < s.ORDER;
-  function v(d) {
-    return d > c >> z;
+  }, H = a * _n + ht < c.ORDER;
+  function O(d) {
+    return d > a >> ht;
   }
-  function B(d, u) {
-    if (!i.isValidNot0(u)) throw new Error(`invalid signature ${d}: out of range 1..Point.Fn.ORDER`);
-    return u;
+  function x(d, l) {
+    if (!s.isValidNot0(l)) throw new Error(`invalid signature ${d}: out of range 1..Point.Fn.ORDER`);
+    return l;
   }
-  function E() {
-    if (x) 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 L(d, u) {
-    Ee(u);
-    const y = w.signature;
-    return C(d, u === "compact" ? y : u === "recovered" ? y + 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 I {
+  class T {
     r;
     s;
     recovery;
-    constructor(u, y, _) {
-      if (this.r = B("r", u), this.s = B("s", y), _ != null) {
-        if (E(), ![
+    constructor(l, b, E) {
+      if (this.r = x("r", l), this.s = x("s", b), E != null) {
+        if (q(), ![
           0,
           1,
           2,
           3
-        ].includes(_)) throw new Error("invalid recovery id");
-        this.recovery = _;
+        ].includes(E)) throw new Error("invalid recovery id");
+        this.recovery = E;
       }
       Object.freeze(this);
     }
-    static fromBytes(u, y = m.format) {
-      L(u, y);
-      let _;
-      if (y === "der") {
-        const { r: R, s: H } = wt.toSig(C(u));
-        return new I(R, H);
+    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);
       }
-      y === "recovered" && (_ = u[0], y = "compact", u = u.subarray(1));
-      const S = w.signature / 2, A = u.subarray(0, S), p = u.subarray(S, S * 2);
-      return new I(i.fromBytes(A), i.fromBytes(p), _);
+      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(u, y) {
-      return this.fromBytes(Mt(u), y);
+    static fromHex(l, b) {
+      return this.fromBytes(se(l), b);
     }
     assertRecovery() {
-      const { recovery: u } = this;
-      if (u == null) throw new Error("invalid recovery id: must be present");
-      return u;
+      const { recovery: l } = this;
+      if (l == null) throw new Error("invalid recovery id: must be present");
+      return l;
     }
-    addRecoveryBit(u) {
-      return new I(this.r, this.s, u);
+    addRecoveryBit(l) {
+      return new T(this.r, this.s, l);
     }
-    recoverPublicKey(u) {
-      const { r: y, s: _ } = this, S = this.assertRecovery(), A = S === 2 || S === 3 ? y + c : y;
-      if (!s.isValid(A)) throw new Error("invalid recovery id: sig.r+curve.n != R.x");
-      const p = s.toBytes(A), R = t.fromBytes(P(_n((S & 1) === 0), p)), H = i.inv(A), $ = M(C(u, void 0, "msgHash")), Z = i.create(-$ * H), q = i.create(_ * H), k = t.BASE.multiplyUnsafe(Z).add(R.multiplyUnsafe(q));
-      if (k.is0()) throw new Error("invalid recovery: point at infinify");
-      return k.assertValidity(), k;
+    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 v(this.s);
-    }
-    toBytes(u = m.format) {
-      if (Ee(u), u === "der") return Mt(wt.hexFromSig(this));
-      const { r: y, s: _ } = this, S = i.toBytes(y), A = i.toBytes(_);
-      return u === "recovered" ? (E(), P(Uint8Array.of(this.assertRecovery()), S, A)) : P(S, A);
-    }
-    toHex(u) {
-      return Xt(this.toBytes(u));
-    }
-  }
-  const V = r.bits2int || function(u) {
-    if (u.length > 8192) throw new Error("input is too large");
-    const y = Dt(u), _ = u.length * 8 - f;
-    return _ > 0 ? y >> BigInt(_) : y;
-  }, M = r.bits2int_modN || function(u) {
-    return i.create(V(u));
-  }, D = Jt(f);
-  function N(d) {
-    return Gn("num < 2^" + f, d, rt, D), i.toBytes(d);
-  }
-  function O(d, u) {
-    return C(d, void 0, "message"), u ? C(e(d), void 0, "prehashed message") : d;
-  }
-  function nt(d, u, y) {
-    const { lowS: _, prehash: S, extraEntropy: A } = fe(y, m);
-    d = O(d, S);
-    const p = M(d), R = i.fromBytes(u);
-    if (!i.isValidNot0(R)) throw new Error("invalid private key");
-    const H = [N(R), N(p)];
-    if (A != null && A !== !1) {
-      const k = A === !0 ? n(w.secretKey) : A;
-      H.push(C(k, void 0, "extraEntropy"));
-    }
-    const $ = P(...H), Z = p;
-    function q(k) {
-      const j = V(k);
-      if (!i.isValidNot0(j)) return;
-      const ot = i.inv(j), T = t.BASE.multiply(j).toAffine(), Q = i.create(T.x);
-      if (Q === rt) return;
-      const Ct = i.create(ot * i.create(Z + Q * R));
-      if (Ct === rt) return;
-      let Se = (T.x === Q ? 0 : 2) | Number(T.y & z), Re = Ct;
-      return _ && v(Ct) && (Re = i.neg(Ct), Se ^= 1), new I(Q, Re, x ? void 0 : Se);
+      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: $,
-      k2sig: q
+      seed: I,
+      k2sig: j
     };
   }
-  function F(d, u, y = {}) {
-    const { seed: _, k2sig: S } = nt(d, u, y);
-    return Xn(e.outputLen, i.BYTES, o)(_, S).toBytes(y.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 U(d, u, y, _ = {}) {
-    const { lowS: S, prehash: A, format: p } = fe(_, m);
-    if (y = C(y, void 0, "publicKey"), u = O(u, A), !Kt(d)) {
-      const R = d instanceof I ? ", use sig.toBytes()" : "";
-      throw new Error("verify expects Uint8Array signature" + R);
+  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);
     }
-    L(d, p);
+    Z(d, S);
     try {
-      const R = I.fromBytes(d, p), H = t.fromBytes(y);
-      if (S && R.hasHighS()) return !1;
-      const { r: $, s: Z } = R, q = M(u), k = i.inv(Z), j = i.create(q * k), ot = i.create($ * k), T = t.BASE.multiplyUnsafe(j).add(H.multiplyUnsafe(ot));
-      return T.is0() ? !1 : i.create(T.x) === $;
+      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 h(d, u, y = {}) {
-    const { prehash: _ } = fe(y, m);
-    return u = O(u, _), I.fromBytes(d, "recovered").recoverPublicKey(u).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: l,
-    getPublicKey: a,
-    getSharedSecret: g,
-    utils: b,
-    lengths: w,
+    keygen: f,
+    getPublicKey: g,
+    getSharedSecret: m,
+    utils: w,
+    lengths: A,
     Point: t,
-    sign: F,
-    verify: U,
-    recoverPublicKey: h,
-    Signature: I,
-    hash: e
+    sign: h,
+    verify: y,
+    recoverPublicKey: B,
+    Signature: T,
+    hash: n
   });
 }
-$n();
-var Ae = {
+var ve = {
   p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
   n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
   h: BigInt(1),
@@ -2008,95 +1947,55 @@ var Ae = {
   b: BigInt(7),
   Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
   Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
-}, _r = {
+}, pr = {
   beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
   basises: [[BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")], [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]]
-}, $e = /* @__PURE__ */ BigInt(2);
-function Ar(t) {
-  const e = Ae.p, r = BigInt(3), n = BigInt(6), o = BigInt(11), s = BigInt(22), i = BigInt(23), c = BigInt(44), f = BigInt(88), l = t * t * t % e, a = l * l * t % e, g = tt(tt(tt(a, r, e) * a % e, r, e) * a % e, $e, e) * l % e, b = tt(g, o, e) * g % e, w = tt(b, s, e) * b % e, m = tt(w, c, e) * w % e, x = tt(tt(tt(tt(tt(tt(m, f, e) * m % e, c, e) * w % e, r, e) * a % e, i, e) * b % e, n, e) * l % e, $e, e);
-  if (!gt.eql(gt.sqr(x), t)) throw new Error("Cannot find square root");
-  return x;
-}
-var gt = te(Ae.p, { sqrt: Ar }), Sn = /* @__PURE__ */ Er(Ae, {
-  Fp: gt,
-  endo: _r
-}), Nr = /* @__PURE__ */ Br(Sn, zt), Sr = br(gt, [
-  [
-    "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
-    "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
-    "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
-    "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
-  ],
-  [
-    "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
-    "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
-    "0x0000000000000000000000000000000000000000000000000000000000000001"
-  ],
-  [
-    "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
-    "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
-    "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
-    "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
-  ],
-  [
-    "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
-    "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
-    "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
-    "0x0000000000000000000000000000000000000000000000000000000000000001"
-  ]
-].map((t) => t.map((e) => BigInt(e)))), Rr = pr(gt, {
-  A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
-  B: BigInt("1771"),
-  Z: gt.create(BigInt("-11"))
-}), Dr = gr(Sn, (t) => {
-  const { x: e, y: r } = Rr(gt.create(t[0]));
-  return Sr(e, r);
-}, {
-  DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
-  encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
-  p: gt.ORDER,
-  m: 1,
-  k: 128,
-  expand: "xmd",
-  hash: zt
-});
+}, 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 {
-  P as A,
-  Lr as C,
-  xt as D,
-  Vt as E,
-  Ge as F,
-  Ir as I,
-  In as L,
-  Nt as M,
-  Kt as N,
-  Rn as O,
-  mt as P,
-  Hr as R,
-  Nn as S,
-  C as T,
-  kn as _,
-  zn as a,
-  ae as b,
-  Pt as c,
-  qr as d,
-  tn as f,
-  Zn as g,
-  Vn as h,
-  Ur as i,
-  _t as j,
-  At as k,
-  $n as l,
-  Tn as m,
-  et as n,
-  jt as o,
-  Mn as p,
-  Wn as r,
-  Dt as s,
-  Nr as t,
-  zt as u,
-  Cn as v,
-  Ln as w,
-  Un as x,
-  qn 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
 };