@ozdao/prometheus-framework 0.2.30 → 0.2.32

package/dist/node_modules/@noble/curves/esm/abstract/weierstrass.js

@@ -1,11 +1,11 @@
-import { mod as ut, hashToPrivateScalar as dt, invert as ht } from "./modular.js";
-import * as mt from "./utils.js";
-import { bytesToNumberBE as _, bitMask as yt, concatBytes as et, validateObject as lt, ensureBytes as Y, hexToBytes as at, numberToBytesBE as rt, createHmacDrbg as pt, bytesToHex as nt } from "./utils.js";
-import { wNAF as wt, validateBasic as ft } from "./curve.js";
+import { mod as lt, getMinHashLength as ht, mapHashToField as mt, invert as pt } from "./modular.js";
+import * as yt from "./utils.js";
+import { bytesToNumberBE as _, bitMask as wt, concatBytes as rt, validateObject as ft, ensureBytes as Y, hexToBytes as at, createHmacDrbg as Et, isBytes as tt, bytesToHex as nt, numberToBytesBE as ct } from "./utils.js";
+import { wNAF as gt, validateBasic as dt } from "./curve.js";
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-function Et(B) {
-  const n = ft(B);
-  lt(n, {
+function bt(B) {
+  const n = dt(B);
+  ft(n, {
     a: "field",
     b: "field"
   }, {
@@ -26,7 +26,7 @@ function Et(B) {
   }
   return Object.freeze({ ...n });
 }
-const { bytesToNumberBE: gt, hexToBytes: bt } = mt, k = {
+const { bytesToNumberBE: Bt, hexToBytes: vt } = yt, k = {
   // asn.1 DER encoding utils
   Err: class extends Error {
     constructor(n = "") {
@@ -44,58 +44,58 @@ const { bytesToNumberBE: gt, hexToBytes: bt } = mt, k = {
       throw new n("Invalid signature integer: negative");
     if (v[0] === 0 && !(v[1] & 128))
       throw new n("Invalid signature integer: unnecessary leading zero");
-    return { d: gt(v), l: B.subarray(t + 2) };
+    return { d: Bt(v), l: B.subarray(t + 2) };
   },
   toSig(B) {
-    const { Err: n } = k, t = typeof B == "string" ? bt(B) : B;
-    if (!(t instanceof Uint8Array))
+    const { Err: n } = k, t = typeof B == "string" ? vt(B) : B;
+    if (!tt(t))
       throw new Error("ui8a expected");
     let v = t.length;
     if (v < 2 || t[0] != 48)
       throw new n("Invalid signature tag");
     if (t[1] !== v - 2)
       throw new n("Invalid signature: incorrect length");
-    const { d: A, l: O } = k._parseInt(t.subarray(2)), { d: F, l: S } = k._parseInt(O);
+    const { d: A, l: O } = k._parseInt(t.subarray(2)), { d: C, l: S } = k._parseInt(O);
     if (S.length)
       throw new n("Invalid signature: left bytes after parsing");
-    return { r: A, s: F };
+    return { r: A, s: C };
   },
   hexFromSig(B) {
     const n = (x) => Number.parseInt(x[0], 16) & 8 ? "00" + x : x, t = (x) => {
-      const U = x.toString(16);
-      return U.length & 1 ? `0${U}` : U;
-    }, v = n(t(B.s)), A = n(t(B.r)), O = v.length / 2, F = A.length / 2, S = t(O), L = t(F);
-    return `30${t(F + O + 4)}02${L}${A}02${S}${v}`;
+      const F = x.toString(16);
+      return F.length & 1 ? `0${F}` : F;
+    }, v = n(t(B.s)), A = n(t(B.r)), O = v.length / 2, C = A.length / 2, S = t(O), H = t(C);
+    return `30${t(C + O + 4)}02${H}${A}02${S}${v}`;
   }
-}, C = BigInt(0), z = BigInt(1);
+}, L = BigInt(0), z = BigInt(1);
 BigInt(2);
-const ct = BigInt(3);
+const ut = BigInt(3);
 BigInt(4);
-function Bt(B) {
-  const n = Et(B), { Fp: t } = n, v = n.toBytes || ((m, e, i) => {
-    const s = e.toAffine();
-    return et(Uint8Array.from([4]), t.toBytes(s.x), t.toBytes(s.y));
+function xt(B) {
+  const n = bt(B), { Fp: t } = n, v = n.toBytes || ((m, r, i) => {
+    const s = r.toAffine();
+    return rt(Uint8Array.from([4]), t.toBytes(s.x), t.toBytes(s.y));
   }), A = n.fromBytes || ((m) => {
-    const e = m.subarray(1), i = t.fromBytes(e.subarray(0, t.BYTES)), s = t.fromBytes(e.subarray(t.BYTES, 2 * t.BYTES));
+    const r = m.subarray(1), i = t.fromBytes(r.subarray(0, t.BYTES)), s = t.fromBytes(r.subarray(t.BYTES, 2 * t.BYTES));
     return { x: i, y: s };
   });
   function O(m) {
-    const { a: e, b: i } = n, s = t.sqr(m), u = t.mul(s, m);
-    return t.add(t.add(u, t.mul(m, e)), i);
+    const { a: r, b: i } = n, s = t.sqr(m), u = t.mul(s, m);
+    return t.add(t.add(u, t.mul(m, r)), i);
   }
   if (!t.eql(t.sqr(n.Gy), O(n.Gx)))
     throw new Error("bad generator point: equation left != right");
-  function F(m) {
-    return typeof m == "bigint" && C < m && m < n.n;
+  function C(m) {
+    return typeof m == "bigint" && L < m && m < n.n;
   }
   function S(m) {
-    if (!F(m))
+    if (!C(m))
       throw new Error("Expected valid bigint: 0 < bigint < curve.n");
   }
-  function L(m) {
-    const { allowedPrivateKeyLengths: e, nByteLength: i, wrapPrivateKey: s, n: u } = n;
-    if (e && typeof m != "bigint") {
-      if (m instanceof Uint8Array && (m = nt(m)), typeof m != "string" || !e.includes(m.length))
+  function H(m) {
+    const { allowedPrivateKeyLengths: r, nByteLength: i, wrapPrivateKey: s, n: u } = n;
+    if (r && typeof m != "bigint") {
+      if (tt(m) && (m = nt(m)), typeof m != "string" || !r.includes(m.length))
         throw new Error("Invalid key");
       m = m.padStart(i * 2, "0");
     }
@@ -105,16 +105,16 @@ function Bt(B) {
     } catch {
       throw new Error(`private key must be ${i} bytes, hex or bigint, not ${typeof m}`);
     }
-    return s && (f = ut(f, u)), S(f), f;
+    return s && (f = lt(f, u)), S(f), f;
   }
   const x = /* @__PURE__ */ new Map();
-  function U(m) {
-    if (!(m instanceof y))
+  function F(m) {
+    if (!(m instanceof p))
       throw new Error("ProjectivePoint expected");
   }
-  class y {
-    constructor(e, i, s) {
-      if (this.px = e, this.py = i, this.pz = s, e == null || !t.isValid(e))
+  class p {
+    constructor(r, i, s) {
+      if (this.px = r, this.py = i, this.pz = s, r == null || !t.isValid(r))
         throw new Error("x required");
       if (i == null || !t.isValid(i))
         throw new Error("y required");
@@ -123,14 +123,14 @@ function Bt(B) {
     }
     // Does not validate if the point is on-curve.
     // Use fromHex instead, or call assertValidity() later.
-    static fromAffine(e) {
-      const { x: i, y: s } = e || {};
-      if (!e || !t.isValid(i) || !t.isValid(s))
+    static fromAffine(r) {
+      const { x: i, y: s } = r || {};
+      if (!r || !t.isValid(i) || !t.isValid(s))
         throw new Error("invalid affine point");
-      if (e instanceof y)
+      if (r instanceof p)
         throw new Error("projective point not allowed");
       const u = (f) => t.eql(f, t.ZERO);
-      return u(i) && u(s) ? y.ZERO : new y(i, s, t.ONE);
+      return u(i) && u(s) ? p.ZERO : new p(i, s, t.ONE);
     }
     get x() {
       return this.toAffine().x;
@@ -144,95 +144,95 @@ function Bt(B) {
      * so this improves performance massively.
      * Optimization: converts a list of projective points to a list of identical points with Z=1.
      */
-    static normalizeZ(e) {
-      const i = t.invertBatch(e.map((s) => s.pz));
-      return e.map((s, u) => s.toAffine(i[u])).map(y.fromAffine);
+    static normalizeZ(r) {
+      const i = t.invertBatch(r.map((s) => s.pz));
+      return r.map((s, u) => s.toAffine(i[u])).map(p.fromAffine);
     }
     /**
      * Converts hash string or Uint8Array to Point.
      * @param hex short/long ECDSA hex
      */
-    static fromHex(e) {
-      const i = y.fromAffine(A(Y("pointHex", e)));
+    static fromHex(r) {
+      const i = p.fromAffine(A(Y("pointHex", r)));
       return i.assertValidity(), i;
     }
     // Multiplies generator point by privateKey.
-    static fromPrivateKey(e) {
-      return y.BASE.multiply(L(e));
+    static fromPrivateKey(r) {
+      return p.BASE.multiply(H(r));
     }
     // "Private method", don't use it directly
-    _setWindowSize(e) {
-      this._WINDOW_SIZE = e, x.delete(this);
+    _setWindowSize(r) {
+      this._WINDOW_SIZE = r, x.delete(this);
     }
     // A point on curve is valid if it conforms to equation.
     assertValidity() {
       if (this.is0()) {
-        if (n.allowInfinityPoint)
+        if (n.allowInfinityPoint && !t.is0(this.py))
           return;
         throw new Error("bad point: ZERO");
       }
-      const { x: e, y: i } = this.toAffine();
-      if (!t.isValid(e) || !t.isValid(i))
+      const { x: r, y: i } = this.toAffine();
+      if (!t.isValid(r) || !t.isValid(i))
         throw new Error("bad point: x or y not FE");
-      const s = t.sqr(i), u = O(e);
+      const s = t.sqr(i), u = O(r);
       if (!t.eql(s, u))
         throw new Error("bad point: equation left != right");
       if (!this.isTorsionFree())
         throw new Error("bad point: not in prime-order subgroup");
     }
     hasEvenY() {
-      const { y: e } = this.toAffine();
+      const { y: r } = this.toAffine();
       if (t.isOdd)
-        return !t.isOdd(e);
+        return !t.isOdd(r);
       throw new Error("Field doesn't support isOdd");
     }
     /**
      * Compare one point to another.
      */
-    equals(e) {
-      U(e);
-      const { px: i, py: s, pz: u } = this, { px: f, py: E, pz: h } = e, a = t.eql(t.mul(i, h), t.mul(f, u)), c = t.eql(t.mul(s, h), t.mul(E, u));
+    equals(r) {
+      F(r);
+      const { px: i, py: s, pz: u } = this, { px: f, py: E, pz: h } = r, a = t.eql(t.mul(i, h), t.mul(f, u)), c = t.eql(t.mul(s, h), t.mul(E, u));
       return a && c;
     }
     /**
      * Flips point to one corresponding to (x, -y) in Affine coordinates.
      */
     negate() {
-      return new y(this.px, t.neg(this.py), this.pz);
+      return new p(this.px, t.neg(this.py), this.pz);
     }
     // Renes-Costello-Batina exception-free doubling formula.
     // There is 30% faster Jacobian formula, but it is not complete.
     // https://eprint.iacr.org/2015/1060, algorithm 3
     // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
     double() {
-      const { a: e, b: i } = n, s = t.mul(i, ct), { px: u, py: f, pz: E } = this;
-      let h = t.ZERO, a = t.ZERO, c = t.ZERO, d = t.mul(u, u), q = t.mul(f, f), b = t.mul(E, E), p = t.mul(u, f);
-      return p = t.add(p, p), c = t.mul(u, E), c = t.add(c, c), h = t.mul(e, c), a = t.mul(s, b), a = t.add(h, a), h = t.sub(q, a), a = t.add(q, a), a = t.mul(h, a), h = t.mul(p, h), c = t.mul(s, c), b = t.mul(e, b), p = t.sub(d, b), p = t.mul(e, p), p = t.add(p, c), c = t.add(d, d), d = t.add(c, d), d = t.add(d, b), d = t.mul(d, p), a = t.add(a, d), b = t.mul(f, E), b = t.add(b, b), d = t.mul(b, p), h = t.sub(h, d), c = t.mul(b, q), c = t.add(c, c), c = t.add(c, c), new y(h, a, c);
+      const { a: r, b: i } = n, s = t.mul(i, ut), { px: u, py: f, pz: E } = this;
+      let h = t.ZERO, a = t.ZERO, c = t.ZERO, d = t.mul(u, u), q = t.mul(f, f), b = t.mul(E, E), y = t.mul(u, f);
+      return y = t.add(y, y), c = t.mul(u, E), c = t.add(c, c), h = t.mul(r, c), a = t.mul(s, b), a = t.add(h, a), h = t.sub(q, a), a = t.add(q, a), a = t.mul(h, a), h = t.mul(y, h), c = t.mul(s, c), b = t.mul(r, b), y = t.sub(d, b), y = t.mul(r, y), y = t.add(y, c), c = t.add(d, d), d = t.add(c, d), d = t.add(d, b), d = t.mul(d, y), a = t.add(a, d), b = t.mul(f, E), b = t.add(b, b), d = t.mul(b, y), h = t.sub(h, d), c = t.mul(b, q), c = t.add(c, c), c = t.add(c, c), new p(h, a, c);
     }
     // Renes-Costello-Batina exception-free addition formula.
     // There is 30% faster Jacobian formula, but it is not complete.
     // https://eprint.iacr.org/2015/1060, algorithm 1
     // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
-    add(e) {
-      U(e);
-      const { px: i, py: s, pz: u } = this, { px: f, py: E, pz: h } = e;
+    add(r) {
+      F(r);
+      const { px: i, py: s, pz: u } = this, { px: f, py: E, pz: h } = r;
       let a = t.ZERO, c = t.ZERO, d = t.ZERO;
-      const q = n.a, b = t.mul(n.b, ct);
-      let p = t.mul(i, f), T = t.mul(s, E), Z = t.mul(u, h), H = t.add(i, s), r = t.add(f, E);
-      H = t.mul(H, r), r = t.add(p, T), H = t.sub(H, r), r = t.add(i, u);
+      const q = n.a, b = t.mul(n.b, ut);
+      let y = t.mul(i, f), T = t.mul(s, E), Z = t.mul(u, h), U = t.add(i, s), e = t.add(f, E);
+      U = t.mul(U, e), e = t.add(y, T), U = t.sub(U, e), e = t.add(i, u);
       let o = t.add(f, h);
-      return r = t.mul(r, o), o = t.add(p, Z), r = t.sub(r, o), o = t.add(s, u), a = t.add(E, h), o = t.mul(o, a), a = t.add(T, Z), o = t.sub(o, a), d = t.mul(q, r), a = t.mul(b, Z), d = t.add(a, d), a = t.sub(T, d), d = t.add(T, d), c = t.mul(a, d), T = t.add(p, p), T = t.add(T, p), Z = t.mul(q, Z), r = t.mul(b, r), T = t.add(T, Z), Z = t.sub(p, Z), Z = t.mul(q, Z), r = t.add(r, Z), p = t.mul(T, r), c = t.add(c, p), p = t.mul(o, r), a = t.mul(H, a), a = t.sub(a, p), p = t.mul(H, T), d = t.mul(o, d), d = t.add(d, p), new y(a, c, d);
+      return e = t.mul(e, o), o = t.add(y, Z), e = t.sub(e, o), o = t.add(s, u), a = t.add(E, h), o = t.mul(o, a), a = t.add(T, Z), o = t.sub(o, a), d = t.mul(q, e), a = t.mul(b, Z), d = t.add(a, d), a = t.sub(T, d), d = t.add(T, d), c = t.mul(a, d), T = t.add(y, y), T = t.add(T, y), Z = t.mul(q, Z), e = t.mul(b, e), T = t.add(T, Z), Z = t.sub(y, Z), Z = t.mul(q, Z), e = t.add(e, Z), y = t.mul(T, e), c = t.add(c, y), y = t.mul(o, e), a = t.mul(U, a), a = t.sub(a, y), y = t.mul(U, T), d = t.mul(o, d), d = t.add(d, y), new p(a, c, d);
     }
-    subtract(e) {
-      return this.add(e.negate());
+    subtract(r) {
+      return this.add(r.negate());
     }
     is0() {
-      return this.equals(y.ZERO);
+      return this.equals(p.ZERO);
     }
-    wNAF(e) {
-      return P.wNAFCached(this, x, e, (i) => {
+    wNAF(r) {
+      return P.wNAFCached(this, x, r, (i) => {
         const s = t.invertBatch(i.map((u) => u.pz));
-        return i.map((u, f) => u.toAffine(s[f])).map(y.fromAffine);
+        return i.map((u, f) => u.toAffine(s[f])).map(p.fromAffine);
       });
     }
     /**
@@ -240,19 +240,19 @@ function Bt(B) {
      * It's faster, but should only be used when you don't care about
      * an exposed private key e.g. sig verification, which works over *public* keys.
      */
-    multiplyUnsafe(e) {
-      const i = y.ZERO;
-      if (e === C)
+    multiplyUnsafe(r) {
+      const i = p.ZERO;
+      if (r === L)
         return i;
-      if (S(e), e === z)
+      if (S(r), r === z)
         return this;
       const { endo: s } = n;
       if (!s)
-        return P.unsafeLadder(this, e);
-      let { k1neg: u, k1: f, k2neg: E, k2: h } = s.splitScalar(e), a = i, c = i, d = this;
-      for (; f > C || h > C; )
+        return P.unsafeLadder(this, r);
+      let { k1neg: u, k1: f, k2neg: E, k2: h } = s.splitScalar(r), a = i, c = i, d = this;
+      for (; f > L || h > L; )
         f & z && (a = a.add(d)), h & z && (c = c.add(d)), d = d.double(), f >>= z, h >>= z;
-      return u && (a = a.negate()), E && (c = c.negate()), c = new y(t.mul(c.px, s.beta), c.py, c.pz), a.add(c);
+      return u && (a = a.negate()), E && (c = c.negate()), c = new p(t.mul(c.px, s.beta), c.py, c.pz), a.add(c);
     }
     /**
      * Constant time multiplication.
@@ -263,19 +263,19 @@ function Bt(B) {
      * @param scalar by which the point would be multiplied
      * @returns New point
      */
-    multiply(e) {
-      S(e);
-      let i = e, s, u;
+    multiply(r) {
+      S(r);
+      let i = r, s, u;
       const { endo: f } = n;
       if (f) {
         const { k1neg: E, k1: h, k2neg: a, k2: c } = f.splitScalar(i);
-        let { p: d, f: q } = this.wNAF(h), { p: b, f: p } = this.wNAF(c);
-        d = P.constTimeNegate(E, d), b = P.constTimeNegate(a, b), b = new y(t.mul(b.px, f.beta), b.py, b.pz), s = d.add(b), u = q.add(p);
+        let { p: d, f: q } = this.wNAF(h), { p: b, f: y } = this.wNAF(c);
+        d = P.constTimeNegate(E, d), b = P.constTimeNegate(a, b), b = new p(t.mul(b.px, f.beta), b.py, b.pz), s = d.add(b), u = q.add(y);
       } else {
         const { p: E, f: h } = this.wNAF(i);
         s = E, u = h;
       }
-      return y.normalizeZ([s, u])[0];
+      return p.normalizeZ([s, u])[0];
     }
     /**
      * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
@@ -283,17 +283,17 @@ function Bt(B) {
      * The trick could be useful if both P and Q are not G (not in our case).
      * @returns non-zero affine point
      */
-    multiplyAndAddUnsafe(e, i, s) {
-      const u = y.BASE, f = (h, a) => a === C || a === z || !h.equals(u) ? h.multiplyUnsafe(a) : h.multiply(a), E = f(this, i).add(f(e, s));
+    multiplyAndAddUnsafe(r, i, s) {
+      const u = p.BASE, f = (h, a) => a === L || a === z || !h.equals(u) ? h.multiplyUnsafe(a) : h.multiply(a), E = f(this, i).add(f(r, s));
       return E.is0() ? void 0 : E;
     }
     // Converts Projective point to affine (x, y) coordinates.
     // Can accept precomputed Z^-1 - for example, from invertBatch.
     // (x, y, z) ∋ (x=x/z, y=y/z)
-    toAffine(e) {
+    toAffine(r) {
       const { px: i, py: s, pz: u } = this, f = this.is0();
-      e == null && (e = f ? t.ONE : t.inv(u));
-      const E = t.mul(i, e), h = t.mul(s, e), a = t.mul(u, e);
+      r == null && (r = f ? t.ONE : t.inv(u));
+      const E = t.mul(i, r), h = t.mul(s, r), a = t.mul(u, r);
       if (f)
         return { x: t.ZERO, y: t.ZERO };
       if (!t.eql(a, t.ONE))
@@ -301,37 +301,37 @@ function Bt(B) {
       return { x: E, y: h };
     }
     isTorsionFree() {
-      const { h: e, isTorsionFree: i } = n;
-      if (e === z)
+      const { h: r, isTorsionFree: i } = n;
+      if (r === z)
         return !0;
       if (i)
-        return i(y, this);
+        return i(p, this);
       throw new Error("isTorsionFree() has not been declared for the elliptic curve");
     }
     clearCofactor() {
-      const { h: e, clearCofactor: i } = n;
-      return e === z ? this : i ? i(y, this) : this.multiplyUnsafe(n.h);
+      const { h: r, clearCofactor: i } = n;
+      return r === z ? this : i ? i(p, this) : this.multiplyUnsafe(n.h);
     }
-    toRawBytes(e = !0) {
-      return this.assertValidity(), v(y, this, e);
+    toRawBytes(r = !0) {
+      return this.assertValidity(), v(p, this, r);
     }
-    toHex(e = !0) {
-      return nt(this.toRawBytes(e));
+    toHex(r = !0) {
+      return nt(this.toRawBytes(r));
     }
   }
-  y.BASE = new y(n.Gx, n.Gy, t.ONE), y.ZERO = new y(t.ZERO, t.ONE, t.ZERO);
-  const W = n.nBitLength, P = wt(y, n.endo ? Math.ceil(W / 2) : W);
+  p.BASE = new p(n.Gx, n.Gy, t.ONE), p.ZERO = new p(t.ZERO, t.ONE, t.ZERO);
+  const W = n.nBitLength, P = gt(p, n.endo ? Math.ceil(W / 2) : W);
   return {
     CURVE: n,
-    ProjectivePoint: y,
-    normPrivateKeyToScalar: L,
+    ProjectivePoint: p,
+    normPrivateKeyToScalar: H,
     weierstrassEquation: O,
-    isWithinCurveOrder: F
+    isWithinCurveOrder: C
   };
 }
-function vt(B) {
-  const n = ft(B);
-  return lt(n, {
+function St(B) {
+  const n = dt(B);
+  return ft(n, {
     hash: "hash",
     hmac: "function",
     randomBytes: "function"
@@ -341,30 +341,30 @@ function vt(B) {
     lowS: "boolean"
   }), Object.freeze({ lowS: !0, ...n });
 }
-function Ot(B) {
-  const n = vt(B), { Fp: t, n: v } = n, A = t.BYTES + 1, O = 2 * t.BYTES + 1;
-  function F(r) {
-    return C < r && r < t.ORDER;
+function Zt(B) {
+  const n = St(B), { Fp: t, n: v } = n, A = t.BYTES + 1, O = 2 * t.BYTES + 1;
+  function C(e) {
+    return L < e && e < t.ORDER;
   }
-  function S(r) {
-    return ut(r, v);
+  function S(e) {
+    return lt(e, v);
   }
-  function L(r) {
-    return ht(r, v);
+  function H(e) {
+    return pt(e, v);
   }
-  const { ProjectivePoint: x, normPrivateKeyToScalar: U, weierstrassEquation: y, isWithinCurveOrder: W } = Bt({
+  const { ProjectivePoint: x, normPrivateKeyToScalar: F, weierstrassEquation: p, isWithinCurveOrder: W } = xt({
     ...n,
-    toBytes(r, o, l) {
-      const g = o.toAffine(), w = t.toBytes(g.x), R = et;
+    toBytes(e, o, l) {
+      const g = o.toAffine(), w = t.toBytes(g.x), R = rt;
       return l ? R(Uint8Array.from([o.hasEvenY() ? 2 : 3]), w) : R(Uint8Array.from([4]), w, t.toBytes(g.y));
     },
-    fromBytes(r) {
-      const o = r.length, l = r[0], g = r.subarray(1);
+    fromBytes(e) {
+      const o = e.length, l = e[0], g = e.subarray(1);
       if (o === A && (l === 2 || l === 3)) {
         const w = _(g);
-        if (!F(w))
+        if (!C(w))
           throw new Error("Point is not on curve");
-        const R = y(w);
+        const R = p(w);
         let I = t.sqrt(R);
         const N = (I & z) === z;
         return (l & 1) === 1 !== N && (I = t.neg(I)), { x: w, y: I };
@@ -374,15 +374,15 @@ function Ot(B) {
       } else
         throw new Error(`Point of length ${o} was invalid. Expected ${A} compressed bytes or ${O} uncompressed bytes`);
     }
-  }), P = (r) => nt(rt(r, n.nByteLength));
-  function m(r) {
+  }), P = (e) => nt(ct(e, n.nByteLength));
+  function m(e) {
     const o = v >> z;
-    return r > o;
+    return e > o;
   }
-  function e(r) {
-    return m(r) ? S(-r) : r;
+  function r(e) {
+    return m(e) ? S(-e) : e;
   }
-  const i = (r, o, l) => _(r.slice(o, l));
+  const i = (e, o, l) => _(e.slice(o, l));
   class s {
     constructor(o, l, g) {
       this.r = o, this.s = l, this.recovery = g, this.assertValidity();
@@ -414,7 +414,7 @@ function Ot(B) {
       const I = w === 2 || w === 3 ? l + n.n : l;
       if (I >= t.ORDER)
         throw new Error("recovery id 2 or 3 invalid");
-      const N = w & 1 ? "03" : "02", D = x.fromHex(N + P(I)), K = L(I), X = S(-R * K), J = S(g * K), $ = x.BASE.multiplyAndAddUnsafe(D, X, J);
+      const N = w & 1 ? "03" : "02", D = x.fromHex(N + P(I)), K = H(I), X = S(-R * K), J = S(g * K), $ = x.BASE.multiplyAndAddUnsafe(D, X, J);
       if (!$)
         throw new Error("point at infinify");
       return $.assertValidity(), $;
@@ -442,21 +442,21 @@ function Ot(B) {
     }
   }
   const u = {
-    isValidPrivateKey(r) {
+    isValidPrivateKey(e) {
       try {
-        return U(r), !0;
+        return F(e), !0;
       } catch {
         return !1;
       }
     },
-    normPrivateKeyToScalar: U,
+    normPrivateKeyToScalar: F,
     /**
-     * Produces cryptographically secure private key from random of size (nBitLength+64)
-     * as per FIPS 186 B.4.1 with modulo bias being neglible.
+     * Produces cryptographically secure private key from random of size
+     * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
      */
     randomPrivateKey: () => {
-      const r = n.randomBytes(t.BYTES + 8), o = dt(r, v);
-      return rt(o, n.nByteLength);
+      const e = ht(n.n);
+      return mt(n.randomBytes(e), n.n);
     },
     /**
      * Creates precompute table for an arbitrary EC point. Makes point "cached".
@@ -466,79 +466,79 @@ function Ot(B) {
      * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
      * fast.multiply(privKey); // much faster ECDH now
      */
-    precompute(r = 8, o = x.BASE) {
-      return o._setWindowSize(r), o.multiply(BigInt(3)), o;
+    precompute(e = 8, o = x.BASE) {
+      return o._setWindowSize(e), o.multiply(BigInt(3)), o;
     }
   };
-  function f(r, o = !0) {
-    return x.fromPrivateKey(r).toRawBytes(o);
+  function f(e, o = !0) {
+    return x.fromPrivateKey(e).toRawBytes(o);
   }
-  function E(r) {
-    const o = r instanceof Uint8Array, l = typeof r == "string", g = (o || l) && r.length;
-    return o ? g === A || g === O : l ? g === 2 * A || g === 2 * O : r instanceof x;
+  function E(e) {
+    const o = tt(e), l = typeof e == "string", g = (o || l) && e.length;
+    return o ? g === A || g === O : l ? g === 2 * A || g === 2 * O : e instanceof x;
   }
-  function h(r, o, l = !0) {
-    if (E(r))
+  function h(e, o, l = !0) {
+    if (E(e))
       throw new Error("first arg must be private key");
     if (!E(o))
       throw new Error("second arg must be public key");
-    return x.fromHex(o).multiply(U(r)).toRawBytes(l);
+    return x.fromHex(o).multiply(F(e)).toRawBytes(l);
   }
-  const a = n.bits2int || function(r) {
-    const o = _(r), l = r.length * 8 - n.nBitLength;
+  const a = n.bits2int || function(e) {
+    const o = _(e), l = e.length * 8 - n.nBitLength;
     return l > 0 ? o >> BigInt(l) : o;
-  }, c = n.bits2int_modN || function(r) {
-    return S(a(r));
-  }, d = yt(n.nBitLength);
-  function q(r) {
-    if (typeof r != "bigint")
+  }, c = n.bits2int_modN || function(e) {
+    return S(a(e));
+  }, d = wt(n.nBitLength);
+  function q(e) {
+    if (typeof e != "bigint")
       throw new Error("bigint expected");
-    if (!(C <= r && r < d))
+    if (!(L <= e && e < d))
       throw new Error(`bigint expected < 2^${n.nBitLength}`);
-    return rt(r, n.nByteLength);
+    return ct(e, n.nByteLength);
   }
-  function b(r, o, l = p) {
+  function b(e, o, l = y) {
     if (["recovered", "canonical"].some((j) => j in l))
       throw new Error("sign() legacy options not supported");
     const { hash: g, randomBytes: w } = n;
     let { lowS: R, prehash: I, extraEntropy: N } = l;
-    R == null && (R = !0), r = Y("msgHash", r), I && (r = Y("prehashed msgHash", g(r)));
-    const D = c(r), K = U(o), X = [q(K), q(D)];
+    R == null && (R = !0), e = Y("msgHash", e), I && (e = Y("prehashed msgHash", g(e)));
+    const D = c(e), K = F(o), X = [q(K), q(D)];
     if (N != null) {
       const j = N === !0 ? w(t.BYTES) : N;
-      X.push(Y("extraEntropy", j, t.BYTES));
+      X.push(Y("extraEntropy", j));
     }
-    const J = et(...X), $ = D;
-    function tt(j) {
+    const J = rt(...X), $ = D;
+    function et(j) {
       const G = a(j);
       if (!W(G))
         return;
-      const ot = L(G), M = x.BASE.multiply(G).toAffine(), V = S(M.x);
-      if (V === C)
+      const ot = H(G), M = x.BASE.multiply(G).toAffine(), V = S(M.x);
+      if (V === L)
         return;
       const Q = S(ot * S($ + V * K));
-      if (Q === C)
+      if (Q === L)
         return;
       let st = (M.x === V ? 0 : 2) | Number(M.y & z), it = Q;
-      return R && m(Q) && (it = e(Q), st ^= 1), new s(V, it, st);
+      return R && m(Q) && (it = r(Q), st ^= 1), new s(V, it, st);
     }
-    return { seed: J, k2sig: tt };
+    return { seed: J, k2sig: et };
   }
-  const p = { lowS: n.lowS, prehash: !1 }, T = { lowS: n.lowS, prehash: !1 };
-  function Z(r, o, l = p) {
-    const { seed: g, k2sig: w } = b(r, o, l), R = n;
-    return pt(R.hash.outputLen, R.nByteLength, R.hmac)(g, w);
+  const y = { lowS: n.lowS, prehash: !1 }, T = { lowS: n.lowS, prehash: !1 };
+  function Z(e, o, l = y) {
+    const { seed: g, k2sig: w } = b(e, o, l), R = n;
+    return Et(R.hash.outputLen, R.nByteLength, R.hmac)(g, w);
   }
   x.BASE._setWindowSize(8);
-  function H(r, o, l, g = T) {
+  function U(e, o, l, g = T) {
     var M;
-    const w = r;
+    const w = e;
     if (o = Y("msgHash", o), l = Y("publicKey", l), "strict" in g)
       throw new Error("options.strict was renamed to lowS");
     const { lowS: R, prehash: I } = g;
     let N, D;
     try {
-      if (typeof w == "string" || w instanceof Uint8Array)
+      if (typeof w == "string" || tt(w))
         try {
           N = s.fromDER(w);
         } catch (V) {
@@ -560,7 +560,7 @@ function Ot(B) {
     if (R && N.hasHighS())
       return !1;
     I && (o = n.hash(o));
-    const { r: K, s: X } = N, J = c(o), $ = L(X), tt = S(J * $), j = S(K * $), G = (M = x.BASE.multiplyAndAddUnsafe(D, tt, j)) == null ? void 0 : M.toAffine();
+    const { r: K, s: X } = N, J = c(o), $ = H(X), et = S(J * $), j = S(K * $), G = (M = x.BASE.multiplyAndAddUnsafe(D, et, j)) == null ? void 0 : M.toAffine();
     return G ? S(G.x) === K : !1;
   }
   return {
@@ -568,7 +568,7 @@ function Ot(B) {
     getPublicKey: f,
     getSharedSecret: h,
     sign: Z,
-    verify: H,
+    verify: U,
     ProjectivePoint: x,
     Signature: s,
     utils: u
@@ -576,6 +576,6 @@ function Ot(B) {
 }
 export {
   k as DER,
-  Ot as weierstrass,
-  Bt as weierstrassPoints
+  Zt as weierstrass,
+  xt as weierstrassPoints
 };