@hinkal/common 0.0.116 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/ejs/package.json.mjs

@@ -0,0 +1,62 @@
+const e = "ejs", s = "Embedded JavaScript templates", t = [
+  "template",
+  "engine",
+  "ejs"
+], n = "3.1.9", i = "Matthew Eernisse <mde@fleegix.org> (http://fleegix.org)", o = "Apache-2.0", c = {
+  ejs: "./bin/cli.js"
+}, r = "./lib/ejs.js", d = "ejs.min.js", p = "ejs.min.js", g = {
+  type: "git",
+  url: "git://github.com/mde/ejs.git"
+}, a = "https://github.com/mde/ejs/issues", m = "https://github.com/mde/ejs", j = {
+  jake: "^10.8.5"
+}, l = {
+  browserify: "^16.5.1",
+  eslint: "^6.8.0",
+  "git-directory-deploy": "^1.5.1",
+  jsdoc: "^4.0.2",
+  "lru-cache": "^4.0.1",
+  mocha: "^10.2.0",
+  "uglify-js": "^3.3.16"
+}, u = {
+  node: ">=0.10.0"
+}, h = {
+  test: "mocha -u tdd"
+}, b = {
+  name: e,
+  description: s,
+  keywords: t,
+  version: n,
+  author: i,
+  license: o,
+  bin: c,
+  main: r,
+  jsdelivr: d,
+  unpkg: p,
+  repository: g,
+  bugs: a,
+  homepage: m,
+  dependencies: j,
+  devDependencies: l,
+  engines: u,
+  scripts: h
+};
+export {
+  i as author,
+  c as bin,
+  a as bugs,
+  b as default,
+  j as dependencies,
+  s as description,
+  l as devDependencies,
+  u as engines,
+  m as homepage,
+  d as jsdelivr,
+  t as keywords,
+  o as license,
+  r as main,
+  e as name,
+  g as repository,
+  h as scripts,
+  p as unpkg,
+  n as version
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/elliptic/lib/elliptic/curve/base.mjs

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

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/elliptic/lib/elliptic/curve/edwards.mjs

@@ -0,0 +1,145 @@
+import "../utils.mjs";
+import { b as M } from "../../../node_modules/bn.js/lib/bn.mjs";
+import { i as b } from "../../../../inherits/inherits_browser.mjs";
+import { b as x } from "./base.mjs";
+import { __exports as z } from "../../../../../../../../../../_virtual/utils6.mjs";
+var A = z, c = M, y = b, m = x, _ = A.assert;
+function v(i) {
+  this.twisted = (i.a | 0) !== 1, this.mOneA = this.twisted && (i.a | 0) === -1, this.extended = this.mOneA, m.call(this, "edwards", i), this.a = new c(i.a, 16).umod(this.red.m), this.a = this.a.toRed(this.red), this.c = new c(i.c, 16).toRed(this.red), this.c2 = this.c.redSqr(), this.d = new c(i.d, 16).toRed(this.red), this.dd = this.d.redAdd(this.d), _(!this.twisted || this.c.fromRed().cmpn(1) === 0), this.oneC = (i.c | 0) === 1;
+}
+y(v, m);
+var R = v;
+v.prototype._mulA = function(r) {
+  return this.mOneA ? r.redNeg() : this.a.redMul(r);
+};
+v.prototype._mulC = function(r) {
+  return this.oneC ? r : this.c.redMul(r);
+};
+v.prototype.jpoint = function(r, t, e, s) {
+  return this.point(r, t, e, s);
+};
+v.prototype.pointFromX = function(r, t) {
+  r = new c(r, 16), r.red || (r = r.toRed(this.red));
+  var e = r.redSqr(), s = this.c2.redSub(this.a.redMul(e)), h = this.one.redSub(this.c2.redMul(this.d).redMul(e)), n = s.redMul(h.redInvm()), d = n.redSqrt();
+  if (d.redSqr().redSub(n).cmp(this.zero) !== 0)
+    throw new Error("invalid point");
+  var o = d.fromRed().isOdd();
+  return (t && !o || !t && o) && (d = d.redNeg()), this.point(r, d);
+};
+v.prototype.pointFromY = function(r, t) {
+  r = new c(r, 16), r.red || (r = r.toRed(this.red));
+  var e = r.redSqr(), s = e.redSub(this.c2), h = e.redMul(this.d).redMul(this.c2).redSub(this.a), n = s.redMul(h.redInvm());
+  if (n.cmp(this.zero) === 0) {
+    if (t)
+      throw new Error("invalid point");
+    return this.point(this.zero, r);
+  }
+  var d = n.redSqrt();
+  if (d.redSqr().redSub(n).cmp(this.zero) !== 0)
+    throw new Error("invalid point");
+  return d.fromRed().isOdd() !== t && (d = d.redNeg()), this.point(d, r);
+};
+v.prototype.validate = function(r) {
+  if (r.isInfinity())
+    return !0;
+  r.normalize();
+  var t = r.x.redSqr(), e = r.y.redSqr(), s = t.redMul(this.a).redAdd(e), h = this.c2.redMul(this.one.redAdd(this.d.redMul(t).redMul(e)));
+  return s.cmp(h) === 0;
+};
+function u(i, r, t, e, s) {
+  m.BasePoint.call(this, i, "projective"), r === null && t === null && e === null ? (this.x = this.curve.zero, this.y = this.curve.one, this.z = this.curve.one, this.t = this.curve.zero, this.zOne = !0) : (this.x = new c(r, 16), this.y = new c(t, 16), this.z = e ? new c(e, 16) : this.curve.one, this.t = s && new c(s, 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.t && !this.t.red && (this.t = this.t.toRed(this.curve.red)), this.zOne = this.z === this.curve.one, this.curve.extended && !this.t && (this.t = this.x.redMul(this.y), this.zOne || (this.t = this.t.redMul(this.z.redInvm()))));
+}
+y(u, m.BasePoint);
+v.prototype.pointFromJSON = function(r) {
+  return u.fromJSON(this, r);
+};
+v.prototype.point = function(r, t, e, s) {
+  return new u(this, r, t, e, s);
+};
+u.fromJSON = function(r, t) {
+  return new u(r, t[0], t[1], t[2]);
+};
+u.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) + " z: " + this.z.fromRed().toString(16, 2) + ">";
+};
+u.prototype.isInfinity = function() {
+  return this.x.cmpn(0) === 0 && (this.y.cmp(this.z) === 0 || this.zOne && this.y.cmp(this.curve.c) === 0);
+};
+u.prototype._extDbl = function() {
+  var r = this.x.redSqr(), t = this.y.redSqr(), e = this.z.redSqr();
+  e = e.redIAdd(e);
+  var s = this.curve._mulA(r), h = this.x.redAdd(this.y).redSqr().redISub(r).redISub(t), n = s.redAdd(t), d = n.redSub(e), o = s.redSub(t), a = h.redMul(d), l = n.redMul(o), p = h.redMul(o), f = d.redMul(n);
+  return this.curve.point(a, l, f, p);
+};
+u.prototype._projDbl = function() {
+  var r = this.x.redAdd(this.y).redSqr(), t = this.x.redSqr(), e = this.y.redSqr(), s, h, n, d, o, a;
+  if (this.curve.twisted) {
+    d = this.curve._mulA(t);
+    var l = d.redAdd(e);
+    this.zOne ? (s = r.redSub(t).redSub(e).redMul(l.redSub(this.curve.two)), h = l.redMul(d.redSub(e)), n = l.redSqr().redSub(l).redSub(l)) : (o = this.z.redSqr(), a = l.redSub(o).redISub(o), s = r.redSub(t).redISub(e).redMul(a), h = l.redMul(d.redSub(e)), n = l.redMul(a));
+  } else
+    d = t.redAdd(e), o = this.curve._mulC(this.z).redSqr(), a = d.redSub(o).redSub(o), s = this.curve._mulC(r.redISub(d)).redMul(a), h = this.curve._mulC(d).redMul(t.redISub(e)), n = d.redMul(a);
+  return this.curve.point(s, h, n);
+};
+u.prototype.dbl = function() {
+  return this.isInfinity() ? this : this.curve.extended ? this._extDbl() : this._projDbl();
+};
+u.prototype._extAdd = function(r) {
+  var t = this.y.redSub(this.x).redMul(r.y.redSub(r.x)), e = this.y.redAdd(this.x).redMul(r.y.redAdd(r.x)), s = this.t.redMul(this.curve.dd).redMul(r.t), h = this.z.redMul(r.z.redAdd(r.z)), n = e.redSub(t), d = h.redSub(s), o = h.redAdd(s), a = e.redAdd(t), l = n.redMul(d), p = o.redMul(a), f = n.redMul(a), S = d.redMul(o);
+  return this.curve.point(l, p, S, f);
+};
+u.prototype._projAdd = function(r) {
+  var t = this.z.redMul(r.z), e = t.redSqr(), s = this.x.redMul(r.x), h = this.y.redMul(r.y), n = this.curve.d.redMul(s).redMul(h), d = e.redSub(n), o = e.redAdd(n), a = this.x.redAdd(this.y).redMul(r.x.redAdd(r.y)).redISub(s).redISub(h), l = t.redMul(d).redMul(a), p, f;
+  return this.curve.twisted ? (p = t.redMul(o).redMul(h.redSub(this.curve._mulA(s))), f = d.redMul(o)) : (p = t.redMul(o).redMul(h.redSub(s)), f = this.curve._mulC(d).redMul(o)), this.curve.point(l, p, f);
+};
+u.prototype.add = function(r) {
+  return this.isInfinity() ? r : r.isInfinity() ? this : this.curve.extended ? this._extAdd(r) : this._projAdd(r);
+};
+u.prototype.mul = function(r) {
+  return this._hasDoubles(r) ? this.curve._fixedNafMul(this, r) : this.curve._wnafMul(this, r);
+};
+u.prototype.mulAdd = function(r, t, e) {
+  return this.curve._wnafMulAdd(1, [this, t], [r, e], 2, !1);
+};
+u.prototype.jmulAdd = function(r, t, e) {
+  return this.curve._wnafMulAdd(1, [this, t], [r, e], 2, !0);
+};
+u.prototype.normalize = function() {
+  if (this.zOne)
+    return this;
+  var r = this.z.redInvm();
+  return this.x = this.x.redMul(r), this.y = this.y.redMul(r), this.t && (this.t = this.t.redMul(r)), this.z = this.curve.one, this.zOne = !0, this;
+};
+u.prototype.neg = function() {
+  return this.curve.point(
+    this.x.redNeg(),
+    this.y,
+    this.z,
+    this.t && this.t.redNeg()
+  );
+};
+u.prototype.getX = function() {
+  return this.normalize(), this.x.fromRed();
+};
+u.prototype.getY = function() {
+  return this.normalize(), this.y.fromRed();
+};
+u.prototype.eq = function(r) {
+  return this === r || this.getX().cmp(r.getX()) === 0 && this.getY().cmp(r.getY()) === 0;
+};
+u.prototype.eqXToP = function(r) {
+  var t = r.toRed(this.curve.red).redMul(this.z);
+  if (this.x.cmp(t) === 0)
+    return !0;
+  for (var e = r.clone(), s = this.curve.redN.redMul(this.z); ; ) {
+    if (e.iadd(this.curve.n), e.cmp(this.curve.p) >= 0)
+      return !1;
+    if (t.redIAdd(s), this.x.cmp(t) === 0)
+      return !0;
+  }
+};
+u.prototype.toP = u.prototype.normalize;
+u.prototype.mixedAdd = u.prototype.add;
+export {
+  R as e
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/elliptic/lib/elliptic/curve/index.mjs

@@ -0,0 +1,9 @@
+import { __exports as m } from "../../../../../../../../../../_virtual/index77.mjs";
+import { b as s } from "./base.mjs";
+import { s as t } from "./short.mjs";
+import { m as a } from "./mont.mjs";
+import { e } from "./edwards.mjs";
+(function(o) {
+  var r = o;
+  r.base = s, r.short = t, r.mont = a, r.edwards = e;
+})(m);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/elliptic/lib/elliptic/curve/mont.mjs

@@ -0,0 +1,78 @@
+import { b as m } from "../../../node_modules/bn.js/lib/bn.mjs";
+import { i as y } from "../../../../inherits/inherits_browser.mjs";
+import { b as x } from "./base.mjs";
+import "../utils.mjs";
+import { __exports as z } from "../../../../../../../../../../_virtual/utils6.mjs";
+var h = m, v = y, a = x, b = z;
+function p(r) {
+  a.call(this, "mont", r), this.a = new h(r.a, 16).toRed(this.red), this.b = new h(r.b, 16).toRed(this.red), this.i4 = new h(4).toRed(this.red).redInvm(), this.two = new h(2).toRed(this.red), this.a24 = this.i4.redMul(this.a.redAdd(this.two));
+}
+v(p, a);
+var q = p;
+p.prototype.validate = function(t) {
+  var e = t.normalize().x, n = e.redSqr(), i = n.redMul(e).redAdd(n.redMul(this.a)).redAdd(e), d = i.redSqrt();
+  return d.redSqr().cmp(i) === 0;
+};
+function o(r, t, e) {
+  a.BasePoint.call(this, r, "projective"), t === null && e === null ? (this.x = this.curve.one, this.z = this.curve.zero) : (this.x = new h(t, 16), this.z = new h(e, 16), this.x.red || (this.x = this.x.toRed(this.curve.red)), this.z.red || (this.z = this.z.toRed(this.curve.red)));
+}
+v(o, a.BasePoint);
+p.prototype.decodePoint = function(t, e) {
+  return this.point(b.toArray(t, e), 1);
+};
+p.prototype.point = function(t, e) {
+  return new o(this, t, e);
+};
+p.prototype.pointFromJSON = function(t) {
+  return o.fromJSON(this, t);
+};
+o.prototype.precompute = function() {
+};
+o.prototype._encode = function() {
+  return this.getX().toArray("be", this.curve.p.byteLength());
+};
+o.fromJSON = function(t, e) {
+  return new o(t, e[0], e[1] || t.one);
+};
+o.prototype.inspect = function() {
+  return this.isInfinity() ? "<EC Point Infinity>" : "<EC Point x: " + this.x.fromRed().toString(16, 2) + " z: " + this.z.fromRed().toString(16, 2) + ">";
+};
+o.prototype.isInfinity = function() {
+  return this.z.cmpn(0) === 0;
+};
+o.prototype.dbl = function() {
+  var t = this.x.redAdd(this.z), e = t.redSqr(), n = this.x.redSub(this.z), i = n.redSqr(), d = e.redSub(i), u = e.redMul(i), s = d.redMul(i.redAdd(this.curve.a24.redMul(d)));
+  return this.curve.point(u, s);
+};
+o.prototype.add = function() {
+  throw new Error("Not supported on Montgomery curve");
+};
+o.prototype.diffAdd = function(t, e) {
+  var n = this.x.redAdd(this.z), i = this.x.redSub(this.z), d = t.x.redAdd(t.z), u = t.x.redSub(t.z), s = u.redMul(n), c = d.redMul(i), l = e.z.redMul(s.redAdd(c).redSqr()), f = e.x.redMul(s.redISub(c).redSqr());
+  return this.curve.point(l, f);
+};
+o.prototype.mul = function(t) {
+  for (var e = t.clone(), n = this, i = this.curve.point(null, null), d = this, u = []; e.cmpn(0) !== 0; e.iushrn(1))
+    u.push(e.andln(1));
+  for (var s = u.length - 1; s >= 0; s--)
+    u[s] === 0 ? (n = n.diffAdd(i, d), i = i.dbl()) : (i = n.diffAdd(i, d), n = n.dbl());
+  return i;
+};
+o.prototype.mulAdd = function() {
+  throw new Error("Not supported on Montgomery curve");
+};
+o.prototype.jumlAdd = function() {
+  throw new Error("Not supported on Montgomery curve");
+};
+o.prototype.eq = function(t) {
+  return this.getX().cmp(t.getX()) === 0;
+};
+o.prototype.normalize = function() {
+  return this.x = this.x.redMul(this.z.redInvm()), this.z = this.curve.one, this;
+};
+o.prototype.getX = function() {
+  return this.normalize(), this.x.fromRed();
+};
+export {
+  q as m
+};