@flemist/simple-utils 2.1.4 → 2.1.6

package/build/urlGet-OHY_Qdk-.mjs

@@ -0,0 +1,2416 @@
+import { AbortControllerFast as It, AbortError as te, toAbortSignal as ee } from "@flemist/abort-controller-fast";
+import { timeControllerDefault as bt } from "@flemist/time-controller";
+import { isPromiseLike as E, promiseLikeToPromise as Ot, delay as re, EMPTY_FUNC as ne, ValueState as se } from "@flemist/async-utils";
+import { gzip as ie, gunzip as oe } from "fflate";
+function ae(t) {
+  if (!t || t.timeout == null)
+    return null;
+  const e = new It(), r = t.timeController ?? bt;
+  if (t.timeout) {
+    const n = r.setTimeout(() => {
+      e.abort(
+        new te(
+          `[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 = ae(e);
+  try {
+    return await t(r?.signal ?? e?.abortSignal ?? null);
+  } finally {
+    r?.abort();
+  }
+}
+class Sr {
+  _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 (E(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 xr {
+  _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 (E(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);
+  }
+}
+class ue {
+  _lockPromise = null;
+  get hasQueued() {
+    return this._lockPromise != null;
+  }
+  lock(e) {
+    if (this._lockPromise)
+      return Ot(
+        this._lockPromise.then(() => this.lock(e))
+      );
+    const r = e();
+    if (E(r)) {
+      const n = r.then(
+        () => {
+          this._lockPromise === n && (this._lockPromise = null);
+        },
+        () => {
+          this._lockPromise === n && (this._lockPromise = null);
+        }
+      );
+      this._lockPromise = n;
+    }
+    return Ot(r);
+  }
+}
+class le {
+  _lockers = /* @__PURE__ */ new Map();
+  lock(e, r) {
+    let n = this._lockers.get(e);
+    n == null && (n = new ue(), this._lockers.set(e, n));
+    const s = () => {
+      n.hasQueued || this._lockers.delete(e);
+    };
+    let i;
+    try {
+      i = n.lock(r);
+    } catch (o) {
+      throw s(), o;
+    }
+    return E(i) ? i.then(
+      (o) => (s(), o),
+      (o) => {
+        throw s(), o;
+      }
+    ) : (s(), i);
+  }
+  hasQueued(e) {
+    const r = this._lockers.get(e);
+    return r != null && r.hasQueued;
+  }
+}
+var Ut = /* @__PURE__ */ ((t) => (t[t.none = 0] = "none", t[t.error = 1] = "error", t[t.warn = 2] = "warn", t[t.debug = 3] = "debug", t))(Ut || {});
+async function Er(t) {
+  const e = t.abortSignal ?? null, r = t.timeController ?? bt;
+  let n = 0;
+  for (; ; )
+    try {
+      return await t.func({ abortSignal: e });
+    } catch (s) {
+      if ((t.logLevel == null || t.logLevel >= Ut.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 re(i, e ?? void 0, r) : await i(), e?.aborted))
+        throw s;
+    }
+}
+function Or({
+  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;
+  };
+}
+async function I(t) {
+  const e = await Promise.allSettled(t), r = [];
+  return e.forEach((n) => {
+    if (n.status === "fulfilled")
+      r.push(n.value);
+    else
+      throw n.reason;
+  }), r;
+}
+class ce {
+  _options;
+  _statsMap = null;
+  _totalSize = null;
+  _initPromise = null;
+  constructor(e) {
+    this._options = e;
+  }
+  async loadStatsMap(e) {
+    const r = await this._options.storage.getEntries(), n = [];
+    r.forEach((s, i) => {
+      const o = this._options.converter ? this._options.converter.from(s) : s;
+      E(o) ? n.push(
+        o.then((a) => {
+          e(i, a);
+        })
+      ) : e(i, o);
+    }), await Promise.all(n);
+  }
+  init() {
+    return this._initPromise == null && (this._initPromise = this._init()), this._initPromise;
+  }
+  async _init() {
+    const e = /* @__PURE__ */ new Map();
+    let r = 0;
+    await this.loadStatsMap((n, s) => {
+      e.set(n, s), r += s.size;
+    }), this._statsMap = e, this._totalSize = r;
+  }
+  async getTotalSize() {
+    return await this.init(), this._totalSize;
+  }
+  async get(e) {
+    return await this.init(), this._statsMap.get(e) ?? null;
+  }
+  async set(e, r) {
+    if (await this.init(), r != null) {
+      const n = this._options.converter ? await this._options.converter.to(r) : r;
+      await this._options.storage.set(e, n);
+      const s = this._statsMap.get(e);
+      this._statsMap.set(e, r), this._totalSize += r.size - (s?.size ?? 0);
+    } else {
+      await this._options.storage.delete(e);
+      const n = this._statsMap.get(e);
+      n != null && (this._statsMap.delete(e), this._totalSize -= n.size);
+    }
+  }
+  async getEntries() {
+    return await this.init(), this._statsMap;
+  }
+}
+function fe(t, e) {
+  return t[1].dateUsed !== e[1].dateUsed ? t[1].dateUsed < e[1].dateUsed ? -1 : 1 : t[1].size !== e[1].size ? t[1].size < e[1].size ? -1 : 1 : t[1].dateModified !== e[1].dateModified ? t[1].dateModified < e[1].dateModified ? -1 : 1 : t[0] !== e[0] ? t[0] < e[0] ? -1 : 1 : 0;
+}
+class $r {
+  _options;
+  _timeController;
+  _locker;
+  _stats;
+  constructor(e) {
+    this._options = e, this._timeController = e.timeController ?? bt, this._locker = new le(), this._stats = new ce({
+      storage: e.storages.stat,
+      converter: e.converterStat
+    });
+  }
+  async freeUpSpace(e, r, n) {
+    if (this._options.totalSize == null)
+      return;
+    const s = this._options.totalSize[0], i = this._options.totalSize[1];
+    if (n > i)
+      throw new Error(
+        `[Cache][freeUpSpace] value size (${n}) exceeds maximum total size (${i})`
+      );
+    let o = await this._stats.getTotalSize();
+    if (o += n - (r ?? 0), o <= i)
+      return;
+    const a = [], u = await this._stats.getEntries(), l = Array.from(u.entries());
+    l.sort(fe), l.forEach(([c, d]) => {
+      if (c === e || this._locker.hasQueued(c))
+        return;
+      const f = -d.size;
+      (o > i || o + f > s) && (a.push(
+        this._locker.lock(c, async () => (await I([
+          this._options.storages.value.delete(c),
+          this._options.storages.error.delete(c)
+        ]), this._stats.set(c, null)))
+      ), o += f);
+    }), await I(a);
+  }
+  async getOrCreate(e, r) {
+    const n = this._options.converterInput ? await this._options.converterInput(e) : e;
+    return this._locker.lock(n, async () => {
+      let s = await this._stats.get(n);
+      if (s == null || this._options.isExpired != null && this._options.isExpired(s))
+        await I([
+          this._options.storages.value.delete(n),
+          this._options.storages.error.delete(n),
+          this._stats.set(n, null)
+        ]), s = null;
+      else {
+        const [p, f] = await Promise.all([
+          this._options.storages.value.get(n),
+          this._options.storages.error.get(n)
+        ]), h = this._timeController.now();
+        if (!s.hasError && p != null) {
+          const m = {
+            ...s,
+            dateUsed: h
+          }, y = this._options.converterValue ? await this._options.converterValue.from(p) : p;
+          return await this._stats.set(n, m), y;
+        }
+        if (s.hasError && f != null) {
+          const m = {
+            ...s,
+            dateUsed: h
+          }, y = this._options.converterError ? await this._options.converterError.from(f) : f;
+          throw await this._stats.set(n, m), y;
+        }
+      }
+      let i = null, o = null, a = !1;
+      try {
+        i = await r(e);
+      } catch (p) {
+        o = p, a = !0;
+      }
+      if (a) {
+        const p = this._options.converterError ? await this._options.converterError.to(o) : o, f = this._options.getSize.error(p) + this._options.getSize.stat();
+        await this.freeUpSpace(n, s?.size, f), await I([
+          this._options.storages.error.set(n, p),
+          this._options.storages.value.delete(n)
+        ]);
+        const h = this._timeController.now(), m = {
+          dateModified: h,
+          dateUsed: h,
+          size: f,
+          hasError: !0
+        };
+        throw await this._stats.set(n, m), o;
+      }
+      const u = this._options.converterValue ? await this._options.converterValue.to(i) : i, l = this._options.getSize.value(u) + this._options.getSize.stat();
+      await this.freeUpSpace(n, s?.size, l), await I([
+        this._options.storages.value.set(n, u),
+        this._options.storages.error.delete(n)
+      ]);
+      const c = this._timeController.now(), d = {
+        dateModified: c,
+        dateUsed: c,
+        size: l
+      };
+      return await this._stats.set(n, d), i;
+    });
+  }
+  async delete(e) {
+    const r = this._options.converterInput ? await this._options.converterInput(e) : e;
+    return this._locker.lock(r, async () => {
+      await I([
+        this._options.storages.value.delete(r),
+        this._options.storages.error.delete(r),
+        this._stats.set(r, null)
+      ]);
+    });
+  }
+  /**
+   * Deletes all cache entries at this moment.
+   * But does not prevent new entries from being added during the clearing process
+   */
+  async clear() {
+    const [e, r, n] = await Promise.all([
+      this._options.storages.value.getKeys(),
+      this._options.storages.error.getKeys(),
+      this._options.storages.stat.getKeys()
+    ]), s = /* @__PURE__ */ new Set([...e, ...r, ...n]), i = [];
+    s.forEach((o) => {
+      const a = this._locker.lock(o, async () => {
+        const u = [], l = this._options.storages.value.delete(o);
+        E(l) && u.push(l);
+        const c = this._options.storages.error.delete(o);
+        E(c) && u.push(c);
+        const d = this._stats.set(o, null);
+        E(d) && u.push(d), await I(u);
+      });
+      E(a) && i.push(a);
+    }), await I(i);
+  }
+}
+class Mr {
+  _cache = /* @__PURE__ */ new Map();
+  set(e, r) {
+    this._cache.set(e, r);
+  }
+  get(e) {
+    return this._cache.get(e);
+  }
+  delete(e) {
+    this._cache.delete(e);
+  }
+  clear() {
+    this._cache.clear();
+  }
+  getKeys() {
+    return Array.from(this._cache.keys());
+  }
+  getEntries() {
+    return new Map(this._cache);
+  }
+}
+function $t(t) {
+  if (t == null)
+    return null;
+  if (Array.isArray(t)) {
+    const e = t.length, r = [];
+    for (let n = 0; n < e; n++)
+      r.push($t(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] = $t(t[r]));
+    return e;
+  }
+  return t;
+}
+function Z(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 (!Z(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) && !Z(
+        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) && !Z(e[r], null))
+        return !1;
+    return !0;
+  }
+  return !1;
+}
+function Ar(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 (!Z(n, e.get(r)))
+      return !1;
+  return !0;
+}
+function Cr(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 gt(t) {
+  return !t || typeof t != "object" ? t : Array.isArray(t) ? t.map(gt) : t && Object.keys(t).sort().reduce((e, r) => {
+    const n = gt(t[r]);
+    return n != null && (e[r] = n), e;
+  }, {});
+}
+function kr(t, e) {
+  return Object.defineProperty(t, "name", { value: e, configurable: !0 }), t;
+}
+function he(t) {
+  return t = gt(t), JSON.stringify(t ?? null);
+}
+let H = null;
+function me() {
+  if (!H) {
+    H = new Array(256);
+    for (let t = 0; t < 256; t++)
+      H[t] = t.toString(16).padStart(2, "0");
+  }
+  return H;
+}
+function pe(t) {
+  const e = me(), 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 yt = null, Pt = null, tt = null, zt = null;
+function de() {
+  yt || (yt = 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
+  ]), Pt = new Uint32Array(64), zt = new TextEncoder(), tt = new Uint8Array(65536));
+}
+function _e(t) {
+  if (t == null)
+    return null;
+  de();
+  const e = yt, r = Pt, n = zt;
+  let s = tt, i;
+  if (typeof t == "string") {
+    const w = t.length * 3;
+    s.length < w + 128 && (s = tt = new Uint8Array(w + 128));
+    const g = n.encodeInto(t, s);
+    i = s.subarray(0, g.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, a = o + 72 >>> 6 << 6;
+  s.length < a && (s = tt = new Uint8Array(a)), i !== s && s.set(i), s[o] = 128;
+  for (let w = o + 1; w < a; w++)
+    s[w] = 0;
+  const u = o * 8, l = u / 4294967296 | 0, c = u | 0;
+  s[a - 8] = l >>> 24, s[a - 7] = l >>> 16, s[a - 6] = l >>> 8, s[a - 5] = l, s[a - 4] = c >>> 24, s[a - 3] = c >>> 16, s[a - 2] = c >>> 8, s[a - 1] = c;
+  let d = 1779033703, p = -1150833019, f = 1013904242, h = -1521486534, m = 1359893119, y = -1694144372, S = 528734635, O = 1541459225;
+  for (let w = 0; w < a; w += 64) {
+    for (let b = 0; b < 16; b++) {
+      const x = w + (b << 2);
+      r[b] = s[x] << 24 | s[x + 1] << 16 | s[x + 2] << 8 | s[x + 3];
+    }
+    for (let b = 16; b < 64; b++) {
+      const x = r[b - 15], T = r[b - 2], ft = (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3, G = (T >>> 17 | T << 15) ^ (T >>> 19 | T << 13) ^ T >>> 10;
+      r[b] = r[b - 16] + ft + r[b - 7] + G | 0;
+    }
+    let g = d, M = p, q = f, lt = h, A = m, J = y, L = S, ct = O;
+    for (let b = 0; b < 64; b += 4)
+      for (let x = 0; x < 4; x++) {
+        const T = b + x, ft = (A >>> 6 | A << 26) ^ (A >>> 11 | A << 21) ^ (A >>> 25 | A << 7), G = ct + ft + (L ^ A & (J ^ L)) + e[T] + r[T] | 0, Zt = ((g >>> 2 | g << 30) ^ (g >>> 13 | g << 19) ^ (g >>> 22 | g << 10)) + (g & M ^ q & (g ^ M)) | 0;
+        ct = L, L = J, J = A, A = lt + G | 0, lt = q, q = M, M = g, g = G + Zt | 0;
+      }
+    d = d + g | 0, p = p + M | 0, f = f + q | 0, h = h + lt | 0, m = m + A | 0, y = y + J | 0, S = S + L | 0, O = O + ct | 0;
+  }
+  const $ = new Uint8Array(32), K = [d, p, f, h, m, y, S, O];
+  for (let w = 0; w < 8; w++) {
+    const g = K[w], M = w << 2;
+    $[M] = g >>> 24, $[M + 1] = g >>> 16 & 255, $[M + 2] = g >>> 8 & 255, $[M + 3] = g & 255;
+  }
+  return $;
+}
+function ge(t) {
+  const e = _e(t);
+  return e ? pe(e) : null;
+}
+function Tr(t) {
+  const e = he(t);
+  return ge(e);
+}
+function Ir(t, e) {
+  return t == null ? e : (r, n) => t(r, (s) => e(s, n));
+}
+function Ur(t, e) {
+  return t == null ? e : (r) => t(r, (n) => e(n));
+}
+function ye(t, e) {
+  return t == null ? e : (r, n) => t(r, (s) => e(s, n));
+}
+function we(t, e) {
+  return t == null ? e : (r, n) => t(r, (s) => e(s, n));
+}
+function be(t, e) {
+  return t == null ? e : {
+    to: ye(
+      (r, n) => t.to(r, n),
+      (r, n) => e.to(r, n)
+    )
+  };
+}
+function Se(t, e) {
+  return t == null ? e : {
+    from: we(
+      (r, n) => t.from(r, n),
+      (r, n) => e.from(r, n)
+    )
+  };
+}
+function Pr(t, e) {
+  return t == null ? e : {
+    to: be(t, e).to,
+    from: Se(t, e).from
+  };
+}
+function xe(t, e) {
+  return t == null ? e : (r) => t(r, (n) => e(n));
+}
+function Ee(t, e) {
+  return t == null ? e : (r) => t(r, (n) => e(n));
+}
+function Oe(t, e) {
+  return t == null ? e : {
+    to: xe(
+      (r, n) => t.to(r, n),
+      (r) => e.to(r)
+    )
+  };
+}
+function $e(t, e) {
+  return t == null ? e : {
+    from: Ee(
+      (r, n) => t.from(r, n),
+      (r) => e.from(r)
+    )
+  };
+}
+function zr(t, e) {
+  return t == null ? e : {
+    to: Oe(t, e).to,
+    from: $e(t, e).from
+  };
+}
+const Mt = {
+  to: (t) => JSON.stringify(t ?? null, null, 2),
+  from: (t) => JSON.parse(t)
+}, et = {
+  to: (t) => new TextEncoder().encode(t),
+  from: (t) => new TextDecoder().decode(t)
+}, Nr = {
+  to: (t) => {
+    const e = Mt.to(t);
+    return et.to(e);
+  },
+  from: (t) => {
+    const e = et.from(t);
+    return Mt.from(e);
+  }
+};
+function vr(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 Dr(t) {
+  return t == null ? null : t?.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+function Nt(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 Me(t, e) {
+  t = Nt(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"), a = t.getUTCSeconds().toString().padStart(2, "0");
+  return `${r}-${n}-${s} ${i}:${o}:${a}`;
+}
+let Ae = 0;
+const ht = /* @__PURE__ */ new WeakMap();
+function j(t) {
+  if (ht.has(t))
+    return ht.get(t);
+  const e = Ae++;
+  return ht.set(t, e), e;
+}
+function Q(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 At(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: a,
+    maxStringLength: u,
+    showObjectId: l,
+    showArrayIndex: c,
+    customToString: d
+  } = e ?? {};
+  if (r == null && (r = []), n == null && (n = /* @__PURE__ */ new Set()), d) {
+    const f = d(
+      t,
+      r,
+      (h) => U(h, e, r, n)
+    );
+    if (f != null)
+      return Q(f, u, e?.truncateOptions);
+  }
+  const p = r.length;
+  if (typeof t == "string")
+    return t = Q(t, u, 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 ?? ""}#${j(t)}[${t.byteLength}]`;
+  if (t instanceof RegExp)
+    return Q(
+      String(t),
+      u,
+      e?.truncateOptions
+    );
+  if (t instanceof Date)
+    return Me(t);
+  if (t instanceof Object) {
+    if (n.has(t) || o != null && p >= o)
+      return `${t.constructor === Object ? "" : t.constructor?.name ?? ""}#${j(t)}`;
+    n.add(t);
+  }
+  if (t instanceof Error)
+    return Q(
+      t.stack || t.message || String(t),
+      u,
+      e?.truncateOptions
+    );
+  if (Array.isArray(t)) {
+    const f = s ? "  ".repeat(p) : "";
+    let h = "";
+    l && (h += `#${j(t)} `), h += "[";
+    let m = 0, y = !1;
+    for (let S = 0; S < t.length; S++) {
+      if (a != null && m >= a) {
+        y = !0;
+        break;
+      }
+      const O = [...r, String(S)], $ = At(t, S);
+      if (i != null && !i(O, $))
+        continue;
+      const K = U($, e, O, n);
+      m > 0 && (h += ","), s && (h += `
+`), s && (h += `${f}  `), c && (h += `${S}: `), h += `${K}`, m++;
+    }
+    return y ? (m > 0 && (h += ","), s ? (h += `
+`, h += `${f}  ...
+`) : h += "...", h += f, h += "]") : (m > 0 && s && (h += `
+${f}`), h += "]"), h;
+  }
+  if (t instanceof Map) {
+    let f = "";
+    return l && (f += `#${j(t)} `), f += "Map", f += U(Array.from(t.entries()), e, r, n), f;
+  }
+  if (t instanceof Set) {
+    let f = "";
+    return l && (f += `#${j(t)} `), f += "Set", f += U(Array.from(t.values()), e, r, n), f;
+  }
+  {
+    const f = t.constructor === Object ? "" : t.constructor?.name ?? "", h = s ? "  ".repeat(p) : "";
+    let m = f ? `${f} ` : "";
+    l && (m += `#${j(t)} `), m += "{";
+    let y = 0, S = !1;
+    for (const O in t) {
+      if (a != null && y >= a) {
+        S = !0;
+        break;
+      }
+      const $ = [...r, O], K = At(t, O);
+      if (i != null && !i($, K))
+        continue;
+      const w = U(K, e, $, n);
+      y > 0 && (m += ","), s && (m += `
+`), s && (m += `${h}  `), m += `${O}: ${w}`, y++;
+    }
+    return S && (y > 0 && (m += ","), s ? (m += `
+`, m += `${h}  ...
+`) : m += "...", m += h), y > 0 && s && !S && (m += `
+${h}`), m += "}", m;
+  }
+}
+function Ce(t, e) {
+  t = Nt(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"), a = t.getUTCSeconds().toString().padStart(2, "0");
+  return `${r}-${n}-${s}_${i}-${o}-${a}`;
+}
+const Rr = {
+  to: (t) => {
+    const e = U(t, {
+      pretty: !0,
+      maxDepth: 10,
+      maxItems: 50,
+      maxStringLength: 1e3
+    });
+    return et.to(e);
+  },
+  from: (t) => et.from(t)
+}, Kr = {
+  to: (t) => Array.from(t.entries()).reduce((e, [r, n]) => (e[r] = n, e), {}),
+  from: (t) => new Map(Object.entries(t))
+}, jr = {
+  to: (t) => Array.from(t),
+  from: (t) => new Set(t)
+};
+async function Vr(t, e) {
+  return new Promise((r, n) => {
+    ie(t, { level: e.level }, (s, i) => {
+      s ? n(s) : r(i);
+    });
+  });
+}
+function Lr(t) {
+  return t[0] === 31 && t[1] === 139;
+}
+async function Fr(t) {
+  return new Promise((e, r) => {
+    oe(t, (n, s) => {
+      n ? r(n) : e(s);
+    });
+  });
+}
+function ke(t, e) {
+  return t == null ? e : e == null ? t : Math.min(t, e);
+}
+function Te(t, e) {
+  return t == null ? e : e == null ? t : Math.max(t, e);
+}
+function Br(t, e, r) {
+  return Te(ke(t, e), r);
+}
+function Wr(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 qr() {
+  return Math.random() * 2 ** 32 >>> 0;
+}
+function Pe(t) {
+  return t != null ? Ie(t) : Ue;
+}
+class wt {
+  _seed;
+  _rnd;
+  constructor(e) {
+    this._seed = e, this._rnd = Pe(e);
+  }
+  get seed() {
+    return this._seed;
+  }
+  nextSeed() {
+    return this.next() * 2 ** 32 >>> 0;
+  }
+  nextRandom() {
+    return new wt(this.nextSeed());
+  }
+  next() {
+    return this._rnd();
+  }
+  clone() {
+    return new wt(this._seed);
+  }
+}
+function vt(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 ze(t, e, r) {
+  return Math.floor(vt(t, e, r));
+}
+function Jr(t, e) {
+  return t.next() < (e ?? 0.5);
+}
+function Gr(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 = vt(t, n);
+  for (let i = 0; i < e; i++)
+    if (s -= r(i), s < 0)
+      return i;
+  return e - 1;
+}
+function Dt(t, e) {
+  if (e.length === 0)
+    throw new Error("[random][randomItem] items is empty");
+  const r = ze(t, e.length);
+  return e[r];
+}
+function Hr(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(Dt(t, e));
+  return n;
+}
+function Qr(t, e, r) {
+  let n = Object.values(e);
+  return r && (n = n.filter(r)), Dt(t, n);
+}
+const Rt = 1073741789, mt = (Rt >> 2) - 1;
+function Xr(t = mt, e) {
+  if (t <= 0)
+    throw new Error(`[random][PseudoRandom] count(${t}) must be > 0`);
+  if (t > mt)
+    throw new Error(
+      `[random][PseudoRandom] count(${t}) must be <= ${mt}`
+    );
+  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 + Rt) % t, r;
+  };
+}
+let F = null;
+function Yr() {
+  const t = Date.now();
+  return F == null || t > F ? (F = t, t) : (F++, F);
+}
+async function Zr({
+  url: t,
+  timeout: e
+} = {}) {
+  t || (t = typeof window < "u" ? "/" : "https://google.com");
+  let r;
+  try {
+    const n = new It();
+    r = e ? setTimeout(() => {
+      n.abort();
+    }, e) : null;
+    const s = await fetch(t, {
+      method: "HEAD",
+      signal: ee(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 tn(t) {
+  const e = alert;
+  return window.alert = (r) => t(e, r), () => {
+    window.alert = e;
+  };
+}
+var B = /* @__PURE__ */ ((t) => (t.log = "log", t.warn = "warn", t.error = "error", t.info = "info", t.debug = "debug", t.trace = "trace", t.assert = "assert", t))(B || {});
+const Ct = Object.values(B);
+function N(t) {
+  return function() {
+    t.apply(console, arguments);
+  };
+}
+const kt = {
+  log: N(console.log),
+  warn: N(console.warn),
+  error: N(console.error),
+  info: N(console.info),
+  debug: N(console.debug),
+  trace: N(console.trace),
+  assert: N(console.assert)
+};
+function Kt(t) {
+  return Ct.forEach((e) => {
+    console[e] = (...r) => {
+      t(kt, e, r);
+    };
+  }), () => {
+    Ct.forEach((e) => {
+      console[e] = kt[e];
+    });
+  };
+}
+function en(t) {
+  return function(r) {
+    let n = null;
+    const i = Kt((a, u, l) => {
+      try {
+        t(a, u, l);
+      } catch (c) {
+        throw n || (n = c), c;
+      }
+    }), o = () => {
+      if (i(), n)
+        throw n;
+    };
+    try {
+      const a = r();
+      return E(a) ? a.then(
+        (u) => (o(), u),
+        (u) => {
+          throw o(), u;
+        }
+      ) : (o(), a);
+    } catch (a) {
+      throw o(), a;
+    }
+  };
+}
+class jt {
+  _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);
+        E(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 Ne(t, e) {
+  return U(t, {
+    maxDepth: 5,
+    maxItems: 10,
+    ...e
+  });
+}
+function ve(t) {
+  return t.map(
+    (e) => e && typeof e == "object" ? Ne(e) : e
+  );
+}
+function rn(t) {
+  return `${Ce(/* @__PURE__ */ new Date())} [${t.level.toUpperCase()}] ${ve(
+    t.args
+  ).join(" ")}`;
+}
+let rt = null, pt = null;
+function De() {
+  return pt || (pt = new jt({
+    startStopNotifier: (t) => (rt = t, () => {
+      rt = null;
+    })
+  })), pt;
+}
+function nn() {
+  return Kt((t, e, r) => {
+    e === "assert" && r[0] === !0 || (e === B.error || e === B.warn || e === B.assert) && (rt && rt({
+      date: Date.now(),
+      level: e,
+      args: r
+    }), t[e](...r));
+  });
+}
+function sn(t) {
+  if (typeof window > "u")
+    return ne;
+  const { levels: e, predicate: r } = t;
+  return De().subscribe((n) => {
+    if (e && !e.includes(n.level))
+      return;
+    const s = n.args.join(`
+`);
+    r && !r({ text: s, message: n }) || alert(s);
+  });
+}
+function Re() {
+  let t = new Error().stack;
+  if (t != null) {
+    const e = t.indexOf(`
+`);
+    e != null && e >= 0 && (t = t.substring(e + 1));
+  }
+  return t ?? "";
+}
+function on(t) {
+  return function(...e) {
+    const r = Re();
+    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 an(t) {
+  return t != null && typeof t == "object" && typeof t.subscribe == "function";
+}
+class un {
+  _subjects = /* @__PURE__ */ new Map();
+  _getLastEvent;
+  constructor({
+    getLastEvent: e
+  } = {}) {
+    this._getLastEvent = e;
+  }
+  subscribe(e, r) {
+    let n = this._subjects.get(e);
+    n || (n = new jt(), 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 ln(t, e, r) {
+  return new Promise((n) => {
+    let s = !1, i;
+    function o(c) {
+      u?.(), i?.(), s = !0, n(c);
+    }
+    function a(c) {
+      u?.(), i?.(), s = !0, n(Promise.reject(c));
+    }
+    const u = r?.subscribe(a);
+    let l = !0;
+    i = t.subscribe((c) => {
+      (!e || e(c, l)) && o(c), l = !1;
+    }), s && i?.();
+  });
+}
+class v extends Error {
+  constructor(e) {
+    super(e);
+  }
+}
+class _ {
+  _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 Vt(t, e) {
+  return U(t, {
+    maxDepth: 1,
+    maxItems: 5,
+    ...e
+  });
+}
+function D(t) {
+  return t instanceof _;
+}
+function it(t) {
+  return Vt(t);
+}
+function St(t, ...e) {
+  if (t == null)
+    return "";
+  const r = Vt(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 nt(t) {
+  const { result: e, cause: r, nested: n, error: s } = t;
+  if (s) {
+    if (!(s instanceof Error))
+      throw new v(
+        `[test][validateMatchResult] error must be an instance of Error, but it is: ${s}`
+      );
+    if (e != null)
+      throw new v(
+        `[test][validateMatchResult] result must be null if error is set, but it is: ${e}`
+      );
+    if (r != null)
+      throw new v(
+        `[test][validateMatchResult] cause must be null if error is set, but it is: ${r}`
+      );
+    if (n != null)
+      throw new v(
+        `[test][validateMatchResult] nested must be null if error is set, but it is: ${n}`
+      );
+    return t;
+  }
+  if (typeof e != "boolean")
+    throw new v(
+      `[test][validateMatchResult] result must be a boolean, but it is: ${e}`
+    );
+  if (typeof r != "string" && r != null)
+    throw new v(
+      `[test][validateMatchResult] cause must be a string or null, but it is: ${r}`
+    );
+  if (n != null && !(n instanceof Array))
+    throw new v(
+      `[test][validateMatchResult] nested must be an array or null, but it is: ${n}`
+    );
+  return t;
+}
+function Ke(t, e, r) {
+  return nt({
+    actual: t,
+    expected: e,
+    result: null,
+    cause: null,
+    nested: null,
+    error: r
+  });
+}
+function Lt(t, e, r) {
+  return nt({
+    actual: t,
+    expected: e,
+    result: r,
+    cause: null,
+    nested: null,
+    error: null
+  });
+}
+function Ft(t, e, r) {
+  return typeof r == "boolean" ? Lt(t, e, r) : nt(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 C(t, e) {
+  try {
+    if (D(e)) {
+      const r = e.match(t);
+      return Ft(t, e, r);
+    }
+    return Lt(t, e, t === e);
+  } catch (r) {
+    return Ke(t, e, r);
+  }
+}
+class Bt extends _ {
+  match(e) {
+    const r = this._args.expected, n = C(e, r);
+    return {
+      result: !n.result,
+      nested: [
+        {
+          actualKey: null,
+          result: n
+        }
+      ]
+    };
+  }
+  nameDefault() {
+    return "not";
+  }
+}
+function je(t, e) {
+  const r = Wt(t.result, e);
+  return r ? {
+    actualKey: t.actualKey,
+    expectedKey: t.expectedKey,
+    result: r
+  } : null;
+}
+function Wt(t, e) {
+  if (e ? !t.result : t.result)
+    return null;
+  t.expected instanceof Bt && (e = !e);
+  let r = null;
+  return t.nested && t.nested.forEach((n) => {
+    const s = je(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 = qt(t.result, e + "  ");
+  return `${e}${t.actualKey == null ? "| " : t.actualKey + ": "}${r}`;
+}
+function qt(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 = D(t.expected) ? t.expected.toString(t.actual) : ""), `${n}
+${r}`) : `${n}
+${e}expected: ${D(t.expected) ? t.expected.toString(t.actual) : t.expected}
+${e}actual: ${it(t.actual)}`;
+}
+class Jt extends Error {
+  constructor(e) {
+    super(e);
+  }
+}
+function X(t) {
+  return function(r, n) {
+    const s = C(t, r);
+    if (s.error)
+      throw s.error;
+    const i = Wt(s, !1);
+    if (!i)
+      return;
+    const o = qt(i, "");
+    console.log(`[test][check] CheckError:
+` + o);
+    const a = new Jt(o);
+    throw n?.(a), a;
+  };
+}
+function cn(t) {
+  return function(r, n) {
+    let s;
+    try {
+      s = t();
+    } catch (i) {
+      X(i)(n);
+      return;
+    }
+    return E(s) ? s.then((i) => (X(i)(r), i)).catch((i) => {
+      if (i instanceof Jt)
+        throw i;
+      try {
+        X(i)(n);
+      } catch (o) {
+        throw console.error("[test][check] error", o), i;
+      }
+    }) : (X(s)(r), s);
+  };
+}
+const ot = 10;
+class Gt extends _ {
+  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 ?? ot, 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, a = 0;
+      const u = [];
+      for (let l = 0; l < r.length; l++) {
+        const c = e[l], d = r[l], p = C(c, d);
+        if (p.result ? (o < n && u.push({
+          actualKey: l,
+          expectedKey: l,
+          result: p
+        }), o++) : (a < n && u.push({
+          actualKey: l,
+          expectedKey: l,
+          result: p
+        }), a++, i = !1), !i && o >= n && a >= n)
+          break;
+      }
+      return {
+        result: i,
+        nested: u
+      };
+    }
+    if (s === "includes") {
+      let i = !0;
+      const o = [];
+      let a = 0, u = 0;
+      for (let l = 0; l < r.length; l++) {
+        const c = r[l];
+        let d = !1;
+        for (let p = 0; p < e.length; p++) {
+          const f = e[p], h = C(f, c);
+          if (h.result) {
+            d = !0, a < n && o.push({
+              actualKey: p,
+              expectedKey: l,
+              result: h
+            }), a++;
+            break;
+          }
+        }
+        if (d || (i = !1, u < n && o.push({
+          expectedKey: l,
+          result: {
+            result: !1,
+            actual: void 0,
+            expected: c
+          }
+        }), u++), !i && a >= n && u >= n)
+          break;
+      }
+      return {
+        result: i,
+        nested: o
+      };
+    }
+    return `Unknown matchType "${s}"`;
+  }
+  nameDefault() {
+    return `array ${this._args?.matchType || "equals"} ${it(this._args?.expected)}`;
+  }
+}
+class Le extends _ {
+  match() {
+    return !0;
+  }
+  nameDefault() {
+    return "any";
+  }
+}
+class Fe extends _ {
+  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 ?? ot;
+    let o = 0, a = 0;
+    for (let u = 0; u < e.length; u++) {
+      const l = e[u], c = C(l, r);
+      if (c.result ? (o < i && s.push({
+        actualKey: u,
+        expectedKey: u,
+        result: c
+      }), o++) : (a < i && s.push({
+        actualKey: u,
+        expectedKey: u,
+        result: c
+      }), a++, n = !1), !n && o >= i && a >= i)
+        break;
+    }
+    return {
+      result: n,
+      nested: s
+    };
+  }
+  nameDefault() {
+    return "array item";
+  }
+}
+class Be extends _ {
+  match(e) {
+    const { expected: r, convert: n } = this._args, s = C(n(e), r), i = [
+      {
+        result: s
+      }
+    ];
+    return {
+      result: s.result,
+      nested: i
+    };
+  }
+  nameDefault() {
+    return "convert";
+  }
+}
+class Ht extends _ {
+  match(e) {
+    const { expected: r, nonStrict: n } = this._args;
+    return n ? e == r : e === r;
+  }
+  nameDefault() {
+    return `is(${it(this._args.expected)})`;
+  }
+}
+class We extends _ {
+  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(${St(this._args)})`;
+  }
+}
+class qe extends _ {
+  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 ?? ot;
+    let o = 0, a = 0;
+    for (const u in r) {
+      if (!Object.prototype.hasOwnProperty.call(r, u))
+        continue;
+      const l = e[u], c = r[u], d = C(l, c);
+      if (d.result ? (o < i && s.push({
+        actualKey: u,
+        expectedKey: u,
+        result: d
+      }), o++) : (a < i && s.push({
+        actualKey: u,
+        expectedKey: u,
+        result: d
+      }), a++, n = !1), !n && o >= i && a >= i)
+        break;
+    }
+    if (!this._args?.ignoreExtraKeys)
+      for (const u in e) {
+        if (!Object.prototype.hasOwnProperty.call(e, u) || Object.prototype.hasOwnProperty.call(r, u))
+          continue;
+        const l = e[u];
+        if (a < i && s.push({
+          actualKey: u,
+          expectedKey: u,
+          result: Ft(l, void 0, "Unexpected key")
+        }), a++, n = !1, a >= i)
+          break;
+      }
+    return {
+      result: n,
+      nested: s
+    };
+  }
+  nameDefault() {
+    return "object" + St(this._args);
+  }
+}
+class Je extends _ {
+  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 Ge extends _ {
+  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 He extends _ {
+  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(${it(this._args.expected)})`;
+  }
+}
+class at extends _ {
+  match(e) {
+    const { type: r, expecteds: n, pipe: s } = this._args;
+    let i = r === "and";
+    const o = [];
+    for (let a = 0; a < n.length; a++) {
+      const u = n[a], l = C(e, u);
+      if (o.push({
+        actualKey: `<${r} ${a}>`,
+        expectedKey: `<${r} ${a}>`,
+        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 Qe extends _ {
+  match(e) {
+    const r = this._args.matcher;
+    return D(r) ? r.match(e) : r(e);
+  }
+  nameDefault(e) {
+    const r = this._args.name;
+    return typeof r == "string" ? r : r ? r(e) : "custom";
+  }
+}
+class Xe extends _ {
+  match() {
+    return !1;
+  }
+  nameDefault() {
+    return "never";
+  }
+}
+class Ye extends _ {
+  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 ?? ot;
+    let o = 0, a = 0;
+    for (const u in e) {
+      if (!Object.prototype.hasOwnProperty.call(e, u))
+        continue;
+      const l = [u, e[u]], c = C(l, r);
+      if (c.result ? (o < i && s.push({
+        actualKey: u,
+        expectedKey: u,
+        result: c
+      }), o++) : (a < i && s.push({
+        actualKey: u,
+        expectedKey: u,
+        result: c
+      }), a++, n = !1), !n && o >= i && a >= i)
+        break;
+    }
+    return {
+      result: n,
+      nested: s
+    };
+  }
+  nameDefault() {
+    return "object entries" + St(this._args);
+  }
+}
+class Ze extends _ {
+  _hasExpected = !1;
+  _expected = void 0;
+  get expected() {
+    return this._expected;
+  }
+  set expected(e) {
+    this._expected = e, this._hasExpected = !0;
+  }
+  match(e) {
+    const r = C(e, this._expected), n = [
+      {
+        result: r
+      }
+    ];
+    return {
+      result: r.result,
+      nested: n
+    };
+  }
+  nameDefault() {
+    return "ref";
+  }
+}
+function R(t) {
+  return new Gt({ expected: t });
+}
+function fn(t) {
+  return new Gt({ expected: t, matchType: "includes" });
+}
+function W() {
+  return new Le();
+}
+function hn() {
+  return new Ze();
+}
+function mn(t) {
+  return new Xe({ name: t });
+}
+function pn(t, e) {
+  const r = new Fe({ expected: e });
+  return t == null ? r : k(
+    sr(
+      D(t) || typeof t == "number" ? t : ut(t)
+    ),
+    r
+  ).name("array item");
+}
+function P(t, e, r) {
+  return new Be({ name: t, convert: e, expected: r });
+}
+function tr(t) {
+  return new Ht({ expected: t, nonStrict: !0 });
+}
+function er(t) {
+  return new Ht({ expected: t, nonStrict: !1 });
+}
+function Qt(t) {
+  return new We(t);
+}
+function ut(t) {
+  return Qt({
+    ...t,
+    float: !1
+  });
+}
+function dn(t) {
+  return Qt({
+    ...t,
+    float: !0
+  });
+}
+function z(t) {
+  return new qe({ expected: t });
+}
+function dt(t, e, r = null) {
+  if (t instanceof _ || e && (t = e(t, r), t instanceof _))
+    return t;
+  if (t == null)
+    return st();
+  if (Array.isArray(t)) {
+    const n = t.map((s, i) => dt(s, e, i));
+    return R(n);
+  }
+  if (t.constructor === Object) {
+    const n = {};
+    for (const s in t)
+      Object.prototype.hasOwnProperty.call(t, s) && (n[s] = dt(t[s], e, s));
+    return z(n);
+  }
+  return t instanceof se ? cr({
+    ...t,
+    value: dt(t.value, e, "value")
+  }) : er(t);
+}
+function _n(t) {
+  return z(t).set({
+    ignoreExtraKeys: !0
+  });
+}
+function Xt(t) {
+  return new Je({
+    pattern: t
+  });
+}
+function gn(t) {
+  return new Ge({ expected: t });
+}
+function rr(t) {
+  return P(
+    "typeof",
+    (e) => e === null ? "null" : typeof e,
+    t
+  );
+}
+function yn(t) {
+  return P(
+    "constructor",
+    (e) => e.constructor,
+    t
+  );
+}
+function _t() {
+  return rr("boolean");
+}
+function st() {
+  return tr(null);
+}
+function wn() {
+  return lr(st());
+}
+function bn(...t) {
+  return new at({
+    expecteds: t,
+    type: "or",
+    pipe: !1
+  });
+}
+function Sn(...t) {
+  return new at({
+    expecteds: t,
+    type: "and",
+    pipe: !1
+  });
+}
+function nr(...t) {
+  return new at({
+    expecteds: t,
+    type: "or",
+    pipe: !0
+  });
+}
+function k(...t) {
+  return new at({
+    expecteds: t,
+    type: "and",
+    pipe: !0
+  });
+}
+function V(t, e) {
+  return e == null ? nr(st(), t) : e ? t : st();
+}
+function sr(t) {
+  const e = typeof t == "number" || D(t) ? t : ut(t ?? { min: 1 });
+  return k(
+    R(),
+    P("length", (r) => r.length, e)
+  ).name("array length");
+}
+function xn(t) {
+  const e = typeof t == "number" || D(t) ? t : ut(t ?? { min: 1 });
+  return k(
+    Xt(),
+    P("length", (r) => r.length, e)
+  ).name("string length");
+}
+function En(t) {
+  return k(z(), t);
+}
+function On(t) {
+  return k(R(), t);
+}
+function $n(t) {
+  return k(
+    z(),
+    P(
+      "keys",
+      (e) => Object.keys(e),
+      t
+    )
+  );
+}
+function Mn(t) {
+  return k(
+    z(),
+    P(
+      "values",
+      (e) => Object.values(e),
+      t
+    )
+  );
+}
+function An(t) {
+  return k(
+    z(),
+    P(
+      "entries",
+      (e) => Object.entries(e),
+      t
+    )
+  );
+}
+function xt(t) {
+  return new Ye({ expected: t });
+}
+function Cn(t) {
+  return xt(R([t, W()]));
+}
+function kn(t) {
+  return xt(R([W(), t]));
+}
+function Tn(t, e) {
+  return xt(R([t, e]));
+}
+function In(t) {
+  return k(
+    z(),
+    P(
+      "keys not null",
+      (e) => Object.keys(e).filter((r) => e[r] != null),
+      t
+    )
+  );
+}
+function ir(t) {
+  return new He({ expected: t });
+}
+function Un(t) {
+  return ir(Object.values(t));
+}
+function Yt(t, e) {
+  return new Qe({ matcher: e, name: t });
+}
+const or = Math.ceil(Date.now() - 10 * 365.25 * 24 * 60 * 60 * 1e3), ar = Math.ceil(Date.now() + 10 * 365.25 * 24 * 60 * 60 * 1e3);
+function Y(t) {
+  return ut({
+    ...t,
+    min: t?.min ?? or,
+    max: t?.max ?? ar
+  }).name("int date");
+}
+function ur(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 k(
+    R([
+      e.optional ? V(Y()) : Y(),
+      r.optional ? V(Y()) : Y()
+    ]),
+    Yt("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 Pn(t) {
+  return ur({
+    ...t,
+    common: {
+      min: new Date(2020, 0, 1).getTime(),
+      max: Date.now() + 900 * 1e3,
+      ...t?.common
+    }
+  }).name("range date");
+}
+function lr(t) {
+  return new Bt({ expected: t });
+}
+function zn() {
+  return Xt(/^[\da-f-]{36}|[\da-f]{32}$/i).name("uuid");
+}
+function cr(t) {
+  return z({
+    [Symbol.toStringTag]: V(W()),
+    loading: V(_t()),
+    hasValue: V(_t()),
+    value: W(),
+    hasError: V(_t()),
+    error: W(),
+    ...t
+  });
+}
+function Nn(t) {
+  return t != null && typeof t == "string" && (t = new TextEncoder().encode(t).buffer), Yt("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 Tt(t) {
+  return t.replace(/\W/g, "").toLowerCase();
+}
+function fr(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 hr(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 mr(t) {
+  if (t == null)
+    return null;
+  t = t.trim();
+  const e = parseInt(t, 10);
+  return isNaN(e) ? null : e;
+}
+function pr(t) {
+  if (t == null)
+    return null;
+  t = t.trim();
+  const e = parseFloat(t);
+  return isNaN(e) ? null : e;
+}
+function Et(t, e) {
+  const r = fr(e), n = Tt(t);
+  for (const [s, i] of r.entries())
+    if (Tt(s) === n)
+      return i;
+  return null;
+}
+function vn(t, e) {
+  return hr(Et(t, e));
+}
+function Dn(t, e) {
+  return mr(Et(t, e));
+}
+function Rn(t, e) {
+  return pr(Et(t, e));
+}
+export {
+  j as $,
+  Fr as A,
+  ke as B,
+  $r as C,
+  Te as D,
+  Br as E,
+  Wr as F,
+  qr as G,
+  Pe as H,
+  vt as I,
+  ze as J,
+  Jr as K,
+  Gr as L,
+  Mr as M,
+  Dt as N,
+  Hr as O,
+  Qr as P,
+  Xr as Q,
+  wt as R,
+  Yr as S,
+  Zr as T,
+  mt as U,
+  Nt as V,
+  vr as W,
+  Dr as X,
+  U as Y,
+  Me as Z,
+  Ce as _,
+  Tr as a,
+  _n as a$,
+  Q as a0,
+  $t as a1,
+  Z as a2,
+  Ar as a3,
+  Cr as a4,
+  gt as a5,
+  kr as a6,
+  tn as a7,
+  rn as a8,
+  De as a9,
+  nt as aA,
+  Ke as aB,
+  Lt as aC,
+  Ft as aD,
+  C as aE,
+  Jt as aF,
+  X as aG,
+  cn as aH,
+  je as aI,
+  Wt as aJ,
+  Ve as aK,
+  qt as aL,
+  ot as aM,
+  R as aN,
+  fn as aO,
+  W as aP,
+  hn as aQ,
+  mn as aR,
+  pn as aS,
+  P as aT,
+  tr as aU,
+  er as aV,
+  Qt as aW,
+  ut as aX,
+  dn as aY,
+  z as aZ,
+  dt as a_,
+  nn as aa,
+  sn as ab,
+  B as ac,
+  Kt as ad,
+  en as ae,
+  Ut as af,
+  on as ag,
+  Re as ah,
+  ae as ai,
+  br as aj,
+  Sr as ak,
+  xr as al,
+  ue as am,
+  le as an,
+  Er as ao,
+  Or as ap,
+  I as aq,
+  an as ar,
+  jt as as,
+  un as at,
+  ln as au,
+  v as av,
+  _ as aw,
+  D as ax,
+  it as ay,
+  St as az,
+  ce as b,
+  Xt as b0,
+  gn as b1,
+  rr as b2,
+  yn as b3,
+  _t as b4,
+  st as b5,
+  wn as b6,
+  bn as b7,
+  Sn as b8,
+  nr as b9,
+  Fe as bA,
+  Be as bB,
+  Qe as bC,
+  at as bD,
+  He as bE,
+  Ht as bF,
+  Xe as bG,
+  Bt as bH,
+  We as bI,
+  qe as bJ,
+  Ye as bK,
+  Ze as bL,
+  Je as bM,
+  Ge as bN,
+  fr as bO,
+  hr as bP,
+  mr as bQ,
+  pr as bR,
+  Et as bS,
+  vn as bT,
+  Dn as bU,
+  Rn as bV,
+  k as ba,
+  V as bb,
+  sr as bc,
+  xn as bd,
+  En as be,
+  On as bf,
+  $n as bg,
+  Mn as bh,
+  An as bi,
+  xt as bj,
+  Cn as bk,
+  kn as bl,
+  Tn as bm,
+  In as bn,
+  ir as bo,
+  Un as bp,
+  Yt as bq,
+  Y as br,
+  ur as bs,
+  Pn as bt,
+  lr as bu,
+  zn as bv,
+  cr as bw,
+  Nn as bx,
+  Le as by,
+  Gt as bz,
+  Ur as c,
+  ye as d,
+  we as e,
+  be as f,
+  he as g,
+  Se as h,
+  Pr as i,
+  xe as j,
+  Ee as k,
+  Oe as l,
+  $e as m,
+  zr as n,
+  Mt as o,
+  et as p,
+  Nr as q,
+  Rr as r,
+  Kr as s,
+  Ir as t,
+  jr as u,
+  _e as v,
+  ge as w,
+  pe as x,
+  Vr as y,
+  Lr as z
+};