astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es1173.js

@@ -0,0 +1,16 @@
+var i, n;
+function o() {
+  if (n) return i;
+  n = 1, i = e;
+  function e(s, r) {
+    if (!s)
+      throw new Error(r || "Assertion failed");
+  }
+  return e.equal = function(r, t, a) {
+    if (r != t)
+      throw new Error(a || "Assertion failed: " + r + " != " + t);
+  }, i;
+}
+export {
+  o as __require
+};

package/dist/astra-sdk.es1174.js

@@ -0,0 +1,45 @@
+import { __exports as i } from "./astra-sdk.es1276.js";
+var v;
+function s() {
+  return v ? i : (v = 1, function(c) {
+    var u = c;
+    function p(r, n) {
+      if (Array.isArray(r))
+        return r.slice();
+      if (!r)
+        return [];
+      var t = [];
+      if (typeof r != "string") {
+        for (var e = 0; e < r.length; e++)
+          t[e] = r[e] | 0;
+        return t;
+      }
+      if (n === "hex") {
+        r = r.replace(/[^a-z0-9]+/ig, ""), r.length % 2 !== 0 && (r = "0" + r);
+        for (var e = 0; e < r.length; e += 2)
+          t.push(parseInt(r[e] + r[e + 1], 16));
+      } else
+        for (var e = 0; e < r.length; e++) {
+          var a = r.charCodeAt(e), l = a >> 8, h = a & 255;
+          l ? t.push(l, h) : t.push(h);
+        }
+      return t;
+    }
+    u.toArray = p;
+    function f(r) {
+      return r.length === 1 ? "0" + r : r;
+    }
+    u.zero2 = f;
+    function o(r) {
+      for (var n = "", t = 0; t < r.length; t++)
+        n += f(r[t].toString(16));
+      return n;
+    }
+    u.toHex = o, u.encode = function(n, t) {
+      return t === "hex" ? o(n) : n;
+    };
+  }(i), i);
+}
+export {
+  s as __require
+};

package/dist/astra-sdk.es1175.js

@@ -0,0 +1,4 @@
+var r = { exports: {} };
+export {
+  r as __module
+};

package/dist/astra-sdk.es1176.js

@@ -0,0 +1,6 @@
+import * as e from "./astra-sdk.es1277.js";
+import { getAugmentedNamespace as r } from "./astra-sdk.es474.js";
+const o = /* @__PURE__ */ r(e);
+export {
+  o as default
+};

package/dist/astra-sdk.es1177.js

@@ -0,0 +1,4 @@
+var r = {};
+export {
+  r as __exports
+};

package/dist/astra-sdk.es1178.js

