@hinkal/common 0.0.116 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/call-bind/callBound.mjs

@@ -0,0 +1,9 @@
+import { g as c } from "../get-intrinsic/index.mjs";
+import { c as a } from "./index.mjs";
+var t = c, i = a, e = i(t("String.prototype.indexOf")), s = function(n, o) {
+  var r = t(n, !!o);
+  return typeof r == "function" && e(n, ".prototype.") > -1 ? i(r) : r;
+};
+export {
+  s as c
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/call-bind/index.mjs

@@ -0,0 +1,27 @@
+import { __module as s } from "../../../../../../../_virtual/index81.mjs";
+import { f as v } from "../function-bind/index.mjs";
+import { g as d } from "../get-intrinsic/index.mjs";
+import { s as g } from "../set-function-length/index.mjs";
+import { t as x } from "../es-errors/type.mjs";
+import { e as $ } from "../es-define-property/index.mjs";
+(function(t) {
+  var e = v, r = d, c = g, f = x, n = r("%Function.prototype.apply%"), a = r("%Function.prototype.call%"), p = r("%Reflect.apply%", !0) || e.call(a, n), o = $, u = r("%Math.max%");
+  t.exports = function(l) {
+    if (typeof l != "function")
+      throw new f("a function is required");
+    var y = p(e, a, arguments);
+    return c(
+      y,
+      1 + u(0, l.length - (arguments.length - 1)),
+      !0
+    );
+  };
+  var i = function() {
+    return p(e, n, arguments);
+  };
+  o ? o(t.exports, "apply", { value: i }) : t.exports.apply = i;
+})(s);
+var L = s.exports;
+export {
+  L as c
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/check-types/src/check-types.mjs

@@ -0,0 +1,447 @@
+import { commonjsGlobal as Hn } from "../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __module as K } from "../../../../../../../../_virtual/check-types.mjs";
+K.exports;
+(function(q) {
+  (function(sn) {
+    var N, s, S, c, b, E, w, l, P, T, x, m, F, L, I, U, k;
+    N = {}, s = {}, [
+      { n: "equal", f: cn, s: "equal {e}" },
+      { n: "undefined", f: ln, s: "be undefined" },
+      { n: "null", f: bn, s: "be null" },
+      { n: "assigned", f: u, s: "be assigned" },
+      { n: "primitive", f: mn, s: "be primitive type" },
+      { n: "contains", f: Z, s: "contain {e}" },
+      { n: "in", f: Ln, s: "be in {e}" },
+      { n: "containsKey", f: $, s: "contain key {e}" },
+      { n: "keyIn", f: _n, s: "be key in {e}" },
+      { n: "zero", f: an, s: "be 0" },
+      { n: "one", f: pn, s: "be 1" },
+      { n: "infinity", f: yn, s: "be infinity" },
+      { n: "number", f: y, s: "be Number" },
+      { n: "integer", f: _, s: "be integer" },
+      { n: "float", f: gn, s: "be non-integer number" },
+      { n: "even", f: vn, s: "be even number" },
+      { n: "odd", f: hn, s: "be odd number" },
+      { n: "greater", f: R, s: "be greater than {e}" },
+      { n: "less", f: z, s: "be less than {e}" },
+      { n: "between", f: En, s: "be between {e} and {e2}" },
+      { n: "greaterOrEqual", f: H, s: "be greater than or equal to {e}" },
+      { n: "lessOrEqual", f: J, s: "be less than or equal to {e}" },
+      { n: "inRange", f: On, s: "be in the range {e} to {e2}" },
+      { n: "positive", f: jn, s: "be positive number" },
+      { n: "negative", f: Sn, s: "be negative number" },
+      { n: "string", f: O, s: "be String" },
+      { n: "emptyString", f: wn, s: "be empty string" },
+      { n: "nonEmptyString", f: Q, s: "be non-empty string" },
+      { n: "match", f: In, s: "match {e}" },
+      { n: "boolean", f: Mn, s: "be Boolean" },
+      { n: "object", f: a, s: "be Object" },
+      { n: "emptyObject", f: An, s: "be empty object" },
+      { n: "nonEmptyObject", f: qn, s: "be non-empty object" },
+      { n: "instanceStrict", f: g, s: "be instanceof {t}" },
+      { n: "thenable", f: Nn, s: "be promise-like" },
+      { n: "instance", f: Pn, s: "be {t}" },
+      { n: "like", f: W, s: "be like {e}" },
+      { n: "identical", f: D, s: "be identical to {e}" },
+      { n: "array", f: Tn, s: "be Array" },
+      { n: "emptyArray", f: xn, s: "be empty array" },
+      { n: "nonEmptyArray", f: Fn, s: "be non-empty array" },
+      { n: "arrayLike", f: G, s: "be array-like" },
+      { n: "iterable", f: X, s: "be iterable" },
+      { n: "date", f: zn, s: "be valid Date" },
+      { n: "function", f: p, s: "be Function" },
+      { n: "hasLength", f: Rn, s: "have length {e}" },
+      { n: "throws", f: Cn, s: "throw" }
+    ].map(function(n) {
+      var e = n.n;
+      N[e] = "assert failed: expected {a} to " + n.s, s[e] = n.f;
+    }), S = {
+      map: d,
+      all: Dn,
+      any: Gn
+    }, w = ["array", "arrayLike", "iterable", "object"], l = Object.prototype.hasOwnProperty, P = Object.prototype.toString, T = Object.keys, x = Array.prototype.slice, m = Array.isArray, F = Number.NEGATIVE_INFINITY, L = Number.POSITIVE_INFINITY, I = typeof Symbol == "function", U = typeof Map == "function", k = typeof Set == "function", S = en(S, s), c = B(v, rn), b = B(tn, fn), E = B(Vn, Yn), c.not = j(v, b, "not "), c.maybe = j(v, E, "maybe "), w.forEach(Kn), on(c, v), on(b, tn), w.forEach(Un), kn(en(S, {
+      assert: c,
+      not: b,
+      maybe: E
+    }));
+    function cn(n, e) {
+      return n === e;
+    }
+    function ln(n) {
+      return n === void 0;
+    }
+    function bn(n) {
+      return n === null;
+    }
+    function u(n) {
+      return n != null;
+    }
+    function mn(n) {
+      var e;
+      switch (n) {
+        case null:
+        case void 0:
+        case !1:
+        case !0:
+          return !0;
+      }
+      return e = typeof n, e === "string" || e === "number" || I && e === "symbol";
+    }
+    function an(n) {
+      return n === 0;
+    }
+    function pn(n) {
+      return n === 1;
+    }
+    function yn(n) {
+      return n === F || n === L;
+    }
+    function y(n) {
+      return typeof n == "number" && n > F && n < L;
+    }
+    function _(n) {
+      return typeof n == "number" && n % 1 === 0;
+    }
+    function gn(n) {
+      return y(n) && n % 1 !== 0;
+    }
+    function vn(n) {
+      return typeof n == "number" && n % 2 === 0;
+    }
+    function hn(n) {
+      return _(n) && n % 2 !== 0;
+    }
+    function R(n, e) {
+      return y(n) && n > e;
+    }
+    function z(n, e) {
+      return y(n) && n < e;
+    }
+    function En(n, e, r) {
+      return e < r ? R(n, e) && n < r : z(n, e) && n > r;
+    }
+    function H(n, e) {
+      return y(n) && n >= e;
+    }
+    function J(n, e) {
+      return y(n) && n <= e;
+    }
+    function On(n, e, r) {
+      return e < r ? H(n, e) && n <= r : J(n, e) && n >= r;
+    }
+    function jn(n) {
+      return R(n, 0);
+    }
+    function Sn(n) {
+      return z(n, 0);
+    }
+    function O(n) {
+      return typeof n == "string";
+    }
+    function wn(n) {
+      return n === "";
+    }
+    function Q(n) {
+      return O(n) && n !== "";
+    }
+    function In(n, e) {
+      return O(n) && !!n.match(e);
+    }
+    function Mn(n) {
+      return n === !1 || n === !0;
+    }
+    function a(n) {
+      return P.call(n) === "[object Object]";
+    }
+    function An(n) {
+      return a(n) && !C(n, function() {
+        return !0;
+      });
+    }
+    function C(n, e) {
+      for (var r in n)
+        if (l.call(n, r) && e(r, n[r]))
+          return !0;
+      return !1;
+    }
+    function qn(n) {
+      return a(n) && C(n, function() {
+        return !0;
+      });
+    }
+    function Nn(n) {
+      return u(n) && p(n.then);
+    }
+    function g(n, e) {
+      try {
+        return n instanceof e;
+      } catch {
+        return !1;
+      }
+    }
+    function Pn(n, e) {
+      try {
+        return g(n, e) || n.constructor.name === e.name || P.call(n) === "[object " + e.name + "]";
+      } catch {
+        return !1;
+      }
+    }
+    function W(n, e) {
+      var r;
+      if (!u(n) || !u(e))
+        return n === e;
+      for (r in e)
+        if (l.call(e, r) && (!l.call(n, r) || typeof n[r] != typeof e[r] || a(n[r]) && !W(n[r], e[r])))
+          return !1;
+      return !0;
+    }
+    function D(n, e) {
+      var r;
+      if (!u(n) || !u(e))
+        return n === e;
+      for (r in e)
+        if (l.call(e, r)) {
+          if (!l.call(n, r))
+            return !1;
+          if (a(n[r])) {
+            if (!D(n[r], e[r]))
+              return !1;
+          } else if (n[r] !== e[r])
+            return !1;
+        }
+      for (r in n)
+        if (l.call(n, r)) {
+          if (!l.call(e, r))
+            return !1;
+          if (a(e[r])) {
+            if (!D(e[r], n[r]))
+              return !1;
+          } else if (e[r] !== n[r])
+            return !1;
+        }
+      return !0;
+    }
+    function Tn(n) {
+      return m(n);
+    }
+    function xn(n) {
+      return m(n) && n.length === 0;
+    }
+    function Fn(n) {
+      return m(n) && n.length > 0;
+    }
+    function G(n) {
+      return u(n) && n.length >= 0;
+    }
+    function X(n) {
+      return I ? u(n) && p(n[Symbol.iterator]) : G(n);
+    }
+    function Z(n, e) {
+      var r, t;
+      if (!u(n))
+        return !1;
+      if (k && g(n, Set))
+        return n.has(e);
+      if (O(n))
+        return n.indexOf(e) !== -1;
+      if (I && n[Symbol.iterator] && p(n.values)) {
+        r = n.values();
+        do
+          if (t = r.next(), t.value === e)
+            return !0;
+        while (!t.done);
+        return !1;
+      }
+      return C(n, function(i, f) {
+        return f === e;
+      });
+    }
+    function Ln(n, e) {
+      return Z(e, n);
+    }
+    function $(n, e) {
+      return u(n) ? U && g(n, Map) ? n.has(e) : X(n) && !y(+e) ? !1 : !!n[e] : !1;
+    }
+    function _n(n, e) {
+      return $(e, n);
+    }
+    function Rn(n, e) {
+      return u(n) && n.length === e;
+    }
+    function zn(n) {
+      return g(n, Date) && _(n.getTime());
+    }
+    function p(n) {
+      return typeof n == "function";
+    }
+    function Cn(n) {
+      if (!p(n))
+        return !1;
+      try {
+        n();
+      } catch {
+        return !0;
+      }
+      return !1;
+    }
+    function d(n, e) {
+      var r;
+      if (m(n) ? r = [] : r = {}, p(e))
+        M(n, function(i, f) {
+          r[i] = e(f);
+        });
+      else {
+        m(e) || c.object(e);
+        var t = T(n || {});
+        M(e, function(i, f) {
+          t.some(function(o, h) {
+            return o === i ? (t.splice(h, 1), !0) : !1;
+          }), p(f) ? b.assigned(n) ? r[i] = !!f.m : r[i] = f(n[i]) : r[i] = d(n[i], f);
+        });
+      }
+      return r;
+    }
+    function M(n, e) {
+      for (var r in n)
+        l.call(n, r) && e(r, n[r]);
+    }
+    function Dn(n) {
+      return m(n) ? nn(n, !1) : (c.object(n), V(n, !1));
+    }
+    function nn(n, e) {
+      var r;
+      for (r = 0; r < n.length; r += 1)
+        if (n[r] === e)
+          return e;
+      return !e;
+    }
+    function V(n, e) {
+      var r, t;
+      for (r in n)
+        if (l.call(n, r) && (t = n[r], a(t) && V(t, e) === e || t === e))
+          return e;
+      return !e;
+    }
+    function Gn(n) {
+      return m(n) ? nn(n, !0) : (c.object(n), V(n, !0));
+    }
+    function en(n, e) {
+      return M(e, function(r, t) {
+        n[r] = t;
+      }), n;
+    }
+    function v(n, e) {
+      return function() {
+        var r = arguments, t = n.l || n.length, i = r[t], f = r[t + 1];
+        return rn(
+          n.apply(null, r),
+          Q(i) ? i : e.replace("{a}", Y(r[0])).replace("{e}", Y(r[1])).replace("{e2}", Y(r[2])).replace("{t}", function() {
+            var o = r[1];
+            return o && o.name ? o.name : o;
+          }),
+          p(f) ? f : TypeError
+        ), r[0];
+      };
+    }
+    function Y(n) {
+      return function() {
+        return O(n) ? '"' + n.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"' : n && n !== !0 && n.constructor && !g(n, RegExp) && typeof n != "number" ? n.constructor.name : n;
+      };
+    }
+    function rn(n, e, r) {
+      if (n)
+        return n;
+      throw new (r || Error)(e || "assert failed");
+    }
+    function tn(n) {
+      var e = function() {
+        return fn(n.apply(null, arguments));
+      };
+      return e.l = n.length, e;
+    }
+    function fn(n) {
+      return !n;
+    }
+    function Vn(n) {
+      var e = function() {
+        return b.assigned(arguments[0]) ? !0 : n.apply(null, arguments);
+      };
+      return e.l = n.length, e.m = !0, e;
+    }
+    function Yn(n) {
+      return u(n) ? n : !0;
+    }
+    function un(n, e, r) {
+      var t = function() {
+        var i, f;
+        if (i = arguments[0], n === "maybe" && b.assigned(i))
+          return !0;
+        if (!e(i))
+          return !1;
+        i = Bn(e, i), f = x.call(arguments, 1);
+        try {
+          i.forEach(function(o) {
+            if ((n !== "maybe" || u(o)) && !r.apply(null, [o].concat(f)))
+              throw 0;
+          });
+        } catch {
+          return !1;
+        }
+        return !0;
+      };
+      return t.l = r.length, t;
+    }
+    function Bn(n, e) {
+      switch (n) {
+        case G:
+          return x.call(e);
+        case a:
+          return T(e).map(function(r) {
+            return e[r];
+          });
+        default:
+          return e;
+      }
+    }
+    function B(n, e) {
+      return A([n, s, e, ""]);
+    }
+    function A(n) {
+      var e, r, t, i;
+      return e = n.shift(), r = n.pop(), t = n.pop(), i = n.pop(), M(i, function(f, o) {
+        var h = N[f];
+        h && r && (h = h.replace("to", r + "to")), Object.defineProperty(t, f, {
+          configurable: !1,
+          enumerable: !0,
+          writable: !1,
+          value: e.apply(null, n.concat(o, h))
+        });
+      }), t;
+    }
+    function j(n, e, r) {
+      return A([n, e, {}, r]);
+    }
+    function Kn(n) {
+      s[n].of = A(
+        [un.bind(null, null), s[n], s, {}, ""]
+      );
+    }
+    function on(n, e) {
+      w.forEach(function(r) {
+        n[r].of = j(e, s[r].of);
+      });
+    }
+    function Un(n) {
+      E[n].of = A(
+        [un.bind(null, "maybe"), s[n], s, {}, ""]
+      ), c.maybe[n].of = j(v, E[n].of), c.not[n].of = j(v, b[n].of);
+    }
+    function kn(n) {
+      q !== null && q.exports ? q.exports = n : sn.check = n;
+    }
+  })(Hn);
+})(K);
+var Wn = K.exports;
+export {
+  Wn as c
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/circom_runtime/js/utils.mjs

@@ -0,0 +1,35 @@
+function l(h) {
+  var i = [];
+  return t(i, h), i;
+  function t(r, n) {
+    if (Array.isArray(n))
+      for (let e = 0; e < n.length; e++)
+        t(r, n[e]);
+    else
+      r.push(n);
+  }
+}
+function a(h) {
+  const i = BigInt(2) ** BigInt(64);
+  let t = BigInt("0xCBF29CE484222325");
+  for (var r = 0; r < h.length; r++)
+    t ^= BigInt(h[r].charCodeAt()), t *= BigInt(1099511628211), t %= i;
+  let n = t.toString(16), e = 16 - n.length;
+  return n = "0".repeat(e).concat(n), n;
+}
+function o(h, i) {
+  const t = [];
+  let r = BigInt(h);
+  const n = BigInt(4294967296);
+  for (; r; )
+    t.unshift(Number(r % n)), r = r / n;
+  if (i)
+    for (var e = i - t.length; e > 0; )
+      t.unshift(0), e--;
+  return t;
+}
+export {
+  l as flatArray,
+  a as fnvHash,
+  o as toArray32
+};