@uva-glass/component-library 3.0.3 → 3.0.5

package/dist/setupTests.js

@@ -0,0 +1,1573 @@
+var It = Object.defineProperty;
+var Ft = (r, o, a) => o in r ? It(r, o, { enumerable: !0, configurable: !0, writable: !0, value: a }) : r[o] = a;
+var yr = (r, o, a) => Ft(r, typeof o != "symbol" ? o + "" : o, a);
+import { c as mt } from "./index-BqHyOZsF.js";
+var gr = {}, vr = {}, br, he;
+function At() {
+  return he || (he = 1, br = function() {
+    if (typeof Symbol != "function" || typeof Object.getOwnPropertySymbols != "function")
+      return !1;
+    if (typeof Symbol.iterator == "symbol")
+      return !0;
+    var o = {}, a = Symbol("test"), f = Object(a);
+    if (typeof a == "string" || Object.prototype.toString.call(a) !== "[object Symbol]" || Object.prototype.toString.call(f) !== "[object Symbol]")
+      return !1;
+    var s = 42;
+    o[a] = s;
+    for (var v in o)
+      return !1;
+    if (typeof Object.keys == "function" && Object.keys(o).length !== 0 || typeof Object.getOwnPropertyNames == "function" && Object.getOwnPropertyNames(o).length !== 0)
+      return !1;
+    var y = Object.getOwnPropertySymbols(o);
+    if (y.length !== 1 || y[0] !== a || !Object.prototype.propertyIsEnumerable.call(o, a))
+      return !1;
+    if (typeof Object.getOwnPropertyDescriptor == "function") {
+      var c = (
+        /** @type {PropertyDescriptor} */
+        Object.getOwnPropertyDescriptor(o, a)
+      );
+      if (c.value !== s || c.enumerable !== !0)
+        return !1;
+    }
+    return !0;
+  }), br;
+}
+var hr, me;
+function pr() {
+  if (me) return hr;
+  me = 1;
+  var r = At();
+  return hr = function() {
+    return r() && !!Symbol.toStringTag;
+  }, hr;
+}
+var mr, Ae;
+function St() {
+  return Ae || (Ae = 1, mr = Object), mr;
+}
+var Ar, Se;
+function Tt() {
+  return Se || (Se = 1, Ar = Error), Ar;
+}
+var Sr, Pe;
+function Dt() {
+  return Pe || (Pe = 1, Sr = EvalError), Sr;
+}
+var Pr, Oe;
+function Ut() {
+  return Oe || (Oe = 1, Pr = RangeError), Pr;
+}
+var Or, we;
+function $t() {
+  return we || (we = 1, Or = ReferenceError), Or;
+}
+var wr, je;
+function Pt() {
+  return je || (je = 1, wr = SyntaxError), wr;
+}
+var jr, Re;
+function ir() {
+  return Re || (Re = 1, jr = TypeError), jr;
+}
+var Rr, Ee;
+function Mt() {
+  return Ee || (Ee = 1, Rr = URIError), Rr;
+}
+var Er, Be;
+function _t() {
+  return Be || (Be = 1, Er = Math.abs), Er;
+}
+var Br, qe;
+function Nt() {
+  return qe || (qe = 1, Br = Math.floor), Br;
+}
+var qr, Ie;
+function Ct() {
+  return Ie || (Ie = 1, qr = Math.max), qr;
+}
+var Ir, Fe;
+function Gt() {
+  return Fe || (Fe = 1, Ir = Math.min), Ir;
+}
+var Fr, Te;
+function kt() {
+  return Te || (Te = 1, Fr = Math.pow), Fr;
+}
+var Tr, De;
+function Wt() {
+  return De || (De = 1, Tr = Math.round), Tr;
+}
+var Dr, Ue;
+function zt() {
+  return Ue || (Ue = 1, Dr = Number.isNaN || function(o) {
+    return o !== o;
+  }), Dr;
+}
+var Ur, $e;
+function Vt() {
+  if ($e) return Ur;
+  $e = 1;
+  var r = /* @__PURE__ */ zt();
+  return Ur = function(a) {
+    return r(a) || a === 0 ? a : a < 0 ? -1 : 1;
+  }, Ur;
+}
+var $r, Me;
+function Lt() {
+  return Me || (Me = 1, $r = Object.getOwnPropertyDescriptor), $r;
+}
+var Mr, _e;
+function tr() {
+  if (_e) return Mr;
+  _e = 1;
+  var r = /* @__PURE__ */ Lt();
+  if (r)
+    try {
+      r([], "length");
+    } catch {
+      r = null;
+    }
+  return Mr = r, Mr;
+}
+var _r, Ne;
+function dr() {
+  if (Ne) return _r;
+  Ne = 1;
+  var r = Object.defineProperty || !1;
+  if (r)
+    try {
+      r({}, "a", { value: 1 });
+    } catch {
+      r = !1;
+    }
+  return _r = r, _r;
+}
+var Nr, Ce;
+function Ht() {
+  if (Ce) return Nr;
+  Ce = 1;
+  var r = typeof Symbol < "u" && Symbol, o = At();
+  return Nr = function() {
+    return typeof r != "function" || typeof Symbol != "function" || typeof r("foo") != "symbol" || typeof Symbol("bar") != "symbol" ? !1 : o();
+  }, Nr;
+}
+var Cr, Ge;
+function Ot() {
+  return Ge || (Ge = 1, Cr = typeof Reflect < "u" && Reflect.getPrototypeOf || null), Cr;
+}
+var Gr, ke;
+function wt() {
+  if (ke) return Gr;
+  ke = 1;
+  var r = /* @__PURE__ */ St();
+  return Gr = r.getPrototypeOf || null, Gr;
+}
+var kr, We;
+function Jt() {
+  if (We) return kr;
+  We = 1;
+  var r = "Function.prototype.bind called on incompatible ", o = Object.prototype.toString, a = Math.max, f = "[object Function]", s = function(u, d) {
+    for (var p = [], l = 0; l < u.length; l += 1)
+      p[l] = u[l];
+    for (var g = 0; g < d.length; g += 1)
+      p[g + u.length] = d[g];
+    return p;
+  }, v = function(u, d) {
+    for (var p = [], l = d, g = 0; l < u.length; l += 1, g += 1)
+      p[g] = u[l];
+    return p;
+  }, y = function(c, u) {
+    for (var d = "", p = 0; p < c.length; p += 1)
+      d += c[p], p + 1 < c.length && (d += u);
+    return d;
+  };
+  return kr = function(u) {
+    var d = this;
+    if (typeof d != "function" || o.apply(d) !== f)
+      throw new TypeError(r + d);
+    for (var p = v(arguments, 1), l, g = function() {
+      if (this instanceof l) {
+        var P = d.apply(
+          this,
+          s(p, arguments)
+        );
+        return Object(P) === P ? P : this;
+      }
+      return d.apply(
+        u,
+        s(p, arguments)
+      );
+    }, N = a(0, d.length - p.length), T = [], I = 0; I < N; I++)
+      T[I] = "$" + I;
+    if (l = Function("binder", "return function (" + y(T, ",") + "){ return binder.apply(this,arguments); }")(g), d.prototype) {
+      var O = function() {
+      };
+      O.prototype = d.prototype, l.prototype = new O(), O.prototype = null;
+    }
+    return l;
+  }, kr;
+}
+var Wr, ze;
+function ar() {
+  if (ze) return Wr;
+  ze = 1;
+  var r = Jt();
+  return Wr = Function.prototype.bind || r, Wr;
+}
+var zr, Ve;
+function ge() {
+  return Ve || (Ve = 1, zr = Function.prototype.call), zr;
+}
+var Vr, Le;
+function ve() {
+  return Le || (Le = 1, Vr = Function.prototype.apply), Vr;
+}
+var Lr, He;
+function Zt() {
+  return He || (He = 1, Lr = typeof Reflect < "u" && Reflect && Reflect.apply), Lr;
+}
+var Hr, Je;
+function jt() {
+  if (Je) return Hr;
+  Je = 1;
+  var r = ar(), o = ve(), a = ge(), f = Zt();
+  return Hr = f || r.call(a, o), Hr;
+}
+var Jr, Ze;
+function be() {
+  if (Ze) return Jr;
+  Ze = 1;
+  var r = ar(), o = /* @__PURE__ */ ir(), a = ge(), f = jt();
+  return Jr = function(v) {
+    if (v.length < 1 || typeof v[0] != "function")
+      throw new o("a function is required");
+    return f(r, a, v);
+  }, Jr;
+}
+var Zr, Ye;
+function Yt() {
+  if (Ye) return Zr;
+  Ye = 1;
+  var r = be(), o = /* @__PURE__ */ tr(), a;
+  try {
+    a = /** @type {{ __proto__?: typeof Array.prototype }} */
+    [].__proto__ === Array.prototype;
+  } catch (y) {
+    if (!y || typeof y != "object" || !("code" in y) || y.code !== "ERR_PROTO_ACCESS")
+      throw y;
+  }
+  var f = !!a && o && o(
+    Object.prototype,
+    /** @type {keyof typeof Object.prototype} */
+    "__proto__"
+  ), s = Object, v = s.getPrototypeOf;
+  return Zr = f && typeof f.get == "function" ? r([f.get]) : typeof v == "function" ? (
+    /** @type {import('./get')} */
+    function(c) {
+      return v(c == null ? c : s(c));
+    }
+  ) : !1, Zr;
+}
+var Yr, Ke;
+function Rt() {
+  if (Ke) return Yr;
+  Ke = 1;
+  var r = Ot(), o = wt(), a = /* @__PURE__ */ Yt();
+  return Yr = r ? function(s) {
+    return r(s);
+  } : o ? function(s) {
+    if (!s || typeof s != "object" && typeof s != "function")
+      throw new TypeError("getProto: not an object");
+    return o(s);
+  } : a ? function(s) {
+    return a(s);
+  } : null, Yr;
+}
+var Kr, Qe;
+function Et() {
+  if (Qe) return Kr;
+  Qe = 1;
+  var r = Function.prototype.call, o = Object.prototype.hasOwnProperty, a = ar();
+  return Kr = a.call(r, o), Kr;
+}
+var Qr, Xe;
+function Bt() {
+  if (Xe) return Qr;
+  Xe = 1;
+  var r, o = /* @__PURE__ */ St(), a = /* @__PURE__ */ Tt(), f = /* @__PURE__ */ Dt(), s = /* @__PURE__ */ Ut(), v = /* @__PURE__ */ $t(), y = /* @__PURE__ */ Pt(), c = /* @__PURE__ */ ir(), u = /* @__PURE__ */ Mt(), d = /* @__PURE__ */ _t(), p = /* @__PURE__ */ Nt(), l = /* @__PURE__ */ Ct(), g = /* @__PURE__ */ Gt(), N = /* @__PURE__ */ kt(), T = /* @__PURE__ */ Wt(), I = /* @__PURE__ */ Vt(), O = Function, P = function(h) {
+    try {
+      return O('"use strict"; return (' + h + ").constructor;")();
+    } catch {
+    }
+  }, w = /* @__PURE__ */ tr(), A = /* @__PURE__ */ dr(), F = function() {
+    throw new c();
+  }, z = w ? function() {
+    try {
+      return arguments.callee, F;
+    } catch {
+      try {
+        return w(arguments, "callee").get;
+      } catch {
+        return F;
+      }
+    }
+  }() : F, V = Ht()(), B = Rt(), J = wt(), L = Ot(), Z = ve(), G = ge(), M = {}, nr = typeof Uint8Array > "u" || !B ? r : B(Uint8Array), _ = {
+    __proto__: null,
+    "%AggregateError%": typeof AggregateError > "u" ? r : AggregateError,
+    "%Array%": Array,
+    "%ArrayBuffer%": typeof ArrayBuffer > "u" ? r : ArrayBuffer,
+    "%ArrayIteratorPrototype%": V && B ? B([][Symbol.iterator]()) : r,
+    "%AsyncFromSyncIteratorPrototype%": r,
+    "%AsyncFunction%": M,
+    "%AsyncGenerator%": M,
+    "%AsyncGeneratorFunction%": M,
+    "%AsyncIteratorPrototype%": M,
+    "%Atomics%": typeof Atomics > "u" ? r : Atomics,
+    "%BigInt%": typeof BigInt > "u" ? r : BigInt,
+    "%BigInt64Array%": typeof BigInt64Array > "u" ? r : BigInt64Array,
+    "%BigUint64Array%": typeof BigUint64Array > "u" ? r : BigUint64Array,
+    "%Boolean%": Boolean,
+    "%DataView%": typeof DataView > "u" ? r : DataView,
+    "%Date%": Date,
+    "%decodeURI%": decodeURI,
+    "%decodeURIComponent%": decodeURIComponent,
+    "%encodeURI%": encodeURI,
+    "%encodeURIComponent%": encodeURIComponent,
+    "%Error%": a,
+    "%eval%": eval,
+    // eslint-disable-line no-eval
+    "%EvalError%": f,
+    "%Float32Array%": typeof Float32Array > "u" ? r : Float32Array,
+    "%Float64Array%": typeof Float64Array > "u" ? r : Float64Array,
+    "%FinalizationRegistry%": typeof FinalizationRegistry > "u" ? r : FinalizationRegistry,
+    "%Function%": O,
+    "%GeneratorFunction%": M,
+    "%Int8Array%": typeof Int8Array > "u" ? r : Int8Array,
+    "%Int16Array%": typeof Int16Array > "u" ? r : Int16Array,
+    "%Int32Array%": typeof Int32Array > "u" ? r : Int32Array,
+    "%isFinite%": isFinite,
+    "%isNaN%": isNaN,
+    "%IteratorPrototype%": V && B ? B(B([][Symbol.iterator]())) : r,
+    "%JSON%": typeof JSON == "object" ? JSON : r,
+    "%Map%": typeof Map > "u" ? r : Map,
+    "%MapIteratorPrototype%": typeof Map > "u" || !V || !B ? r : B((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+    "%Math%": Math,
+    "%Number%": Number,
+    "%Object%": o,
+    "%Object.getOwnPropertyDescriptor%": w,
+    "%parseFloat%": parseFloat,
+    "%parseInt%": parseInt,
+    "%Promise%": typeof Promise > "u" ? r : Promise,
+    "%Proxy%": typeof Proxy > "u" ? r : Proxy,
+    "%RangeError%": s,
+    "%ReferenceError%": v,
+    "%Reflect%": typeof Reflect > "u" ? r : Reflect,
+    "%RegExp%": RegExp,
+    "%Set%": typeof Set > "u" ? r : Set,
+    "%SetIteratorPrototype%": typeof Set > "u" || !V || !B ? r : B((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+    "%SharedArrayBuffer%": typeof SharedArrayBuffer > "u" ? r : SharedArrayBuffer,
+    "%String%": String,
+    "%StringIteratorPrototype%": V && B ? B(""[Symbol.iterator]()) : r,
+    "%Symbol%": V ? Symbol : r,
+    "%SyntaxError%": y,
+    "%ThrowTypeError%": z,
+    "%TypedArray%": nr,
+    "%TypeError%": c,
+    "%Uint8Array%": typeof Uint8Array > "u" ? r : Uint8Array,
+    "%Uint8ClampedArray%": typeof Uint8ClampedArray > "u" ? r : Uint8ClampedArray,
+    "%Uint16Array%": typeof Uint16Array > "u" ? r : Uint16Array,
+    "%Uint32Array%": typeof Uint32Array > "u" ? r : Uint32Array,
+    "%URIError%": u,
+    "%WeakMap%": typeof WeakMap > "u" ? r : WeakMap,
+    "%WeakRef%": typeof WeakRef > "u" ? r : WeakRef,
+    "%WeakSet%": typeof WeakSet > "u" ? r : WeakSet,
+    "%Function.prototype.call%": G,
+    "%Function.prototype.apply%": Z,
+    "%Object.defineProperty%": A,
+    "%Object.getPrototypeOf%": J,
+    "%Math.abs%": d,
+    "%Math.floor%": p,
+    "%Math.max%": l,
+    "%Math.min%": g,
+    "%Math.pow%": N,
+    "%Math.round%": T,
+    "%Math.sign%": I,
+    "%Reflect.getPrototypeOf%": L
+  };
+  if (B)
+    try {
+      null.error;
+    } catch (h) {
+      var Q = B(B(h));
+      _["%Error.prototype%"] = Q;
+    }
+  var Y = function h(b) {
+    var E;
+    if (b === "%AsyncFunction%")
+      E = P("async function () {}");
+    else if (b === "%GeneratorFunction%")
+      E = P("function* () {}");
+    else if (b === "%AsyncGeneratorFunction%")
+      E = P("async function* () {}");
+    else if (b === "%AsyncGenerator%") {
+      var q = h("%AsyncGeneratorFunction%");
+      q && (E = q.prototype);
+    } else if (b === "%AsyncIteratorPrototype%") {
+      var D = h("%AsyncGenerator%");
+      D && B && (E = B(D.prototype));
+    }
+    return _[b] = E, E;
+  }, x = {
+    __proto__: null,
+    "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+    "%ArrayPrototype%": ["Array", "prototype"],
+    "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+    "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+    "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+    "%ArrayProto_values%": ["Array", "prototype", "values"],
+    "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+    "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+    "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
+    "%BooleanPrototype%": ["Boolean", "prototype"],
+    "%DataViewPrototype%": ["DataView", "prototype"],
+    "%DatePrototype%": ["Date", "prototype"],
+    "%ErrorPrototype%": ["Error", "prototype"],
+    "%EvalErrorPrototype%": ["EvalError", "prototype"],
+    "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+    "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+    "%FunctionPrototype%": ["Function", "prototype"],
+    "%Generator%": ["GeneratorFunction", "prototype"],
+    "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+    "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+    "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+    "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+    "%JSONParse%": ["JSON", "parse"],
+    "%JSONStringify%": ["JSON", "stringify"],
+    "%MapPrototype%": ["Map", "prototype"],
+    "%NumberPrototype%": ["Number", "prototype"],
+    "%ObjectPrototype%": ["Object", "prototype"],
+    "%ObjProto_toString%": ["Object", "prototype", "toString"],
+    "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+    "%PromisePrototype%": ["Promise", "prototype"],
+    "%PromiseProto_then%": ["Promise", "prototype", "then"],
+    "%Promise_all%": ["Promise", "all"],
+    "%Promise_reject%": ["Promise", "reject"],
+    "%Promise_resolve%": ["Promise", "resolve"],
+    "%RangeErrorPrototype%": ["RangeError", "prototype"],
+    "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+    "%RegExpPrototype%": ["RegExp", "prototype"],
+    "%SetPrototype%": ["Set", "prototype"],
+    "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+    "%StringPrototype%": ["String", "prototype"],
+    "%SymbolPrototype%": ["Symbol", "prototype"],
+    "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+    "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+    "%TypeErrorPrototype%": ["TypeError", "prototype"],
+    "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+    "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+    "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+    "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+    "%URIErrorPrototype%": ["URIError", "prototype"],
+    "%WeakMapPrototype%": ["WeakMap", "prototype"],
+    "%WeakSetPrototype%": ["WeakSet", "prototype"]
+  }, k = ar(), C = /* @__PURE__ */ Et(), K = k.call(G, Array.prototype.concat), rr = k.call(Z, Array.prototype.splice), e = k.call(G, String.prototype.replace), t = k.call(G, String.prototype.slice), i = k.call(G, RegExp.prototype.exec), m = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g, j = /\\(\\)?/g, R = function(b) {
+    var E = t(b, 0, 1), q = t(b, -1);
+    if (E === "%" && q !== "%")
+      throw new y("invalid intrinsic syntax, expected closing `%`");
+    if (q === "%" && E !== "%")
+      throw new y("invalid intrinsic syntax, expected opening `%`");
+    var D = [];
+    return e(b, m, function(U, W, $, er) {
+      D[D.length] = $ ? e(er, j, "$1") : W || U;
+    }), D;
+  }, S = function(b, E) {
+    var q = b, D;
+    if (C(x, q) && (D = x[q], q = "%" + D[0] + "%"), C(_, q)) {
+      var U = _[q];
+      if (U === M && (U = Y(q)), typeof U > "u" && !E)
+        throw new c("intrinsic " + b + " exists, but is not available. Please file an issue!");
+      return {
+        alias: D,
+        name: q,
+        value: U
+      };
+    }
+    throw new y("intrinsic " + b + " does not exist!");
+  };
+  return Qr = function(b, E) {
+    if (typeof b != "string" || b.length === 0)
+      throw new c("intrinsic name must be a non-empty string");
+    if (arguments.length > 1 && typeof E != "boolean")
+      throw new c('"allowMissing" argument must be a boolean');
+    if (i(/^%?[^%]*%?$/, b) === null)
+      throw new y("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+    var q = R(b), D = q.length > 0 ? q[0] : "", U = S("%" + D + "%", E), W = U.name, $ = U.value, er = !1, or = U.alias;
+    or && (D = or[0], rr(q, K([0, 1], or)));
+    for (var n = 1, X = !0; n < q.length; n += 1) {
+      var H = q[n], fr = t(H, 0, 1), cr = t(H, -1);
+      if ((fr === '"' || fr === "'" || fr === "`" || cr === '"' || cr === "'" || cr === "`") && fr !== cr)
+        throw new y("property names with quotes must have matching quotes");
+      if ((H === "constructor" || !X) && (er = !0), D += "." + H, W = "%" + D + "%", C(_, W))
+        $ = _[W];
+      else if ($ != null) {
+        if (!(H in $)) {
+          if (!E)
+            throw new c("base intrinsic for " + b + " exists, but the property is not available.");
+          return;
+        }
+        if (w && n + 1 >= q.length) {
+          var sr = w($, H);
+          X = !!sr, X && "get" in sr && !("originalValue" in sr.get) ? $ = sr.get : $ = $[H];
+        } else
+          X = C($, H), $ = $[H];
+        X && !er && (_[W] = $);
+      }
+    }
+    return $;
+  }, Qr;
+}
+var Xr, xe;
+function ur() {
+  if (xe) return Xr;
+  xe = 1;
+  var r = /* @__PURE__ */ Bt(), o = be(), a = o([r("%String.prototype.indexOf%")]);
+  return Xr = function(s, v) {
+    var y = (
+      /** @type {Parameters<typeof callBindBasic>[0][0]} */
+      r(s, !!v)
+    );
+    return typeof y == "function" && a(s, ".prototype.") > -1 ? o([y]) : y;
+  }, Xr;
+}
+var xr, rt;
+function Kt() {
+  if (rt) return xr;
+  rt = 1;
+  var r = pr()(), o = /* @__PURE__ */ ur(), a = o("Object.prototype.toString"), f = function(c) {
+    return r && c && typeof c == "object" && Symbol.toStringTag in c ? !1 : a(c) === "[object Arguments]";
+  }, s = function(c) {
+    return f(c) ? !0 : c !== null && typeof c == "object" && "length" in c && typeof c.length == "number" && c.length >= 0 && a(c) !== "[object Array]" && "callee" in c && a(c.callee) === "[object Function]";
+  }, v = function() {
+    return f(arguments);
+  }();
+  return f.isLegacyArguments = s, xr = v ? f : s, xr;
+}
+var re, et;
+function Qt() {
+  if (et) return re;
+  et = 1;
+  var r = /* @__PURE__ */ ur(), o = pr()(), a = /* @__PURE__ */ Et(), f = /* @__PURE__ */ tr(), s;
+  if (o) {
+    var v = r("RegExp.prototype.exec"), y = {}, c = function() {
+      throw y;
+    }, u = {
+      toString: c,
+      valueOf: c
+    };
+    typeof Symbol.toPrimitive == "symbol" && (u[Symbol.toPrimitive] = c), s = function(g) {
+      if (!g || typeof g != "object")
+        return !1;
+      var N = (
+        /** @type {NonNullable<typeof gOPD>} */
+        f(
+          /** @type {{ lastIndex?: unknown }} */
+          g,
+          "lastIndex"
+        )
+      ), T = N && a(N, "value");
+      if (!T)
+        return !1;
+      try {
+        v(
+          g,
+          /** @type {string} */
+          /** @type {unknown} */
+          u
+        );
+      } catch (I) {
+        return I === y;
+      }
+    };
+  } else {
+    var d = r("Object.prototype.toString"), p = "[object RegExp]";
+    s = function(g) {
+      return !g || typeof g != "object" && typeof g != "function" ? !1 : d(g) === p;
+    };
+  }
+  return re = s, re;
+}
+var ee, tt;
+function Xt() {
+  if (tt) return ee;
+  tt = 1;
+  var r = /* @__PURE__ */ ur(), o = Qt(), a = r("RegExp.prototype.exec"), f = /* @__PURE__ */ ir();
+  return ee = function(v) {
+    if (!o(v))
+      throw new f("`regex` must be a RegExp");
+    return function(c) {
+      return a(v, c) !== null;
+    };
+  }, ee;
+}
+var te, nt;
+function xt() {
+  if (nt) return te;
+  nt = 1;
+  var r = /* @__PURE__ */ ur(), o = /* @__PURE__ */ Xt(), a = o(/^\s*(?:function)?\*/), f = pr()(), s = Rt(), v = r("Object.prototype.toString"), y = r("Function.prototype.toString"), c = function() {
+    if (!f)
+      return !1;
+    try {
+      return Function("return function*() {}")();
+    } catch {
+    }
+  }, u;
+  return te = function(p) {
+    if (typeof p != "function")
+      return !1;
+    if (a(y(p)))
+      return !0;
+    if (!f) {
+      var l = v(p);
+      return l === "[object GeneratorFunction]";
+    }
+    if (!s)
+      return !1;
+    if (typeof u > "u") {
+      var g = c();
+      u = g ? (
+        /** @type {GeneratorFunctionConstructor} */
+        s(g)
+      ) : !1;
+    }
+    return s(p) === u;
+  }, te;
+}
+var ne, ot;
+function rn() {
+  if (ot) return ne;
+  ot = 1;
+  var r = Function.prototype.toString, o = typeof Reflect == "object" && Reflect !== null && Reflect.apply, a, f;
+  if (typeof o == "function" && typeof Object.defineProperty == "function")
+    try {
+      a = Object.defineProperty({}, "length", {
+        get: function() {
+          throw f;
+        }
+      }), f = {}, o(function() {
+        throw 42;
+      }, null, a);
+    } catch (w) {
+      w !== f && (o = null);
+    }
+  else
+    o = null;
+  var s = /^\s*class\b/, v = function(A) {
+    try {
+      var F = r.call(A);
+      return s.test(F);
+    } catch {
+      return !1;
+    }
+  }, y = function(A) {
+    try {
+      return v(A) ? !1 : (r.call(A), !0);
+    } catch {
+      return !1;
+    }
+  }, c = Object.prototype.toString, u = "[object Object]", d = "[object Function]", p = "[object GeneratorFunction]", l = "[object HTMLAllCollection]", g = "[object HTML document.all class]", N = "[object HTMLCollection]", T = typeof Symbol == "function" && !!Symbol.toStringTag, I = !(0 in [,]), O = function() {
+    return !1;
+  };
+  if (typeof document == "object") {
+    var P = document.all;
+    c.call(P) === c.call(document.all) && (O = function(A) {
+      if ((I || !A) && (typeof A > "u" || typeof A == "object"))
+        try {
+          var F = c.call(A);
+          return (F === l || F === g || F === N || F === u) && A("") == null;
+        } catch {
+        }
+      return !1;
+    });
+  }
+  return ne = o ? function(A) {
+    if (O(A))
+      return !0;
+    if (!A || typeof A != "function" && typeof A != "object")
+      return !1;
+    try {
+      o(A, null, a);
+    } catch (F) {
+      if (F !== f)
+        return !1;
+    }
+    return !v(A) && y(A);
+  } : function(A) {
+    if (O(A))
+      return !0;
+    if (!A || typeof A != "function" && typeof A != "object")
+      return !1;
+    if (T)
+      return y(A);
+    if (v(A))
+      return !1;
+    var F = c.call(A);
+    return F !== d && F !== p && !/^\[object HTML/.test(F) ? !1 : y(A);
+  }, ne;
+}
+var oe, it;
+function en() {
+  if (it) return oe;
+  it = 1;
+  var r = rn(), o = Object.prototype.toString, a = Object.prototype.hasOwnProperty, f = function(u, d, p) {
+    for (var l = 0, g = u.length; l < g; l++)
+      a.call(u, l) && (p == null ? d(u[l], l, u) : d.call(p, u[l], l, u));
+  }, s = function(u, d, p) {
+    for (var l = 0, g = u.length; l < g; l++)
+      p == null ? d(u.charAt(l), l, u) : d.call(p, u.charAt(l), l, u);
+  }, v = function(u, d, p) {
+    for (var l in u)
+      a.call(u, l) && (p == null ? d(u[l], l, u) : d.call(p, u[l], l, u));
+  }, y = function(u, d, p) {
+    if (!r(d))
+      throw new TypeError("iterator must be a function");
+    var l;
+    arguments.length >= 3 && (l = p), o.call(u) === "[object Array]" ? f(u, d, l) : typeof u == "string" ? s(u, d, l) : v(u, d, l);
+  };
+  return oe = y, oe;
+}
+var ie, at;
+function tn() {
+  return at || (at = 1, ie = [
+    "Float16Array",
+    "Float32Array",
+    "Float64Array",
+    "Int8Array",
+    "Int16Array",
+    "Int32Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Uint16Array",
+    "Uint32Array",
+    "BigInt64Array",
+    "BigUint64Array"
+  ]), ie;
+}
+var ae, ut;
+function nn() {
+  if (ut) return ae;
+  ut = 1;
+  var r = /* @__PURE__ */ tn(), o = typeof globalThis > "u" ? mt : globalThis;
+  return ae = function() {
+    for (var f = [], s = 0; s < r.length; s++)
+      typeof o[r[s]] == "function" && (f[f.length] = r[s]);
+    return f;
+  }, ae;
+}
+var ue = { exports: {} }, fe, ft;
+function on() {
+  if (ft) return fe;
+  ft = 1;
+  var r = /* @__PURE__ */ dr(), o = /* @__PURE__ */ Pt(), a = /* @__PURE__ */ ir(), f = /* @__PURE__ */ tr();
+  return fe = function(v, y, c) {
+    if (!v || typeof v != "object" && typeof v != "function")
+      throw new a("`obj` must be an object or a function`");
+    if (typeof y != "string" && typeof y != "symbol")
+      throw new a("`property` must be a string or a symbol`");
+    if (arguments.length > 3 && typeof arguments[3] != "boolean" && arguments[3] !== null)
+      throw new a("`nonEnumerable`, if provided, must be a boolean or null");
+    if (arguments.length > 4 && typeof arguments[4] != "boolean" && arguments[4] !== null)
+      throw new a("`nonWritable`, if provided, must be a boolean or null");
+    if (arguments.length > 5 && typeof arguments[5] != "boolean" && arguments[5] !== null)
+      throw new a("`nonConfigurable`, if provided, must be a boolean or null");
+    if (arguments.length > 6 && typeof arguments[6] != "boolean")
+      throw new a("`loose`, if provided, must be a boolean");
+    var u = arguments.length > 3 ? arguments[3] : null, d = arguments.length > 4 ? arguments[4] : null, p = arguments.length > 5 ? arguments[5] : null, l = arguments.length > 6 ? arguments[6] : !1, g = !!f && f(v, y);
+    if (r)
+      r(v, y, {
+        configurable: p === null && g ? g.configurable : !p,
+        enumerable: u === null && g ? g.enumerable : !u,
+        value: c,
+        writable: d === null && g ? g.writable : !d
+      });
+    else if (l || !u && !d && !p)
+      v[y] = c;
+    else
+      throw new o("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
+  }, fe;
+}
+var ce, ct;
+function an() {
+  if (ct) return ce;
+  ct = 1;
+  var r = /* @__PURE__ */ dr(), o = function() {
+    return !!r;
+  };
+  return o.hasArrayLengthDefineBug = function() {
+    if (!r)
+      return null;
+    try {
+      return r([], "length", { value: 1 }).length !== 1;
+    } catch {
+      return !0;
+    }
+  }, ce = o, ce;
+}
+var se, st;
+function un() {
+  if (st) return se;
+  st = 1;
+  var r = /* @__PURE__ */ Bt(), o = /* @__PURE__ */ on(), a = /* @__PURE__ */ an()(), f = /* @__PURE__ */ tr(), s = /* @__PURE__ */ ir(), v = r("%Math.floor%");
+  return se = function(c, u) {
+    if (typeof c != "function")
+      throw new s("`fn` is not a function");
+    if (typeof u != "number" || u < 0 || u > 4294967295 || v(u) !== u)
+      throw new s("`length` must be a positive 32-bit integer");
+    var d = arguments.length > 2 && !!arguments[2], p = !0, l = !0;
+    if ("length" in c && f) {
+      var g = f(c, "length");
+      g && !g.configurable && (p = !1), g && !g.writable && (l = !1);
+    }
+    return (p || l || !d) && (a ? o(
+      /** @type {Parameters<define>[0]} */
+      c,
+      "length",
+      u,
+      !0,
+      !0
+    ) : o(
+      /** @type {Parameters<define>[0]} */
+      c,
+      "length",
+      u
+    )), c;
+  }, se;
+}
+var ye, yt;
+function fn() {
+  if (yt) return ye;
+  yt = 1;
+  var r = ar(), o = ve(), a = jt();
+  return ye = function() {
+    return a(r, o, arguments);
+  }, ye;
+}
+var lt;
+function cn() {
+  return lt || (lt = 1, function(r) {
+    var o = /* @__PURE__ */ un(), a = /* @__PURE__ */ dr(), f = be(), s = fn();
+    r.exports = function(y) {
+      var c = f(arguments), u = y.length - (arguments.length - 1);
+      return o(
+        c,
+        1 + (u > 0 ? u : 0),
+        !0
+      );
+    }, a ? a(r.exports, "apply", { value: s }) : r.exports.apply = s;
+  }(ue)), ue.exports;
+}
+var le, pt;
+function qt() {
+  if (pt) return le;
+  pt = 1;
+  var r = en(), o = /* @__PURE__ */ nn(), a = cn(), f = /* @__PURE__ */ ur(), s = /* @__PURE__ */ tr(), v = f("Object.prototype.toString"), y = pr()(), c = typeof globalThis > "u" ? mt : globalThis, u = o(), d = f("String.prototype.slice"), p = Object.getPrototypeOf, l = f("Array.prototype.indexOf", !0) || function(O, P) {
+    for (var w = 0; w < O.length; w += 1)
+      if (O[w] === P)
+        return w;
+    return -1;
+  }, g = { __proto__: null };
+  y && s && p ? r(u, function(I) {
+    var O = new c[I]();
+    if (Symbol.toStringTag in O) {
+      var P = p(O), w = s(P, Symbol.toStringTag);
+      if (!w) {
+        var A = p(P);
+        w = s(A, Symbol.toStringTag);
+      }
+      g["$" + I] = a(w.get);
+    }
+  }) : r(u, function(I) {
+    var O = new c[I](), P = O.slice || O.set;
+    P && (g["$" + I] = a(P));
+  });
+  var N = function(O) {
+    var P = !1;
+    return r(
+      // eslint-disable-next-line no-extra-parens
+      /** @type {Record<`\$${TypedArrayName}`, Getter>} */
+      /** @type {any} */
+      g,
+      /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */
+      function(w, A) {
+        if (!P)
+          try {
+            "$" + w(O) === A && (P = d(A, 1));
+          } catch {
+          }
+      }
+    ), P;
+  }, T = function(O) {
+    var P = !1;
+    return r(
+      // eslint-disable-next-line no-extra-parens
+      /** @type {Record<`\$${TypedArrayName}`, Getter>} */
+      /** @type {any} */
+      g,
+      /** @type {(getter: typeof cache, name: `\$${import('.').TypedArrayName}`) => void} */
+      function(w, A) {
+        if (!P)
+          try {
+            w(O), P = d(A, 1);
+          } catch {
+          }
+      }
+    ), P;
+  };
+  return le = function(O) {
+    if (!O || typeof O != "object")
+      return !1;
+    if (!y) {
+      var P = d(v(O), 8, -1);
+      return l(u, P) > -1 ? P : P !== "Object" ? !1 : T(O);
+    }
+    return s ? N(O) : null;
+  }, le;
+}
+var pe, dt;
+function sn() {
+  if (dt) return pe;
+  dt = 1;
+  var r = /* @__PURE__ */ qt();
+  return pe = function(a) {
+    return !!r(a);
+  }, pe;
+}
+var gt;
+function yn() {
+  return gt || (gt = 1, function(r) {
+    var o = /* @__PURE__ */ Kt(), a = xt(), f = /* @__PURE__ */ qt(), s = /* @__PURE__ */ sn();
+    function v(n) {
+      return n.call.bind(n);
+    }
+    var y = typeof BigInt < "u", c = typeof Symbol < "u", u = v(Object.prototype.toString), d = v(Number.prototype.valueOf), p = v(String.prototype.valueOf), l = v(Boolean.prototype.valueOf);
+    if (y)
+      var g = v(BigInt.prototype.valueOf);
+    if (c)
+      var N = v(Symbol.prototype.valueOf);
+    function T(n, X) {
+      if (typeof n != "object")
+        return !1;
+      try {
+        return X(n), !0;
+      } catch {
+        return !1;
+      }
+    }
+    r.isArgumentsObject = o, r.isGeneratorFunction = a, r.isTypedArray = s;
+    function I(n) {
+      return typeof Promise < "u" && n instanceof Promise || n !== null && typeof n == "object" && typeof n.then == "function" && typeof n.catch == "function";
+    }
+    r.isPromise = I;
+    function O(n) {
+      return typeof ArrayBuffer < "u" && ArrayBuffer.isView ? ArrayBuffer.isView(n) : s(n) || t(n);
+    }
+    r.isArrayBufferView = O;
+    function P(n) {
+      return f(n) === "Uint8Array";
+    }
+    r.isUint8Array = P;
+    function w(n) {
+      return f(n) === "Uint8ClampedArray";
+    }
+    r.isUint8ClampedArray = w;
+    function A(n) {
+      return f(n) === "Uint16Array";
+    }
+    r.isUint16Array = A;
+    function F(n) {
+      return f(n) === "Uint32Array";
+    }
+    r.isUint32Array = F;
+    function z(n) {
+      return f(n) === "Int8Array";
+    }
+    r.isInt8Array = z;
+    function V(n) {
+      return f(n) === "Int16Array";
+    }
+    r.isInt16Array = V;
+    function B(n) {
+      return f(n) === "Int32Array";
+    }
+    r.isInt32Array = B;
+    function J(n) {
+      return f(n) === "Float32Array";
+    }
+    r.isFloat32Array = J;
+    function L(n) {
+      return f(n) === "Float64Array";
+    }
+    r.isFloat64Array = L;
+    function Z(n) {
+      return f(n) === "BigInt64Array";
+    }
+    r.isBigInt64Array = Z;
+    function G(n) {
+      return f(n) === "BigUint64Array";
+    }
+    r.isBigUint64Array = G;
+    function M(n) {
+      return u(n) === "[object Map]";
+    }
+    M.working = typeof Map < "u" && M(/* @__PURE__ */ new Map());
+    function nr(n) {
+      return typeof Map > "u" ? !1 : M.working ? M(n) : n instanceof Map;
+    }
+    r.isMap = nr;
+    function _(n) {
+      return u(n) === "[object Set]";
+    }
+    _.working = typeof Set < "u" && _(/* @__PURE__ */ new Set());
+    function Q(n) {
+      return typeof Set > "u" ? !1 : _.working ? _(n) : n instanceof Set;
+    }
+    r.isSet = Q;
+    function Y(n) {
+      return u(n) === "[object WeakMap]";
+    }
+    Y.working = typeof WeakMap < "u" && Y(/* @__PURE__ */ new WeakMap());
+    function x(n) {
+      return typeof WeakMap > "u" ? !1 : Y.working ? Y(n) : n instanceof WeakMap;
+    }
+    r.isWeakMap = x;
+    function k(n) {
+      return u(n) === "[object WeakSet]";
+    }
+    k.working = typeof WeakSet < "u" && k(/* @__PURE__ */ new WeakSet());
+    function C(n) {
+      return k(n);
+    }
+    r.isWeakSet = C;
+    function K(n) {
+      return u(n) === "[object ArrayBuffer]";
+    }
+    K.working = typeof ArrayBuffer < "u" && K(new ArrayBuffer());
+    function rr(n) {
+      return typeof ArrayBuffer > "u" ? !1 : K.working ? K(n) : n instanceof ArrayBuffer;
+    }
+    r.isArrayBuffer = rr;
+    function e(n) {
+      return u(n) === "[object DataView]";
+    }
+    e.working = typeof ArrayBuffer < "u" && typeof DataView < "u" && e(new DataView(new ArrayBuffer(1), 0, 1));
+    function t(n) {
+      return typeof DataView > "u" ? !1 : e.working ? e(n) : n instanceof DataView;
+    }
+    r.isDataView = t;
+    var i = typeof SharedArrayBuffer < "u" ? SharedArrayBuffer : void 0;
+    function m(n) {
+      return u(n) === "[object SharedArrayBuffer]";
+    }
+    function j(n) {
+      return typeof i > "u" ? !1 : (typeof m.working > "u" && (m.working = m(new i())), m.working ? m(n) : n instanceof i);
+    }
+    r.isSharedArrayBuffer = j;
+    function R(n) {
+      return u(n) === "[object AsyncFunction]";
+    }
+    r.isAsyncFunction = R;
+    function S(n) {
+      return u(n) === "[object Map Iterator]";
+    }
+    r.isMapIterator = S;
+    function h(n) {
+      return u(n) === "[object Set Iterator]";
+    }
+    r.isSetIterator = h;
+    function b(n) {
+      return u(n) === "[object Generator]";
+    }
+    r.isGeneratorObject = b;
+    function E(n) {
+      return u(n) === "[object WebAssembly.Module]";
+    }
+    r.isWebAssemblyCompiledModule = E;
+    function q(n) {
+      return T(n, d);
+    }
+    r.isNumberObject = q;
+    function D(n) {
+      return T(n, p);
+    }
+    r.isStringObject = D;
+    function U(n) {
+      return T(n, l);
+    }
+    r.isBooleanObject = U;
+    function W(n) {
+      return y && T(n, g);
+    }
+    r.isBigIntObject = W;
+    function $(n) {
+      return c && T(n, N);
+    }
+    r.isSymbolObject = $;
+    function er(n) {
+      return q(n) || D(n) || U(n) || W(n) || $(n);
+    }
+    r.isBoxedPrimitive = er;
+    function or(n) {
+      return typeof Uint8Array < "u" && (rr(n) || j(n));
+    }
+    r.isAnyArrayBuffer = or, ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(n) {
+      Object.defineProperty(r, n, {
+        enumerable: !1,
+        value: function() {
+          throw new Error(n + " is not supported in userland");
+        }
+      });
+    });
+  }(vr)), vr;
+}
+var de, vt;
+function ln() {
+  return vt || (vt = 1, de = function(o) {
+    return o && typeof o == "object" && typeof o.copy == "function" && typeof o.fill == "function" && typeof o.readUInt8 == "function";
+  }), de;
+}
+var lr = { exports: {} }, bt;
+function pn() {
+  return bt || (bt = 1, typeof Object.create == "function" ? lr.exports = function(o, a) {
+    a && (o.super_ = a, o.prototype = Object.create(a.prototype, {
+      constructor: {
+        value: o,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }));
+  } : lr.exports = function(o, a) {
+    if (a) {
+      o.super_ = a;
+      var f = function() {
+      };
+      f.prototype = a.prototype, o.prototype = new f(), o.prototype.constructor = o;
+    }
+  }), lr.exports;
+}
+var ht;
+function dn() {
+  return ht || (ht = 1, function(r) {
+    var o = Object.getOwnPropertyDescriptors || function(t) {
+      for (var i = Object.keys(t), m = {}, j = 0; j < i.length; j++)
+        m[i[j]] = Object.getOwnPropertyDescriptor(t, i[j]);
+      return m;
+    }, a = /%[sdj%]/g;
+    r.format = function(e) {
+      if (!z(e)) {
+        for (var t = [], i = 0; i < arguments.length; i++)
+          t.push(y(arguments[i]));
+        return t.join(" ");
+      }
+      for (var i = 1, m = arguments, j = m.length, R = String(e).replace(a, function(h) {
+        if (h === "%%") return "%";
+        if (i >= j) return h;
+        switch (h) {
+          case "%s":
+            return String(m[i++]);
+          case "%d":
+            return Number(m[i++]);
+          case "%j":
+            try {
+              return JSON.stringify(m[i++]);
+            } catch {
+              return "[Circular]";
+            }
+          default:
+            return h;
+        }
+      }), S = m[i]; i < j; S = m[++i])
+        w(S) || !L(S) ? R += " " + S : R += " " + y(S);
+      return R;
+    }, r.deprecate = function(e, t) {
+      if (typeof process < "u" && process.noDeprecation === !0)
+        return e;
+      if (typeof process > "u")
+        return function() {
+          return r.deprecate(e, t).apply(this, arguments);
+        };
+      var i = !1;
+      function m() {
+        if (!i) {
+          if (process.throwDeprecation)
+            throw new Error(t);
+          process.traceDeprecation ? console.trace(t) : console.error(t), i = !0;
+        }
+        return e.apply(this, arguments);
+      }
+      return m;
+    };
+    var f = {}, s = /^$/;
+    if (process.env.NODE_DEBUG) {
+      var v = process.env.NODE_DEBUG;
+      v = v.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase(), s = new RegExp("^" + v + "$", "i");
+    }
+    r.debuglog = function(e) {
+      if (e = e.toUpperCase(), !f[e])
+        if (s.test(e)) {
+          var t = process.pid;
+          f[e] = function() {
+            var i = r.format.apply(r, arguments);
+            console.error("%s %d: %s", e, t, i);
+          };
+        } else
+          f[e] = function() {
+          };
+      return f[e];
+    };
+    function y(e, t) {
+      var i = {
+        seen: [],
+        stylize: u
+      };
+      return arguments.length >= 3 && (i.depth = arguments[2]), arguments.length >= 4 && (i.colors = arguments[3]), P(t) ? i.showHidden = t : t && r._extend(i, t), B(i.showHidden) && (i.showHidden = !1), B(i.depth) && (i.depth = 2), B(i.colors) && (i.colors = !1), B(i.customInspect) && (i.customInspect = !0), i.colors && (i.stylize = c), p(i, e, i.depth);
+    }
+    r.inspect = y, y.colors = {
+      bold: [1, 22],
+      italic: [3, 23],
+      underline: [4, 24],
+      inverse: [7, 27],
+      white: [37, 39],
+      grey: [90, 39],
+      black: [30, 39],
+      blue: [34, 39],
+      cyan: [36, 39],
+      green: [32, 39],
+      magenta: [35, 39],
+      red: [31, 39],
+      yellow: [33, 39]
+    }, y.styles = {
+      special: "cyan",
+      number: "yellow",
+      boolean: "yellow",
+      undefined: "grey",
+      null: "bold",
+      string: "green",
+      date: "magenta",
+      // "name": intentionally not styling
+      regexp: "red"
+    };
+    function c(e, t) {
+      var i = y.styles[t];
+      return i ? "\x1B[" + y.colors[i][0] + "m" + e + "\x1B[" + y.colors[i][1] + "m" : e;
+    }
+    function u(e, t) {
+      return e;
+    }
+    function d(e) {
+      var t = {};
+      return e.forEach(function(i, m) {
+        t[i] = !0;
+      }), t;
+    }
+    function p(e, t, i) {
+      if (e.customInspect && t && M(t.inspect) && // Filter out the util module, it's inspect function is special
+      t.inspect !== r.inspect && // Also filter out any prototype objects using the circular check.
+      !(t.constructor && t.constructor.prototype === t)) {
+        var m = t.inspect(i, e);
+        return z(m) || (m = p(e, m, i)), m;
+      }
+      var j = l(e, t);
+      if (j)
+        return j;
+      var R = Object.keys(t), S = d(R);
+      if (e.showHidden && (R = Object.getOwnPropertyNames(t)), G(t) && (R.indexOf("message") >= 0 || R.indexOf("description") >= 0))
+        return g(t);
+      if (R.length === 0) {
+        if (M(t)) {
+          var h = t.name ? ": " + t.name : "";
+          return e.stylize("[Function" + h + "]", "special");
+        }
+        if (J(t))
+          return e.stylize(RegExp.prototype.toString.call(t), "regexp");
+        if (Z(t))
+          return e.stylize(Date.prototype.toString.call(t), "date");
+        if (G(t))
+          return g(t);
+      }
+      var b = "", E = !1, q = ["{", "}"];
+      if (O(t) && (E = !0, q = ["[", "]"]), M(t)) {
+        var D = t.name ? ": " + t.name : "";
+        b = " [Function" + D + "]";
+      }
+      if (J(t) && (b = " " + RegExp.prototype.toString.call(t)), Z(t) && (b = " " + Date.prototype.toUTCString.call(t)), G(t) && (b = " " + g(t)), R.length === 0 && (!E || t.length == 0))
+        return q[0] + b + q[1];
+      if (i < 0)
+        return J(t) ? e.stylize(RegExp.prototype.toString.call(t), "regexp") : e.stylize("[Object]", "special");
+      e.seen.push(t);
+      var U;
+      return E ? U = N(e, t, i, S, R) : U = R.map(function(W) {
+        return T(e, t, i, S, W, E);
+      }), e.seen.pop(), I(U, b, q);
+    }
+    function l(e, t) {
+      if (B(t))
+        return e.stylize("undefined", "undefined");
+      if (z(t)) {
+        var i = "'" + JSON.stringify(t).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+        return e.stylize(i, "string");
+      }
+      if (F(t))
+        return e.stylize("" + t, "number");
+      if (P(t))
+        return e.stylize("" + t, "boolean");
+      if (w(t))
+        return e.stylize("null", "null");
+    }
+    function g(e) {
+      return "[" + Error.prototype.toString.call(e) + "]";
+    }
+    function N(e, t, i, m, j) {
+      for (var R = [], S = 0, h = t.length; S < h; ++S)
+        k(t, String(S)) ? R.push(T(
+          e,
+          t,
+          i,
+          m,
+          String(S),
+          !0
+        )) : R.push("");
+      return j.forEach(function(b) {
+        b.match(/^\d+$/) || R.push(T(
+          e,
+          t,
+          i,
+          m,
+          b,
+          !0
+        ));
+      }), R;
+    }
+    function T(e, t, i, m, j, R) {
+      var S, h, b;
+      if (b = Object.getOwnPropertyDescriptor(t, j) || { value: t[j] }, b.get ? b.set ? h = e.stylize("[Getter/Setter]", "special") : h = e.stylize("[Getter]", "special") : b.set && (h = e.stylize("[Setter]", "special")), k(m, j) || (S = "[" + j + "]"), h || (e.seen.indexOf(b.value) < 0 ? (w(i) ? h = p(e, b.value, null) : h = p(e, b.value, i - 1), h.indexOf(`
+`) > -1 && (R ? h = h.split(`
+`).map(function(E) {
+        return "  " + E;
+      }).join(`
+`).slice(2) : h = `
+` + h.split(`
+`).map(function(E) {
+        return "   " + E;
+      }).join(`
+`))) : h = e.stylize("[Circular]", "special")), B(S)) {
+        if (R && j.match(/^\d+$/))
+          return h;
+        S = JSON.stringify("" + j), S.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (S = S.slice(1, -1), S = e.stylize(S, "name")) : (S = S.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), S = e.stylize(S, "string"));
+      }
+      return S + ": " + h;
+    }
+    function I(e, t, i) {
+      var m = e.reduce(function(j, R) {
+        return R.indexOf(`
+`) >= 0, j + R.replace(/\u001b\[\d\d?m/g, "").length + 1;
+      }, 0);
+      return m > 60 ? i[0] + (t === "" ? "" : t + `
+ `) + " " + e.join(`,
+  `) + " " + i[1] : i[0] + t + " " + e.join(", ") + " " + i[1];
+    }
+    r.types = yn();
+    function O(e) {
+      return Array.isArray(e);
+    }
+    r.isArray = O;
+    function P(e) {
+      return typeof e == "boolean";
+    }
+    r.isBoolean = P;
+    function w(e) {
+      return e === null;
+    }
+    r.isNull = w;
+    function A(e) {
+      return e == null;
+    }
+    r.isNullOrUndefined = A;
+    function F(e) {
+      return typeof e == "number";
+    }
+    r.isNumber = F;
+    function z(e) {
+      return typeof e == "string";
+    }
+    r.isString = z;
+    function V(e) {
+      return typeof e == "symbol";
+    }
+    r.isSymbol = V;
+    function B(e) {
+      return e === void 0;
+    }
+    r.isUndefined = B;
+    function J(e) {
+      return L(e) && _(e) === "[object RegExp]";
+    }
+    r.isRegExp = J, r.types.isRegExp = J;
+    function L(e) {
+      return typeof e == "object" && e !== null;
+    }
+    r.isObject = L;
+    function Z(e) {
+      return L(e) && _(e) === "[object Date]";
+    }
+    r.isDate = Z, r.types.isDate = Z;
+    function G(e) {
+      return L(e) && (_(e) === "[object Error]" || e instanceof Error);
+    }
+    r.isError = G, r.types.isNativeError = G;
+    function M(e) {
+      return typeof e == "function";
+    }
+    r.isFunction = M;
+    function nr(e) {
+      return e === null || typeof e == "boolean" || typeof e == "number" || typeof e == "string" || typeof e == "symbol" || // ES6 symbol
+      typeof e > "u";
+    }
+    r.isPrimitive = nr, r.isBuffer = ln();
+    function _(e) {
+      return Object.prototype.toString.call(e);
+    }
+    function Q(e) {
+      return e < 10 ? "0" + e.toString(10) : e.toString(10);
+    }
+    var Y = [
+      "Jan",
+      "Feb",
+      "Mar",
+      "Apr",
+      "May",
+      "Jun",
+      "Jul",
+      "Aug",
+      "Sep",
+      "Oct",
+      "Nov",
+      "Dec"
+    ];
+    function x() {
+      var e = /* @__PURE__ */ new Date(), t = [
+        Q(e.getHours()),
+        Q(e.getMinutes()),
+        Q(e.getSeconds())
+      ].join(":");
+      return [e.getDate(), Y[e.getMonth()], t].join(" ");
+    }
+    r.log = function() {
+      console.log("%s - %s", x(), r.format.apply(r, arguments));
+    }, r.inherits = pn(), r._extend = function(e, t) {
+      if (!t || !L(t)) return e;
+      for (var i = Object.keys(t), m = i.length; m--; )
+        e[i[m]] = t[i[m]];
+      return e;
+    };
+    function k(e, t) {
+      return Object.prototype.hasOwnProperty.call(e, t);
+    }
+    var C = typeof Symbol < "u" ? Symbol("util.promisify.custom") : void 0;
+    r.promisify = function(t) {
+      if (typeof t != "function")
+        throw new TypeError('The "original" argument must be of type Function');
+      if (C && t[C]) {
+        var i = t[C];
+        if (typeof i != "function")
+          throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+        return Object.defineProperty(i, C, {
+          value: i,
+          enumerable: !1,
+          writable: !1,
+          configurable: !0
+        }), i;
+      }
+      function i() {
+        for (var m, j, R = new Promise(function(b, E) {
+          m = b, j = E;
+        }), S = [], h = 0; h < arguments.length; h++)
+          S.push(arguments[h]);
+        S.push(function(b, E) {
+          b ? j(b) : m(E);
+        });
+        try {
+          t.apply(this, S);
+        } catch (b) {
+          j(b);
+        }
+        return R;
+      }
+      return Object.setPrototypeOf(i, Object.getPrototypeOf(t)), C && Object.defineProperty(i, C, {
+        value: i,
+        enumerable: !1,
+        writable: !1,
+        configurable: !0
+      }), Object.defineProperties(
+        i,
+        o(t)
+      );
+    }, r.promisify.custom = C;
+    function K(e, t) {
+      if (!e) {
+        var i = new Error("Promise was rejected with a falsy value");
+        i.reason = e, e = i;
+      }
+      return t(e);
+    }
+    function rr(e) {
+      if (typeof e != "function")
+        throw new TypeError('The "original" argument must be of type Function');
+      function t() {
+        for (var i = [], m = 0; m < arguments.length; m++)
+          i.push(arguments[m]);
+        var j = i.pop();
+        if (typeof j != "function")
+          throw new TypeError("The last argument must be of type Function");
+        var R = this, S = function() {
+          return j.apply(R, arguments);
+        };
+        e.apply(this, i).then(
+          function(h) {
+            process.nextTick(S.bind(null, null, h));
+          },
+          function(h) {
+            process.nextTick(K.bind(null, h, S));
+          }
+        );
+      }
+      return Object.setPrototypeOf(t, Object.getPrototypeOf(e)), Object.defineProperties(
+        t,
+        o(e)
+      ), t;
+    }
+    r.callbackify = rr;
+  }(gr)), gr;
+}
+var gn = dn();
+global.TextEncoder = gn.TextEncoder;
+globalThis.IntersectionObserver = class {
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor() {
+    yr(this, "root", null);
+    yr(this, "rootMargin", "");
+    yr(this, "thresholds", []);
+  }
+  disconnect() {
+    return null;
+  }
+  observe() {
+    return null;
+  }
+  takeRecords() {
+    return [];
+  }
+  unobserve() {
+    return null;
+  }
+};
+//# sourceMappingURL=setupTests.js.map