vitest 0.9.2 → 0.10.0

package/dist/entry.js

@@ -1,924 +1,20 @@
-import { promises } from 'fs';
-import { g as getWorkerState, t as toArray, m as relative, D as partitionSuiteChildren, E as hasTests, q as hasFailed, p as getFullName, r as resetModules } from './chunk-utils-global.10dcdfa6.js';
-import { Console } from 'console';
-import { Writable } from 'stream';
-import { importModule } from 'local-pkg';
-import { r as resetRunOnceCounter, i as index, R as RealDate, c as clearContext, d as defaultSuite, s as setHooks, g as getHooks, a as context, b as getSnapshotClient, e as setState, f as getFn, h as getState, v as vi } from './chunk-runtime-chain.94cf66a4.js';
-import { r as rpc } from './chunk-runtime-rpc.4b80b6bd.js';
-import { c as clearTimeout, s as setTimeout, d as stringify } from './chunk-utils-timers.4800834c.js';
-import { t as takeCoverage } from './chunk-defaults.9aa0ce42.js';
-import { createHash } from 'crypto';
-import { format } from 'util';
-import 'path';
+export { r as run } from './vendor-entry.369fd6c9.js';
+import 'fs';
+import './chunk-utils-global.37a7c822.js';
 import 'tty';
+import 'local-pkg';
+import 'path';
+import 'console';
+import 'stream';
+import './chunk-runtime-chain.f863f182.js';
 import 'chai';
-import './vendor-_commonjsHelpers.34b404ce.js';
-import './spy.js';
+import './vendor-_commonjsHelpers.addc3445.js';
+import './chunk-runtime-rpc.8f648236.js';
+import './chunk-utils-timers.12bc05d1.js';
+import './chunk-integrations-spy.f036df6f.js';
 import 'tinyspy';
+import 'util';
+import './chunk-defaults.04d5d90b.js';
 import 'module';
 import 'url';
