@flemist/test-variants 5.0.0 → 5.0.1

package/build/createTestVariants-BE_TQ9u5.mjs

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