module-develop-kit 1.3.1 → 1.4.0

package/dist/vendor/@noble/ciphers/esm/_polyval.js

@@ -0,0 +1,116 @@
+import { toBytes as y, u32 as x, abytes as W, createView as G, aexists as U, clean as k, aoutput as H, copyBytes as M } from "./utils.js";
+const f = 16, v = /* @__PURE__ */ new Uint8Array(16), l = x(v), R = 225, V = (o, t, s, e) => {
+  const n = e & 1;
+  return {
+    s3: s << 31 | e >>> 1,
+    s2: t << 31 | s >>> 1,
+    s1: o << 31 | t >>> 1,
+    s0: o >>> 1 ^ R << 24 & -(n & 1)
+    // reduce % poly
+  };
+}, c = (o) => (o >>> 0 & 255) << 24 | (o >>> 8 & 255) << 16 | (o >>> 16 & 255) << 8 | o >>> 24 & 255 | 0;
+function j(o) {
+  o.reverse();
+  const t = o[15] & 1;
+  let s = 0;
+  for (let e = 0; e < o.length; e++) {
+    const n = o[e];
+    o[e] = n >>> 1 | s, s = (n & 1) << 7;
+  }
+  return o[0] ^= -t & 225, o;
+}
+const C = (o) => o > 64 * 1024 ? 8 : o > 1024 ? 4 : 2;
+class I {
+  // We select bits per window adaptively based on expectedLength
+  constructor(t, s) {
+    this.blockLen = f, this.outputLen = f, this.s0 = 0, this.s1 = 0, this.s2 = 0, this.s3 = 0, this.finished = !1, t = y(t), W(t, 16);
+    const e = G(t);
+    let n = e.getUint32(0, !1), i = e.getUint32(4, !1), r = e.getUint32(8, !1), b = e.getUint32(12, !1);
+    const g = [];
+    for (let u = 0; u < 128; u++)
+      g.push({ s0: c(n), s1: c(i), s2: c(r), s3: c(b) }), { s0: n, s1: i, s2: r, s3: b } = V(n, i, r, b);
+    const h = C(s || 1024);
+    if (![1, 2, 4, 8].includes(h))
+      throw new Error("ghash: invalid window size, expected 2, 4 or 8");
+    this.W = h;
+    const B = 128 / h, A = this.windowSize = 2 ** h, a = [];
+    for (let u = 0; u < B; u++)
+      for (let w = 0; w < A; w++) {
+        let L = 0, d = 0, m = 0, S = 0;
+        for (let p = 0; p < h; p++) {
+          if (!(w >>> h - p - 1 & 1))
+            continue;
+          const { s0: E, s1: O, s2: P, s3: Z } = g[h * u + p];
+          L ^= E, d ^= O, m ^= P, S ^= Z;
+        }
+        a.push({ s0: L, s1: d, s2: m, s3: S });
+      }
+    this.t = a;
+  }
+  _updateBlock(t, s, e, n) {
+    t ^= this.s0, s ^= this.s1, e ^= this.s2, n ^= this.s3;
+    const { W: i, t: r, windowSize: b } = this;
+    let g = 0, h = 0, _ = 0, B = 0;
+    const A = (1 << i) - 1;
+    let a = 0;
+    for (const u of [t, s, e, n])
+      for (let w = 0; w < 4; w++) {
+        const L = u >>> 8 * w & 255;
+        for (let d = 8 / i - 1; d >= 0; d--) {
+          const m = L >>> i * d & A, { s0: S, s1: p, s2: z, s3: E } = r[a * b + m];
+          g ^= S, h ^= p, _ ^= z, B ^= E, a += 1;
+        }
+      }
+    this.s0 = g, this.s1 = h, this.s2 = _, this.s3 = B;
+  }
+  update(t) {
+    U(this), t = y(t), W(t);
+    const s = x(t), e = Math.floor(t.length / f), n = t.length % f;
+    for (let i = 0; i < e; i++)
+      this._updateBlock(s[i * 4 + 0], s[i * 4 + 1], s[i * 4 + 2], s[i * 4 + 3]);
+    return n && (v.set(t.subarray(e * f)), this._updateBlock(l[0], l[1], l[2], l[3]), k(l)), this;
+  }
+  destroy() {
+    const { t } = this;
+    for (const s of t)
+      s.s0 = 0, s.s1 = 0, s.s2 = 0, s.s3 = 0;
+  }
+  digestInto(t) {
+    U(this), H(t, this), this.finished = !0;
+    const { s0: s, s1: e, s2: n, s3: i } = this, r = x(t);
+    return r[0] = s, r[1] = e, r[2] = n, r[3] = i, t;
+  }
+  digest() {
+    const t = new Uint8Array(f);
+    return this.digestInto(t), this.destroy(), t;
+  }
+}
+class Y extends I {
+  constructor(t, s) {
+    t = y(t), W(t);
+    const e = j(M(t));
+    super(e, s), k(e);
+  }
+  update(t) {
+    t = y(t), U(this);
+    const s = x(t), e = t.length % f, n = Math.floor(t.length / f);
+    for (let i = 0; i < n; i++)
+      this._updateBlock(c(s[i * 4 + 3]), c(s[i * 4 + 2]), c(s[i * 4 + 1]), c(s[i * 4 + 0]));
+    return e && (v.set(t.subarray(n * f)), this._updateBlock(c(l[3]), c(l[2]), c(l[1]), c(l[0])), k(l)), this;
+  }
+  digestInto(t) {
+    U(this), H(t, this), this.finished = !0;
+    const { s0: s, s1: e, s2: n, s3: i } = this, r = x(t);
+    return r[0] = s, r[1] = e, r[2] = n, r[3] = i, t.reverse();
+  }
+}
+function K(o) {
+  const t = (e, n) => o(n, e.length).update(y(e)).digest(), s = o(new Uint8Array(16), 0);
+  return t.outputLen = s.outputLen, t.blockLen = s.blockLen, t.create = (e, n) => o(e, n), t;
+}
+const D = K((o, t) => new I(o, t));
+K((o, t) => new Y(o, t));
+export {
+  j as _toGHASHKey,
+  D as ghash
+};

