@flemist/test-variants 5.0.2 → 5.0.4

package/build/createTestVariants-D3rpiTL9.mjs

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