@@ -0,0 +1,188 @@
+import { __require as j } from "./astra-sdk.es1172.js";
+import { __require as C } from "./astra-sdk.es1071.js";
+var M, T;
+function U() {
+  if (T) return M;
+  T = 1;
+  var _ = j(), x = C(), y = x.getNAF, J = x.getJSF, N = x.assert;
+  function g(d, e) {
+    this.type = d, this.p = new _(e.p, 16), this.red = e.prime ? _.red(e.prime) : _.mont(this.p), this.zero = new _(0).toRed(this.red), this.one = new _(1).toRed(this.red), this.two = new _(2).toRed(this.red), this.n = e.n && new _(e.n, 16), this.g = e.g && this.pointFromJSON(e.g, e.gRed), this._wnafT1 = new Array(4), this._wnafT2 = new Array(4), this._wnafT3 = new Array(4), this._wnafT4 = new Array(4), this._bitLength = this.n ? this.n.bitLength() : 0;
+    var t = this.n && this.p.div(this.n);
+    !t || t.cmpn(100) > 0 ? this.redN = null : (this._maxwellTrick = !0, this.redN = this.n.toRed(this.red));
+  }
+  M = g, g.prototype.point = function() {
+    throw new Error("Not implemented");
+  }, g.prototype.validate = function() {
+    throw new Error("Not implemented");
+  }, g.prototype._fixedNafMul = function(e, t) {
+    N(e.precomputed);
+    var n = e._getDoubles(), u = y(t, 1, this._bitLength), s = (1 << n.step + 1) - (n.step % 2 === 0 ? 2 : 1);
+    s /= 3;
+    var f = [], i, o;
+    for (i = 0; i < u.length; i += n.step) {
+      o = 0;
+      for (var l = i + n.step - 1; l >= i; l--)
+        o = (o << 1) + u[l];
+      f.push(o);
+    }
+    for (var r = this.jpoint(null, null, null), a = this.jpoint(null, null, null), c = s; c > 0; c--) {
+      for (i = 0; i < f.length; i++)
+        o = f[i], o === c ? a = a.mixedAdd(n.points[i]) : o === -c && (a = a.mixedAdd(n.points[i].neg()));
+      r = r.add(a);
+    }
+    return r.toP();
+  }, g.prototype._wnafMul = function(e, t) {
+    var n = 4, u = e._getNAFPoints(n);
+    n = u.wnd;
+    for (var s = u.points, f = y(t, n, this._bitLength), i = this.jpoint(null, null, null), o = f.length - 1; o >= 0; o--) {
+      for (var l = 0; o >= 0 && f[o] === 0; o--)
+        l++;
+      if (o >= 0 && l++, i = i.dblp(l), o < 0)
+        break;
+      var r = f[o];
+      N(r !== 0), e.type === "affine" ? r > 0 ? i = i.mixedAdd(s[r - 1 >> 1]) : i = i.mixedAdd(s[-r - 1 >> 1].neg()) : r > 0 ? i = i.add(s[r - 1 >> 1]) : i = i.add(s[-r - 1 >> 1].neg());
+    }
+    return e.type === "affine" ? i.toP() : i;
+  }, g.prototype._wnafMulAdd = function(e, t, n, u, s) {
+    var f = this._wnafT1, i = this._wnafT2, o = this._wnafT3, l = 0, r, a, c;
+    for (r = 0; r < u; r++) {
+      c = t[r];
+      var q = c._getNAFPoints(e);
+      f[r] = q.wnd, i[r] = q.points;
+    }
+    for (r = u - 1; r >= 1; r -= 2) {
+      var h = r - 1, p = r;
+      if (f[h] !== 1 || f[p] !== 1) {
+        o[h] = y(n[h], f[h], this._bitLength), o[p] = y(n[p], f[p], this._bitLength), l = Math.max(o[h].length, l), l = Math.max(o[p].length, l);
+        continue;
+      }
+      var w = [
+        t[h],
+        /* 1 */
+        null,
+        /* 3 */
+        null,
+        /* 5 */
+        t[p]
+        /* 7 */
+      ];
+      t[h].y.cmp(t[p].y) === 0 ? (w[1] = t[h].add(t[p]), w[2] = t[h].toJ().mixedAdd(t[p].neg())) : t[h].y.cmp(t[p].y.redNeg()) === 0 ? (w[1] = t[h].toJ().mixedAdd(t[p]), w[2] = t[h].add(t[p].neg())) : (w[1] = t[h].toJ().mixedAdd(t[p]), w[2] = t[h].toJ().mixedAdd(t[p].neg()));
+      var D = [
+        -3,
+        /* -1 -1 */
+        -1,
+        /* -1 0 */
+        -5,
+        /* -1 1 */
+        -7,
+        /* 0 -1 */
+        0,
+        /* 0 0 */
+        7,
+        /* 0 1 */
+        5,
+        /* 1 -1 */
+        1,
+        /* 1 0 */
+        3
+        /* 1 1 */
+      ], P = J(n[h], n[p]);
+      for (l = Math.max(P[0].length, l), o[h] = new Array(l), o[p] = new Array(l), a = 0; a < l; a++) {
+        var R = P[0][a] | 0, E = P[1][a] | 0;
+        o[h][a] = D[(R + 1) * 3 + (E + 1)], o[p][a] = 0, i[h] = w;
+      }
+    }
+    var m = this.jpoint(null, null, null), F = this._wnafT4;
+    for (r = l; r >= 0; r--) {
+      for (var B = 0; r >= 0; ) {
+        var L = !0;
+        for (a = 0; a < u; a++)
+          F[a] = o[a][r] | 0, F[a] !== 0 && (L = !1);
+        if (!L)
+          break;
+        B++, r--;
+      }
+      if (r >= 0 && B++, m = m.dblp(B), r < 0)
+        break;
+      for (a = 0; a < u; a++) {
+        var A = F[a];
+        A !== 0 && (A > 0 ? c = i[a][A - 1 >> 1] : A < 0 && (c = i[a][-A - 1 >> 1].neg()), c.type === "affine" ? m = m.mixedAdd(c) : m = m.add(c));
+      }
+    }
+    for (r = 0; r < u; r++)
+      i[r] = null;
+    return s ? m : m.toP();
+  };
+  function v(d, e) {
+    this.curve = d, this.type = e, this.precomputed = null;
+  }
+  return g.BasePoint = v, v.prototype.eq = function() {
+    throw new Error("Not implemented");
+  }, v.prototype.validate = function() {
+    return this.curve.validate(this);
+  }, g.prototype.decodePoint = function(e, t) {
+    e = x.toArray(e, t);
+    var n = this.p.byteLength();
+    if ((e[0] === 4 || e[0] === 6 || e[0] === 7) && e.length - 1 === 2 * n) {
+      e[0] === 6 ? N(e[e.length - 1] % 2 === 0) : e[0] === 7 && N(e[e.length - 1] % 2 === 1);
+      var u = this.point(
+        e.slice(1, 1 + n),
+        e.slice(1 + n, 1 + 2 * n)
+      );
+      return u;
+    } else if ((e[0] === 2 || e[0] === 3) && e.length - 1 === n)
+      return this.pointFromX(e.slice(1, 1 + n), e[0] === 3);
+    throw new Error("Unknown point format");
+  }, v.prototype.encodeCompressed = function(e) {
+    return this.encode(e, !0);
+  }, v.prototype._encode = function(e) {
+    var t = this.curve.p.byteLength(), n = this.getX().toArray("be", t);
+    return e ? [this.getY().isEven() ? 2 : 3].concat(n) : [4].concat(n, this.getY().toArray("be", t));
+  }, v.prototype.encode = function(e, t) {
+    return x.encode(this._encode(t), e);
+  }, v.prototype.precompute = function(e) {
+    if (this.precomputed)
+      return this;
+    var t = {
+      doubles: null,
+      naf: null,
+      beta: null
+    };
+    return t.naf = this._getNAFPoints(8), t.doubles = this._getDoubles(4, e), t.beta = this._getBeta(), this.precomputed = t, this;
+  }, v.prototype._hasDoubles = function(e) {
+    if (!this.precomputed)
+      return !1;
+    var t = this.precomputed.doubles;
+    return t ? t.points.length >= Math.ceil((e.bitLength() + 1) / t.step) : !1;
+  }, v.prototype._getDoubles = function(e, t) {
+    if (this.precomputed && this.precomputed.doubles)
+      return this.precomputed.doubles;
+    for (var n = [this], u = this, s = 0; s < t; s += e) {
+      for (var f = 0; f < e; f++)
+        u = u.dbl();
+      n.push(u);
+    }
+    return {
+      step: e,
+      points: n
+    };
+  }, v.prototype._getNAFPoints = function(e) {
+    if (this.precomputed && this.precomputed.naf)
+      return this.precomputed.naf;
+    for (var t = [this], n = (1 << e) - 1, u = n === 1 ? null : this.dbl(), s = 1; s < n; s++)
+      t[s] = t[s - 1].add(u);
+    return {
+      wnd: e,
+      points: t
+    };
+  }, v.prototype._getBeta = function() {
+    return null;
+  }, v.prototype.dblp = function(e) {
+    for (var t = this, n = 0; n < e; n++)
+      t = t.dbl();
+    return t;
+  }, M;
+}
+export {
+  U as __require
+};