package/dist/vendor/@noble/ciphers/esm/utils.js

@@ -0,0 +1,68 @@
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+function i(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function y(t, ...e) {
+  if (!i(t))
+    throw new Error("Uint8Array expected");
+  if (e.length > 0 && !e.includes(t.length))
+    throw new Error("Uint8Array expected of length " + e + ", got length=" + t.length);
+}
+function l(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 p(t, e) {
+  y(t);
+  const n = e.outputLen;
+  if (t.length < n)
+    throw new Error("digestInto() expects output buffer of length at least " + n);
+}
+function U(t) {
+  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
+}
+function x(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function B(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function g(t) {
+  if (typeof t != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function d(t) {
+  if (typeof t == "string")
+    t = g(t);
+  else if (i(t))
+    t = w(t);
+  else
+    throw new Error("Uint8Array expected, got " + typeof t);
+  return t;
+}
+function A(t, e, n, r) {
+  if (typeof t.setBigUint64 == "function")
+    return t.setBigUint64(e, n, r);
+  const f = BigInt(32), o = BigInt(4294967295), c = Number(n >> f & o), s = Number(n & o), u = 0, h = 4;
+  t.setUint32(e + u, c, r), t.setUint32(e + h, s, r);
+}
+function w(t) {
+  return Uint8Array.from(t);
+}
+export {
+  y as abytes,
+  l as aexists,
+  p as aoutput,
+  x as clean,
+  w as copyBytes,
+  B as createView,
+  i as isBytes,
+  A as setBigUint64,
+  d as toBytes,
+  U as u32,
+  g as utf8ToBytes
+};

package/dist/vendor/@noble/curves/esm/abstract/curve.js

@@ -0,0 +1,203 @@
+import { bitLen as M, bitMask as y } from "../utils.js";
+import { validateField as I, Field as z, FpInvertBatch as R } from "./modular.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const m = BigInt(0), b = BigInt(1);
+function v(r, t) {
+  const e = t.negate();
+  return r ? e : t;
+}
+function D(r, t) {
+  const e = R(r.Fp, t.map((n) => n.Z));
+  return t.map((n, i) => r.fromAffine(n.toAffine(e[i])));
+}
+function O(r, t) {
+  if (!Number.isSafeInteger(r) || r <= 0 || r > t)
+    throw new Error("invalid window size, expected [1.." + t + "], got W=" + r);
+}
+function F(r, t) {
+  O(r, t);
+  const e = Math.ceil(t / r) + 1, n = 2 ** (r - 1), i = 2 ** r, o = y(r), s = BigInt(r);
+  return { windows: e, windowSize: n, mask: o, maxNumber: i, shiftBy: s };
+}
+function S(r, t, e) {
+  const { windowSize: n, mask: i, maxNumber: o, shiftBy: s } = e;
+  let a = Number(r & i), f = r >> s;
+  a > n && (a -= o, f += b);
+  const c = t * n, d = c + Math.abs(a) - 1, u = a === 0, w = a < 0, h = t % 2 !== 0;
+  return { nextN: f, offset: d, isZero: u, isNeg: w, isNegF: h, offsetF: c };
+}
+function j(r, t) {
+  if (!Array.isArray(r))
+    throw new Error("array expected");
+  r.forEach((e, n) => {
+    if (!(e instanceof t))
+      throw new Error("invalid point at index " + n);
+  });
+}
+function _(r, t) {
+  if (!Array.isArray(r))
+    throw new Error("array of scalars expected");
+  r.forEach((e, n) => {
+    if (!t.isValid(e))
+      throw new Error("invalid scalar at index " + n);
+  });
+}
+const E = /* @__PURE__ */ new WeakMap(), B = /* @__PURE__ */ new WeakMap();
+function N(r) {
+  return B.get(r) || 1;
+}
+function Z(r) {
+  if (r !== m)
+    throw new Error("invalid wNAF");
+}
+class G {
+  // Parametrized with a given Point class (not individual point)
+  constructor(t, e) {
+    this.BASE = t.BASE, this.ZERO = t.ZERO, this.Fn = t.Fn, this.bits = e;
+  }
+  // non-const time multiplication ladder
+  _unsafeLadder(t, e, n = this.ZERO) {
+    let i = t;
+    for (; e > m; )
+      e & b && (n = n.add(i)), i = i.double(), e >>= b;
+    return n;
+  }
+  /**
+   * Creates a wNAF precomputation window. Used for caching.
+   * Default window size is set by `utils.precompute()` and is equal to 8.
+   * Number of precomputed points depends on the curve size:
+   * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+   * - 𝑊 is the window size
+   * - 𝑛 is the bitlength of the curve order.
+   * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+   * @param point Point instance
+   * @param W window size
+   * @returns precomputed point tables flattened to a single array
+   */
+  precomputeWindow(t, e) {
+    const { windows: n, windowSize: i } = F(e, this.bits), o = [];
+    let s = t, a = s;
+    for (let f = 0; f < n; f++) {
+      a = s, o.push(a);
+      for (let c = 1; c < i; c++)
+        a = a.add(s), o.push(a);
+      s = a.double();
+    }
+    return o;
+  }
+  /**
+   * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+   * More compact implementation:
+   * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
+   * @returns real and fake (for const-time) points
+   */
+  wNAF(t, e, n) {
+    if (!this.Fn.isValid(n))
+      throw new Error("invalid scalar");
+    let i = this.ZERO, o = this.BASE;
+    const s = F(t, this.bits);
+    for (let a = 0; a < s.windows; a++) {
+      const { nextN: f, offset: c, isZero: d, isNeg: u, isNegF: w, offsetF: h } = S(n, a, s);
+      n = f, d ? o = o.add(v(w, e[h])) : i = i.add(v(u, e[c]));
+    }
+    return Z(n), { p: i, f: o };
+  }
+  /**
+   * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+   * @param acc accumulator point to add result of multiplication
+   * @returns point
+   */
+  wNAFUnsafe(t, e, n, i = this.ZERO) {
+    const o = F(t, this.bits);
+    for (let s = 0; s < o.windows && n !== m; s++) {
+      const { nextN: a, offset: f, isZero: c, isNeg: d } = S(n, s, o);
+      if (n = a, !c) {
+        const u = e[f];
+        i = i.add(d ? u.negate() : u);
+      }
+    }
+    return Z(n), i;
+  }
+  getPrecomputes(t, e, n) {
+    let i = E.get(e);
+    return i || (i = this.precomputeWindow(e, t), t !== 1 && (typeof n == "function" && (i = n(i)), E.set(e, i))), i;
+  }
+  cached(t, e, n) {
+    const i = N(t);
+    return this.wNAF(i, this.getPrecomputes(i, t, n), e);
+  }
+  unsafe(t, e, n, i) {
+    const o = N(t);
+    return o === 1 ? this._unsafeLadder(t, e, i) : this.wNAFUnsafe(o, this.getPrecomputes(o, t, n), e, i);
+  }
+  // We calculate precomputes for elliptic curve point multiplication
+  // using windowed method. This specifies window size and
+  // stores precomputed values. Usually only base point would be precomputed.
+  createCache(t, e) {
+    O(e, this.bits), B.set(t, e), E.delete(t);
+  }
+  hasCache(t) {
+    return N(t) !== 1;
+  }
+}
+function q(r, t, e, n) {
+  let i = t, o = r.ZERO, s = r.ZERO;
+  for (; e > m || n > m; )
+    e & b && (o = o.add(i)), n & b && (s = s.add(i)), i = i.double(), e >>= b, n >>= b;
+  return { p1: o, p2: s };
+}
+function K(r, t, e, n) {
+  j(e, r), _(n, t);
+  const i = e.length, o = n.length;
+  if (i !== o)
+    throw new Error("arrays of points and scalars must have equal length");
+  const s = r.ZERO, a = M(BigInt(i));
+  let f = 1;
+  a > 12 ? f = a - 3 : a > 4 ? f = a - 2 : a > 0 && (f = 2);
+  const c = y(f), d = new Array(Number(c) + 1).fill(s), u = Math.floor((t.BITS - 1) / f) * f;
+  let w = s;
+  for (let h = u; h >= 0; h -= f) {
+    d.fill(s);
+    for (let l = 0; l < o; l++) {
+      const p = n[l], A = Number(p >> BigInt(h) & c);
+      d[A] = d[A].add(e[l]);
+    }
+    let g = s;
+    for (let l = d.length - 1, p = s; l > 0; l--)
+      p = p.add(d[l]), g = g.add(p);
+    if (w = w.add(g), h !== 0)
+      for (let l = 0; l < f; l++)
+        w = w.double();
+  }
+  return w;
+}
+function x(r, t, e) {
+  if (t) {
+    if (t.ORDER !== r)
+      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+    return I(t), t;
+  } else
+    return z(r, { isLE: e });
+}
+function P(r, t, e = {}, n) {
+  if (n === void 0 && (n = r === "edwards"), !t || typeof t != "object")
+    throw new Error(`expected valid ${r} CURVE object`);
+  for (const f of ["p", "n", "h"]) {
+    const c = t[f];
+    if (!(typeof c == "bigint" && c > m))
+      throw new Error(`CURVE.${f} must be positive bigint`);
+  }
+  const i = x(t.p, e.Fp, n), o = x(t.n, e.Fn, n), a = ["Gx", "Gy", "a", "b"];
+  for (const f of a)
+    if (!i.isValid(t[f]))
+      throw new Error(`CURVE.${f} must be valid field element of CURVE.Fp`);
+  return t = Object.freeze(Object.assign({}, t)), { CURVE: t, Fp: i, Fn: o };
+}
+export {
+  P as _createCurveFields,
+  q as mulEndoUnsafe,
+  v as negateCt,
+  D as normalizeZ,
+  K as pippenger,
+  G as wNAF
+};

package/dist/vendor/@noble/curves/esm/abstract/modular.js

@@ -0,0 +1,240 @@
+import { numberToBytesLE as _, numberToBytesBE as S, bitMask as K, bytesToNumberLE as x, bytesToNumberBE as T, _validateObject as Q } from "../utils.js";
+import { anumber as Y } from "../../../hashes/esm/utils.js";
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+const m = BigInt(0), g = BigInt(1), B = /* @__PURE__ */ BigInt(2), L = /* @__PURE__ */ BigInt(3), M = /* @__PURE__ */ BigInt(4), A = /* @__PURE__ */ BigInt(5), U = /* @__PURE__ */ BigInt(7), V = /* @__PURE__ */ BigInt(8), k = /* @__PURE__ */ BigInt(9), Z = /* @__PURE__ */ BigInt(16);
+function q(t, n) {
+  const r = t % n;
+  return r >= m ? r : n + r;
+}
+function y(t, n) {
+  if (t === m)
+    throw new Error("invert: expected non-zero number");
+  if (n <= m)
+    throw new Error("invert: expected positive modulus, got " + n);
+  let r = q(t, n), o = n, l = m, u = g;
+  for (; r !== m; ) {
+    const i = o / r, s = o % r, f = l - u * i;
+    o = r, r = s, l = u, u = f;
+  }
+  if (o !== g)
+    throw new Error("invert: does not exist");
+  return q(l, n);
+}
+function b(t, n, r) {
+  if (!t.eql(t.sqr(n), r))
+    throw new Error("Cannot find square root");
+}
+function j(t, n) {
+  const r = (t.ORDER + g) / M, o = t.pow(n, r);
+  return b(t, o, n), o;
+}
+function G(t, n) {
+  const r = (t.ORDER - A) / V, o = t.mul(n, B), l = t.pow(o, r), u = t.mul(n, l), d = t.mul(t.mul(u, B), l), i = t.mul(u, t.sub(d, t.ONE));
+  return b(t, i, n), i;
+}
+function J(t) {
+  const n = C(t), r = z(t), o = r(n, n.neg(n.ONE)), l = r(n, o), u = r(n, n.neg(o)), d = (t + U) / Z;
+  return (i, s) => {
+    let f = i.pow(s, d), w = i.mul(f, o);
+    const a = i.mul(f, l), e = i.mul(f, u), c = i.eql(i.sqr(w), s), h = i.eql(i.sqr(a), s);
+    f = i.cmov(f, w, c), w = i.cmov(e, a, h);
+    const v = i.eql(i.sqr(w), s), E = i.cmov(f, w, v);
+    return b(i, E, s), E;
+  };
+}
+function z(t) {
+  if (t < L)
+    throw new Error("sqrt is not defined for small field");
+  let n = t - g, r = 0;
+  for (; n % B === m; )
+    n /= B, r++;
+  let o = B;
+  const l = C(t);
+  for (; I(l, o) === 1; )
+    if (o++ > 1e3)
+      throw new Error("Cannot find square root: probably non-prime P");
+  if (r === 1)
+    return j;
+  let u = l.pow(o, n);
+  const d = (n + g) / B;
+  return function(s, f) {
+    if (s.is0(f))
+      return f;
+    if (I(s, f) !== 1)
+      throw new Error("Cannot find square root");
+    let w = r, a = s.mul(s.ONE, u), e = s.pow(f, n), c = s.pow(f, d);
+    for (; !s.eql(e, s.ONE); ) {
+      if (s.is0(e))
+        return s.ZERO;
+      let h = 1, v = s.sqr(e);
+      for (; !s.eql(v, s.ONE); )
+        if (h++, v = s.sqr(v), h === w)
+          throw new Error("Cannot find square root");
+      const E = g << BigInt(w - h - 1), N = s.pow(a, E);
+      w = h, a = s.sqr(N), e = s.mul(e, a), c = s.mul(c, N);
+    }
+    return c;
+  };
+}
+function O(t) {
+  return t % M === L ? j : t % V === A ? G : t % Z === k ? J(t) : z(t);
+}
+const W = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function F(t) {
+  const n = {
+    ORDER: "bigint",
+    MASK: "bigint",
+    BYTES: "number",
+    BITS: "number"
+  }, r = W.reduce((o, l) => (o[l] = "function", o), n);
+  return Q(t, r), t;
+}
+function X(t, n, r) {
+  if (r < m)
+    throw new Error("invalid exponent, negatives unsupported");
+  if (r === m)
+    return t.ONE;
+  if (r === g)
+    return n;
+  let o = t.ONE, l = n;
+  for (; r > m; )
+    r & g && (o = t.mul(o, l)), l = t.sqr(l), r >>= g;
+  return o;
+}
+function $(t, n, r = !1) {
+  const o = new Array(n.length).fill(r ? t.ZERO : void 0), l = n.reduce((d, i, s) => t.is0(i) ? d : (o[s] = d, t.mul(d, i)), t.ONE), u = t.inv(l);
+  return n.reduceRight((d, i, s) => t.is0(i) ? d : (o[s] = t.mul(d, o[s]), t.mul(d, i)), u), o;
+}
+function I(t, n) {
+  const r = (t.ORDER - g) / B, o = t.pow(n, r), l = t.eql(o, t.ONE), u = t.eql(o, t.ZERO), d = t.eql(o, t.neg(t.ONE));
+  if (!l && !u && !d)
+    throw new Error("invalid Legendre symbol result");
+  return l ? 1 : u ? 0 : -1;
+}
+function P(t, n) {
+  n !== void 0 && Y(n);
+  const r = n !== void 0 ? n : t.toString(2).length, o = Math.ceil(r / 8);
+  return { nBitLength: r, nByteLength: o };
+}
+function C(t, n, r = !1, o = {}) {
+  if (t <= m)
+    throw new Error("invalid field: expected ORDER > 0, got " + t);
+  let l, u, d = !1, i;
+  if (typeof n == "object" && n != null) {
+    if (o.sqrt || r)
+      throw new Error("cannot specify opts in two arguments");
+    const e = n;
+    e.BITS && (l = e.BITS), e.sqrt && (u = e.sqrt), typeof e.isLE == "boolean" && (r = e.isLE), typeof e.modFromBytes == "boolean" && (d = e.modFromBytes), i = e.allowedLengths;
+  } else
+    typeof n == "number" && (l = n), o.sqrt && (u = o.sqrt);
+  const { nBitLength: s, nByteLength: f } = P(t, l);
+  if (f > 2048)
+    throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+  let w;
+  const a = Object.freeze({
+    ORDER: t,
+    isLE: r,
+    BITS: s,
+    BYTES: f,
+    MASK: K(s),
+    ZERO: m,
+    ONE: g,
+    allowedLengths: i,
+    create: (e) => q(e, t),
+    isValid: (e) => {
+      if (typeof e != "bigint")
+        throw new Error("invalid field element: expected bigint, got " + typeof e);
+      return m <= e && e < t;
+    },
+    is0: (e) => e === m,
+    // is valid and invertible
+    isValidNot0: (e) => !a.is0(e) && a.isValid(e),
+    isOdd: (e) => (e & g) === g,
+    neg: (e) => q(-e, t),
+    eql: (e, c) => e === c,
+    sqr: (e) => q(e * e, t),
+    add: (e, c) => q(e + c, t),
+    sub: (e, c) => q(e - c, t),
+    mul: (e, c) => q(e * c, t),
+    pow: (e, c) => X(a, e, c),
+    div: (e, c) => q(e * y(c, t), t),
+    // Same as above, but doesn't normalize
+    sqrN: (e) => e * e,
+    addN: (e, c) => e + c,
+    subN: (e, c) => e - c,
+    mulN: (e, c) => e * c,
+    inv: (e) => y(e, t),
+    sqrt: u || ((e) => (w || (w = O(t)), w(a, e))),
+    toBytes: (e) => r ? _(e, f) : S(e, f),
+    fromBytes: (e, c = !0) => {
+      if (i) {
+        if (!i.includes(e.length) || e.length > f)
+          throw new Error("Field.fromBytes: expected " + i + " bytes, got " + e.length);
+        const v = new Uint8Array(f);
+        v.set(e, r ? 0 : v.length - e.length), e = v;
+      }
+      if (e.length !== f)
+        throw new Error("Field.fromBytes: expected " + f + " bytes, got " + e.length);
+      let h = r ? x(e) : T(e);
+      if (d && (h = q(h, t)), !c && !a.isValid(h))
+        throw new Error("invalid field element: outside of range 0..ORDER");
+      return h;
+    },
+    // TODO: we don't need it here, move out to separate fn
+    invertBatch: (e) => $(a, e),
+    // We can't move this out because Fp6, Fp12 implement it
+    // and it's unclear what to return in there.
+    cmov: (e, c, h) => h ? c : e
+  });
+  return Object.freeze(a);
+}
+function H(t) {
+  if (typeof t != "bigint")
+    throw new Error("field order must be bigint");
+  const n = t.toString(2).length;
+  return Math.ceil(n / 8);
+}
+function D(t) {
+  const n = H(t);
+  return n + Math.ceil(n / 2);
+}
+function tt(t, n, r = !1) {
+  const o = t.length, l = H(n), u = D(n);
+  if (o < 16 || o < u || o > 1024)
+    throw new Error("expected " + u + "-1024 bytes of input, got " + o);
+  const d = r ? x(t) : T(t), i = q(d, n - g) + g;
+  return r ? _(i, l) : S(i, l);
+}
+export {
+  C as Field,
+  $ as FpInvertBatch,
+  I as FpLegendre,
+  X as FpPow,
+  O as FpSqrt,
+  H as getFieldBytesLength,
+  D as getMinHashLength,
+  y as invert,
+  tt as mapHashToField,
+  q as mod,
+  P as nLength,
+  z as tonelliShanks,
+  F as validateField
+};

package/dist/vendor/@noble/curves/esm/abstract/utils.js

@@ -0,0 +1,10 @@
+import { hexToNumber as e, numberToBytesBE as o, numberToHexUnpadded as t } from "../utils.js";
+import { concatBytes as s, bytesToHex as n } from "../../../hashes/esm/utils.js";
+const b = n, T = s, a = t, c = e, x = o;
+export {
+  b as bytesToHex,
+  T as concatBytes,
+  c as hexToNumber,
+  x as numberToBytesBE,
+  a as numberToHexUnpadded
+};