@flemist/test-variants 5.0.15 → 5.0.17

package/build/createTestVariants-CHmhRbUZ.mjs

@@ -0,0 +1,1124 @@
+import { timeControllerDefault as q } from "@flemist/time-controller";
+import { formatAny as ge, Subject as Je, combineAbortSignals as K, isPromiseLike as O, abortSignalToPromise as Xe, deepCloneJsonLike as Ze, waitMicrotasks as Ke } from "@flemist/simple-utils";
+import { AbortError as Qe, AbortControllerFast as Q } from "@flemist/abort-controller-fast";
+import { poolWait as le, Pool as Ye } from "@flemist/time-limits";
+class et extends Error {
+}
+function pe() {
+  if (typeof process < "u" && process.memoryUsage)
+    try {
+      return process.memoryUsage.rss();
+    } catch {
+    }
+  if (typeof performance < "u") {
+    const e = performance.memory;
+    if (e)
+      try {
+        return e.usedJSHeapSize;
+      } catch {
+      }
+  }
+  return null;
+}
+const tt = 1e3, R = [];
+function rt(e) {
+  return ge(e, { pretty: !0, maxDepth: 5, maxItems: 50 });
+}
+function nt(...e) {
+  const t = e.map((r) => typeof r == "string" ? r : rt(r)).join(" ");
+  R.push(t), R.length > tt && R.shift(), console.log(t);
+}
+function it() {
+  return R.join(`
+`);
+}
+globalThis.__getStressTestLogLast = it;
+const he = (e, t) => {
+  nt(t);
+}, be = (e) => ge(e, {
+  pretty: !0,
+  maxDepth: 20,
+  maxItems: 100,
+  maxStringLength: 5e3,
+  dontExpandClassInstances: !0,
+  dontExpandFunctions: !0
+}), I = {
+  replay: !0,
+  start: !0,
+  progress: 5e3,
+  completed: !0,
+  error: !0,
+  modeChange: !0,
+  debug: !1,
+  func: he,
+  format: be
+}, ot = {
+  replay: !1,
+  start: !1,
+  progress: !1,
+  completed: !1,
+  error: !1,
+  modeChange: !1,
+  debug: !1,
+  func: he,
+  format: be
+};
+function ye(e) {
+  return e === !1 ? ot : e === !0 || !e ? I : {
+    replay: e.replay ?? I.replay,
+    start: e.start ?? I.start,
+    progress: e.progress ?? I.progress,
+    completed: e.completed ?? I.completed,
+    error: e.error ?? I.error,
+    modeChange: e.modeChange ?? I.modeChange,
+    debug: e.debug ?? I.debug,
+    func: e.func ?? I.func,
+    format: e.format ?? I.format
+  };
+}
+function st(e, t) {
+  const r = e.now();
+  return {
+    startTime: r,
+    startMemory: t,
+    debugMode: !1,
+    tests: 0,
+    iterations: 0,
+    iterationsAsync: 0,
+    maxTestDuration: 0,
+    prevLogTime: r,
+    prevLogMemory: t,
+    pendingModeChange: null,
+    prevGcTime: r,
+    prevGcIterations: 0,
+    prevGcIterationsAsync: 0
+  };
+}
+class V extends Qe {
+}
+class at {
+  _timeController;
+  _subject;
+  _interval;
+  _timer;
+  constructor(t, r) {
+    this._interval = t, this._timeController = r ?? q, this._subject = new Je({
+      startStopNotifier: () => (this.update(), () => {
+        this._timeController.clearTimeout(this._timer);
+      })
+    });
+  }
+  update() {
+    this._subject.emit(this._timeController.now()), this._timer = this._timeController.setTimeout(
+      () => this.update(),
+      this._interval
+    );
+  }
+  get interval() {
+    return this._interval;
+  }
+  set interval(t) {
+    this._interval = t, this._timer && (this._timeController.clearTimeout(this._timer), this.update());
+  }
+  subscribe(t) {
+    return this._subject.subscribe(t);
+  }
+}
+const lt = 50, ut = 5;
+function ct(e, t) {
+  return e == null ? null : typeof e == "number" ? e : e(t) ?? null;
+}
+function ue(e, t) {
+  return typeof e == "number" ? { iterationsAsync: 0, iterationsSync: e } : e != null && typeof e == "object" ? e : t ? { iterationsAsync: 1, iterationsSync: 0 } : { iterationsAsync: 0, iterationsSync: 1 };
+}
+function ft(e, t) {
+  const r = t.log, o = t.pauseDebuggerOnError ?? !0, i = t.onStart, s = t.onEnd, n = t.state;
+  let l = null, c = 0;
+  function d(v, b, f) {
+    l == null && (l = { error: v, args: b, tests: f }, r.error && r.func(
+      "error",
+      `[test-variants] error variant: ${r.format(b)}
+tests: ${f}
+${r.format(v)}`
+    ));
+    const h = Date.now();
+    if (o)
+      debugger;
+    if (Date.now() - h > lt && c < ut) {
+      r.func(
+        "debug",
+        `[test-variants] debug iteration: ${c}`
+      ), c++;
+      return;
+    }
+    const E = l;
+    throw l = null, t.onError && t.onError(E), E.error;
+  }
+  const g = new at(100);
+  return function(b, f, h) {
+    i && i({ args: b, tests: f });
+    const S = ct(t.timeout, b), E = Date.now();
+    let m = h, x = null;
+    S && (x = new Q(), m = {
+      abortSignal: K(
+        h.abortSignal,
+        x.signal
+      ),
+      timeController: h.timeController
+    });
+    function C() {
+      x.abort(
+        new et(
+          `[test-variants] test timeout ${S}ms exceeded`
+        )
+      );
+    }
+    function w() {
+      const y = Date.now() - E;
+      y > n.maxTestDuration && (n.maxTestDuration = y);
+    }
+    try {
+      let y = e(b, m);
+      if (O(y)) {
+        let _ = null;
+        return x && (_ = g.subscribe(() => {
+          Date.now() - E > S && (C(), _());
+        }), y = Promise.race([
+          y,
+          Xe(x.signal)
+        ])), y.then(
+          (A) => {
+            _?.(), w();
+            const D = ue(A, !0);
+            return s && s({ args: b, tests: f, result: D }), D;
+          },
+          (A) => (_?.(), w(), s && !(A instanceof V) && s({ args: b, tests: f, error: A }), d(A, b, f))
+        );
+      }
+      w(), x && Date.now() - E > S && (C(), x.signal.throwIfAborted());
+      const U = ue(y, !1);
+      return s && s({ args: b, tests: f, result: U }), U;
+    } catch (y) {
+      return w(), y instanceof V ? void 0 : (s && s({ args: b, tests: f, error: y }), d(y, b, f));
+    }
+  };
+}
+function j(e, t, r) {
+  for (let o = 0, i = e.length; o < i; o++)
+    if (r ? r(e[o], t) : e[o] === t)
+      return o;
+  return -1;
+}
+function ce(e, t, r, o) {
+  const i = Object.keys(e.templates), s = {}, n = [], l = [], c = [], d = i.length;
+  for (let g = 0; g < d; g++) {
+    const v = i[g];
+    s[v] = void 0, n.push(-1), l.push(void 0), c.push(null);
+  }
+  return {
+    args: s,
+    argsNames: i,
+    indexes: n,
+    argValues: l,
+    argLimits: c,
+    attempts: 0,
+    templates: e,
+    limitArgOnError: r,
+    equals: t,
+    includeErrorVariant: o ?? !1
+  };
+}
+function P(e, t) {
+  const r = e.templates.templates[t], o = e.templates.extra[t];
+  let i;
+  if (typeof r == "function" ? i = r(e.args) : i = r, o == null)
+    return i;
+  let s = null;
+  const n = o.length;
+  for (let l = 0; l < n; l++) {
+    const c = o[l];
+    j(i, c, e.equals) < 0 && (s == null ? s = [...i, c] : s.push(c));
+  }
+  return s ?? i;
+}
+function M(e, t, r) {
+  const o = e.argValues[t].length;
+  if (o === 0)
+    return -1;
+  const i = e.argLimits[t];
+  if (i == null)
+    return o - 1;
+  let s = e.limitArgOnError;
+  if (typeof s == "function") {
+    const n = e.argsNames[t];
+    s = s({
+      name: n,
+      values: e.argValues[t],
+      maxValueIndex: i
+    });
+  }
+  return !r || s ? Math.min(i, o - 1) : o - 1;
+}
+function L(e) {
+  const t = e.indexes.length;
+  for (let r = 0; r < t; r++) {
+    const o = e.argLimits[r];
+    if (o == null)
+      return !1;
+    const i = e.indexes[r];
+    if (i > o)
+      return !0;
+    if (i < o)
+      return !1;
+  }
+  return !e.includeErrorVariant;
+}
+function $(e) {
+  const t = e.indexes.length;
+  for (let r = 0; r < t; r++)
+    e.indexes[r] = -1, e.argValues[r] = void 0, e.args[e.argsNames[r]] = void 0;
+}
+function ve(e) {
+  let t = !1, r = !0;
+  const o = e.indexes.length;
+  let i = o, s = !1, n = 0;
+  for (; n < o; n++) {
+    const l = e.argValues[n] == null;
+    (l || s) && (l && (t = !0), e.argValues[n] = P(
+      e,
+      e.argsNames[n]
+    ));
+    const c = M(
+      e,
+      n,
+      n > i
+    );
+    if (c < 0) {
+      r = !1, e.indexes[n] = -1;
+      break;
+    }
+    l && (e.indexes[n] = 0, e.args[e.argsNames[n]] = e.argValues[n][0]), (s || e.indexes[n] > c) && (e.indexes[n] = c, e.args[e.argsNames[n]] = e.argValues[n][c], s = !0), i === o && e.indexes[n] < c && (i = n);
+  }
+  if (L(e))
+    return $(e), !1;
+  if (t && r)
+    return !0;
+  for (n--; n >= 0; n--) {
+    if (e.argValues[n] == null)
+      continue;
+    let l = n > i;
+    const c = M(e, n, l), d = e.indexes[n] + 1;
+    if (d <= c) {
+      e.indexes[n] = d, e.args[e.argsNames[n]] = e.argValues[n][d], d < c && (l = !0);
+      for (let g = n + 1; g < o; g++)
+        e.args[e.argsNames[g]] = void 0;
+      for (n++; n < o; n++) {
+        e.argValues[n] = P(
+          e,
+          e.argsNames[n]
+        );
+        const g = M(e, n, l);
+        if (g < 0)
+          break;
+        e.indexes[n] = 0, e.args[e.argsNames[n]] = e.argValues[n][0], g > 0 && (l = !0);
+      }
+      if (n >= o)
+        return L(e) ? ($(e), !1) : !0;
+    }
+  }
+  return $(e), !1;
+}
+function Y(e) {
+  L(e) && $(e);
+  let t = !1, r = !0;
+  const o = e.indexes.length;
+  let i = o, s = !1, n = 0;
+  for (; n < o; n++) {
+    const l = e.argValues[n] == null;
+    (l || s) && (l && (t = !0), e.argValues[n] = P(
+      e,
+      e.argsNames[n]
+    ));
+    const c = M(
+      e,
+      n,
+      n > i
+    );
+    if (c < 0) {
+      r = !1, e.indexes[n] = -1;
+      break;
+    }
+    l && (e.indexes[n] = c, e.args[e.argsNames[n]] = e.argValues[n][c]), (s || e.indexes[n] > c) && (e.indexes[n] = c, e.args[e.argsNames[n]] = e.argValues[n][c], s = !0), i === o && e.indexes[n] < c && (i = n);
+  }
+  if ((t || s) && r && !L(e))
+    return !0;
+  for (n--; n >= 0; n--) {
+    if (e.argValues[n] == null)
+      continue;
+    let l = n > i;
+    const c = M(e, n, l);
+    let d = e.indexes[n] - 1;
+    if (d > c && (d = c), d >= 0) {
+      e.indexes[n] = d, e.args[e.argsNames[n]] = e.argValues[n][d], d < c && (l = !0);
+      for (let g = n + 1; g < o; g++)
+        e.args[e.argsNames[g]] = void 0;
+      for (n++; n < o; n++) {
+        e.argValues[n] = P(
+          e,
+          e.argsNames[n]
+        );
+        const g = M(e, n, l);
+        if (g < 0)
+          break;
+        e.indexes[n] = g, e.args[e.argsNames[n]] = e.argValues[n][g], g > 0 && (l = !0);
+      }
+      if (n >= o)
+        return !0;
+    }
+  }
+  return $(e), !1;
+}
+function mt(e, t) {
+  $(e);
+  const r = e.argsNames, o = r.length;
+  let i = !1;
+  for (let s = 0; s < o; s++) {
+    const n = r[s], l = t[n];
+    if (l === void 0)
+      return null;
+    e.argValues[s] = P(e, n);
+    const c = M(e, s, i);
+    if (c < 0)
+      return null;
+    const d = j(
+      e.argValues[s],
+      l,
+      e.equals
+    );
+    if (d < 0 || d > c)
+      return null;
+    e.indexes[s] = d, e.args[e.argsNames[s]] = e.argValues[s][d], e.indexes[s] < c && (i = !0);
+  }
+  return L(e) ? null : e.indexes.slice();
+}
+function dt(e) {
+  const t = e.indexes.length;
+  if (t === 0)
+    return !1;
+  let r = !1;
+  for (let o = 0; o < t; o++) {
+    e.argValues[o] = P(e, e.argsNames[o]);
+    const i = M(e, o, r);
+    if (i < 0)
+      return Math.random() < 0.5 ? ve(e) : Y(e);
+    e.indexes[o] = Math.floor(Math.random() * (i + 1)), e.args[e.argsNames[o]] = e.argValues[o][e.indexes[o]], e.indexes[o] < i && (r = !0);
+  }
+  return L(e) ? Y(e) : !0;
+}
+function F(e) {
+  return e.mode === "forward" || e.mode === "backward";
+}
+function gt(e, t, r, o) {
+  const i = t[r], s = e.templates[r];
+  if (typeof s != "function") {
+    if (j(s, i, o) >= 0)
+      return;
+    s.push(i);
+    return;
+  }
+  const n = e.extra[r];
+  if (n == null) {
+    e.extra[r] = [i];
+    return;
+  }
+  j(n, i, o) >= 0 || n.push(i);
+}
+function pt(e, t, r) {
+  for (const o in t)
+    if (Object.prototype.hasOwnProperty.call(t, o)) {
+      if (o === "seed")
+        continue;
+      gt(e, t, o, r);
+    }
+}
+function fe(e, t) {
+  for (const r in t)
+    if (Object.prototype.hasOwnProperty.call(t, r)) {
+      if (r === "seed")
+        continue;
+      if (!e[r])
+        return !1;
+    }
+  return !0;
+}
+const ht = [{ mode: "forward" }];
+function bt(e) {
+  const {
+    argsTemplates: t,
+    equals: r,
+    limitArgOnError: o,
+    includeErrorVariant: i,
+    getSeed: s,
+    iterationModes: n,
+    onModeChange: l,
+    limitCompletionCount: c,
+    limitTests: d,
+    limitTime: g
+  } = e, v = e.timeControllerInternal ?? q, b = {
+    templates: Ze(t),
+    extra: {}
+  }, f = n == null || n.length === 0 ? ht : n, h = [];
+  let S = null, E = null, m = 0, x = 0, C = !1, w = 0;
+  function y() {
+    C || (C = !0, w = v.now(), U(), m = 0, D(), A());
+  }
+  function U() {
+    for (let a = 0, u = f.length; a < u; a++)
+      h.push(_());
+  }
+  function _() {
+    return {
+      navigationState: ce(
+        b,
+        r ?? null,
+        o ?? null,
+        i ?? null
+      ),
+      cycleCount: 0,
+      completedCount: 0,
+      testsInLastTurn: 0,
+      tryNextVariantAttempts: 0,
+      startTime: null
+    };
+  }
+  function A() {
+    S = ce(
+      b,
+      r ?? null,
+      // Initial values; overwritten in calcIndexes before each use
+      !1,
+      !1
+    );
+  }
+  function D() {
+    l?.({
+      mode: f[m],
+      modeIndex: m,
+      tests: x
+    });
+  }
+  function Te(a) {
+    y(), fe(b.templates, a) && pt(b, a, r);
+  }
+  function se(a, u) {
+    return y(), fe(b.templates, a) ? (S.limitArgOnError = u?.limitArg ?? o ?? null, S.includeErrorVariant = u?.includeLimit ?? i ?? !1, mt(S, a)) : null;
+  }
+  function Ie(a) {
+    const u = a?.args;
+    if (u == null)
+      return;
+    y();
+    const p = se(u);
+    if (p != null) {
+      E = {
+        args: u,
+        error: a?.error,
+        tests: a?.tests ?? x
+      }, S.argLimits = p;
+      for (let T = 0, k = h.length; T < k; T++) {
+        const X = h[T].navigationState;
+        X.argLimits = p;
+      }
+    }
+  }
+  function Me() {
+    return y(), Ve();
+  }
+  function Ve() {
+    for (; ; ) {
+      if (!Ce())
+        return null;
+      for (; ; ) {
+        const a = qe();
+        if (a != null)
+          return h[m].testsInLastTurn++, x++, a;
+        if ($e()) {
+          if (!Pe())
+            return null;
+          Ge();
+          break;
+        }
+      }
+    }
+  }
+  function Ce() {
+    return !(Ae() || Oe() || B() && (Le() || !_e()) || !Ne());
+  }
+  function Ae() {
+    return d != null && x >= d;
+  }
+  function Oe() {
+    return g != null && v.now() - w >= g;
+  }
+  function Le() {
+    if (!B())
+      throw new Error("Unexpected behavior");
+    return c != null && c <= 0;
+  }
+  function _e() {
+    if (!B())
+      throw new Error("Unexpected behavior");
+    for (let a = 0, u = f.length; a < u; a++)
+      if (N(f[a]) && H(a))
+        return !0;
+    return !1;
+  }
+  function Ne() {
+    for (let a = 0, u = f.length; a < u; a++)
+      if (H(a))
+        return !0;
+    return !1;
+  }
+  function $e() {
+    m++;
+    const a = m >= f.length;
+    return a && (m = 0), D(), a;
+  }
+  function Pe() {
+    if (B()) {
+      const a = De();
+      if (c != null && a >= c)
+        return !1;
+    }
+    return !0;
+  }
+  function B() {
+    for (let a = 0, u = f.length; a < u; a++)
+      if (F(f[a]))
+        return !0;
+    return !1;
+  }
+  function De() {
+    let a = !1, u = 1 / 0;
+    for (let p = 0, T = h.length; p < T; p++) {
+      const k = h[p], X = f[p];
+      F(X) && (a = !0, H(p) && k.completedCount < u && (u = k.completedCount));
+    }
+    if (!a)
+      throw new Error("Unexpected behavior");
+    return u;
+  }
+  function H(a) {
+    const u = f[a], p = h[a];
+    return u.limitTests != null && u.limitTests <= 0 || N(u) && (u.cycles != null && u.cycles <= 0 || u.attemptsPerVariant != null && u.attemptsPerVariant <= 0) ? !1 : p.tryNextVariantAttempts < 2;
+  }
+  function Ge() {
+    m = 0;
+    for (let a = 0, u = h.length; a < u; a++) {
+      const p = h[a];
+      p.testsInLastTurn = 0, p.startTime = null;
+    }
+  }
+  function qe() {
+    let a = 0;
+    for (; a < 2; ) {
+      if (!Ue())
+        return null;
+      const u = je();
+      if (u != null)
+        return u;
+      if (N(f[m]) && Re())
+        return null;
+      a++;
+    }
+    return null;
+  }
+  function Ue() {
+    const a = f[m];
+    return !(Be() || ke() || N(a) && !Fe(m));
+  }
+  function Be() {
+    const a = f[m], u = h[m];
+    return a.limitTests != null && u.testsInLastTurn >= a.limitTests;
+  }
+  function ke() {
+    const a = f[m], u = h[m];
+    return a.limitTime != null && u.startTime != null && v.now() - u.startTime >= a.limitTime;
+  }
+  function N(a) {
+    return F(a);
+  }
+  function Fe(a) {
+    const u = f[a], p = h[a];
+    if (!N(u))
+      throw new Error("Unexpected behavior");
+    return p.cycleCount < (u.cycles ?? 1);
+  }
+  function Re() {
+    const a = f[m], u = h[m];
+    if (!N(a))
+      throw new Error("Unexpected behavior");
+    return u.cycleCount++, u.cycleCount >= (a.cycles ?? 1) ? (u.cycleCount = 0, u.completedCount++, !0) : !1;
+  }
+  function je() {
+    const a = f[m], u = h[m], p = u.navigationState;
+    if (G(a)) {
+      if (J())
+        return null;
+      const T = We();
+      if (T != null)
+        return u.startTime == null && (u.startTime = v.now()), T;
+    }
+    return He() ? (u.tryNextVariantAttempts = 0, G(a) && ze(), u.startTime == null && (u.startTime = v.now()), ae(p.args)) : (u.tryNextVariantAttempts++, null);
+  }
+  function We() {
+    const a = f[m], p = h[m].navigationState;
+    if (!G(a))
+      throw new Error("Unexpected behavior");
+    if (J())
+      throw new Error("Unexpected behavior");
+    const T = a.attemptsPerVariant ?? 1;
+    return p.attempts > 0 && p.attempts < T ? L(p) ? null : (p.attempts++, ae(p.args)) : null;
+  }
+  function ze() {
+    const a = f[m], p = h[m].navigationState;
+    if (!G(a))
+      throw new Error("Unexpected behavior");
+    if (J())
+      throw new Error("Unexpected behavior");
+    p.attempts = 1;
+  }
+  function G(a) {
+    return F(a);
+  }
+  function J() {
+    const a = f[m];
+    if (!G(a))
+      throw new Error("Unexpected behavior");
+    return (a.attemptsPerVariant ?? 1) <= 0;
+  }
+  function He() {
+    const a = f[m], p = h[m].navigationState;
+    switch (a.mode) {
+      case "forward":
+        return ve(p);
+      case "backward":
+        return Y(p);
+      case "random":
+        return dt(p);
+      default:
+        throw new Error(`Unknown mode: ${a.mode}`);
+    }
+  }
+  function ae(a) {
+    const u = { ...a };
+    return s != null && (u.seed = s({ tests: x })), u;
+  }
+  return {
+    get limit() {
+      return E;
+    },
+    get modeIndex() {
+      return m;
+    },
+    get modeConfigs() {
+      return f;
+    },
+    get modeStates() {
+      return h;
+    },
+    get tests() {
+      return x;
+    },
+    calcIndexes: se,
+    extendTemplates: Te,
+    addLimit: Ie,
+    next: Me
+  };
+}
+function oe(e) {
+  if (e == null || e <= 0)
+    throw new Error(`Iterations = ${e}`);
+  e--;
+  const t = Ke().then(() => e);
+  return e <= 0 ? t : t.then(oe);
+}
+function yt(e, t, r) {
+  const o = t.limit ? {
+    error: t.limit.error,
+    args: t.limit.args,
+    tests: t.limit.tests
+  } : null;
+  if (o && !r)
+    throw o.error;
+  return {
+    iterations: e.iterations,
+    bestError: o
+  };
+}
+const me = 2 ** 31;
+function vt(e) {
+  if (e == null)
+    return { parallel: 1, sequentialOnError: !1 };
+  if (typeof e == "boolean")
+    return {
+      parallel: e ? me : 1,
+      sequentialOnError: !1
+    };
+  if (typeof e == "number")
+    return { parallel: e > 0 ? e : 1, sequentialOnError: !1 };
+  const t = e.count;
+  let r = 1;
+  return t === !0 ? r = me : typeof t == "number" && t > 0 && (r = t), {
+    parallel: r,
+    sequentialOnError: e.sequentialOnError ?? !1
+  };
+}
+function xt(e) {
+  const t = e?.saveErrorVariants, r = t && e.createSaveErrorVariantsStore ? e.createSaveErrorVariantsStore(t) : null, o = e?.findBestError, { parallel: i, sequentialOnError: s } = vt(
+    e?.parallel
+  );
+  return {
+    store: r,
+    GC_Iterations: e?.GC_Iterations ?? 1e6,
+    GC_IterationsAsync: e?.GC_IterationsAsync ?? 1e4,
+    GC_Interval: e?.GC_Interval ?? 1e3,
+    logOptions: ye(e?.log),
+    abortSignalExternal: e?.abortSignal,
+    findBestError: o,
+    dontThrowIfError: o?.dontThrowIfError,
+    timeController: e?.timeController ?? q,
+    timeControllerInternal: e?.timeControllerInternal ?? q,
+    parallel: i,
+    sequentialOnError: s
+  };
+}
+function W(e, t, r) {
+  const { options: o, variantsIterator: i } = e, s = i.limit?.args ?? t;
+  if (!o.store)
+    return;
+  const n = o.store.save(s);
+  if (r)
+    return n;
+}
+function St(e, t, r, o) {
+  const { abortControllerParallel: i, state: s, options: n } = e, { logOptions: l } = n;
+  if (e.options.findBestError)
+    e.variantsIterator.addLimit({ args: t, error: r, tests: o }), s.debugMode = !1, W(e, t, !1), n.sequentialOnError && !i.signal.aborted ? (l.debug && l.func(
+      "debug",
+      "[test-variants] sequentialOnError: aborting parallel, switching to sequential"
+    ), i.abort(new V())) : l.debug && l.func(
+      "debug",
+      "[test-variants] parallel error in findBestError mode, continuing with new limits"
+    );
+  else {
+    if (i.signal.aborted)
+      return;
+    W(e, t, !1), i.abort(r);
+  }
+}
+function de(e, t, r, o) {
+  const { state: i } = e;
+  if (e.options.findBestError) {
+    e.variantsIterator.addLimit({ args: t, error: r, tests: o });
+    const n = W(e, t, !0);
+    if (n)
+      return n.then(() => {
+        i.debugMode = !1;
+      });
+    i.debugMode = !1;
+    return;
+  }
+  const s = W(e, t, !0);
+  if (s)
+    return s.then(() => {
+      throw r;
+    });
+  throw r;
+}
+function Et(e, t) {
+  const { GC_Iterations: r, GC_IterationsAsync: o, GC_Interval: i } = e.options;
+  return r > 0 && e.state.iterations - e.state.prevGcIterations >= r || o > 0 && e.state.iterationsAsync - e.state.prevGcIterationsAsync >= o || i > 0 && t - e.state.prevGcTime >= i;
+}
+async function wt(e, t) {
+  e.prevGcIterations = e.iterations, e.prevGcIterationsAsync = e.iterationsAsync, e.prevGcTime = t, await oe(1);
+}
+function ee(e) {
+  const t = e / 1e3;
+  if (t < 0.1)
+    return `${t.toFixed(3)}s`;
+  if (t < 1)
+    return `${t.toFixed(2)}s`;
+  if (t < 10)
+    return `${t.toFixed(1)}s`;
+  if (t < 60)
+    return `${t.toFixed(0)}s`;
+  const r = t / 60;
+  if (r < 10)
+    return `${r.toFixed(1)}m`;
+  if (r < 60)
+    return `${r.toFixed(0)}m`;
+  const o = r / 60;
+  return o < 10 ? `${o.toFixed(1)}h` : `${o.toFixed(0)}h`;
+}
+function te(e) {
+  const t = e / 1073741824;
+  if (t >= 1)
+    return t >= 10 ? `${Math.round(t)}GB` : `${t.toFixed(1)}GB`;
+  const r = e / (1024 * 1024);
+  return r >= 10 ? `${Math.round(r)}MB` : `${r.toFixed(1)}MB`;
+}
+function Tt(e, t) {
+  const r = e - t, o = r >= 0 ? "+" : "";
+  return `${te(e)} (${o}${te(r)})`;
+}
+function xe(e, t, r, o, i) {
+  let s = `tests: ${e} (${ee(t)}), maxTime: ${ee(r)}, async: ${o}`, n = null;
+  return i != null && (n = pe(), n != null && (s += `, memory: ${Tt(n, i)}`)), { message: s, memory: n };
+}
+function It(e, t) {
+  if (!e)
+    return `mode[${t}]: null`;
+  let r = `mode[${t}]: ${e.mode}`;
+  return (e.mode === "forward" || e.mode === "backward") && (e.cycles != null && (r += `, cycles=${e.cycles}`), e.attemptsPerVariant != null && (r += `, attempts=${e.attemptsPerVariant}`)), e.limitTime != null && (r += `, limitTime=${ee(e.limitTime)}`), e.limitTests != null && (r += `, limitTests=${e.limitTests}`), r;
+}
+function Mt(e, t) {
+  if (!e.start)
+    return;
+  let r = "[test-variants] start";
+  t != null && (r += `, memory: ${te(t)}`), e.func("start", r);
+}
+function Vt(e) {
+  const { options: t, state: r } = e, { logOptions: o, timeControllerInternal: i } = t;
+  if (!o.completed)
+    return;
+  const s = i.now() - r.startTime, n = xe(r.tests, s, r.maxTestDuration, r.iterationsAsync, r.startMemory);
+  o.func("completed", `[test-variants] end, ${n.message}`);
+}
+function Se(e) {
+  const { options: t, state: r } = e, { logOptions: o } = t, i = r.pendingModeChange;
+  !o.modeChange || i == null || (o.func(
+    "modeChange",
+    `[test-variants] ${It(i.mode, i.modeIndex)}`
+  ), r.pendingModeChange = null);
+}
+function Ct(e) {
+  const { options: t, state: r } = e, { logOptions: o, timeControllerInternal: i } = t, s = i.now();
+  if (!o.progress || s - r.prevLogTime < o.progress)
+    return !1;
+  Se(e);
+  const n = s - r.startTime, l = xe(r.tests, n, r.maxTestDuration, r.iterationsAsync, r.prevLogMemory);
+  return l.memory != null && (r.prevLogMemory = l.memory), o.func("progress", `[test-variants] ${l.message}`), r.prevLogTime = s, !0;
+}
+function re(e, t) {
+  e.debugMode = !1, t && (e.iterationsAsync += t.iterationsAsync, e.iterations += t.iterationsSync + t.iterationsAsync);
+}
+function ne(e) {
+  e.state.debugMode = !0, e.abortControllerParallel.abort(new V());
+}
+function Ee(e, t) {
+  const { testRun: r, testOptions: o, state: i } = e, s = i.tests;
+  i.tests++;
+  try {
+    const n = r(t, s, o);
+    if (O(n))
+      return n.then(
+        (l) => {
+          if (!l) {
+            ne(e);
+            return;
+          }
+          re(i, l);
+        },
+        (l) => de(e, t, l, s)
+      );
+    if (!n) {
+      ne(e);
+      return;
+    }
+    re(i, n);
+  } catch (n) {
+    return n instanceof V ? void 0 : de(e, t, n, s);
+  }
+}
+function At(e, t) {
+  const { pool: r, abortSignal: o, testRun: i, testOptionsParallel: s, state: n } = e;
+  if (!r)
+    return;
+  const l = n.tests;
+  n.tests++, (async () => {
+    try {
+      if (o.aborted)
+        return;
+      let c = i(t, l, s);
+      if (O(c) && (c = await c), !c) {
+        ne(e);
+        return;
+      }
+      re(n, c);
+    } catch (c) {
+      if (c instanceof V)
+        return;
+      St(e, t, c, l);
+    } finally {
+      r.release(1);
+    }
+  })();
+}
+function we(e) {
+  const { options: t, state: r } = e, { logOptions: o, timeControllerInternal: i, GC_Interval: s } = t;
+  if (!o.progress && !s)
+    return;
+  Ct(e);
+  const n = i.now();
+  if (Et(e, n))
+    return wt(r, n);
+}
+function z(e) {
+  return e.options.abortSignalExternal?.aborted ?? !1;
+}
+function ie(e) {
+  return e.abortSignal.aborted;
+}
+async function Z(e, t) {
+  const { pool: r, state: o, options: i } = e, { parallel: s, logOptions: n } = i;
+  let l = null;
+  for (; !z(e); ) {
+    const c = r && !ie(e);
+    let d = !1;
+    c && (r.hold(1) || await le({ pool: r, count: 1, hold: !0 }), d = !0);
+    try {
+      if (t != null ? (l = t, t = null) : e.state.debugMode || (l = e.variantsIterator.next()), l == null)
+        break;
+      const g = we(e);
+      if (O(g) && await g, z(e))
+        continue;
+      if (c)
+        At(e, l), d = !1;
+      else {
+        n.debug && r && ie(e) && n.func(
+          "debug",
+          `[test-variants] parallel aborted, running sequential: tests=${o.tests}`
+        );
+        const v = Ee(e, l);
+        O(v) && await v;
+      }
+    } finally {
+      d && r.release(1);
+    }
+  }
+  r && (await le({ pool: r, count: s, hold: !0 }), r.release(s));
+}
+function Ot(e) {
+  const { pool: t, state: r, options: o } = e, { logOptions: i } = o;
+  if (t)
+    return Z(e);
+  let s = null;
+  for (; !z(e) && (e.state.debugMode || (s = e.variantsIterator.next()), s != null); ) {
+    const n = we(e);
+    if (O(n))
+      return n.then(() => Z(e, s));
+    if (z(e))
+      continue;
+    i.debug && ie(e) && i.func(
+      "debug",
+      `[test-variants] parallel aborted, running sequential: tests=${r.tests}`
+    );
+    const l = Ee(e, s);
+    if (O(l))
+      return l.then(() => Z(e));
+  }
+}
+async function Lt(e, t, r, o) {
+  const i = xt(o), {
+    store: s,
+    logOptions: n,
+    abortSignalExternal: l,
+    findBestError: c,
+    dontThrowIfError: d,
+    timeController: g,
+    timeControllerInternal: v,
+    parallel: b
+  } = i, f = new Q(), h = new Q(), S = K(
+    l,
+    f.signal
+  ), E = K(
+    S,
+    h.signal
+  ), m = {
+    abortSignal: S,
+    timeController: g
+  }, x = {
+    abortSignal: E,
+    timeController: g
+  };
+  s && await s.replay({
+    testRun: e,
+    variantsIterator: t,
+    testOptions: m,
+    findBestErrorEnabled: !!c,
+    state: r,
+    logOptions: n,
+    timeControllerInternal: v
+  });
+  const C = b <= 1 ? null : new Ye(b);
+  Mt(n, r.startMemory);
+  const w = {
+    options: i,
+    testRun: e,
+    variantsIterator: t,
+    testOptions: m,
+    testOptionsParallel: x,
+    abortControllerGlobal: f,
+    abortControllerParallel: h,
+    abortSignal: E,
+    pool: C,
+    state: r
+  };
+  Se(w);
+  try {
+    await Ot(w), E.throwIfAborted();
+  } catch (y) {
+    throw f.abort(new V()), y;
+  }
+  return S.throwIfAborted(), f.abort(new V()), Vt(w), await oe(1), yt(r, t, d);
+}
+function Gt(e) {
+  return function(r) {
+    return async function(i) {
+      const s = ye(i?.log), n = i?.timeControllerInternal ?? q, l = pe(), c = st(n, l), d = ft(e, {
+        onStart: i?.onStart,
+        onEnd: i?.onEnd,
+        onError: i?.onError,
+        log: s,
+        pauseDebuggerOnError: i?.pauseDebuggerOnError,
+        timeout: i?.timeout,
+        state: c
+      }), g = i?.onModeChange;
+      function v(f) {
+        c.pendingModeChange = f, g?.(f);
+      }
+      const b = bt({
+        argsTemplates: r,
+        getSeed: i?.getSeed,
+        iterationModes: i?.iterationModes,
+        equals: i?.findBestError?.equals,
+        limitArgOnError: i?.findBestError?.limitArgOnError,
+        includeErrorVariant: i?.findBestError?.includeErrorVariant,
+        timeControllerInternal: n,
+        onModeChange: v,
+        limitCompletionCount: i?.cycles ?? 1,
+        limitTests: i?.limitTests,
+        limitTime: i?.limitTime
+      });
+      return Lt(d, b, c, i);
+    };
+  };
+}
+export {
+  et as T,
+  xe as a,
+  Gt as c,
+  te as f,
+  pe as g
+};