package/dist/astra-sdk.es1179.js

@@ -0,0 +1,355 @@
+import { __require as J } from "./astra-sdk.es1071.js";
+import { __require as B } from "./astra-sdk.es1172.js";
+import { __require as P } from "./astra-sdk.es1284.js";
+import { __require as O } from "./astra-sdk.es1178.js";
+var _, w;
+function C() {
+  if (w) return _;
+  w = 1;
+  var g = J(), S = B(), z = P(), x = O(), R = g.assert;
+  function q(s) {
+    x.call(this, "short", s), this.a = new S(s.a, 16).toRed(this.red), this.b = new S(s.b, 16).toRed(this.red), this.tinv = this.two.redInvm(), this.zeroA = this.a.fromRed().cmpn(0) === 0, this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0, this.endo = this._getEndomorphism(s), this._endoWnafT1 = new Array(4), this._endoWnafT2 = new Array(4);
+  }
+  z(q, x), _ = q, q.prototype._getEndomorphism = function(r) {
+    if (!(!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)) {
+      var e, t;
+      if (r.beta)
+        e = new S(r.beta, 16).toRed(this.red);
+      else {
+        var d = this._getEndoRoots(this.p);
+        e = d[0].cmp(d[1]) < 0 ? d[0] : d[1], e = e.toRed(this.red);
+      }
+      if (r.lambda)
+        t = new S(r.lambda, 16);
+      else {
+        var i = this._getEndoRoots(this.n);
+        this.g.mul(i[0]).x.cmp(this.g.x.redMul(e)) === 0 ? t = i[0] : (t = i[1], R(this.g.mul(t).x.cmp(this.g.x.redMul(e)) === 0));
+      }
+      var u;
+      return r.basis ? u = r.basis.map(function(n) {
+        return {
+          a: new S(n.a, 16),
+          b: new S(n.b, 16)
+        };
+      }) : u = this._getEndoBasis(t), {
+        beta: e,
+        lambda: t,
+        basis: u
+      };
+    }
+  }, q.prototype._getEndoRoots = function(r) {
+    var e = r === this.p ? this.red : S.mont(r), t = new S(2).toRed(e).redInvm(), d = t.redNeg(), i = new S(3).toRed(e).redNeg().redSqrt().redMul(t), u = d.redAdd(i).fromRed(), n = d.redSub(i).fromRed();
+    return [u, n];
+  }, q.prototype._getEndoBasis = function(r) {
+    for (var e = this.n.ushrn(Math.floor(this.n.bitLength() / 2)), t = r, d = this.n.clone(), i = new S(1), u = new S(0), n = new S(0), l = new S(1), a, v, o, f, h, p, I, M = 0, c, m; t.cmpn(0) !== 0; ) {
+      var y = d.div(t);
+      c = d.sub(y.mul(t)), m = n.sub(y.mul(i));
+      var j = l.sub(y.mul(u));
+      if (!o && c.cmp(e) < 0)
+        a = I.neg(), v = i, o = c.neg(), f = m;
+      else if (o && ++M === 2)
+        break;
+      I = c, d = t, t = c, n = i, i = m, l = u, u = j;
+    }
+    h = c.neg(), p = m;
+    var N = o.sqr().add(f.sqr()), E = h.sqr().add(p.sqr());
+    return E.cmp(N) >= 0 && (h = a, p = v), o.negative && (o = o.neg(), f = f.neg()), h.negative && (h = h.neg(), p = p.neg()), [
+      { a: o, b: f },
+      { a: h, b: p }
+    ];
+  }, q.prototype._endoSplit = function(r) {
+    var e = this.endo.basis, t = e[0], d = e[1], i = d.b.mul(r).divRound(this.n), u = t.b.neg().mul(r).divRound(this.n), n = i.mul(t.a), l = u.mul(d.a), a = i.mul(t.b), v = u.mul(d.b), o = r.sub(n).sub(l), f = a.add(v).neg();
+    return { k1: o, k2: f };
+  }, q.prototype.pointFromX = function(r, e) {
+    r = new S(r, 16), r.red || (r = r.toRed(this.red));
+    var t = r.redSqr().redMul(r).redIAdd(r.redMul(this.a)).redIAdd(this.b), d = t.redSqrt();
+    if (d.redSqr().redSub(t).cmp(this.zero) !== 0)
+      throw new Error("invalid point");
+    var i = d.fromRed().isOdd();
+    return (e && !i || !e && i) && (d = d.redNeg()), this.point(r, d);
+  }, q.prototype.validate = function(r) {
+    if (r.inf)
+      return !0;
+    var e = r.x, t = r.y, d = this.a.redMul(e), i = e.redSqr().redMul(e).redIAdd(d).redIAdd(this.b);
+    return t.redSqr().redISub(i).cmpn(0) === 0;
+  }, q.prototype._endoWnafMulAdd = function(r, e, t) {
+    for (var d = this._endoWnafT1, i = this._endoWnafT2, u = 0; u < r.length; u++) {
+      var n = this._endoSplit(e[u]), l = r[u], a = l._getBeta();
+      n.k1.negative && (n.k1.ineg(), l = l.neg(!0)), n.k2.negative && (n.k2.ineg(), a = a.neg(!0)), d[u * 2] = l, d[u * 2 + 1] = a, i[u * 2] = n.k1, i[u * 2 + 1] = n.k2;
+    }
+    for (var v = this._wnafMulAdd(1, d, i, u * 2, t), o = 0; o < u * 2; o++)
+      d[o] = null, i[o] = null;
+    return v;
+  };
+  function b(s, r, e, t) {
+    x.BasePoint.call(this, s, "affine"), r === null && e === null ? (this.x = null, this.y = null, this.inf = !0) : (this.x = new S(r, 16), this.y = new S(e, 16), t && (this.x.forceRed(this.curve.red), this.y.forceRed(this.curve.red)), this.x.red || (this.x = this.x.toRed(this.curve.red)), this.y.red || (this.y = this.y.toRed(this.curve.red)), this.inf = !1);
+  }
+  z(b, x.BasePoint), q.prototype.point = function(r, e, t) {
+    return new b(this, r, e, t);
+  }, q.prototype.pointFromJSON = function(r, e) {
+    return b.fromJSON(this, r, e);
+  }, b.prototype._getBeta = function() {
+    if (this.curve.endo) {
+      var r = this.precomputed;
+      if (r && r.beta)
+        return r.beta;
+      var e = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);
+      if (r) {
+        var t = this.curve, d = function(i) {
+          return t.point(i.x.redMul(t.endo.beta), i.y);
+        };
+        r.beta = e, e.precomputed = {
+          beta: null,
+          naf: r.naf && {
+            wnd: r.naf.wnd,
+            points: r.naf.points.map(d)
+          },
+          doubles: r.doubles && {
+            step: r.doubles.step,
+            points: r.doubles.points.map(d)
+          }
+        };
+      }
+      return e;
+    }
+  }, b.prototype.toJSON = function() {
+    return this.precomputed ? [this.x, this.y, this.precomputed && {
+      doubles: this.precomputed.doubles && {
+        step: this.precomputed.doubles.step,
+        points: this.precomputed.doubles.points.slice(1)
+      },
+      naf: this.precomputed.naf && {
+        wnd: this.precomputed.naf.wnd,
+        points: this.precomputed.naf.points.slice(1)
+      }
+    }] : [this.x, this.y];
+  }, b.fromJSON = function(r, e, t) {
+    typeof e == "string" && (e = JSON.parse(e));
+    var d = r.point(e[0], e[1], t);
+    if (!e[2])
+      return d;
+    function i(n) {
+      return r.point(n[0], n[1], t);
+    }
+    var u = e[2];
+    return d.precomputed = {
+      beta: null,
+      doubles: u.doubles && {
+        step: u.doubles.step,
+        points: [d].concat(u.doubles.points.map(i))
+      },
+      naf: u.naf && {
+        wnd: u.naf.wnd,
+        points: [d].concat(u.naf.points.map(i))
+      }
+    }, d;
+  }, b.prototype.inspect = function() {
+    return this.isInfinity() ? "<EC Point Infinity>" : "<EC Point x: " + this.x.fromRed().toString(16, 2) + " y: " + this.y.fromRed().toString(16, 2) + ">";
+  }, b.prototype.isInfinity = function() {
+    return this.inf;
+  }, b.prototype.add = function(r) {
+    if (this.inf)
+      return r;
+    if (r.inf)
+      return this;
+    if (this.eq(r))
+      return this.dbl();
+    if (this.neg().eq(r))
+      return this.curve.point(null, null);
+    if (this.x.cmp(r.x) === 0)
+      return this.curve.point(null, null);
+    var e = this.y.redSub(r.y);
+    e.cmpn(0) !== 0 && (e = e.redMul(this.x.redSub(r.x).redInvm()));
+    var t = e.redSqr().redISub(this.x).redISub(r.x), d = e.redMul(this.x.redSub(t)).redISub(this.y);
+    return this.curve.point(t, d);
+  }, b.prototype.dbl = function() {
+    if (this.inf)
+      return this;
+    var r = this.y.redAdd(this.y);
+    if (r.cmpn(0) === 0)
+      return this.curve.point(null, null);
+    var e = this.curve.a, t = this.x.redSqr(), d = r.redInvm(), i = t.redAdd(t).redIAdd(t).redIAdd(e).redMul(d), u = i.redSqr().redISub(this.x.redAdd(this.x)), n = i.redMul(this.x.redSub(u)).redISub(this.y);
+    return this.curve.point(u, n);
+  }, b.prototype.getX = function() {
+    return this.x.fromRed();
+  }, b.prototype.getY = function() {
+    return this.y.fromRed();
+  }, b.prototype.mul = function(r) {
+    return r = new S(r, 16), this.isInfinity() ? this : this._hasDoubles(r) ? this.curve._fixedNafMul(this, r) : this.curve.endo ? this.curve._endoWnafMulAdd([this], [r]) : this.curve._wnafMul(this, r);
+  }, b.prototype.mulAdd = function(r, e, t) {
+    var d = [this, e], i = [r, t];
+    return this.curve.endo ? this.curve._endoWnafMulAdd(d, i) : this.curve._wnafMulAdd(1, d, i, 2);
+  }, b.prototype.jmulAdd = function(r, e, t) {
+    var d = [this, e], i = [r, t];
+    return this.curve.endo ? this.curve._endoWnafMulAdd(d, i, !0) : this.curve._wnafMulAdd(1, d, i, 2, !0);
+  }, b.prototype.eq = function(r) {
+    return this === r || this.inf === r.inf && (this.inf || this.x.cmp(r.x) === 0 && this.y.cmp(r.y) === 0);
+  }, b.prototype.neg = function(r) {
+    if (this.inf)
+      return this;
+    var e = this.curve.point(this.x, this.y.redNeg());
+    if (r && this.precomputed) {
+      var t = this.precomputed, d = function(i) {
+        return i.neg();
+      };
+      e.precomputed = {
+        naf: t.naf && {
+          wnd: t.naf.wnd,
+          points: t.naf.points.map(d)
+        },
+        doubles: t.doubles && {
+          step: t.doubles.step,
+          points: t.doubles.points.map(d)
+        }
+      };
+    }
+    return e;
+  }, b.prototype.toJ = function() {
+    if (this.inf)
+      return this.curve.jpoint(null, null, null);
+    var r = this.curve.jpoint(this.x, this.y, this.curve.one);
+    return r;
+  };
+  function A(s, r, e, t) {
+    x.BasePoint.call(this, s, "jacobian"), r === null && e === null && t === null ? (this.x = this.curve.one, this.y = this.curve.one, this.z = new S(0)) : (this.x = new S(r, 16), this.y = new S(e, 16), this.z = new S(t, 16)), this.x.red || (this.x = this.x.toRed(this.curve.red)), this.y.red || (this.y = this.y.toRed(this.curve.red)), this.z.red || (this.z = this.z.toRed(this.curve.red)), this.zOne = this.z === this.curve.one;
+  }
+  return z(A, x.BasePoint), q.prototype.jpoint = function(r, e, t) {
+    return new A(this, r, e, t);
+  }, A.prototype.toP = function() {
+    if (this.isInfinity())
+      return this.curve.point(null, null);
+    var r = this.z.redInvm(), e = r.redSqr(), t = this.x.redMul(e), d = this.y.redMul(e).redMul(r);
+    return this.curve.point(t, d);
+  }, A.prototype.neg = function() {
+    return this.curve.jpoint(this.x, this.y.redNeg(), this.z);
+  }, A.prototype.add = function(r) {
+    if (this.isInfinity())
+      return r;
+    if (r.isInfinity())
+      return this;
+    var e = r.z.redSqr(), t = this.z.redSqr(), d = this.x.redMul(e), i = r.x.redMul(t), u = this.y.redMul(e.redMul(r.z)), n = r.y.redMul(t.redMul(this.z)), l = d.redSub(i), a = u.redSub(n);
+    if (l.cmpn(0) === 0)
+      return a.cmpn(0) !== 0 ? this.curve.jpoint(null, null, null) : this.dbl();
+    var v = l.redSqr(), o = v.redMul(l), f = d.redMul(v), h = a.redSqr().redIAdd(o).redISub(f).redISub(f), p = a.redMul(f.redISub(h)).redISub(u.redMul(o)), I = this.z.redMul(r.z).redMul(l);
+    return this.curve.jpoint(h, p, I);
+  }, A.prototype.mixedAdd = function(r) {
+    if (this.isInfinity())
+      return r.toJ();
+    if (r.isInfinity())
+      return this;
+    var e = this.z.redSqr(), t = this.x, d = r.x.redMul(e), i = this.y, u = r.y.redMul(e).redMul(this.z), n = t.redSub(d), l = i.redSub(u);
+    if (n.cmpn(0) === 0)
+      return l.cmpn(0) !== 0 ? this.curve.jpoint(null, null, null) : this.dbl();
+    var a = n.redSqr(), v = a.redMul(n), o = t.redMul(a), f = l.redSqr().redIAdd(v).redISub(o).redISub(o), h = l.redMul(o.redISub(f)).redISub(i.redMul(v)), p = this.z.redMul(n);
+    return this.curve.jpoint(f, h, p);
+  }, A.prototype.dblp = function(r) {
+    if (r === 0)
+      return this;
+    if (this.isInfinity())
+      return this;
+    if (!r)
+      return this.dbl();
+    var e;
+    if (this.curve.zeroA || this.curve.threeA) {
+      var t = this;
+      for (e = 0; e < r; e++)
+        t = t.dbl();
+      return t;
+    }
+    var d = this.curve.a, i = this.curve.tinv, u = this.x, n = this.y, l = this.z, a = l.redSqr().redSqr(), v = n.redAdd(n);
+    for (e = 0; e < r; e++) {
+      var o = u.redSqr(), f = v.redSqr(), h = f.redSqr(), p = o.redAdd(o).redIAdd(o).redIAdd(d.redMul(a)), I = u.redMul(f), M = p.redSqr().redISub(I.redAdd(I)), c = I.redISub(M), m = p.redMul(c);
+      m = m.redIAdd(m).redISub(h);
+      var y = v.redMul(l);
+      e + 1 < r && (a = a.redMul(h)), u = M, l = y, v = m;
+    }
+    return this.curve.jpoint(u, v.redMul(i), l);
+  }, A.prototype.dbl = function() {
+    return this.isInfinity() ? this : this.curve.zeroA ? this._zeroDbl() : this.curve.threeA ? this._threeDbl() : this._dbl();
+  }, A.prototype._zeroDbl = function() {
+    var r, e, t;
+    if (this.zOne) {
+      var d = this.x.redSqr(), i = this.y.redSqr(), u = i.redSqr(), n = this.x.redAdd(i).redSqr().redISub(d).redISub(u);
+      n = n.redIAdd(n);
+      var l = d.redAdd(d).redIAdd(d), a = l.redSqr().redISub(n).redISub(n), v = u.redIAdd(u);
+      v = v.redIAdd(v), v = v.redIAdd(v), r = a, e = l.redMul(n.redISub(a)).redISub(v), t = this.y.redAdd(this.y);
+    } else {
+      var o = this.x.redSqr(), f = this.y.redSqr(), h = f.redSqr(), p = this.x.redAdd(f).redSqr().redISub(o).redISub(h);
+      p = p.redIAdd(p);
+      var I = o.redAdd(o).redIAdd(o), M = I.redSqr(), c = h.redIAdd(h);
+      c = c.redIAdd(c), c = c.redIAdd(c), r = M.redISub(p).redISub(p), e = I.redMul(p.redISub(r)).redISub(c), t = this.y.redMul(this.z), t = t.redIAdd(t);
+    }
+    return this.curve.jpoint(r, e, t);
+  }, A.prototype._threeDbl = function() {
+    var r, e, t;
+    if (this.zOne) {
+      var d = this.x.redSqr(), i = this.y.redSqr(), u = i.redSqr(), n = this.x.redAdd(i).redSqr().redISub(d).redISub(u);
+      n = n.redIAdd(n);
+      var l = d.redAdd(d).redIAdd(d).redIAdd(this.curve.a), a = l.redSqr().redISub(n).redISub(n);
+      r = a;
+      var v = u.redIAdd(u);
+      v = v.redIAdd(v), v = v.redIAdd(v), e = l.redMul(n.redISub(a)).redISub(v), t = this.y.redAdd(this.y);
+    } else {
+      var o = this.z.redSqr(), f = this.y.redSqr(), h = this.x.redMul(f), p = this.x.redSub(o).redMul(this.x.redAdd(o));
+      p = p.redAdd(p).redIAdd(p);
+      var I = h.redIAdd(h);
+      I = I.redIAdd(I);
+      var M = I.redAdd(I);
+      r = p.redSqr().redISub(M), t = this.y.redAdd(this.z).redSqr().redISub(f).redISub(o);
+      var c = f.redSqr();
+      c = c.redIAdd(c), c = c.redIAdd(c), c = c.redIAdd(c), e = p.redMul(I.redISub(r)).redISub(c);
+    }
+    return this.curve.jpoint(r, e, t);
+  }, A.prototype._dbl = function() {
+    var r = this.curve.a, e = this.x, t = this.y, d = this.z, i = d.redSqr().redSqr(), u = e.redSqr(), n = t.redSqr(), l = u.redAdd(u).redIAdd(u).redIAdd(r.redMul(i)), a = e.redAdd(e);
+    a = a.redIAdd(a);
+    var v = a.redMul(n), o = l.redSqr().redISub(v.redAdd(v)), f = v.redISub(o), h = n.redSqr();
+    h = h.redIAdd(h), h = h.redIAdd(h), h = h.redIAdd(h);
+    var p = l.redMul(f).redISub(h), I = t.redAdd(t).redMul(d);
+    return this.curve.jpoint(o, p, I);
+  }, A.prototype.trpl = function() {
+    if (!this.curve.zeroA)
+      return this.dbl().add(this);
+    var r = this.x.redSqr(), e = this.y.redSqr(), t = this.z.redSqr(), d = e.redSqr(), i = r.redAdd(r).redIAdd(r), u = i.redSqr(), n = this.x.redAdd(e).redSqr().redISub(r).redISub(d);
+    n = n.redIAdd(n), n = n.redAdd(n).redIAdd(n), n = n.redISub(u);
+    var l = n.redSqr(), a = d.redIAdd(d);
+    a = a.redIAdd(a), a = a.redIAdd(a), a = a.redIAdd(a);
+    var v = i.redIAdd(n).redSqr().redISub(u).redISub(l).redISub(a), o = e.redMul(v);
+    o = o.redIAdd(o), o = o.redIAdd(o);
+    var f = this.x.redMul(l).redISub(o);
+    f = f.redIAdd(f), f = f.redIAdd(f);
+    var h = this.y.redMul(v.redMul(a.redISub(v)).redISub(n.redMul(l)));
+    h = h.redIAdd(h), h = h.redIAdd(h), h = h.redIAdd(h);
+    var p = this.z.redAdd(n).redSqr().redISub(t).redISub(l);
+    return this.curve.jpoint(f, h, p);
+  }, A.prototype.mul = function(r, e) {
+    return r = new S(r, e), this.curve._wnafMul(this, r);
+  }, A.prototype.eq = function(r) {
+    if (r.type === "affine")
+      return this.eq(r.toJ());
+    if (this === r)
+      return !0;
+    var e = this.z.redSqr(), t = r.z.redSqr();
+    if (this.x.redMul(t).redISub(r.x.redMul(e)).cmpn(0) !== 0)
+      return !1;
+    var d = e.redMul(this.z), i = t.redMul(r.z);
+    return this.y.redMul(i).redISub(r.y.redMul(d)).cmpn(0) === 0;
+  }, A.prototype.eqXToP = function(r) {
+    var e = this.z.redSqr(), t = r.toRed(this.curve.red).redMul(e);
+    if (this.x.cmp(t) === 0)
+      return !0;
+    for (var d = r.clone(), i = this.curve.redN.redMul(e); ; ) {
+      if (d.iadd(this.curve.n), d.cmp(this.curve.p) >= 0)
+        return !1;
+      if (t.redIAdd(i), this.x.cmp(t) === 0)
+        return !0;
+    }
+  }, A.prototype.inspect = function() {
+    return this.isInfinity() ? "<EC JPoint Infinity>" : "<EC JPoint x: " + this.x.toString(16, 2) + " y: " + this.y.toString(16, 2) + " z: " + this.z.toString(16, 2) + ">";
+  }, A.prototype.isInfinity = function() {
+    return this.z.cmpn(0) === 0;
+  }, _;
+}
+export {
+  C as __require
+};