-
-var node = {
-  name: "node",
-  async setup() {
-    return {
-      teardown() {
-      }
-    };
-  }
-};
-
-const LIVING_KEYS = [
-  "DOMException",
-  "URL",
-  "URLSearchParams",
-  "EventTarget",
-  "NamedNodeMap",
-  "Node",
-  "Attr",
-  "Element",
-  "DocumentFragment",
-  "DOMImplementation",
-  "Document",
-  "XMLDocument",
-  "CharacterData",
-  "Text",
-  "CDATASection",
-  "ProcessingInstruction",
-  "Comment",
-  "DocumentType",
-  "NodeList",
-  "HTMLCollection",
-  "HTMLOptionsCollection",
-  "DOMStringMap",
-  "DOMTokenList",
-  "StyleSheetList",
-  "HTMLElement",
-  "HTMLHeadElement",
-  "HTMLTitleElement",
-  "HTMLBaseElement",
-  "HTMLLinkElement",
-  "HTMLMetaElement",
-  "HTMLStyleElement",
-  "HTMLBodyElement",
-  "HTMLHeadingElement",
-  "HTMLParagraphElement",
-  "HTMLHRElement",
-  "HTMLPreElement",
-  "HTMLUListElement",
-  "HTMLOListElement",
-  "HTMLLIElement",
-  "HTMLMenuElement",
-  "HTMLDListElement",
-  "HTMLDivElement",
-  "HTMLAnchorElement",
-  "HTMLAreaElement",
-  "HTMLBRElement",
-  "HTMLButtonElement",
-  "HTMLCanvasElement",
-  "HTMLDataElement",
-  "HTMLDataListElement",
-  "HTMLDetailsElement",
-  "HTMLDialogElement",
-  "HTMLDirectoryElement",
-  "HTMLFieldSetElement",
-  "HTMLFontElement",
-  "HTMLFormElement",
-  "HTMLHtmlElement",
-  "HTMLImageElement",
-  "HTMLInputElement",
-  "HTMLLabelElement",
-  "HTMLLegendElement",
-  "HTMLMapElement",
-  "HTMLMarqueeElement",
-  "HTMLMediaElement",
-  "HTMLMeterElement",
-  "HTMLModElement",
-  "HTMLOptGroupElement",
-  "HTMLOptionElement",
-  "HTMLOutputElement",
-  "HTMLPictureElement",
-  "HTMLProgressElement",
-  "HTMLQuoteElement",
-  "HTMLScriptElement",
-  "HTMLSelectElement",
-  "HTMLSlotElement",
-  "HTMLSourceElement",
-  "HTMLSpanElement",
-  "HTMLTableCaptionElement",
-  "HTMLTableCellElement",
-  "HTMLTableColElement",
-  "HTMLTableElement",
-  "HTMLTimeElement",
-  "HTMLTableRowElement",
-  "HTMLTableSectionElement",
-  "HTMLTemplateElement",
-  "HTMLTextAreaElement",
-  "HTMLUnknownElement",
-  "HTMLFrameElement",
-  "HTMLFrameSetElement",
-  "HTMLIFrameElement",
-  "HTMLEmbedElement",
-  "HTMLObjectElement",
-  "HTMLParamElement",
-  "HTMLVideoElement",
-  "HTMLAudioElement",
-  "HTMLTrackElement",
-  "SVGElement",
-  "SVGGraphicsElement",
-  "SVGSVGElement",
-  "SVGTitleElement",
-  "SVGAnimatedString",
-  "SVGNumber",
-  "SVGStringList",
-  "Event",
-  "CloseEvent",
-  "CustomEvent",
-  "MessageEvent",
-  "ErrorEvent",
-  "HashChangeEvent",
-  "PopStateEvent",
-  "StorageEvent",
-  "ProgressEvent",
-  "PageTransitionEvent",
-  "UIEvent",
-  "FocusEvent",
-  "InputEvent",
-  "MouseEvent",
-  "KeyboardEvent",
-  "TouchEvent",
-  "CompositionEvent",
-  "WheelEvent",
-  "BarProp",
-  "External",
-  "Location",
-  "History",
-  "Screen",
-  "Performance",
-  "Navigator",
-  "PluginArray",
-  "MimeTypeArray",
-  "Plugin",
-  "MimeType",
-  "FileReader",
-  "Blob",
-  "File",
-  "FileList",
-  "ValidityState",
-  "DOMParser",
-  "XMLSerializer",
-  "FormData",
-  "XMLHttpRequestEventTarget",
-  "XMLHttpRequestUpload",
-  "XMLHttpRequest",
-  "WebSocket",
-  "NodeFilter",
-  "NodeIterator",
-  "TreeWalker",
-  "AbstractRange",
-  "Range",
-  "StaticRange",
-  "Selection",
-  "Storage",
-  "CustomElementRegistry",
-  "ShadowRoot",
-  "MutationObserver",
-  "MutationRecord",
-  "Headers",
-  "AbortController",
-  "AbortSignal",
-  "Image"
-];
-const OTHER_KEYS = [
-  "addEventListener",
-  "alert",
-  "atob",
-  "blur",
-  "btoa",
-  "close",
-  "confirm",
-  "createPopup",
-  "dispatchEvent",
-  "document",
-  "focus",
-  "frames",
-  "getComputedStyle",
-  "history",
-  "innerHeight",
-  "innerWidth",
-  "length",
-  "location",
-  "matchMedia",
-  "moveBy",
-  "moveTo",
-  "name",
-  "navigator",
-  "open",
-  "outerHeight",
-  "outerWidth",
-  "pageXOffset",
-  "pageYOffset",
-  "parent",
-  "postMessage",
-  "print",
-  "prompt",
-  "removeEventListener",
-  "resizeBy",
-  "resizeTo",
-  "screen",
-  "screenLeft",
-  "screenTop",
-  "screenX",
-  "screenY",
-  "scroll",
-  "scrollBy",
-  "scrollLeft",
-  "scrollTo",
-  "scrollTop",
-  "scrollX",
-  "scrollY",
-  "self",
-  "stop",
-  "top",
-  "Window",
-  "window"
-];
-const KEYS = LIVING_KEYS.concat(OTHER_KEYS);
-
-const allowRewrite = /* @__PURE__ */ new Set([
-  "Event",
-  "EventTarget"
-]);
-function getWindowKeys(global, win) {
-  const keys = new Set(KEYS.concat(Object.getOwnPropertyNames(win)).filter((k) => {
-    if (k.startsWith("_"))
-      return false;
-    if (k in global)
-      return allowRewrite.has(k);
-    return true;
-  }));
-  return keys;
-}
-
-var __defProp$1 = Object.defineProperty;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
-    }
-  return a;
-};
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-var jsdom = {
-  name: "jsdom",
-  async setup(global, { jsdom = {} }) {
-    const {
-      CookieJar,
-      JSDOM,
-      ResourceLoader,
-      VirtualConsole
-    } = await importModule("jsdom");
-    const _a = jsdom, {
-      html = "<!DOCTYPE html>",
-      userAgent,
-      url = "http://localhost:3000",
-      contentType = "text/html",
-      pretendToBeVisual = true,
-      includeNodeLocations = false,
-      runScripts = "dangerously",
-      resources,
-      console = false,
-      cookieJar = false
-    } = _a, restOptions = __objRest(_a, [
-      "html",
-      "userAgent",
-      "url",
-      "contentType",
-      "pretendToBeVisual",
-      "includeNodeLocations",
-      "runScripts",
-      "resources",
-      "console",
-      "cookieJar"
-    ]);
-    const dom = new JSDOM(html, __spreadValues$1({
-      pretendToBeVisual,
-      resources: resources ?? (userAgent ? new ResourceLoader({ userAgent }) : void 0),
-      runScripts,
-      url,
-      virtualConsole: console && global.console ? new VirtualConsole().sendTo(global.console) : void 0,
-      cookieJar: cookieJar ? new CookieJar() : void 0,
-      includeNodeLocations,
-      contentType,
-      userAgent
-    }, restOptions));
-    const keys = getWindowKeys(global, dom.window);
-    const overrideObject = /* @__PURE__ */ new Map();
-    for (const key of keys) {
-      Object.defineProperty(global, key, {
-        get() {
-          if (overrideObject.has(key))
-            return overrideObject.get(key);
-          return dom.window[key];
-        },
-        set(v) {
-          overrideObject.set(key, v);
-        },
-        configurable: true
-      });
-    }
-    return {
-      teardown(global2) {
-        keys.forEach((key) => delete global2[key]);
-      }
-    };
-  }
-};
-
-var happy = {
-  name: "happy-dom",
-  async setup(global) {
-    const { Window } = await importModule("happy-dom");
-    const win = new Window();
-    const keys = getWindowKeys(global, win);
-    const overrideObject = /* @__PURE__ */ new Map();
-    for (const key of keys) {
-      Object.defineProperty(global, key, {
-        get() {
-          if (overrideObject.has(key))
-            return overrideObject.get(key);
-          return win[key];
-        },
-        set(v) {
-          overrideObject.set(key, v);
-        },
-        configurable: true
-      });
-    }
-    return {
-      teardown(global2) {
-        win.happyDOM.cancelAsync();
-        keys.forEach((key) => delete global2[key]);
-      }
-    };
-  }
-};
-
-const environments = {
-  node,
-  jsdom,
-  "happy-dom": happy
-};
-
-let globalSetup = false;
-async function setupGlobalEnv(config) {
-  resetRunOnceCounter();
-  Object.defineProperty(globalThis, "__vitest_index__", {
-    value: index,
-    enumerable: false
-  });
-  setupDefines(config.defines);
-  if (globalSetup)
-    return;
-  globalSetup = true;
-  setupConsoleLogSpy();
-  if (config.globals)
-    (await import('./chunk-integrations-globals.c040aaa9.js')).registerApiGlobally();
-}
-function setupDefines(defines) {
-  for (const key in defines)
-    globalThis[key] = defines[key];
-}
-function setupConsoleLogSpy() {
-  const stdoutBuffer = /* @__PURE__ */ new Map();
-  const stderrBuffer = /* @__PURE__ */ new Map();
-  const timers = /* @__PURE__ */ new Map();
-  const unknownTestId = "__vitest__unknown_test__";
-  function schedule(taskId) {
-    const timer = timers.get(taskId);
-    const { stdoutTime, stderrTime } = timer;
-    clearTimeout(timer.timer);
-    timer.timer = setTimeout(() => {
-      if (stderrTime < stdoutTime) {
-        sendStderr(taskId);
-        sendStdout(taskId);
-      } else {
-        sendStdout(taskId);
-        sendStderr(taskId);
-      }
-    });
-  }
-  function sendStdout(taskId) {
-    const buffer = stdoutBuffer.get(taskId);
-    if (buffer) {
-      const timer = timers.get(taskId);
-      rpc().onUserConsoleLog({
-        type: "stdout",
-        content: buffer.map((i) => String(i)).join(""),
-        taskId,
-        time: timer.stdoutTime || RealDate.now(),
-        size: buffer.length
-      });
-      stdoutBuffer.set(taskId, []);
-      timer.stdoutTime = 0;
-    }
-  }
-  function sendStderr(taskId) {
-    const buffer = stderrBuffer.get(taskId);
-    if (buffer) {
-      const timer = timers.get(taskId);
-      rpc().onUserConsoleLog({
-        type: "stderr",
-        content: buffer.map((i) => String(i)).join(""),
-        taskId,
-        time: timer.stderrTime || RealDate.now(),
-        size: buffer.length
-      });
-      stderrBuffer.set(taskId, []);
-      timer.stderrTime = 0;
-    }
-  }
-  const stdout = new Writable({
-    write(data, encoding, callback) {
-      var _a, _b;
-      const id = ((_b = (_a = getWorkerState()) == null ? void 0 : _a.current) == null ? void 0 : _b.id) ?? unknownTestId;
-      let timer = timers.get(id);
-      if (timer) {
-        timer.stdoutTime = timer.stdoutTime || RealDate.now();
-      } else {
-        timer = { stdoutTime: RealDate.now(), stderrTime: RealDate.now(), timer: 0 };
-        timers.set(id, timer);
-      }
-      let buffer = stdoutBuffer.get(id);
-      if (!buffer) {
-        buffer = [];
-        stdoutBuffer.set(id, buffer);
-      }
-      buffer.push(data);
-      schedule(id);
-      callback();
-    }
-  });
-  const stderr = new Writable({
-    write(data, encoding, callback) {
-      var _a, _b;
-      const id = ((_b = (_a = getWorkerState()) == null ? void 0 : _a.current) == null ? void 0 : _b.id) ?? unknownTestId;
-      let timer = timers.get(id);
-      if (timer) {
-        timer.stderrTime = timer.stderrTime || RealDate.now();
-      } else {
-        timer = { stderrTime: RealDate.now(), stdoutTime: RealDate.now(), timer: 0 };
-        timers.set(id, timer);
-      }
-      let buffer = stderrBuffer.get(id);
-      if (!buffer) {
-        buffer = [];
-        stderrBuffer.set(id, buffer);
-      }
-      buffer.push(data);
-      schedule(id);
-      callback();
-    }
-  });
-  globalThis.console = new Console({
-    stdout,
-    stderr,
-    colorMode: true,
-    groupIndentation: 2
-  });
-}
-async function withEnv(name, options, fn) {
-  const env = await environments[name].setup(globalThis, options);
-  try {
-    await fn();
-  } finally {
-    await env.teardown(globalThis);
-  }
-}
-async function runSetupFiles(config) {
-  const files = toArray(config.setupFiles);
-  await Promise.all(files.map(async (file) => {
-    getWorkerState().moduleCache.delete(file);
-    await import(file);
-  }));
-}
-
-const OBJECT_PROTO = Object.getPrototypeOf({});
-function serializeError(val, seen = /* @__PURE__ */ new WeakMap()) {
-  if (!val || typeof val === "string")
-    return val;
-  if (typeof val === "function")
-    return `Function<${val.name}>`;
-  if (typeof val !== "object")
-    return val;
-  if (val instanceof Promise || "then" in val || val.constructor && val.constructor.prototype === "AsyncFunction")
-    return "Promise";
-  if (typeof Element !== "undefined" && val instanceof Element)
-    return val.tagName;
-  if (typeof val.asymmetricMatch === "function")
-    return `${val.toString()} ${format(val.sample)}`;
-  if (seen.has(val))
-    return seen.get(val);
-  if (Array.isArray(val)) {
-    const clone = new Array(val.length);
-    seen.set(val, clone);
-    val.forEach((e, i) => {
-      clone[i] = serializeError(e, seen);
-    });
-    return clone;
-  } else {
-    const clone = /* @__PURE__ */ Object.create(null);
-    seen.set(val, clone);
-    let obj = val;
-    while (obj && obj !== OBJECT_PROTO) {
-      Object.getOwnPropertyNames(obj).forEach((key) => {
-        if (!(key in clone))
-          clone[key] = serializeError(obj[key], seen);
-      });
-      obj = Object.getPrototypeOf(obj);
-    }
-    return clone;
-  }
-}
-function processError(err) {
-  if (!err)
-    return err;
-  if (err.stack)
-    err.stackStr = String(err.stack);
-  if (err.name)
-    err.nameStr = String(err.name);
-  if (typeof err.expected !== "string")
-    err.expected = stringify(err.expected);
-  if (typeof err.actual !== "string")
-    err.actual = stringify(err.actual);
-  try {
-    return serializeError(err);
-  } catch (e) {
-    return serializeError(new Error(`Failed to fully serialize error: ${e == null ? void 0 : e.message}.
-Inner error message: ${err == null ? void 0 : err.message}`));
-  }
-}
-
-const now$1 = Date.now;
-function hash(str, length = 10) {
-  return createHash("md5").update(str).digest("hex").slice(0, length);
-}
-async function collectTests(paths, config) {
-  const files = [];
-  for (const filepath of paths) {
-    const path = relative(config.root, filepath);
-    const file = {
-      id: hash(path),
-      name: path,
-      type: "suite",
-      mode: "run",
-      filepath,
-      tasks: []
-    };
-    clearContext();
-    try {
-      await runSetupFiles(config);
-      await import(filepath);
-      const defaultTasks = await defaultSuite.collect(file);
-      setHooks(file, getHooks(defaultTasks));
-      for (const c of [...defaultTasks.tasks, ...context.tasks]) {
-        if (c.type === "test") {
-          file.tasks.push(c);
-        } else if (c.type === "suite") {
-          file.tasks.push(c);
-        } else {
-          const start = now$1();
-          const suite = await c.collect(file);
-          file.collectDuration = now$1() - start;
-          if (suite.name || suite.tasks.length)
-            file.tasks.push(suite);
-        }
-      }
-    } catch (e) {
-      file.result = {
-        state: "fail",
-        error: processError(e)
-      };
-      process.stdout.write("\0");
-    }
-    calculateHash(file);
-    const hasOnlyTasks = someTasksAreOnly(file);
-    interpretTaskModes(file, config.testNamePattern, hasOnlyTasks, false, config.allowOnly);
-    files.push(file);
-  }
-  return files;
-}
-function interpretTaskModes(suite, namePattern, onlyMode, parentIsOnly, allowOnly) {
-  const suiteIsOnly = parentIsOnly || suite.mode === "only";
-  suite.tasks.forEach((t) => {
-    const includeTask = suiteIsOnly || t.mode === "only";
-    if (onlyMode) {
-      if (t.type === "suite" && (includeTask || someTasksAreOnly(t))) {
-        if (t.mode === "only") {
-          checkAllowOnly(t, allowOnly);
-          t.mode = "run";
-        }
-      } else if (t.mode === "run" && !includeTask) {
-        t.mode = "skip";
-      } else if (t.mode === "only") {
-        checkAllowOnly(t, allowOnly);
-        t.mode = "run";
-      }
-    }
-    if (t.type === "test") {
-      if (namePattern && !getTaskFullName(t).match(namePattern))
-        t.mode = "skip";
-    } else if (t.type === "suite") {
-      if (t.mode === "skip")
-        skipAllTasks(t);
-      else
-        interpretTaskModes(t, namePattern, onlyMode, includeTask, allowOnly);
-    }
-  });
-  if (suite.mode === "run") {
-    if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run"))
-      suite.mode = "skip";
-  }
-}
-function getTaskFullName(task) {
-  return `${task.suite ? `${getTaskFullName(task.suite)} ` : ""}${task.name}`;
-}
-function someTasksAreOnly(suite) {
-  return suite.tasks.some((t) => t.mode === "only" || t.type === "suite" && someTasksAreOnly(t));
-}
-function skipAllTasks(suite) {
-  suite.tasks.forEach((t) => {
-    if (t.mode === "run") {
-      t.mode = "skip";
-      if (t.type === "suite")
-        skipAllTasks(t);
-    }
-  });
-}
-function checkAllowOnly(task, allowOnly) {
-  if (allowOnly)
-    return;
-  task.result = {
-    state: "fail",
-    error: processError(new Error("[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error"))
-  };
-}
-function calculateHash(parent) {
-  parent.tasks.forEach((t, idx) => {
-    t.id = `${parent.id}_${idx}`;
-    if (t.type === "suite")
-      calculateHash(t);
-  });
-}
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-const now = Date.now;
-function updateSuiteHookState(suite, name, state) {
-  var _a;
-  if (!suite.result)
-    suite.result = { state: "run" };
-  if (!((_a = suite.result) == null ? void 0 : _a.hooks))
-    suite.result.hooks = {};
-  const suiteHooks = suite.result.hooks;
-  if (suiteHooks) {
-    suiteHooks[name] = state;
-    updateTask(suite);
-  }
-}
-async function callSuiteHook(suite, currentTask, name, args) {
-  if (name === "beforeEach" && suite.suite)
-    await callSuiteHook(suite.suite, currentTask, name, args);
-  updateSuiteHookState(currentTask, name, "run");
-  await Promise.all(getHooks(suite)[name].map((fn) => fn(...args)));
-  updateSuiteHookState(currentTask, name, "pass");
-  if (name === "afterEach" && suite.suite)
-    await callSuiteHook(suite.suite, currentTask, name, args);
-}
-const packs = /* @__PURE__ */ new Map();
-let updateTimer;
-let previousUpdate;
-function updateTask(task) {
-  packs.set(task.id, task.result);
-  clearTimeout(updateTimer);
-  updateTimer = setTimeout(() => {
-    previousUpdate = sendTasksUpdate();
-  }, 10);
-}
-async function sendTasksUpdate() {
-  clearTimeout(updateTimer);
-  await previousUpdate;
-  if (packs.size) {
-    const p = rpc().onTaskUpdate(Array.from(packs));
-    packs.clear();
-    return p;
-  }
-}
-async function runTest(test) {
-  var _a, _b;
-  if (test.mode !== "run")
-    return;
-  if (((_a = test.result) == null ? void 0 : _a.state) === "fail") {
-    updateTask(test);
-    return;
-  }
-  const start = now();
-  test.result = {
-    state: "run",
-    startTime: start
-  };
-  updateTask(test);
-  clearModuleMocks();
-  await getSnapshotClient().setTest(test);
-  const workerState = getWorkerState();
-  workerState.current = test;
-  try {
-    await callSuiteHook(test.suite, test, "beforeEach", [test, test.suite]);
-    setState({
-      assertionCalls: 0,
-      isExpectingAssertions: false,
-      isExpectingAssertionsError: null,
-      expectedAssertionsNumber: null,
-      expectedAssertionsNumberErrorGen: null,
-      testPath: (_b = test.suite.file) == null ? void 0 : _b.filepath,
-      currentTestName: getFullName(test)
-    });
-    await getFn(test)();
-    const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = getState();
-    if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber)
-      throw expectedAssertionsNumberErrorGen();
-    if (isExpectingAssertions === true && assertionCalls === 0)
-      throw isExpectingAssertionsError;
-    test.result.state = "pass";
-  } catch (e) {
-    test.result.state = "fail";
-    test.result.error = processError(e);
-  }
-  try {
-    await callSuiteHook(test.suite, test, "afterEach", [test, test.suite]);
-  } catch (e) {
-    test.result.state = "fail";
-    test.result.error = processError(e);
-  }
-  if (test.fails) {
-    if (test.result.state === "pass") {
-      test.result.state = "fail";
-      test.result.error = processError(new Error("Expect test to fail"));
-    } else {
-      test.result.state = "pass";
-      test.result.error = void 0;
-    }
-  }
-  getSnapshotClient().clearTest();
-  test.result.duration = now() - start;
-  workerState.current = void 0;
-  updateTask(test);
-}
-function markTasksAsSkipped(suite) {
-  suite.tasks.forEach((t) => {
-    t.mode = "skip";
-    t.result = __spreadProps(__spreadValues({}, t.result), { state: "skip" });
-    updateTask(t);
-    if (t.type === "suite")
-      markTasksAsSkipped(t);
-  });
-}
-async function runSuite(suite) {
-  var _a;
-  if (((_a = suite.result) == null ? void 0 : _a.state) === "fail") {
-    markTasksAsSkipped(suite);
-    updateTask(suite);
-    return;
-  }
-  const start = now();
-  suite.result = {
-    state: "run",
-    startTime: start
-  };
-  updateTask(suite);
-  if (suite.mode === "skip") {
-    suite.result.state = "skip";
-  } else if (suite.mode === "todo") {
-    suite.result.state = "todo";
-  } else {
-    try {
-      await callSuiteHook(suite, suite, "beforeAll", [suite]);
-      for (const tasksGroup of partitionSuiteChildren(suite)) {
-        if (tasksGroup[0].concurrent === true) {
-          await Promise.all(tasksGroup.map((c) => runSuiteChild(c)));
-        } else {
-          for (const c of tasksGroup)
-            await runSuiteChild(c);
-        }
-      }
-      await callSuiteHook(suite, suite, "afterAll", [suite]);
-    } catch (e) {
-      suite.result.state = "fail";
-      suite.result.error = processError(e);
-    }
-  }
-  suite.result.duration = now() - start;
-  if (suite.mode === "run") {
-    if (!hasTests(suite)) {
-      suite.result.state = "fail";
-      if (!suite.result.error)
-        suite.result.error = new Error(`No test found in suite ${suite.name}`);
-    } else if (hasFailed(suite)) {
-      suite.result.state = "fail";
-    } else {
-      suite.result.state = "pass";
-    }
-  }
-  updateTask(suite);
-}
-async function runSuiteChild(c) {
-  return c.type === "test" ? runTest(c) : runSuite(c);
-}
-async function runFiles(files, config) {
-  var _a;
-  for (const file of files) {
-    if (!file.tasks.length && !config.passWithNoTests) {
-      if (!((_a = file.result) == null ? void 0 : _a.error)) {
-        file.result = {
-          state: "fail",
-          error: new Error(`No test suite found in file ${file.filepath}`)
-        };
-      }
-    }
-    await runSuite(file);
-  }
-}
-async function startTests(paths, config) {
-  const files = await collectTests(paths, config);
-  rpc().onCollected(files);
-  await runFiles(files, config);
-  takeCoverage();
-  await getSnapshotClient().saveSnap();
-  await sendTasksUpdate();
-}
-function clearModuleMocks() {
-  const { clearMocks, mockReset, restoreMocks } = getWorkerState().config;
-  if (restoreMocks)
-    vi.restoreAllMocks();
-  else if (mockReset)
-    vi.resetAllMocks();
-  else if (clearMocks)
-    vi.clearAllMocks();
-}
-
-async function run(files, config) {
-  var _a;
-  await setupGlobalEnv(config);
-  const workerState = getWorkerState();
-  for (const file of files) {
-    workerState.mockMap.clear();
-    resetModules();
-    const code = await promises.readFile(file, "utf-8");
-    const env = ((_a = code.match(/@(?:vitest|jest)-environment\s+?([\w-]+)\b/)) == null ? void 0 : _a[1]) || config.environment || "node";
-    if (!["node", "jsdom", "happy-dom"].includes(env))
-      throw new Error(`Unsupported environment: ${env}`);
-    workerState.filepath = file;
-    await withEnv(env, config.environmentOptions || {}, async () => {
-      await startTests([file], config);
-    });
-    workerState.filepath = void 0;
-  }
-}
-
-export { run };
+import 'crypto';