@hinkal/common 0.0.115 → 0.0.117

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

@@ -0,0 +1,413 @@
+import { __module as b } from "../../../../../../../../_virtual/assert3.mjs";
+import { __require as nt } from "./internal/errors.mjs";
+import { __require as rt } from "./internal/assert/assertion_error.mjs";
+import "../../util/util.mjs";
+import { p as ot } from "../../object.assign/polyfill.mjs";
+import { p as it } from "../../object-is/polyfill.mjs";
+import { c as at } from "../../call-bind/callBound.mjs";
+import { __require as ct } from "./internal/util/comparisons.mjs";
+import { __exports as B } from "../../../../../../../../_virtual/util.mjs";
+var W;
+function wt() {
+  if (W)
+    return b.exports;
+  W = 1;
+  function s(e) {
+    "@babel/helpers - typeof";
+    return s = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+      return typeof t;
+    } : function(t) {
+      return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+    }, s(e);
+  }
+  function N(e, t) {
+    for (var n = 0; n < t.length; n++) {
+      var r = t[n];
+      r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, Y(r.key), r);
+    }
+  }
+  function K(e, t, n) {
+    return t && N(e.prototype, t), n && N(e, n), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+  }
+  function Y(e) {
+    var t = z(e, "string");
+    return s(t) === "symbol" ? t : String(t);
+  }
+  function z(e, t) {
+    if (s(e) !== "object" || e === null)
+      return e;
+    var n = e[Symbol.toPrimitive];
+    if (n !== void 0) {
+      var r = n.call(e, t || "default");
+      if (s(r) !== "object")
+        return r;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (t === "string" ? String : Number)(e);
+  }
+  function X(e, t) {
+    if (!(e instanceof t))
+      throw new TypeError("Cannot call a class as a function");
+  }
+  var H = nt(), g = H.codes, x = g.ERR_AMBIGUOUS_ARGUMENT, E = g.ERR_INVALID_ARG_TYPE, J = g.ERR_INVALID_ARG_VALUE, Q = g.ERR_INVALID_RETURN_VALUE, p = g.ERR_MISSING_ARGS, m = rt(), Z = B, d = Z.inspect, _ = B.types, k = _.isPromise, v = _.isRegExp, tt = ot(), I = it(), q = at("RegExp.prototype.test"), h, R;
+  function w() {
+    var e = ct();
+    h = e.isDeepEqual, R = e.isDeepStrictEqual;
+  }
+  var D = !1, a = b.exports = A, S = {};
+  function f(e) {
+    throw e.message instanceof Error ? e.message : new m(e);
+  }
+  function P(e, t, n, r, o) {
+    var i = arguments.length, c;
+    if (i === 0)
+      c = "Failed";
+    else if (i === 1)
+      n = e, e = void 0;
+    else {
+      if (D === !1) {
+        D = !0;
+        var u = process.emitWarning ? process.emitWarning : console.warn.bind(console);
+        u("assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", "DEP0094");
+      }
+      i === 2 && (r = "!=");
+    }
+    if (n instanceof Error)
+      throw n;
+    var l = {
+      actual: e,
+      expected: t,
+      operator: r === void 0 ? "fail" : r,
+      stackStartFn: o || P
+    };
+    n !== void 0 && (l.message = n);
+    var y = new m(l);
+    throw c && (y.message = c, y.generatedMessage = !0), y;
+  }
+  a.fail = P, a.AssertionError = m;
+  function F(e, t, n, r) {
+    if (!n) {
+      var o = !1;
+      if (t === 0)
+        o = !0, r = "No value argument passed to `assert.ok()`";
+      else if (r instanceof Error)
+        throw r;
+      var i = new m({
+        actual: n,
+        expected: !0,
+        message: r,
+        operator: "==",
+        stackStartFn: e
+      });
+      throw i.generatedMessage = o, i;
+    }
+  }
+  function A() {
+    for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+      t[n] = arguments[n];
+    F.apply(void 0, [A, t.length].concat(t));
+  }
+  a.ok = A, a.equal = function e(t, n, r) {
+    if (arguments.length < 2)
+      throw new p("actual", "expected");
+    t != n && f({
+      actual: t,
+      expected: n,
+      message: r,
+      operator: "==",
+      stackStartFn: e
+    });
+  }, a.notEqual = function e(t, n, r) {
+    if (arguments.length < 2)
+      throw new p("actual", "expected");
+    t == n && f({
+      actual: t,
+      expected: n,
+      message: r,
+      operator: "!=",
+      stackStartFn: e
+    });
+  }, a.deepEqual = function e(t, n, r) {
+    if (arguments.length < 2)
+      throw new p("actual", "expected");
+    h === void 0 && w(), h(t, n) || f({
+      actual: t,
+      expected: n,
+      message: r,
+      operator: "deepEqual",
+      stackStartFn: e
+    });
+  }, a.notDeepEqual = function e(t, n, r) {
+    if (arguments.length < 2)
+      throw new p("actual", "expected");
+    h === void 0 && w(), h(t, n) && f({
+      actual: t,
+      expected: n,
+      message: r,
+      operator: "notDeepEqual",
+      stackStartFn: e
+    });
+  }, a.deepStrictEqual = function e(t, n, r) {
+    if (arguments.length < 2)
+      throw new p("actual", "expected");
+    h === void 0 && w(), R(t, n) || f({
+      actual: t,
+      expected: n,
+      message: r,
+      operator: "deepStrictEqual",
+      stackStartFn: e
+    });
+  }, a.notDeepStrictEqual = T;
+  function T(e, t, n) {
+    if (arguments.length < 2)
+      throw new p("actual", "expected");
+    h === void 0 && w(), R(e, t) && f({
+      actual: e,
+      expected: t,
+      message: n,
+      operator: "notDeepStrictEqual",
+      stackStartFn: T
+    });
+  }
+  a.strictEqual = function e(t, n, r) {
+    if (arguments.length < 2)
+      throw new p("actual", "expected");
+    I(t, n) || f({
+      actual: t,
+      expected: n,
+      message: r,
+      operator: "strictEqual",
+      stackStartFn: e
+    });
+  }, a.notStrictEqual = function e(t, n, r) {
+    if (arguments.length < 2)
+      throw new p("actual", "expected");
+    I(t, n) && f({
+      actual: t,
+      expected: n,
+      message: r,
+      operator: "notStrictEqual",
+      stackStartFn: e
+    });
+  };
+  var j = /* @__PURE__ */ K(function e(t, n, r) {
+    var o = this;
+    X(this, e), n.forEach(function(i) {
+      i in t && (r !== void 0 && typeof r[i] == "string" && v(t[i]) && q(t[i], r[i]) ? o[i] = r[i] : o[i] = t[i]);
+    });
+  });
+  function et(e, t, n, r, o, i) {
+    if (!(n in e) || !R(e[n], t[n])) {
+      if (!r) {
+        var c = new j(e, o), u = new j(t, o, e), l = new m({
+          actual: c,
+          expected: u,
+          operator: "deepStrictEqual",
+          stackStartFn: i
+        });
+        throw l.actual = e, l.expected = t, l.operator = i.name, l;
+      }
+      f({
+        actual: e,
+        expected: t,
+        message: r,
+        operator: i.name,
+        stackStartFn: i
+      });
+    }
+  }
+  function M(e, t, n, r) {
+    if (typeof t != "function") {
+      if (v(t))
+        return q(t, e);
+      if (arguments.length === 2)
+        throw new E("expected", ["Function", "RegExp"], t);
+      if (s(e) !== "object" || e === null) {
+        var o = new m({
+          actual: e,
+          expected: t,
+          message: n,
+          operator: "deepStrictEqual",
+          stackStartFn: r
+        });
+        throw o.operator = r.name, o;
+      }
+      var i = Object.keys(t);
+      if (t instanceof Error)
+        i.push("name", "message");
+      else if (i.length === 0)
+        throw new J("error", t, "may not be an empty object");
+      return h === void 0 && w(), i.forEach(function(c) {
+        typeof e[c] == "string" && v(t[c]) && q(t[c], e[c]) || et(e, t, c, n, i, r);
+      }), !0;
+    }
+    return t.prototype !== void 0 && e instanceof t ? !0 : Error.isPrototypeOf(t) ? !1 : t.call({}, e) === !0;
+  }
+  function G(e) {
+    if (typeof e != "function")
+      throw new E("fn", "Function", e);
+    try {
+      e();
+    } catch (t) {
+      return t;
+    }
+    return S;
+  }
+  function L(e) {
+    return k(e) || e !== null && s(e) === "object" && typeof e.then == "function" && typeof e.catch == "function";
+  }
+  function O(e) {
+    return Promise.resolve().then(function() {
+      var t;
+      if (typeof e == "function") {
+        if (t = e(), !L(t))
+          throw new Q("instance of Promise", "promiseFn", t);
+      } else if (L(e))
+        t = e;
+      else
+        throw new E("promiseFn", ["Function", "Promise"], e);
+      return Promise.resolve().then(function() {
+        return t;
+      }).then(function() {
+        return S;
+      }).catch(function(n) {
+        return n;
+      });
+    });
+  }
+  function U(e, t, n, r) {
+    if (typeof n == "string") {
+      if (arguments.length === 4)
+        throw new E("error", ["Object", "Error", "Function", "RegExp"], n);
+      if (s(t) === "object" && t !== null) {
+        if (t.message === n)
+          throw new x("error/message", 'The error message "'.concat(t.message, '" is identical to the message.'));
+      } else if (t === n)
+        throw new x("error/message", 'The error "'.concat(t, '" is identical to the message.'));
+      r = n, n = void 0;
+    } else if (n != null && s(n) !== "object" && typeof n != "function")
+      throw new E("error", ["Object", "Error", "Function", "RegExp"], n);
+    if (t === S) {
+      var o = "";
+      n && n.name && (o += " (".concat(n.name, ")")), o += r ? ": ".concat(r) : ".";
+      var i = e.name === "rejects" ? "rejection" : "exception";
+      f({
+        actual: void 0,
+        expected: n,
+        operator: e.name,
+        message: "Missing expected ".concat(i).concat(o),
+        stackStartFn: e
+      });
+    }
+    if (n && !M(t, n, r, e))
+      throw t;
+  }
+  function V(e, t, n, r) {
+    if (t !== S) {
+      if (typeof n == "string" && (r = n, n = void 0), !n || M(t, n)) {
+        var o = r ? ": ".concat(r) : ".", i = e.name === "doesNotReject" ? "rejection" : "exception";
+        f({
+          actual: t,
+          expected: n,
+          operator: e.name,
+          message: "Got unwanted ".concat(i).concat(o, `
+`) + 'Actual message: "'.concat(t && t.message, '"'),
+          stackStartFn: e
+        });
+      }
+      throw t;
+    }
+  }
+  a.throws = function e(t) {
+    for (var n = arguments.length, r = new Array(n > 1 ? n - 1 : 0), o = 1; o < n; o++)
+      r[o - 1] = arguments[o];
+    U.apply(void 0, [e, G(t)].concat(r));
+  }, a.rejects = function e(t) {
+    for (var n = arguments.length, r = new Array(n > 1 ? n - 1 : 0), o = 1; o < n; o++)
+      r[o - 1] = arguments[o];
+    return O(t).then(function(i) {
+      return U.apply(void 0, [e, i].concat(r));
+    });
+  }, a.doesNotThrow = function e(t) {
+    for (var n = arguments.length, r = new Array(n > 1 ? n - 1 : 0), o = 1; o < n; o++)
+      r[o - 1] = arguments[o];
+    V.apply(void 0, [e, G(t)].concat(r));
+  }, a.doesNotReject = function e(t) {
+    for (var n = arguments.length, r = new Array(n > 1 ? n - 1 : 0), o = 1; o < n; o++)
+      r[o - 1] = arguments[o];
+    return O(t).then(function(i) {
+      return V.apply(void 0, [e, i].concat(r));
+    });
+  }, a.ifError = function e(t) {
+    if (t != null) {
+      var n = "ifError got unwanted exception: ";
+      s(t) === "object" && typeof t.message == "string" ? t.message.length === 0 && t.constructor ? n += t.constructor.name : n += t.message : n += d(t);
+      var r = new m({
+        actual: t,
+        expected: null,
+        operator: "ifError",
+        message: n,
+        stackStartFn: e
+      }), o = t.stack;
+      if (typeof o == "string") {
+        var i = o.split(`
+`);
+        i.shift();
+        for (var c = r.stack.split(`
+`), u = 0; u < i.length; u++) {
+          var l = c.indexOf(i[u]);
+          if (l !== -1) {
+            c = c.slice(0, l);
+            break;
+          }
+        }
+        r.stack = "".concat(c.join(`
+`), `
+`).concat(i.join(`
+`));
+      }
+      throw r;
+    }
+  };
+  function C(e, t, n, r, o) {
+    if (!v(t))
+      throw new E("regexp", "RegExp", t);
+    var i = o === "match";
+    if (typeof e != "string" || q(t, e) !== i) {
+      if (n instanceof Error)
+        throw n;
+      var c = !n;
+      n = n || (typeof e != "string" ? 'The "string" argument must be of type string. Received type ' + "".concat(s(e), " (").concat(d(e), ")") : (i ? "The input did not match the regular expression " : "The input was expected to not match the regular expression ") + "".concat(d(t), `. Input:
+
+`).concat(d(e), `
+`));
+      var u = new m({
+        actual: e,
+        expected: t,
+        message: n,
+        operator: o,
+        stackStartFn: r
+      });
+      throw u.generatedMessage = c, u;
+    }
+  }
+  a.match = function e(t, n, r) {
+    C(t, n, r, e, "match");
+  }, a.doesNotMatch = function e(t, n, r) {
+    C(t, n, r, e, "doesNotMatch");
+  };
+  function $() {
+    for (var e = arguments.length, t = new Array(e), n = 0; n < e; n++)
+      t[n] = arguments[n];
+    F.apply(void 0, [$, t.length].concat(t));
+  }
+  return a.strict = tt($, a, {
+    equal: a.strictEqual,
+    deepEqual: a.deepStrictEqual,
+    notEqual: a.notStrictEqual,
+    notDeepEqual: a.notDeepStrictEqual
+  }), a.strict.strict = a.strict, b.exports;
+}
+export {
+  wt as __require
+};