@flemist/simple-utils 2.0.1 → 2.1.0

package/build/urlGet-BCW9jvAm.mjs

@@ -0,0 +1,1947 @@
+import { AbortControllerFast as Et, toAbortSignal as Gt, AbortError as Jt } from "@flemist/abort-controller-fast";
+import { isPromiseLike as et, EMPTY_FUNC as Xt, delay as Yt, ValueState as Qt } from "@flemist/async-utils";
+import { timeControllerDefault as At } from "@flemist/time-controller";
+let H = null;
+function Zt() {
+  if (!H) {
+    H = new Array(256);
+    for (let t = 0; t < 256; t++)
+      H[t] = t.toString(16).padStart(2, "0");
+  }
+  return H;
+}
+function te(t) {
+  const e = Zt(), r = new Uint8Array(t.buffer, t.byteOffset, t.byteLength);
+  let n = "";
+  for (let s = 0, i = r.length; s < i; s++)
+    n += e[r[s]];
+  return n;
+}
+let pt = null, Mt = null, X = null, Tt = null;
+function ee() {
+  pt || (pt = new Uint32Array([
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ]), Mt = new Uint32Array(64), Tt = new TextEncoder(), X = new Uint8Array(65536));
+}
+function re(t) {
+  if (t == null)
+    return null;
+  ee();
+  const e = pt, r = Mt, n = Tt;
+  let s = X, i;
+  if (typeof t == "string") {
+    const g = t.length * 3;
+    s.length < g + 128 && (s = X = new Uint8Array(g + 128));
+    const d = n.encodeInto(t, s);
+    i = s.subarray(0, d.written);
+  } else if (t instanceof Uint8Array)
+    i = t;
+  else if (ArrayBuffer.isView(t))
+    i = new Uint8Array(
+      t.buffer,
+      t.byteOffset,
+      t.byteLength
+    );
+  else
+    throw new Error(
+      `[sha256Buffer] Unsupported content type: ${typeof t}`
+    );
+  const o = i.length, u = o + 72 >>> 6 << 6;
+  s.length < u && (s = X = new Uint8Array(u)), i !== s && s.set(i), s[o] = 128;
+  for (let g = o + 1; g < u; g++)
+    s[g] = 0;
+  const a = o * 8, l = a / 4294967296 | 0, f = a | 0;
+  s[u - 8] = l >>> 24, s[u - 7] = l >>> 16, s[u - 6] = l >>> 8, s[u - 5] = l, s[u - 4] = f >>> 24, s[u - 3] = f >>> 16, s[u - 2] = f >>> 8, s[u - 1] = f;
+  let w = 1779033703, y = -1150833019, h = 1013904242, c = -1521486534, m = 1359893119, $ = -1694144372, b = 528734635, O = 1541459225;
+  for (let g = 0; g < u; g += 64) {
+    for (let _ = 0; _ < 16; _++) {
+      const x = g + (_ << 2);
+      r[_] = s[x] << 24 | s[x + 1] << 16 | s[x + 2] << 8 | s[x + 3];
+    }
+    for (let _ = 16; _ < 64; _++) {
+      const x = r[_ - 15], C = r[_ - 2], at = (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3, W = (C >>> 17 | C << 15) ^ (C >>> 19 | C << 13) ^ C >>> 10;
+      r[_] = r[_ - 16] + at + r[_ - 7] + W | 0;
+    }
+    let d = w, E = y, B = h, ut = c, A = m, q = $, V = b, ot = O;
+    for (let _ = 0; _ < 64; _ += 4)
+      for (let x = 0; x < 4; x++) {
+        const C = _ + x, at = (A >>> 6 | A << 26) ^ (A >>> 11 | A << 21) ^ (A >>> 25 | A << 7), W = ot + at + (V ^ A & (q ^ V)) + e[C] + r[C] | 0, Ht = ((d >>> 2 | d << 30) ^ (d >>> 13 | d << 19) ^ (d >>> 22 | d << 10)) + (d & E ^ B & (d ^ E)) | 0;
+        ot = V, V = q, q = A, A = ut + W | 0, ut = B, B = E, E = d, d = W + Ht | 0;
+      }
+    w = w + d | 0, y = y + E | 0, h = h + B | 0, c = c + ut | 0, m = m + A | 0, $ = $ + q | 0, b = b + V | 0, O = O + ot | 0;
+  }
+  const S = new Uint8Array(32), K = [w, y, h, c, m, $, b, O];
+  for (let g = 0; g < 8; g++) {
+    const d = K[g], E = g << 2;
+    S[E] = d >>> 24, S[E + 1] = d >>> 16 & 255, S[E + 2] = d >>> 8 & 255, S[E + 3] = d & 255;
+  }
+  return S;
+}
+function Qe(t) {
+  const e = re(t);
+  return e ? te(e) : null;
+}
+function ne(t, e) {
+  return t == null ? e : e == null ? t : Math.min(t, e);
+}
+function se(t, e) {
+  return t == null ? e : e == null ? t : Math.max(t, e);
+}
+function Ze(t, e, r) {
+  return se(ne(t, e), r);
+}
+function tr(t, e) {
+  return (t % e + e) % e;
+}
+function ie(t) {
+  return function() {
+    let r = t += 1831565813;
+    return r = Math.imul(r ^ r >>> 15, r | 1), r ^= r + Math.imul(r ^ r >>> 7, r | 61), (r ^ r >>> 14) / 4294967296 + 0.5;
+  };
+}
+function ue() {
+  return Math.random();
+}
+function er() {
+  return Math.random() * 2 ** 32 >>> 0;
+}
+function oe(t) {
+  return t != null ? ie(t) : ue;
+}
+class dt {
+  _seed;
+  _rnd;
+  constructor(e) {
+    this._seed = e, this._rnd = oe(e);
+  }
+  get seed() {
+    return this._seed;
+  }
+  nextSeed() {
+    return this.next() * 2 ** 32 >>> 0;
+  }
+  nextRandom() {
+    return new dt(this.nextSeed());
+  }
+  next() {
+    return this._rnd();
+  }
+  clone() {
+    return new dt(this._seed);
+  }
+}
+function Ct(t, e, r) {
+  if (r == null && (r = e, e = 0), r <= e)
+    throw new Error(
+      `[random][randomFloat] toExclusive (${r}) must be greater than from (${e})`
+    );
+  return t.next() * (r - e) + e;
+}
+function ae(t, e, r) {
+  return Math.floor(Ct(t, e, r));
+}
+function rr(t, e) {
+  return t.next() < (e ?? 0.5);
+}
+function nr(t, e, r) {
+  if (Array.isArray(e)) {
+    const i = e;
+    e = i.length, r = (o) => i[o];
+  }
+  if (!r)
+    throw new Error("[random][randomIndexWeighted] getWeight is required");
+  let n = 0;
+  for (let i = 0; i < e; i++)
+    n += r(i);
+  if (n === 0)
+    return -1;
+  let s = Ct(t, n);
+  for (let i = 0; i < e; i++)
+    if (s -= r(i), s < 0)
+      return i;
+  return e - 1;
+}
+function It(t, e) {
+  if (e.length === 0)
+    throw new Error("[random][randomItem] items is empty");
+  const r = ae(t, e.length);
+  return e[r];
+}
+function sr(t, e, r) {
+  if (e.length === 0)
+    throw new Error("[random][randomItems] items is empty");
+  const n = [];
+  for (let s = 0; s < r; s++)
+    n.push(It(t, e));
+  return n;
+}
+function ir(t, e, r) {
+  let n = Object.values(e);
+  return r && (n = n.filter(r)), It(t, n);
+}
+const Nt = 1073741789, lt = (Nt >> 2) - 1;
+function ur(t = lt, e) {
+  if (t <= 0)
+    throw new Error(`[random][PseudoRandom] count(${t}) must be > 0`);
+  if (t > lt)
+    throw new Error(
+      `[random][PseudoRandom] count(${t}) must be <= ${lt}`
+    );
+  if (e == null && (e = Math.floor(Math.random() * t)), e >= t)
+    throw new Error(
+      `[random][PseudoRandom] startFrom(${e}) must be < count(${t})`
+    );
+  let r = e;
+  return function() {
+    return r = (r + Nt) % t, r;
+  };
+}
+let F = null;
+function or() {
+  const t = Date.now();
+  return F == null || t > F ? (F = t, t) : (F++, F);
+}
+async function ar({
+  url: t,
+  timeout: e
+} = {}) {
+  t || (t = typeof window < "u" ? "/" : "https://google.com");
+  let r;
+  try {
+    const n = new Et();
+    r = e ? setTimeout(() => {
+      n.abort();
+    }, e) : null;
+    const s = await fetch(t, {
+      method: "HEAD",
+      signal: Gt(n.signal)
+    }), i = s.headers.get("date");
+    if (!i)
+      throw new Error(
+        `[Now][getDateInet] No date header in response: ${s.status} ${t}`
+      );
+    return new Date(i).getTime();
+  } finally {
+    r && clearTimeout(r);
+  }
+}
+function Dt(t, e, r) {
+  const n = e == null ? t : new Date(
+    t.toLocaleString("en-US", {
+      timeZone: e
+    })
+  ), s = r == null ? t : new Date(
+    t.toLocaleString("en-US", {
+      timeZone: r
+    })
+  );
+  return new Date(
+    t.getTime() + s.getTime() - n.getTime()
+  );
+}
+function le(t, e) {
+  t = Dt(t, "UTC", e);
+  const r = t.getUTCFullYear().toString().padStart(4, "0"), n = (t.getUTCMonth() + 1).toString().padStart(2, "0"), s = t.getUTCDate().toString().padStart(2, "0"), i = t.getUTCHours().toString().padStart(2, "0"), o = t.getUTCMinutes().toString().padStart(2, "0"), u = t.getUTCSeconds().toString().padStart(2, "0");
+  return `${r}-${n}-${s} ${i}:${o}:${u}`;
+}
+let ce = 0;
+const ct = /* @__PURE__ */ new WeakMap();
+function P(t) {
+  if (ct.has(t))
+    return ct.get(t);
+  const e = ce++;
+  return ct.set(t, e), e;
+}
+function G(t, e, r) {
+  if (t == null)
+    return null;
+  if (e == null || t.length <= e)
+    return t;
+  const n = r?.appendEllipsis ? "…" : "", s = n.length + (r?.appendTruncatedLength ? String(t.length).length + 2 : 0), i = Math.max(0, e - s), o = r?.appendTruncatedLength ? `(${t.length - i})` : "";
+  return i <= 0 ? o + n : r?.fromStart ? o + n + t.slice(t.length - i) : t.slice(0, i) + n + o;
+}
+function _t(t, e) {
+  try {
+    return t[e];
+  } catch (r) {
+    return "Error: " + (r instanceof Error ? r.message : String(r));
+  }
+}
+function U(t, e, r, n) {
+  const {
+    pretty: s,
+    filter: i,
+    maxDepth: o,
+    maxItems: u,
+    maxStringLength: a,
+    showObjectId: l,
+    showArrayIndex: f,
+    customToString: w
+  } = e ?? {};
+  if (r == null && (r = []), n == null && (n = /* @__PURE__ */ new Set()), w) {
+    const h = w(
+      t,
+      r,
+      (c) => U(c, e, r, n)
+    );
+    if (h != null)
+      return G(h, a, e?.truncateOptions);
+  }
+  const y = r.length;
+  if (typeof t == "string")
+    return t = G(t, a, e?.truncateOptions), n.size > 0 && (t = JSON.stringify(t)), t;
+  if (t == null || typeof t != "object")
+    return String(t);
+  if (t instanceof ArrayBuffer || ArrayBuffer.isView(t))
+    return `${t.constructor?.name ?? ""}#${P(t)}[${t.byteLength}]`;
+  if (t instanceof RegExp)
+    return G(
+      String(t),
+      a,
+      e?.truncateOptions
+    );
+  if (t instanceof Date)
+    return le(t);
+  if (t instanceof Object) {
+    if (n.has(t) || o != null && y >= o)
+      return `${t.constructor === Object ? "" : t.constructor?.name ?? ""}#${P(t)}`;
+    n.add(t);
+  }
+  if (t instanceof Error)
+    return G(
+      t.stack || t.message || String(t),
+      a,
+      e?.truncateOptions
+    );
+  if (Array.isArray(t)) {
+    const h = s ? "  ".repeat(y) : "";
+    let c = "";
+    l && (c += `#${P(t)} `), c += "[";
+    let m = 0, $ = !1;
+    for (let b = 0; b < t.length; b++) {
+      if (u != null && m >= u) {
+        $ = !0;
+        break;
+      }
+      const O = [...r, String(b)], S = _t(t, b);
+      if (i != null && !i(O, S))
+        continue;
+      const K = U(S, e, O, n);
+      m > 0 && (c += ","), s && (c += `
+`), s && (c += `${h}  `), f && (c += `${b}: `), c += `${K}`, m++;
+    }
+    return $ ? (m > 0 && (c += ","), s ? (c += `
+`, c += `${h}  ...
+`) : c += "...", c += h, c += "]") : (m > 0 && s && (c += `
+${h}`), c += "]"), c;
+  }
+  if (t instanceof Map) {
+    let h = "";
+    return l && (h += `#${P(t)} `), h += "Map", h += U(Array.from(t.entries()), e, r, n), h;
+  }
+  if (t instanceof Set) {
+    let h = "";
+    return l && (h += `#${P(t)} `), h += "Set", h += U(Array.from(t.values()), e, r, n), h;
+  }
+  {
+    const h = t.constructor === Object ? "" : t.constructor?.name ?? "", c = s ? "  ".repeat(y) : "";
+    let m = h ? `${h} ` : "";
+    l && (m += `#${P(t)} `), m += "{";
+    let $ = 0, b = !1;
+    for (const O in t) {
+      if (u != null && $ >= u) {
+        b = !0;
+        break;
+      }
+      const S = [...r, O], K = _t(t, O);
+      if (i != null && !i(S, K))
+        continue;
+      const g = U(K, e, S, n);
+      $ > 0 && (m += ","), s && (m += `
+`), s && (m += `${c}  `), m += `${O}: ${g}`, $++;
+    }
+    return b && ($ > 0 && (m += ","), s ? (m += `
+`, m += `${c}  ...
+`) : m += "...", m += c), $ > 0 && s && !b && (m += `
+${c}`), m += "}", m;
+  }
+}
+function fe(t, e) {
+  t = Dt(t, "UTC", e);
+  const r = t.getUTCFullYear().toString().padStart(4, "0"), n = (t.getUTCMonth() + 1).toString().padStart(2, "0"), s = t.getUTCDate().toString().padStart(2, "0"), i = t.getUTCHours().toString().padStart(2, "0"), o = t.getUTCMinutes().toString().padStart(2, "0"), u = t.getUTCSeconds().toString().padStart(2, "0");
+  return `${r}-${n}-${s}_${i}-${o}-${u}`;
+}
+function lr(t) {
+  return t == null ? null : t.replace(/[&<>"']/g, (e) => {
+    switch (e) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&rt;";
+      case '"':
+        return "&quot;";
+      default:
+        return "&#039;";
+    }
+  });
+}
+function cr(t) {
+  return t == null ? null : t?.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+function bt(t) {
+  if (t == null)
+    return null;
+  if (Array.isArray(t)) {
+    const e = t.length, r = [];
+    for (let n = 0; n < e; n++)
+      r.push(bt(t[n]));
+    return r;
+  }
+  if (typeof t == "object") {
+    if (t.constructor && t.constructor !== Object)
+      return t;
+    const e = {};
+    for (const r in t)
+      Object.prototype.hasOwnProperty.call(t, r) && (e[r] = bt(t[r]));
+    return e;
+  }
+  return t;
+}
+function Y(t, e) {
+  if (t === e)
+    return !0;
+  if (t == null)
+    return e == null;
+  if (e == null)
+    return !1;
+  if (Array.isArray(t)) {
+    if (!Array.isArray(e))
+      return !1;
+    const r = t.length;
+    if (r !== e.length)
+      return !1;
+    for (let n = 0; n < r; n++)
+      if (!Y(t[n], e[n]))
+        return !1;
+    return !0;
+  }
+  if (typeof t == "object") {
+    if (typeof e != "object" || t.constructor && t.constructor !== Object || e.constructor && e.constructor !== Object)
+      return !1;
+    for (const r in t)
+      if (Object.prototype.hasOwnProperty.call(t, r) && !Y(
+        t[r],
+        Object.prototype.hasOwnProperty.call(e, r) ? e[r] : null
+      ))
+        return !1;
+    for (const r in e)
+      if (Object.prototype.hasOwnProperty.call(e, r) && !Object.prototype.hasOwnProperty.call(t, r) && !Y(e[r], null))
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+function fr(t, e) {
+  if (t == null || e == null)
+    return t == null == (e == null);
+  if (t.size !== e.size)
+    return !1;
+  for (const [r, n] of t)
+    if (!Y(n, e.get(r)))
+      return !1;
+  return !0;
+}
+function hr(t, e) {
+  const r = t.length;
+  if (r !== e.length)
+    return !1;
+  for (let n = 0; n < r; n++)
+    if (t[n] !== e[n])
+      return !1;
+  return !0;
+}
+function xt(t) {
+  return !t || typeof t != "object" ? t : Array.isArray(t) ? t.map(xt) : t && Object.keys(t).sort().reduce((e, r) => {
+    const n = xt(t[r]);
+    return n != null && (e[r] = n), e;
+  }, {});
+}
+function mr(t, e) {
+  return Object.defineProperty(t, "name", { value: e, configurable: !0 }), t;
+}
+function pr(t) {
+  const e = alert;
+  return window.alert = (r) => t(e, r), () => {
+    window.alert = e;
+  };
+}
+var v = /* @__PURE__ */ ((t) => (t.log = "log", t.warn = "warn", t.error = "error", t.info = "info", t.debug = "debug", t.trace = "trace", t.assert = "assert", t))(v || {});
+const $t = Object.values(v);
+function D(t) {
+  return function() {
+    t.apply(console, arguments);
+  };
+}
+const Ot = {
+  log: D(console.log),
+  warn: D(console.warn),
+  error: D(console.error),
+  info: D(console.info),
+  debug: D(console.debug),
+  trace: D(console.trace),
+  assert: D(console.assert)
+};
+function kt(t) {
+  return $t.forEach((e) => {
+    console[e] = (...r) => {
+      t(Ot, e, r);
+    };
+  }), () => {
+    $t.forEach((e) => {
+      console[e] = Ot[e];
+    });
+  };
+}
+function dr(t) {
+  return function(r) {
+    let n = null;
+    const i = kt((u, a, l) => {
+      try {
+        t(u, a, l);
+      } catch (f) {
+        throw n || (n = f), f;
+      }
+    }), o = () => {
+      if (i(), n)
+        throw n;
+    };
+    try {
+      const u = r();
+      return et(u) ? u.then(
+        (a) => (o(), a),
+        (a) => {
+          throw o(), a;
+        }
+      ) : (o(), u);
+    } catch (u) {
+      throw o(), u;
+    }
+  };
+}
+class Ut {
+  _listeners = /* @__PURE__ */ new Map();
+  _listenersAdd = /* @__PURE__ */ new Map();
+  _startStopNotifier;
+  _emit;
+  _update;
+  _unsubscribeNotifier = null;
+  _emitLast;
+  _hasLast;
+  _last = void 0;
+  _emitting = !1;
+  _subscribing = !1;
+  _actionOnCycle;
+  constructor({
+    emitLastEvent: e,
+    startStopNotifier: r,
+    hasLast: n,
+    last: s,
+    actionOnCycle: i
+  } = {}) {
+    this._startStopNotifier = r ?? null, this._emit = r ? (o) => this.emit(o) : null, this._update = r ? (o) => this.update(o) : null, this._emitLast = e ?? !1, this._hasLast = n ?? !1, this._last = s, this._actionOnCycle = i ?? !1;
+  }
+  get hasLast() {
+    return this._hasLast;
+  }
+  get last() {
+    return this._last;
+  }
+  get hasListeners() {
+    return this._listeners.size > 0;
+  }
+  subscribe(e) {
+    const r = {};
+    if (this._emitting ? this._listenersAdd.set(r, e) : this._listeners.set(r, e), this._subscribing && this._actionOnCycle === "throw")
+      throw new Error("[Rx][Subject] Circular subscription detected");
+    if ((this._hasLast || this._subscribing && this._actionOnCycle === "emitLast") && e(this._last), this._startStopNotifier && this._listeners.size + this._listenersAdd.size === 1)
+      try {
+        this._subscribing = !0, this._unsubscribeNotifier = this._startStopNotifier(this._emit, this._update) ?? null;
+      } finally {
+        this._subscribing = !1;
+      }
+    return () => {
+      if (this._listeners.delete(r), this._listenersAdd.delete(r), this._startStopNotifier && this._listeners.size === 0 && this._listenersAdd.size === 0) {
+        const n = this._unsubscribeNotifier;
+        this._unsubscribeNotifier = null, n?.();
+      }
+    };
+  }
+  emit(e) {
+    if (this._emitting) {
+      if (this._actionOnCycle === "throw")
+        throw new Error("[Rx][Subject] Circular emit detected");
+      this._actionOnCycle === "emitLast" && (this._last = e, this._hasLast = !0);
+      return;
+    }
+    const r = () => {
+      this._listenersAdd.size > 0 && (this._listenersAdd.forEach((n, s) => {
+        this._listeners.set(s, n);
+      }), this._listenersAdd.clear()), this._emitting = !1;
+    };
+    try {
+      this._emitting = !0, this._emitLast && (this._last = e, this._hasLast = !0);
+      let n;
+      if (this._listeners.forEach((s) => {
+        const i = s(e);
+        et(i) && (n || (n = []), n.push(i));
+      }), n)
+        return Promise.all(n).then(r, (s) => {
+          throw r(), s;
+        });
+      r();
+    } catch (n) {
+      throw r(), n;
+    }
+  }
+  update(e) {
+    if (!this._emitLast)
+      throw new Error(
+        "[Rx][Subject] update available only for subjects with emitLastEvent"
+      );
+    const r = e(this._last);
+    return this.emit(r);
+  }
+}
+function he(t, e) {
+  return U(t, {
+    maxDepth: 5,
+    maxItems: 10,
+    ...e
+  });
+}
+function me(t) {
+  return t.map(
+    (e) => e && typeof e == "object" ? he(e) : e
+  );
+}
+function yr(t) {
+  return `${fe(/* @__PURE__ */ new Date())} [${t.level.toUpperCase()}] ${me(
+    t.args
+  ).join(" ")}`;
+}
+let Q = null, ft = null;
+function pe() {
+  return ft || (ft = new Ut({
+    startStopNotifier: (t) => (Q = t, () => {
+      Q = null;
+    })
+  })), ft;
+}
+function gr() {
+  return kt((t, e, r) => {
+    e === "assert" && r[0] === !0 || (e === v.error || e === v.warn || e === v.assert) && (Q && Q({
+      date: Date.now(),
+      level: e,
+      args: r
+    }), t[e](...r));
+  });
+}
+function wr(t) {
+  if (typeof window > "u")
+    return Xt;
+  const { levels: e, predicate: r } = t;
+  return pe().subscribe((n) => {
+    if (e && !e.includes(n.level))
+      return;
+    const s = n.args.join(`
+`);
+    r && !r({ text: s, message: n }) || alert(s);
+  });
+}
+var Rt = /* @__PURE__ */ ((t) => (t[t.none = 0] = "none", t[t.error = 1] = "error", t[t.warn = 2] = "warn", t[t.debug = 3] = "debug", t))(Rt || {});
+function de() {
+  let t = new Error().stack;
+  if (t != null) {
+    const e = t.indexOf(`
+`);
+    e != null && e >= 0 && (t = t.substring(e + 1));
+  }
+  return t ?? "";
+}
+function _r(t) {
+  return function(...e) {
+    const r = de();
+    try {
+      return t.apply(this, e);
+    } catch (n) {
+      throw n instanceof Error || (n = new Error(String(n))), n.stack = n.stack ? n.stack + `
+` + r : r, n;
+    }
+  };
+}
+function ye(t) {
+  if (!t || t.timeout == null)
+    return null;
+  const e = new Et(), r = t.timeController ?? At;
+  if (t.timeout) {
+    const n = r.setTimeout(() => {
+      e.abort(
+        new Jt(
+          `[timeoutAbortController] Timeout error: ${t.timeout}ms`
+        )
+      );
+    }, t.timeout);
+    e.signal.subscribe(() => {
+      clearTimeout(n);
+    });
+  }
+  return t.abortSignal?.subscribe((n) => {
+    e.abort(n);
+  }), e;
+}
+async function br(t, e) {
+  const r = ye(e);
+  try {
+    return await t(r?.signal ?? e?.abortSignal ?? null);
+  } finally {
+    r?.abort();
+  }
+}
+class xr {
+  _options;
+  _hasValue = !1;
+  _promiseOrValue = null;
+  constructor(e) {
+    this._options = e;
+  }
+  run() {
+    if (!this._hasValue) {
+      let e = this._options.func();
+      const r = (s) => (this._options.persist ? this._promiseOrValue = s : (this._promiseOrValue = null, this._hasValue = !1), s), n = (s) => {
+        throw this._options.persist || (this._promiseOrValue = null, this._hasValue = !1), s;
+      };
+      if (et(e))
+        e = e.then(r, n);
+      else if (!this._options.persist)
+        return e;
+      this._promiseOrValue = e, this._hasValue = !0;
+    }
+    return this._promiseOrValue;
+  }
+  set(e) {
+    if (!this._options.persist)
+      throw new Error("[Lazy][set] Cannot set value when persist is false");
+    this._hasValue = !0, this._promiseOrValue = e;
+  }
+}
+class $r {
+  _options;
+  _promiseOrValues = /* @__PURE__ */ new Map();
+  constructor(e) {
+    this._options = e;
+  }
+  run(e) {
+    if (this._promiseOrValues.has(e))
+      return this._promiseOrValues.get(e);
+    let r = this._options.func(e);
+    const n = (i) => (this._options.persist ? this._promiseOrValues.set(e, i) : this._promiseOrValues.delete(e), i), s = (i) => {
+      throw this._options.persist || this._promiseOrValues.delete(e), i;
+    };
+    if (et(r))
+      r = r.then(n, s);
+    else if (!this._options.persist)
+      return r;
+    return this._promiseOrValues.set(e, r), r;
+  }
+  set(e, r) {
+    if (!this._options.persist)
+      throw new Error(
+        "[LazyWithId][set] Cannot set value when persist is false"
+      );
+    this._promiseOrValues.set(e, r);
+  }
+}
+async function Or(t) {
+  const e = t.abortSignal ?? null, r = t.timeController ?? At;
+  let n = 0;
+  for (; ; )
+    try {
+      return await t.func({ abortSignal: e });
+    } catch (s) {
+      if ((t.logLevel == null || t.logLevel >= Rt.error) && console.error("[withRetry] error", s), e?.aborted)
+        throw s;
+      const i = t.delay({
+        error: s,
+        retryCount: n++,
+        abortSignal: e
+      });
+      if (i == null || (typeof i == "number" ? await Yt(i, e ?? void 0, r) : await i(), e?.aborted))
+        throw s;
+    }
+}
+function Sr({
+  maxRetries: t,
+  delays: e,
+  isRetriableError: r
+}) {
+  return function({ retryCount: s, error: i }) {
+    if (s == null || t != null && s >= t)
+      return null;
+    if (r == null || r(i)) {
+      if (Array.isArray(e))
+        return e[Math.min(s, e.length - 1)];
+      {
+        const o = e.mult ?? 2;
+        return Math.min(e.min * o ** s, e.max);
+      }
+    }
+    return null;
+  };
+}
+function Er(t) {
+  return t != null && typeof t == "object" && typeof t.subscribe == "function";
+}
+class Ar {
+  _subjects = /* @__PURE__ */ new Map();
+  _getLastEvent;
+  constructor({
+    getLastEvent: e
+  } = {}) {
+    this._getLastEvent = e;
+  }
+  subscribe(e, r) {
+    let n = this._subjects.get(e);
+    n || (n = new Ut(), this._subjects.set(e, n));
+    const s = n.subscribe(r);
+    if (this._getLastEvent) {
+      const i = this._getLastEvent(e);
+      r(i);
+    }
+    return () => {
+      s(), n?.hasListeners || this._subjects.delete(e);
+    };
+  }
+  emit(e, r) {
+    const n = this._subjects.get(e);
+    if (n)
+      return n.emit(r);
+  }
+  forEach(e) {
+    this._subjects.forEach(e);
+  }
+  observable(e) {
+    return {
+      subscribe: (r) => this.subscribe(e, r)
+    };
+  }
+  emitter(e) {
+    return {
+      emit: (r) => this.emit(e, r)
+    };
+  }
+  subject(e) {
+    return {
+      subscribe: (r) => this.subscribe(e, r),
+      emit: (r) => this.emit(e, r)
+    };
+  }
+}
+function Mr(t, e, r) {
+  return new Promise((n) => {
+    let s = !1, i;
+    function o(f) {
+      a?.(), i?.(), s = !0, n(f);
+    }
+    function u(f) {
+      a?.(), i?.(), s = !0, n(Promise.reject(f));
+    }
+    const a = r?.subscribe(u);
+    let l = !0;
+    i = t.subscribe((f) => {
+      (!e || e(f, l)) && o(f), l = !1;
+    }), s && i?.();
+  });
+}
+class k extends Error {
+  constructor(e) {
+    super(e);
+  }
+}
+class p {
+  _args;
+  constructor(e) {
+    this._args = e && { ...e };
+  }
+  set(e) {
+    return this._args = {
+      ...this._args ?? {},
+      ...e
+    }, this;
+  }
+  name(e) {
+    return this.set({ name: e });
+  }
+  toString(e) {
+    const r = this._args?.name;
+    return r ? typeof r == "string" ? r : r(e) : this.nameDefault(e);
+  }
+}
+function jt(t, e) {
+  return U(t, {
+    maxDepth: 1,
+    maxItems: 5,
+    ...e
+  });
+}
+function R(t) {
+  return t instanceof p;
+}
+function rt(t) {
+  return jt(t);
+}
+function yt(t, ...e) {
+  if (t == null)
+    return "";
+  const r = jt(t, {
+    filter: (n, s) => {
+      if (n.length === 0)
+        return !0;
+      if (n.length !== 1)
+        return !1;
+      const i = n[0];
+      return !(i === "name" || i === "expected" || s == null || s === !1 || e.includes(i));
+    }
+  });
+  return /^(#\d+\s*)\{}$/.test(r) ? "" : `(${r})`;
+}
+function Z(t) {
+  const { result: e, cause: r, nested: n, error: s } = t;
+  if (s) {
+    if (!(s instanceof Error))
+      throw new k(
+        `[test][validateMatchResult] error must be an instance of Error, but it is: ${s}`
+      );
+    if (e != null)
+      throw new k(
+        `[test][validateMatchResult] result must be null if error is set, but it is: ${e}`
+      );
+    if (r != null)
+      throw new k(
+        `[test][validateMatchResult] cause must be null if error is set, but it is: ${r}`
+      );
+    if (n != null)
+      throw new k(
+        `[test][validateMatchResult] nested must be null if error is set, but it is: ${n}`
+      );
+    return t;
+  }
+  if (typeof e != "boolean")
+    throw new k(
+      `[test][validateMatchResult] result must be a boolean, but it is: ${e}`
+    );
+  if (typeof r != "string" && r != null)
+    throw new k(
+      `[test][validateMatchResult] cause must be a string or null, but it is: ${r}`
+    );
+  if (n != null && !(n instanceof Array))
+    throw new k(
+      `[test][validateMatchResult] nested must be an array or null, but it is: ${n}`
+    );
+  return t;
+}
+function ge(t, e, r) {
+  return Z({
+    actual: t,
+    expected: e,
+    result: null,
+    cause: null,
+    nested: null,
+    error: r
+  });
+}
+function Kt(t, e, r) {
+  return Z({
+    actual: t,
+    expected: e,
+    result: r,
+    cause: null,
+    nested: null,
+    error: null
+  });
+}
+function Pt(t, e, r) {
+  return typeof r == "boolean" ? Kt(t, e, r) : Z(typeof r == "string" ? {
+    actual: t,
+    expected: e,
+    result: !1,
+    cause: r,
+    nested: null,
+    error: null
+  } : {
+    actual: t,
+    expected: e,
+    result: r.result,
+    cause: r.cause ?? null,
+    nested: r.nested ?? null,
+    error: null
+  });
+}
+function M(t, e) {
+  try {
+    if (R(e)) {
+      const r = e.match(t);
+      return Pt(t, e, r);
+    }
+    return Kt(t, e, t === e);
+  } catch (r) {
+    return ge(t, e, r);
+  }
+}
+const nt = 10;
+class Lt extends p {
+  match(e) {
+    if (e == null)
+      return `Expected array, got "${e}"`;
+    if (typeof e != "object")
+      return `Expected array, got "${typeof e}"`;
+    if (!(e instanceof Array))
+      return "Expected array";
+    const r = this._args?.expected;
+    if (r == null)
+      return !0;
+    const n = this._args?.maxReportItems ?? nt, s = this._args?.matchType || "equals";
+    if (s === "equals") {
+      if (e.length !== r.length)
+        return `Expected array length to be ${r.length}, got ${e.length}`;
+      let i = !0, o = 0, u = 0;
+      const a = [];
+      for (let l = 0; l < r.length; l++) {
+        const f = e[l], w = r[l], y = M(f, w);
+        if (y.result ? (o < n && a.push({
+          actualKey: l,
+          expectedKey: l,
+          result: y
+        }), o++) : (u < n && a.push({
+          actualKey: l,
+          expectedKey: l,
+          result: y
+        }), u++, i = !1), !i && o >= n && u >= n)
+          break;
+      }
+      return {
+        result: i,
+        nested: a
+      };
+    }
+    if (s === "includes") {
+      let i = !0;
+      const o = [];
+      let u = 0, a = 0;
+      for (let l = 0; l < r.length; l++) {
+        const f = r[l];
+        let w = !1;
+        for (let y = 0; y < e.length; y++) {
+          const h = e[y], c = M(h, f);
+          if (c.result) {
+            w = !0, u < n && o.push({
+              actualKey: y,
+              expectedKey: l,
+              result: c
+            }), u++;
+            break;
+          }
+        }
+        if (w || (i = !1, a < n && o.push({
+          expectedKey: l,
+          result: {
+            result: !1,
+            actual: void 0,
+            expected: f
+          }
+        }), a++), !i && u >= n && a >= n)
+          break;
+      }
+      return {
+        result: i,
+        nested: o
+      };
+    }
+    return `Unknown matchType "${s}"`;
+  }
+  nameDefault() {
+    return `array ${this._args?.matchType || "equals"} ${rt(this._args?.expected)}`;
+  }
+}
+class we extends p {
+  match() {
+    return !0;
+  }
+  nameDefault() {
+    return "any";
+  }
+}
+class _e extends p {
+  match(e) {
+    if (typeof e != "object")
+      return `Expected array, got "${typeof e}"`;
+    if (!(e instanceof Array))
+      return "Expected array";
+    const r = this._args.expected;
+    let n = !0;
+    const s = [], i = this._args?.maxReportItems ?? nt;
+    let o = 0, u = 0;
+    for (let a = 0; a < e.length; a++) {
+      const l = e[a], f = M(l, r);
+      if (f.result ? (o < i && s.push({
+        actualKey: a,
+        expectedKey: a,
+        result: f
+      }), o++) : (u < i && s.push({
+        actualKey: a,
+        expectedKey: a,
+        result: f
+      }), u++, n = !1), !n && o >= i && u >= i)
+        break;
+    }
+    return {
+      result: n,
+      nested: s
+    };
+  }
+  nameDefault() {
+    return "array item";
+  }
+}
+class be extends p {
+  match(e) {
+    const { expected: r, convert: n } = this._args, s = M(n(e), r), i = [
+      {
+        result: s
+      }
+    ];
+    return {
+      result: s.result,
+      nested: i
+    };
+  }
+  nameDefault() {
+    return "convert";
+  }
+}
+class Vt extends p {
+  match(e) {
+    const { expected: r, nonStrict: n } = this._args;
+    return n ? e == r : e === r;
+  }
+  nameDefault() {
+    return `is(${rt(this._args.expected)})`;
+  }
+}
+class xe extends p {
+  match(e) {
+    if (e == null)
+      return `Expected number, got "${e}"`;
+    if (typeof e != "number")
+      return `Expected number, got "${typeof e}"`;
+    if (this._args == null)
+      return Number.isFinite(e) ? !0 : "Expected finite number";
+    if (!this._args.allowNaN && Number.isNaN(e))
+      return "Expected not NaN";
+    if (!this._args.allowInfinity && !Number.isFinite(e))
+      return "Expected not Infinity";
+    const { min: r, max: n, float: s } = this._args;
+    return !s && !Number.isInteger(e) ? `Expected integer, got "${e}"` : r != null && e < r ? `Expected number to be >= ${r}, got ${e}` : n != null && e > n ? `Expected number to be <= ${n}, got ${e}` : !0;
+  }
+  nameDefault() {
+    return `number(${yt(this._args)})`;
+  }
+}
+class $e extends p {
+  match(e) {
+    if (e == null)
+      return `Expected object, got "${e}"`;
+    if (Array.isArray(e))
+      return "Expected object, got array";
+    if (typeof e != "object")
+      return `Expected object, got "${typeof e}"`;
+    const r = this._args?.expected;
+    if (r == null)
+      return !0;
+    let n = !0;
+    const s = [], i = this._args?.maxReportItems ?? nt;
+    let o = 0, u = 0;
+    for (const a in r) {
+      if (!Object.prototype.hasOwnProperty.call(r, a))
+        continue;
+      const l = e[a], f = r[a], w = M(l, f);
+      if (w.result ? (o < i && s.push({
+        actualKey: a,
+        expectedKey: a,
+        result: w
+      }), o++) : (u < i && s.push({
+        actualKey: a,
+        expectedKey: a,
+        result: w
+      }), u++, n = !1), !n && o >= i && u >= i)
+        break;
+    }
+    if (!this._args?.ignoreExtraKeys)
+      for (const a in e) {
+        if (!Object.prototype.hasOwnProperty.call(e, a) || Object.prototype.hasOwnProperty.call(r, a))
+          continue;
+        const l = e[a];
+        if (u < i && s.push({
+          actualKey: a,
+          expectedKey: a,
+          result: Pt(l, void 0, "Unexpected key")
+        }), u++, n = !1, u >= i)
+          break;
+      }
+    return {
+      result: n,
+      nested: s
+    };
+  }
+  nameDefault() {
+    return "object" + yt(this._args);
+  }
+}
+class Oe extends p {
+  match(e) {
+    if (e == null)
+      return `Expected string, got ${e}`;
+    if (typeof e != "string")
+      return `Expected string, got "${typeof e}"`;
+    if (this._args == null)
+      return !0;
+    const { pattern: r } = this._args;
+    if (r != null) {
+      if (typeof r == "function")
+        return r(e);
+      if (!r.test(e))
+        return !1;
+    }
+    return !0;
+  }
+  nameDefault() {
+    return this._args?.pattern ? `string(${this._args.pattern})` : "string";
+  }
+}
+class Se extends p {
+  match(e) {
+    const r = this._args.expected;
+    return e instanceof r ? !0 : `Expected instance of "${r}", got "${e}"`;
+  }
+  nameDefault() {
+    return `instanceOf(${this._args.expected.name})`;
+  }
+}
+class Ee extends p {
+  constructor(e) {
+    super({
+      ...e,
+      expected: e.expected instanceof Set ? e.expected : new Set(e.expected)
+    });
+  }
+  match(e) {
+    return !!this._args.expected.has(e);
+  }
+  nameDefault() {
+    return `in(${rt(this._args.expected)})`;
+  }
+}
+class st extends p {
+  match(e) {
+    const { type: r, expecteds: n, pipe: s } = this._args;
+    let i = r === "and";
+    const o = [];
+    for (let u = 0; u < n.length; u++) {
+      const a = n[u], l = M(e, a);
+      if (o.push({
+        actualKey: `<${r} ${u}>`,
+        expectedKey: `<${r} ${u}>`,
+        result: l
+      }), r === "or") {
+        if (l.result && (i = !0, s))
+          break;
+      } else if (r === "and") {
+        if (!l.result && (i = !1, s))
+          break;
+      } else
+        throw new Error(`[test][MatcherFew] Unknown type "${r}"`);
+    }
+    return {
+      result: n.length === 0 || i,
+      nested: o
+    };
+  }
+  nameDefault() {
+    return this._args.type;
+  }
+}
+class Ae extends p {
+  match(e) {
+    const r = this._args.matcher;
+    return R(r) ? r.match(e) : r(e);
+  }
+  nameDefault(e) {
+    const r = this._args.name;
+    return typeof r == "string" ? r : r ? r(e) : "custom";
+  }
+}
+class Ft extends p {
+  match(e) {
+    const r = this._args.expected, n = M(e, r);
+    return {
+      result: !n.result,
+      nested: [
+        {
+          actualKey: null,
+          result: n
+        }
+      ]
+    };
+  }
+  nameDefault() {
+    return "not";
+  }
+}
+class Me extends p {
+  match() {
+    return !1;
+  }
+  nameDefault() {
+    return "never";
+  }
+}
+class Te extends p {
+  match(e) {
+    if (e == null)
+      return `Expected object, got "${e}"`;
+    if (Array.isArray(e))
+      return "Expected object, got array";
+    if (typeof e != "object")
+      return `Expected object, got "${typeof e}"`;
+    const r = this._args?.expected;
+    if (r == null)
+      return !0;
+    let n = !0;
+    const s = [], i = this._args?.maxReportItems ?? nt;
+    let o = 0, u = 0;
+    for (const a in e) {
+      if (!Object.prototype.hasOwnProperty.call(e, a))
+        continue;
+      const l = [a, e[a]], f = M(l, r);
+      if (f.result ? (o < i && s.push({
+        actualKey: a,
+        expectedKey: a,
+        result: f
+      }), o++) : (u < i && s.push({
+        actualKey: a,
+        expectedKey: a,
+        result: f
+      }), u++, n = !1), !n && o >= i && u >= i)
+        break;
+    }
+    return {
+      result: n,
+      nested: s
+    };
+  }
+  nameDefault() {
+    return "object entries" + yt(this._args);
+  }
+}
+class Ce extends p {
+  _hasExpected = !1;
+  _expected = void 0;
+  get expected() {
+    return this._expected;
+  }
+  set expected(e) {
+    this._expected = e, this._hasExpected = !0;
+  }
+  match(e) {
+    const r = M(e, this._expected), n = [
+      {
+        result: r
+      }
+    ];
+    return {
+      result: r.result,
+      nested: n
+    };
+  }
+  nameDefault() {
+    return "ref";
+  }
+}
+function j(t) {
+  return new Lt({ expected: t });
+}
+function Tr(t) {
+  return new Lt({ expected: t, matchType: "includes" });
+}
+function z() {
+  return new we();
+}
+function Cr() {
+  return new Ce();
+}
+function Ir(t) {
+  return new Me({ name: t });
+}
+function Nr(t, e) {
+  const r = new _e({ expected: e });
+  return t == null ? r : T(
+    Ue(
+      R(t) || typeof t == "number" ? t : it(t)
+    ),
+    r
+  ).name("array item");
+}
+function I(t, e, r) {
+  return new be({ name: t, convert: e, expected: r });
+}
+function Ie(t) {
+  return new Vt({ expected: t, nonStrict: !0 });
+}
+function Ne(t) {
+  return new Vt({ expected: t, nonStrict: !1 });
+}
+function vt(t) {
+  return new xe(t);
+}
+function it(t) {
+  return vt({
+    ...t,
+    float: !1
+  });
+}
+function Dr(t) {
+  return vt({
+    ...t,
+    float: !0
+  });
+}
+function N(t) {
+  return new $e({ expected: t });
+}
+function ht(t, e, r = null) {
+  if (t instanceof p || e && (t = e(t, r), t instanceof p))
+    return t;
+  if (t == null)
+    return tt();
+  if (Array.isArray(t)) {
+    const n = t.map((s, i) => ht(s, e, i));
+    return j(n);
+  }
+  if (t.constructor === Object) {
+    const n = {};
+    for (const s in t)
+      Object.prototype.hasOwnProperty.call(t, s) && (n[s] = ht(t[s], e, s));
+    return N(n);
+  }
+  return t instanceof Qt ? Ve({
+    ...t,
+    value: ht(t.value, e, "value")
+  }) : Ne(t);
+}
+function kr(t) {
+  return N(t).set({
+    ignoreExtraKeys: !0
+  });
+}
+function zt(t) {
+  return new Oe({
+    pattern: t
+  });
+}
+function Ur(t) {
+  return new Se({ expected: t });
+}
+function De(t) {
+  return I(
+    "typeof",
+    (e) => e === null ? "null" : typeof e,
+    t
+  );
+}
+function Rr(t) {
+  return I(
+    "constructor",
+    (e) => e.constructor,
+    t
+  );
+}
+function mt() {
+  return De("boolean");
+}
+function tt() {
+  return Ie(null);
+}
+function jr() {
+  return Le(tt());
+}
+function Kr(...t) {
+  return new st({
+    expecteds: t,
+    type: "or",
+    pipe: !1
+  });
+}
+function Pr(...t) {
+  return new st({
+    expecteds: t,
+    type: "and",
+    pipe: !1
+  });
+}
+function ke(...t) {
+  return new st({
+    expecteds: t,
+    type: "or",
+    pipe: !0
+  });
+}
+function T(...t) {
+  return new st({
+    expecteds: t,
+    type: "and",
+    pipe: !0
+  });
+}
+function L(t, e) {
+  return e == null ? ke(tt(), t) : e ? t : tt();
+}
+function Ue(t) {
+  const e = typeof t == "number" || R(t) ? t : it(t ?? { min: 1 });
+  return T(
+    j(),
+    I("length", (r) => r.length, e)
+  ).name("array length");
+}
+function Lr(t) {
+  const e = typeof t == "number" || R(t) ? t : it(t ?? { min: 1 });
+  return T(
+    zt(),
+    I("length", (r) => r.length, e)
+  ).name("string length");
+}
+function Vr(t) {
+  return T(N(), t);
+}
+function Fr(t) {
+  return T(j(), t);
+}
+function vr(t) {
+  return T(
+    N(),
+    I(
+      "keys",
+      (e) => Object.keys(e),
+      t
+    )
+  );
+}
+function zr(t) {
+  return T(
+    N(),
+    I(
+      "values",
+      (e) => Object.values(e),
+      t
+    )
+  );
+}
+function Br(t) {
+  return T(
+    N(),
+    I(
+      "entries",
+      (e) => Object.entries(e),
+      t
+    )
+  );
+}
+function gt(t) {
+  return new Te({ expected: t });
+}
+function qr(t) {
+  return gt(j([t, z()]));
+}
+function Wr(t) {
+  return gt(j([z(), t]));
+}
+function Hr(t, e) {
+  return gt(j([t, e]));
+}
+function Gr(t) {
+  return T(
+    N(),
+    I(
+      "keys not null",
+      (e) => Object.keys(e).filter((r) => e[r] != null),
+      t
+    )
+  );
+}
+function Re(t) {
+  return new Ee({ expected: t });
+}
+function Jr(t) {
+  return Re(Object.values(t));
+}
+function Bt(t, e) {
+  return new Ae({ matcher: e, name: t });
+}
+const je = Math.ceil(Date.now() - 10 * 365.25 * 24 * 60 * 60 * 1e3), Ke = Math.ceil(Date.now() + 10 * 365.25 * 24 * 60 * 60 * 1e3);
+function J(t) {
+  return it({
+    ...t,
+    min: t?.min ?? je,
+    max: t?.max ?? Ke
+  }).name("int date");
+}
+function Pe(t) {
+  const e = {
+    min: t?.from?.min ?? t?.common?.min,
+    max: t?.from?.max ?? t?.common?.max,
+    float: t?.from?.float ?? t?.common?.float,
+    optional: t?.from?.optional ?? t?.common?.optional
+  }, r = {
+    min: t?.to?.min ?? t?.common?.min,
+    max: t?.to?.max ?? t?.common?.max,
+    float: t?.to?.float ?? t?.common?.float,
+    optional: t?.to?.optional ?? t?.common?.optional
+  };
+  return T(
+    j([
+      e.optional ? L(J()) : J(),
+      r.optional ? L(J()) : J()
+    ]),
+    Bt("min <= max", (n) => n[0] != null && n[1] != null && n[0] > n[1] ? `Expected range to be [min, max], got [${n.join(", ")}]` : !0)
+  ).name("range");
+}
+function Xr(t) {
+  return Pe({
+    ...t,
+    common: {
+      min: new Date(2020, 0, 1).getTime(),
+      max: Date.now() + 900 * 1e3,
+      ...t?.common
+    }
+  }).name("range date");
+}
+function Le(t) {
+  return new Ft({ expected: t });
+}
+function Yr() {
+  return zt(/^[\da-f-]{36}|[\da-f]{32}$/i).name("uuid");
+}
+function Ve(t) {
+  return N({
+    [Symbol.toStringTag]: L(z()),
+    loading: L(mt()),
+    hasValue: L(mt()),
+    value: z(),
+    hasError: L(mt()),
+    error: z(),
+    ...t
+  });
+}
+function Qr(t) {
+  return t != null && typeof t == "string" && (t = new TextEncoder().encode(t).buffer), Bt("array buffer", (e) => {
+    if (e == null || typeof e != "object" || typeof e.byteLength != "number")
+      return `Expected array buffer, got "${e}"`;
+    if (t == null)
+      return !0;
+    if (e.byteLength !== t.byteLength)
+      return `Expected array buffer length to be ${t.byteLength}, got ${e.byteLength}`;
+    for (let r = 0, n = t.byteLength; r < n; r++)
+      if (e[r] !== t[r])
+        return `Expected array buffer[${r}] to be ${t[r]}, got ${e[r]}`;
+    return !0;
+  });
+}
+function Fe(t, e) {
+  const r = qt(t.result, e);
+  return r ? {
+    actualKey: t.actualKey,
+    expectedKey: t.expectedKey,
+    result: r
+  } : null;
+}
+function qt(t, e) {
+  if (e ? !t.result : t.result)
+    return null;
+  t.expected instanceof Ft && (e = !e);
+  let r = null;
+  return t.nested && t.nested.forEach((n) => {
+    const s = Fe(n, e);
+    s && (r || (r = []), r.push(s));
+  }), {
+    actual: t.actual,
+    expected: t.expected,
+    result: t.result,
+    cause: t.cause,
+    nested: r,
+    error: t.error
+  };
+}
+function ve(t, e) {
+  const r = Wt(t.result, e + "  ");
+  return `${e}${t.actualKey == null ? "| " : t.actualKey + ": "}${r}`;
+}
+function Wt(t, e) {
+  if (t.result)
+    return t.expected.toString();
+  let r = "";
+  t.nested && (r = t.nested.map((s) => ve(s, e)).join(`
+`));
+  let n = t.cause || "";
+  return r ? (n || (n = R(t.expected) ? t.expected.toString(t.actual) : ""), `${n}
+${r}`) : `${n}
+${e}expected: ${R(t.expected) ? t.expected.toString(t.actual) : t.expected}
+${e}actual: ${rt(t.actual)}`;
+}
+class ze extends Error {
+  constructor(e) {
+    super(e);
+  }
+}
+function Zr(t) {
+  return function(r, n) {
+    const s = M(t, r);
+    if (s.error)
+      throw s.error;
+    const i = qt(s, !1);
+    if (!i)
+      return;
+    const o = Wt(i, "");
+    console.log(`[test][check] CheckError:
+` + o);
+    const u = new ze(o);
+    throw n?.(u), u;
+  };
+}
+function St(t) {
+  return t.replace(/\W/g, "").toLowerCase();
+}
+function Be(t) {
+  return t instanceof URL ? t.searchParams : t instanceof URLSearchParams ? t : typeof t == "string" ? new URL(t).searchParams : typeof window < "u" ? new URL(window.location.href).searchParams : new URLSearchParams();
+}
+function qe(t) {
+  return t == null ? null : (t = t.toLowerCase().trim(), t === "true" || t === "1" || t === "yes" ? !0 : t === "false" || t === "0" || t === "no" ? !1 : null);
+}
+function We(t) {
+  if (t == null)
+    return null;
+  t = t.trim();
+  const e = parseInt(t, 10);
+  return isNaN(e) ? null : e;
+}
+function He(t) {
+  if (t == null)
+    return null;
+  t = t.trim();
+  const e = parseFloat(t);
+  return isNaN(e) ? null : e;
+}
+function wt(t, e) {
+  const r = Be(e), n = St(t);
+  for (const [s, i] of r.entries())
+    if (St(s) === n)
+      return i;
+  return null;
+}
+function tn(t, e) {
+  return qe(wt(t, e));
+}
+function en(t, e) {
+  return We(wt(t, e));
+}
+function rn(t, e) {
+  return He(wt(t, e));
+}
+export {
+  Ar as $,
+  bt as A,
+  Y as B,
+  fr as C,
+  hr as D,
+  xt as E,
+  mr as F,
+  pr as G,
+  yr as H,
+  pe as I,
+  gr as J,
+  wr as K,
+  v as L,
+  kt as M,
+  dr as N,
+  Rt as O,
+  _r as P,
+  de as Q,
+  dt as R,
+  ye as S,
+  br as T,
+  lt as U,
+  xr as V,
+  $r as W,
+  Or as X,
+  Sr as Y,
+  Er as Z,
+  Ut as _,
+  Qe as a,
+  Mr as a0,
+  M as a1,
+  Zr as a2,
+  j as a3,
+  Tr as a4,
+  z as a5,
+  Cr as a6,
+  Ir as a7,
+  Nr as a8,
+  I as a9,
+  Br as aA,
+  gt as aB,
+  qr as aC,
+  Wr as aD,
+  Hr as aE,
+  Gr as aF,
+  Re as aG,
+  Jr as aH,
+  Bt as aI,
+  J as aJ,
+  Pe as aK,
+  Xr as aL,
+  Le as aM,
+  Yr as aN,
+  Ve as aO,
+  Qr as aP,
+  Be as aQ,
+  qe as aR,
+  We as aS,
+  He as aT,
+  wt as aU,
+  tn as aV,
+  en as aW,
+  rn as aX,
+  Ie as aa,
+  Ne as ab,
+  vt as ac,
+  it as ad,
+  Dr as ae,
+  N as af,
+  ht as ag,
+  kr as ah,
+  zt as ai,
+  Ur as aj,
+  De as ak,
+  Rr as al,
+  mt as am,
+  tt as an,
+  jr as ao,
+  Kr as ap,
+  Pr as aq,
+  ke as ar,
+  T as as,
+  L as at,
+  Ue as au,
+  Lr as av,
+  Vr as aw,
+  Fr as ax,
+  vr as ay,
+  zr as az,
+  se as b,
+  Ze as c,
+  oe as d,
+  ae as e,
+  rr as f,
+  er as g,
+  nr as h,
+  It as i,
+  sr as j,
+  ir as k,
+  ur as l,
+  ne as m,
+  tr as n,
+  or as o,
+  ar as p,
+  Dt as q,
+  Ct as r,
+  re as s,
+  te as t,
+  U as u,
+  le as v,
+  fe as w,
+  G as x,
+  lr as y,
+  cr as z
+};