@hinkal/common 0.0.116 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/assert/build/internal/util/comparisons.mjs

@@ -0,0 +1,389 @@
+import { __require as Ir } from "../../../../object-is/index.mjs";
+import { __require as qr } from "../../../../is-nan/index.mjs";
+import "../../../../util/util.mjs";
+import { __exports as Nr } from "../../../../../../../../../../_virtual/util.mjs";
+var M, _;
+function Mr() {
+  if (_)
+    return M;
+  _ = 1;
+  function F(r, e) {
+    return rr(r) || v(r, e) || k(r, e) || K();
+  }
+  function K() {
+    throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  function k(r, e) {
+    if (r) {
+      if (typeof r == "string")
+        return D(r, e);
+      var t = Object.prototype.toString.call(r).slice(8, -1);
+      if (t === "Object" && r.constructor && (t = r.constructor.name), t === "Map" || t === "Set")
+        return Array.from(r);
+      if (t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t))
+        return D(r, e);
+    }
+  }
+  function D(r, e) {
+    (e == null || e > r.length) && (e = r.length);
+    for (var t = 0, n = new Array(e); t < e; t++)
+      n[t] = r[t];
+    return n;
+  }
+  function v(r, e) {
+    var t = r == null ? null : typeof Symbol < "u" && r[Symbol.iterator] || r["@@iterator"];
+    if (t != null) {
+      var n, u, i, f, o = [], a = !0, s = !1;
+      try {
+        if (i = (t = t.call(r)).next, e === 0) {
+          if (Object(t) !== t)
+            return;
+          a = !1;
+        } else
+          for (; !(a = (n = i.call(t)).done) && (o.push(n.value), o.length !== e); a = !0)
+            ;
+      } catch (c) {
+        s = !0, u = c;
+      } finally {
+        try {
+          if (!a && t.return != null && (f = t.return(), Object(f) !== f))
+            return;
+        } finally {
+          if (s)
+            throw u;
+        }
+      }
+      return o;
+    }
+  }
+  function rr(r) {
+    if (Array.isArray(r))
+      return r;
+  }
+  function p(r) {
+    "@babel/helpers - typeof";
+    return p = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+      return typeof e;
+    } : function(e) {
+      return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+    }, p(r);
+  }
+  var er = /a/g.flags !== void 0, E = function(e) {
+    var t = [];
+    return e.forEach(function(n) {
+      return t.push(n);
+    }), t;
+  }, m = function(e) {
+    var t = [];
+    return e.forEach(function(n, u) {
+      return t.push([u, n]);
+    }), t;
+  }, T = Object.is ? Object.is : Ir(), A = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function() {
+    return [];
+  }, x = Number.isNaN ? Number.isNaN : qr();
+  function B(r) {
+    return r.call.bind(r);
+  }
+  var b = B(Object.prototype.hasOwnProperty), w = B(Object.prototype.propertyIsEnumerable), z = B(Object.prototype.toString), l = Nr.types, tr = l.isAnyArrayBuffer, nr = l.isArrayBufferView, R = l.isDate, I = l.isMap, V = l.isRegExp, q = l.isSet, ur = l.isNativeError, fr = l.isBoxedPrimitive, C = l.isNumberObject, H = l.isStringObject, U = l.isBooleanObject, G = l.isBigIntObject, ir = l.isSymbolObject, or = l.isFloat32Array, ar = l.isFloat64Array;
+  function sr(r) {
+    if (r.length === 0 || r.length > 10)
+      return !0;
+    for (var e = 0; e < r.length; e++) {
+      var t = r.charCodeAt(e);
+      if (t < 48 || t > 57)
+        return !0;
+    }
+    return r.length === 10 && r >= Math.pow(2, 32);
+  }
+  function N(r) {
+    return Object.keys(r).filter(sr).concat(A(r).filter(Object.prototype.propertyIsEnumerable.bind(r)));
+  }
+  /*!
+   * The buffer module from node.js, for the browser.
+   *
+   * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+   * @license  MIT
+   */
+  function W(r, e) {
+    if (r === e)
+      return 0;
+    for (var t = r.length, n = e.length, u = 0, i = Math.min(t, n); u < i; ++u)
+      if (r[u] !== e[u]) {
+        t = r[u], n = e[u];
+        break;
+      }
+    return t < n ? -1 : n < t ? 1 : 0;
+  }
+  var lr = !0, cr = !1, L = 0, P = 1, J = 2, Q = 3;
+  function pr(r, e) {
+    return er ? r.source === e.source && r.flags === e.flags : RegExp.prototype.toString.call(r) === RegExp.prototype.toString.call(e);
+  }
+  function gr(r, e) {
+    if (r.byteLength !== e.byteLength)
+      return !1;
+    for (var t = 0; t < r.byteLength; t++)
+      if (r[t] !== e[t])
+        return !1;
+    return !0;
+  }
+  function hr(r, e) {
+    return r.byteLength !== e.byteLength ? !1 : W(new Uint8Array(r.buffer, r.byteOffset, r.byteLength), new Uint8Array(e.buffer, e.byteOffset, e.byteLength)) === 0;
+  }
+  function yr(r, e) {
+    return r.byteLength === e.byteLength && W(new Uint8Array(r), new Uint8Array(e)) === 0;
+  }
+  function br(r, e) {
+    return C(r) ? C(e) && T(Number.prototype.valueOf.call(r), Number.prototype.valueOf.call(e)) : H(r) ? H(e) && String.prototype.valueOf.call(r) === String.prototype.valueOf.call(e) : U(r) ? U(e) && Boolean.prototype.valueOf.call(r) === Boolean.prototype.valueOf.call(e) : G(r) ? G(e) && BigInt.prototype.valueOf.call(r) === BigInt.prototype.valueOf.call(e) : ir(e) && Symbol.prototype.valueOf.call(r) === Symbol.prototype.valueOf.call(e);
+  }
+  function g(r, e, t, n) {
+    if (r === e)
+      return r !== 0 ? !0 : t ? T(r, e) : !0;
+    if (t) {
+      if (p(r) !== "object")
+        return typeof r == "number" && x(r) && x(e);
+      if (p(e) !== "object" || r === null || e === null || Object.getPrototypeOf(r) !== Object.getPrototypeOf(e))
+        return !1;
+    } else {
+      if (r === null || p(r) !== "object")
+        return e === null || p(e) !== "object" ? r == e : !1;
+      if (e === null || p(e) !== "object")
+        return !1;
+    }
+    var u = z(r), i = z(e);
+    if (u !== i)
+      return !1;
+    if (Array.isArray(r)) {
+      if (r.length !== e.length)
+        return !1;
+      var f = N(r), o = N(e);
+      return f.length !== o.length ? !1 : O(r, e, t, n, P, f);
+    }
+    if (u === "[object Object]" && (!I(r) && I(e) || !q(r) && q(e)))
+      return !1;
+    if (R(r)) {
+      if (!R(e) || Date.prototype.getTime.call(r) !== Date.prototype.getTime.call(e))
+        return !1;
+    } else if (V(r)) {
+      if (!V(e) || !pr(r, e))
+        return !1;
+    } else if (ur(r) || r instanceof Error) {
+      if (r.message !== e.message || r.name !== e.name)
+        return !1;
+    } else if (nr(r)) {
+      if (!t && (or(r) || ar(r))) {
+        if (!gr(r, e))
+          return !1;
+      } else if (!hr(r, e))
+        return !1;
+      var a = N(r), s = N(e);
+      return a.length !== s.length ? !1 : O(r, e, t, n, L, a);
+    } else {
+      if (q(r))
+        return !q(e) || r.size !== e.size ? !1 : O(r, e, t, n, J);
+      if (I(r))
+        return !I(e) || r.size !== e.size ? !1 : O(r, e, t, n, Q);
+      if (tr(r)) {
+        if (!yr(r, e))
+          return !1;
+      } else if (fr(r) && !br(r, e))
+        return !1;
+    }
+    return O(r, e, t, n, L);
+  }
+  function X(r, e) {
+    return e.filter(function(t) {
+      return w(r, t);
+    });
+  }
+  function O(r, e, t, n, u, i) {
+    if (arguments.length === 5) {
+      i = Object.keys(r);
+      var f = Object.keys(e);
+      if (i.length !== f.length)
+        return !1;
+    }
+    for (var o = 0; o < i.length; o++)
+      if (!b(e, i[o]))
+        return !1;
+    if (t && arguments.length === 5) {
+      var a = A(r);
+      if (a.length !== 0) {
+        var s = 0;
+        for (o = 0; o < a.length; o++) {
+          var c = a[o];
+          if (w(r, c)) {
+            if (!w(e, c))
+              return !1;
+            i.push(c), s++;
+          } else if (w(e, c))
+            return !1;
+        }
+        var d = A(e);
+        if (a.length !== d.length && X(e, d).length !== s)
+          return !1;
+      } else {
+        var y = A(e);
+        if (y.length !== 0 && X(e, y).length !== 0)
+          return !1;
+      }
+    }
+    if (i.length === 0 && (u === L || u === P && r.length === 0 || r.size === 0))
+      return !0;
+    if (n === void 0)
+      n = {
+        val1: /* @__PURE__ */ new Map(),
+        val2: /* @__PURE__ */ new Map(),
+        position: 0
+      };
+    else {
+      var j = n.val1.get(r);
+      if (j !== void 0) {
+        var h = n.val2.get(e);
+        if (h !== void 0)
+          return j === h;
+      }
+      n.position++;
+    }
+    n.val1.set(r, n.position), n.val2.set(e, n.position);
+    var S = Er(r, e, t, i, n, u);
+    return n.val1.delete(r), n.val2.delete(e), S;
+  }
+  function Y(r, e, t, n) {
+    for (var u = E(r), i = 0; i < u.length; i++) {
+      var f = u[i];
+      if (g(e, f, t, n))
+        return r.delete(f), !0;
+    }
+    return !1;
+  }
+  function Z(r) {
+    switch (p(r)) {
+      case "undefined":
+        return null;
+      case "object":
+        return;
+      case "symbol":
+        return !1;
+      case "string":
+        r = +r;
+      case "number":
+        if (x(r))
+          return !1;
+    }
+    return !0;
+  }
+  function Or(r, e, t) {
+    var n = Z(t);
+    return n ?? (e.has(n) && !r.has(n));
+  }
+  function dr(r, e, t, n, u) {
+    var i = Z(t);
+    if (i != null)
+      return i;
+    var f = e.get(i);
+    return f === void 0 && !e.has(i) || !g(n, f, !1, u) ? !1 : !r.has(i) && g(n, f, !1, u);
+  }
+  function jr(r, e, t, n) {
+    for (var u = null, i = E(r), f = 0; f < i.length; f++) {
+      var o = i[f];
+      if (p(o) === "object" && o !== null)
+        u === null && (u = /* @__PURE__ */ new Set()), u.add(o);
+      else if (!e.has(o)) {
+        if (t || !Or(r, e, o))
+          return !1;
+        u === null && (u = /* @__PURE__ */ new Set()), u.add(o);
+      }
+    }
+    if (u !== null) {
+      for (var a = E(e), s = 0; s < a.length; s++) {
+        var c = a[s];
+        if (p(c) === "object" && c !== null) {
+          if (!Y(u, c, t, n))
+            return !1;
+        } else if (!t && !r.has(c) && !Y(u, c, t, n))
+          return !1;
+      }
+      return u.size === 0;
+    }
+    return !0;
+  }
+  function $(r, e, t, n, u, i) {
+    for (var f = E(r), o = 0; o < f.length; o++) {
+      var a = f[o];
+      if (g(t, a, u, i) && g(n, e.get(a), u, i))
+        return r.delete(a), !0;
+    }
+    return !1;
+  }
+  function Sr(r, e, t, n) {
+    for (var u = null, i = m(r), f = 0; f < i.length; f++) {
+      var o = F(i[f], 2), a = o[0], s = o[1];
+      if (p(a) === "object" && a !== null)
+        u === null && (u = /* @__PURE__ */ new Set()), u.add(a);
+      else {
+        var c = e.get(a);
+        if (c === void 0 && !e.has(a) || !g(s, c, t, n)) {
+          if (t || !dr(r, e, a, s, n))
+            return !1;
+          u === null && (u = /* @__PURE__ */ new Set()), u.add(a);
+        }
+      }
+    }
+    if (u !== null) {
+      for (var d = m(e), y = 0; y < d.length; y++) {
+        var j = F(d[y], 2), h = j[0], S = j[1];
+        if (p(h) === "object" && h !== null) {
+          if (!$(u, r, h, S, t, n))
+            return !1;
+        } else if (!t && (!r.has(h) || !g(r.get(h), S, !1, n)) && !$(u, r, h, S, !1, n))
+          return !1;
+      }
+      return u.size === 0;
+    }
+    return !0;
+  }
+  function Er(r, e, t, n, u, i) {
+    var f = 0;
+    if (i === J) {
+      if (!jr(r, e, t, u))
+        return !1;
+    } else if (i === Q) {
+      if (!Sr(r, e, t, u))
+        return !1;
+    } else if (i === P)
+      for (; f < r.length; f++)
+        if (b(r, f)) {
+          if (!b(e, f) || !g(r[f], e[f], t, u))
+            return !1;
+        } else {
+          if (b(e, f))
+            return !1;
+          for (var o = Object.keys(r); f < o.length; f++) {
+            var a = o[f];
+            if (!b(e, a) || !g(r[a], e[a], t, u))
+              return !1;
+          }
+          return o.length === Object.keys(e).length;
+        }
+    for (f = 0; f < n.length; f++) {
+      var s = n[f];
+      if (!g(r[s], e[s], t, u))
+        return !1;
+    }
+    return !0;
+  }
+  function Ar(r, e) {
+    return g(r, e, cr);
+  }
+  function wr(r, e) {
+    return g(r, e, lr);
+  }
+  return M = {
+    isDeepEqual: Ar,
+    isDeepStrictEqual: wr
+  }, M;
+}
+export {
+  Mr as __require
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/async-mutex/index.mjs

@@ -0,0 +1,153 @@
+const _ = new Error("request for lock canceled");
+var d = function(a, e, t, i) {
+  function u(r) {
+    return r instanceof t ? r : new t(function(n) {
+      n(r);
+    });
+  }
+  return new (t || (t = Promise))(function(r, n) {
+    function c(s) {
+      try {
+        h(i.next(s));
+      } catch (o) {
+        n(o);
+      }
+    }
+    function l(s) {
+      try {
+        h(i.throw(s));
+      } catch (o) {
+        n(o);
+      }
+    }
+    function h(s) {
+      s.done ? r(s.value) : u(s.value).then(c, l);
+    }
+    h((i = i.apply(a, e || [])).next());
+  });
+};
+class f {
+  constructor(e, t = _) {
+    this._value = e, this._cancelError = t, this._weightedQueues = [], this._weightedWaiters = [];
+  }
+  acquire(e = 1) {
+    if (e <= 0)
+      throw new Error(`invalid weight ${e}: must be positive`);
+    return new Promise((t, i) => {
+      this._weightedQueues[e - 1] || (this._weightedQueues[e - 1] = []), this._weightedQueues[e - 1].push({ resolve: t, reject: i }), this._dispatch();
+    });
+  }
+  runExclusive(e, t = 1) {
+    return d(this, void 0, void 0, function* () {
+      const [i, u] = yield this.acquire(t);
+      try {
+        return yield e(i);
+      } finally {
+        u();
+      }
+    });
+  }
+  waitForUnlock(e = 1) {
+    if (e <= 0)
+      throw new Error(`invalid weight ${e}: must be positive`);
+    return new Promise((t) => {
+      this._weightedWaiters[e - 1] || (this._weightedWaiters[e - 1] = []), this._weightedWaiters[e - 1].push(t), this._dispatch();
+    });
+  }
+  isLocked() {
+    return this._value <= 0;
+  }
+  getValue() {
+    return this._value;
+  }
+  setValue(e) {
+    this._value = e, this._dispatch();
+  }
+  release(e = 1) {
+    if (e <= 0)
+      throw new Error(`invalid weight ${e}: must be positive`);
+    this._value += e, this._dispatch();
+  }
+  cancel() {
+    this._weightedQueues.forEach((e) => e.forEach((t) => t.reject(this._cancelError))), this._weightedQueues = [];
+  }
+  _dispatch() {
+    var e;
+    for (let t = this._value; t > 0; t--) {
+      const i = (e = this._weightedQueues[t - 1]) === null || e === void 0 ? void 0 : e.shift();
+      if (!i)
+        continue;
+      const u = this._value, r = t;
+      this._value -= t, t = this._value + 1, i.resolve([u, this._newReleaser(r)]);
+    }
+    this._drainUnlockWaiters();
+  }
+  _newReleaser(e) {
+    let t = !1;
+    return () => {
+      t || (t = !0, this.release(e));
+    };
+  }
+  _drainUnlockWaiters() {
+    for (let e = this._value; e > 0; e--)
+      this._weightedWaiters[e - 1] && (this._weightedWaiters[e - 1].forEach((t) => t()), this._weightedWaiters[e - 1] = []);
+  }
+}
+var v = function(a, e, t, i) {
+  function u(r) {
+    return r instanceof t ? r : new t(function(n) {
+      n(r);
+    });
+  }
+  return new (t || (t = Promise))(function(r, n) {
+    function c(s) {
+      try {
+        h(i.next(s));
+      } catch (o) {
+        n(o);
+      }
+    }
+    function l(s) {
+      try {
+        h(i.throw(s));
+      } catch (o) {
+        n(o);
+      }
+    }
+    function h(s) {
+      s.done ? r(s.value) : u(s.value).then(c, l);
+    }
+    h((i = i.apply(a, e || [])).next());
+  });
+};
+class w {
+  constructor(e) {
+    this._semaphore = new f(1, e);
+  }
+  acquire() {
+    return v(this, void 0, void 0, function* () {
+      const [, e] = yield this._semaphore.acquire();
+      return e;
+    });
+  }
+  runExclusive(e) {
+    return this._semaphore.runExclusive(() => e());
+  }
+  isLocked() {
+    return this._semaphore.isLocked();
+  }
+  waitForUnlock() {
+    return this._semaphore.waitForUnlock();
+  }
+  release() {
+    this._semaphore.isLocked() && this._semaphore.release();
+  }
+  cancel() {
+    return this._semaphore.cancel();
+  }
+}
+export {
+  _ as E_CANCELED,
+  w as Mutex,
+  f as Semaphore
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/available-typed-arrays/index.mjs

@@ -0,0 +1,10 @@
+import { commonjsGlobal as e } from "../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { p as l } from "../possible-typed-array-names/index.mjs";
+var o = l, s = typeof globalThis > "u" ? e : globalThis, f = function() {
+  for (var r = [], a = 0; a < o.length; a++)
+    typeof s[o[a]] == "function" && (r[r.length] = o[a]);
+  return r;
+};
+export {
+  f as a
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/axios/lib/adapters/adapters.mjs

@@ -0,0 +1,51 @@
+import a from "../utils.mjs";
+import h from "../helpers/null.mjs";
+import m from "./xhr.mjs";
+import d from "../core/AxiosError.mjs";
+const s = {
+  http: h,
+  xhr: m
+};
+a.forEach(s, (e, n) => {
+  if (e) {
+    try {
+      Object.defineProperty(e, "name", { value: n });
+    } catch {
+    }
+    Object.defineProperty(e, "adapterName", { value: n });
+  }
+});
+const c = (e) => `- ${e}`, u = (e) => a.isFunction(e) || e === null || e === !1, R = {
+  getAdapter: (e) => {
+    e = a.isArray(e) ? e : [e];
+    const { length: n } = e;
+    let o, r;
+    const p = {};
+    for (let t = 0; t < n; t++) {
+      o = e[t];
+      let i;
+      if (r = o, !u(o) && (r = s[(i = String(o)).toLowerCase()], r === void 0))
+        throw new d(`Unknown adapter '${i}'`);
+      if (r)
+        break;
+      p[i || "#" + t] = r;
+    }
+    if (!r) {
+      const t = Object.entries(p).map(
+        ([l, f]) => `adapter ${l} ` + (f === !1 ? "is not supported by the environment" : "is not available in the build")
+      );
+      let i = n ? t.length > 1 ? `since :
+` + t.map(c).join(`
+`) : " " + c(t[0]) : "as no adapter specified";
+      throw new d(
+        "There is no suitable adapter to dispatch the request " + i,
+        "ERR_NOT_SUPPORT"
+      );
+    }
+    return r;
+  },
+  adapters: s
+};
+export {
+  R as default
+};