@vitest/browser 5.0.0-beta.1 → 5.0.0-beta.2

package/dist/client/__vitest_browser__/{utils-BYUpz6v6.js → tester-BJtW9QqZ.js}

@@ -1,32 +1,166 @@
-(function polyfill() {
-  const relList = document.createElement("link").relList;
-  if (relList && relList.supports && relList.supports("modulepreload")) return;
-  for (const link of document.querySelectorAll('link[rel="modulepreload"]')) processPreload(link);
-  new MutationObserver((mutations) => {
-    for (const mutation of mutations) {
-      if (mutation.type !== "childList") continue;
-      for (const node of mutation.addedNodes) if (node.tagName === "LINK" && node.rel === "modulepreload") processPreload(node);
-    }
-  }).observe(document, {
-    childList: true,
-    subtree: true
+import { b as resolve$1, g as getBrowserState, n as now$1, m as moduleRunner, c as getWorkerState, a as getConfig$1 } from "./utils-Nd8hqrhP.js";
+import { onCancel, globalChannel, channel, client } from "@vitest/browser/client";
+import { userEvent, page, server } from "vitest/browser";
+import { getSafeTimers as getSafeTimers$1, DecodedMap as DecodedMap$1, getOriginalPosition as getOriginalPosition$1, loadDiffConfig, loadSnapshotSerializers, takeCoverageInsideWorker, format as format$2, setupCommonEnv, startCoverageInsideWorker, stopCoverageInsideWorker, startTests, collectTests, SpyModule } from "vitest/internal/browser";
+import { Traces } from "vitest/internal/traces";
+import { TestRunner, BenchmarkRunner, recordArtifact as recordArtifact$1 } from "vitest";
+const scriptRel = "modulepreload";
+const assetsURL = function(dep) {
+  return "/" + dep;
+};
+const seen = {};
+const __vitePreload = function preload(baseModule, deps, importerUrl) {
+  let promise = Promise.resolve();
+  if (deps && deps.length > 0) {
+    let allSettled = function(promises$2) {
+      return Promise.all(promises$2.map((p) => Promise.resolve(p).then((value$1) => ({
+        status: "fulfilled",
+        value: value$1
+      }), (reason) => ({
+        status: "rejected",
+        reason
+      }))));
+    };
+    document.getElementsByTagName("link");
+    const cspNonceMeta = document.querySelector("meta[property=csp-nonce]");
+    const cspNonce = (cspNonceMeta == null ? void 0 : cspNonceMeta.nonce) || (cspNonceMeta == null ? void 0 : cspNonceMeta.getAttribute("nonce"));
+    promise = allSettled(deps.map((dep) => {
+      dep = assetsURL(dep);
+      if (dep in seen) return;
+      seen[dep] = true;
+      const isCss = dep.endsWith(".css");
+      const cssSelector = isCss ? '[rel="stylesheet"]' : "";
+      if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) return;
+      const link = document.createElement("link");
+      link.rel = isCss ? "stylesheet" : scriptRel;
+      if (!isCss) link.as = "script";
+      link.crossOrigin = "";
+      link.href = dep;
+      if (cspNonce) link.setAttribute("nonce", cspNonce);
+      document.head.appendChild(link);
+      if (isCss) return new Promise((res, rej) => {
+        link.addEventListener("load", res);
+        link.addEventListener("error", () => rej(/* @__PURE__ */ new Error(`Unable to preload CSS for ${dep}`)));
+      });
+    }));
+  }
+  function handlePreloadError(err$2) {
+    const e$1 = new Event("vite:preloadError", { cancelable: true });
+    e$1.payload = err$2;
+    window.dispatchEvent(e$1);
+    if (!e$1.defaultPrevented) throw err$2;
+  }
+  return promise.then((res) => {
+    for (const item of res || []) {
+      if (item.status !== "rejected") continue;
+      handlePreloadError(item.reason);
+    }
+    return baseModule().catch(handlePreloadError);
+  });
+};
+const { parse: $parse } = JSON;
+const { keys } = Object;
+const Primitive = String;
+const primitive = "string";
+const ignore = {};
+const object = "object";
+const noop = (_, value) => value;
+const primitives = (value) => value instanceof Primitive ? Primitive(value) : value;
+const Primitives = (_, value) => typeof value === primitive ? new Primitive(value) : value;
+const resolver = (input, lazy, parsed, $) => (output) => {
+  for (let ke = keys(output), { length } = ke, y2 = 0; y2 < length; y2++) {
+    const k = ke[y2];
+    const value = output[k];
+    if (value instanceof Primitive) {
+      const tmp = input[+value];
+      if (typeof tmp === object && !parsed.has(tmp)) {
+        parsed.add(tmp);
+        output[k] = ignore;
+        lazy.push({ o: output, k, r: tmp });
+      } else
+        output[k] = $.call(output, k, tmp);
+    } else if (output[k] !== ignore)
+      output[k] = $.call(output, k, value);
+  }
+  return output;
+};
+const parse = (text, reviver) => {
+  const input = $parse(text, Primitives).map(primitives);
+  const $ = noop;
+  let value = input[0];
+  if (typeof value === object && value) {
+    const lazy = [];
+    const revive = resolver(input, lazy, /* @__PURE__ */ new Set(), $);
+    value = revive(value);
+    let i2 = 0;
+    while (i2 < lazy.length) {
+      const { o, k, r } = lazy[i2++];
+      o[k] = $.call(o, k, revive(r));
+    }
+  }
+  return $.call({ "": value }, "", value);
+};
+function showPopupWarning(name, value, defaultValue) {
+  return (...params) => {
+    const formattedParams = params.map((p) => JSON.stringify(p)).join(", ");
+    console.warn(`Vitest encountered a \`${name}(${formattedParams})\` call that it cannot handle by default, so it returned \`${value}\`. Read more in https://vitest.dev/guide/browser/#thread-blocking-dialogs.
+If needed, mock the \`${name}\` call manually like:
+
+\`\`\`
+import { expect, vi } from "vitest"
+
+vi.spyOn(window, "${name}")${defaultValue ? `.mockReturnValue(${JSON.stringify(defaultValue)})` : ""}
+${name}(${formattedParams})
+expect(${name}).toHaveBeenCalledWith(${formattedParams})
+\`\`\``);
+    return value;
+  };
+}
+function setupDialogsSpy() {
+  globalThis.alert = showPopupWarning("alert", void 0);
+  globalThis.confirm = showPopupWarning("confirm", false, true);
+  globalThis.prompt = showPopupWarning("prompt", null, "your value");
+}
+const { get } = Reflect;
+function withSafeTimers(getTimers, fn) {
+  const { setTimeout, clearTimeout } = getTimers();
+  const currentSetTimeout = globalThis.setTimeout;
+  const currentClearTimeout = globalThis.clearTimeout;
+  try {
+    globalThis.setTimeout = setTimeout;
+    globalThis.clearTimeout = clearTimeout;
+    const result = fn();
+    return result;
+  } finally {
+    globalThis.setTimeout = currentSetTimeout;
+    globalThis.clearTimeout = currentClearTimeout;
+  }
+}
+const promises = /* @__PURE__ */ new Set();
+function createSafeRpc(client2) {
+  return new Proxy(client2.rpc, {
+    get(target, p, handler) {
+      if (p === "then") {
+        return;
+      }
+      const sendCall = get(target, p, handler);
+      const safeSendCall = (...args) => withSafeTimers(getSafeTimers$1, async () => {
+        const result = sendCall(...args);
+        promises.add(result);
+        try {
+          return await result;
+        } finally {
+          promises.delete(result);
+        }
+      });
+      safeSendCall.asEvent = sendCall.asEvent;
+      return safeSendCall;
+    }
   });
-  function getFetchOpts(link) {
-    const fetchOpts = {};
-    if (link.integrity) fetchOpts.integrity = link.integrity;
-    if (link.referrerPolicy) fetchOpts.referrerPolicy = link.referrerPolicy;
-    if (link.crossOrigin === "use-credentials") fetchOpts.credentials = "include";
-    else if (link.crossOrigin === "anonymous") fetchOpts.credentials = "omit";
-    else fetchOpts.credentials = "same-origin";
-    return fetchOpts;
-  }
-  function processPreload(link) {
-    if (link.ep) return;
-    link.ep = true;
-    const fetchOpts = getFetchOpts(link);
-    fetch(link.href, fetchOpts);
-  }
-})();
+}
+function rpc$2() {
+  return globalThis.__vitest_worker__.rpc;
+}
 var b = {
   reset: [0, 0],
   bold: [1, 22, "\x1B[22m\x1B[1m"],
@@ -123,17 +257,17 @@ function _mergeNamespaces$1(n, m) {
   });
   return Object.freeze(n);
 }
-function getKeysOfEnumerableProperties(object, compareKeys) {
-  const rawKeys = Object.keys(object);
-  const keys = compareKeys === null ? rawKeys : rawKeys.sort(compareKeys);
+function getKeysOfEnumerableProperties(object2, compareKeys) {
+  const rawKeys = Object.keys(object2);
+  const keys2 = compareKeys === null ? rawKeys : rawKeys.sort(compareKeys);
   if (Object.getOwnPropertySymbols) {
-    for (const symbol of Object.getOwnPropertySymbols(object)) {
-      if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
-        keys.push(symbol);
+    for (const symbol of Object.getOwnPropertySymbols(object2)) {
+      if (Object.getOwnPropertyDescriptor(object2, symbol).enumerable) {
+        keys2.push(symbol);
       }
     }
   }
-  return keys;
+  return keys2;
 }
 function printIteratorEntries(iterator, config, indentation, depth, refs, printer2, separator = ": ", length) {
   let result = "";
@@ -216,21 +350,21 @@ function printListItems(list, config, indentation, depth, refs, printer2) {
 }
 function printObjectProperties(val, config, indentation, depth, refs, printer2, compareKeysOverride = config.compareKeys) {
   let result = "";
-  const keys = getKeysOfEnumerableProperties(val, compareKeysOverride);
-  if (keys.length > 0) {
+  const keys2 = getKeysOfEnumerableProperties(val, compareKeysOverride);
+  if (keys2.length > 0) {
     result += config.spacingOuter;
     const indentationNext = indentation + config.indent;
-    for (let i2 = 0; i2 < keys.length; i2++) {
+    for (let i2 = 0; i2 < keys2.length; i2++) {
       result += indentationNext;
       if (i2 === config.maxWidth) {
-        result += `…(${keys.length - i2})`;
+        result += `…(${keys2.length - i2})`;
         break;
       }
-      const key = keys[i2];
+      const key = keys2[i2];
       const name = !config.quoteKeys && isUnquotableKey(key) ? key : printer2(key, config, indentationNext, depth, refs);
       const value = printer2(val[key], config, indentationNext, depth, refs);
       result += `${name}: ${value}`;
-      if (i2 < keys.length - 1) {
+      if (i2 < keys2.length - 1) {
         result += `,${config.spacingInner}`;
       } else if (!config.min) {
         result += ",";
@@ -303,10 +437,10 @@ const plugin$4 = {
 function escapeHTML(str) {
   return str.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
-function printProps(keys, props, config, indentation, depth, refs, printer2) {
+function printProps(keys2, props, config, indentation, depth, refs, printer2) {
   const indentationNext = indentation + config.indent;
   const colors = config.colors;
-  return keys.map((key) => {
+  return keys2.map((key) => {
     const value = props[key];
     if (typeof value === "string" && value[0] === "_" && value.startsWith("__vitest_") && value.match(/__vitest_\d+__/)) {
       return "";
@@ -512,28 +646,28 @@ function requireReactIs_production() {
   if (hasRequiredReactIs_production) return reactIs_production;
   hasRequiredReactIs_production = 1;
   var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy"), REACT_VIEW_TRANSITION_TYPE = Symbol.for("react.view_transition"), REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
-  function typeOf(object) {
-    if ("object" === typeof object && null !== object) {
-      var $$typeof = object.$$typeof;
+  function typeOf(object2) {
+    if ("object" === typeof object2 && null !== object2) {
+      var $$typeof = object2.$$typeof;
       switch ($$typeof) {
         case REACT_ELEMENT_TYPE:
-          switch (object = object.type, object) {
+          switch (object2 = object2.type, object2) {
             case REACT_FRAGMENT_TYPE:
             case REACT_PROFILER_TYPE:
             case REACT_STRICT_MODE_TYPE:
             case REACT_SUSPENSE_TYPE:
             case REACT_SUSPENSE_LIST_TYPE:
             case REACT_VIEW_TRANSITION_TYPE:
-              return object;
+              return object2;
             default:
-              switch (object = object && object.$$typeof, object) {
+              switch (object2 = object2 && object2.$$typeof, object2) {
                 case REACT_CONTEXT_TYPE:
                 case REACT_FORWARD_REF_TYPE:
                 case REACT_LAZY_TYPE:
                 case REACT_MEMO_TYPE:
-                  return object;
+                  return object2;
                 case REACT_CONSUMER_TYPE:
-                  return object;
+                  return object2;
                 default:
                   return $$typeof;
               }
@@ -555,41 +689,41 @@ function requireReactIs_production() {
   reactIs_production.StrictMode = REACT_STRICT_MODE_TYPE;
   reactIs_production.Suspense = REACT_SUSPENSE_TYPE;
   reactIs_production.SuspenseList = REACT_SUSPENSE_LIST_TYPE;
-  reactIs_production.isContextConsumer = function(object) {
-    return typeOf(object) === REACT_CONSUMER_TYPE;
+  reactIs_production.isContextConsumer = function(object2) {
+    return typeOf(object2) === REACT_CONSUMER_TYPE;
   };
-  reactIs_production.isContextProvider = function(object) {
-    return typeOf(object) === REACT_CONTEXT_TYPE;
+  reactIs_production.isContextProvider = function(object2) {
+    return typeOf(object2) === REACT_CONTEXT_TYPE;
   };
-  reactIs_production.isElement = function(object) {
-    return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+  reactIs_production.isElement = function(object2) {
+    return "object" === typeof object2 && null !== object2 && object2.$$typeof === REACT_ELEMENT_TYPE;
   };
-  reactIs_production.isForwardRef = function(object) {
-    return typeOf(object) === REACT_FORWARD_REF_TYPE;
+  reactIs_production.isForwardRef = function(object2) {
+    return typeOf(object2) === REACT_FORWARD_REF_TYPE;
   };
-  reactIs_production.isFragment = function(object) {
-    return typeOf(object) === REACT_FRAGMENT_TYPE;
+  reactIs_production.isFragment = function(object2) {
+    return typeOf(object2) === REACT_FRAGMENT_TYPE;
   };
-  reactIs_production.isLazy = function(object) {
-    return typeOf(object) === REACT_LAZY_TYPE;
+  reactIs_production.isLazy = function(object2) {
+    return typeOf(object2) === REACT_LAZY_TYPE;
   };
-  reactIs_production.isMemo = function(object) {
-    return typeOf(object) === REACT_MEMO_TYPE;
+  reactIs_production.isMemo = function(object2) {
+    return typeOf(object2) === REACT_MEMO_TYPE;
   };
-  reactIs_production.isPortal = function(object) {
-    return typeOf(object) === REACT_PORTAL_TYPE;
+  reactIs_production.isPortal = function(object2) {
+    return typeOf(object2) === REACT_PORTAL_TYPE;
   };
-  reactIs_production.isProfiler = function(object) {
-    return typeOf(object) === REACT_PROFILER_TYPE;
+  reactIs_production.isProfiler = function(object2) {
+    return typeOf(object2) === REACT_PROFILER_TYPE;
   };
-  reactIs_production.isStrictMode = function(object) {
-    return typeOf(object) === REACT_STRICT_MODE_TYPE;
+  reactIs_production.isStrictMode = function(object2) {
+    return typeOf(object2) === REACT_STRICT_MODE_TYPE;
   };
-  reactIs_production.isSuspense = function(object) {
-    return typeOf(object) === REACT_SUSPENSE_TYPE;
+  reactIs_production.isSuspense = function(object2) {
+    return typeOf(object2) === REACT_SUSPENSE_TYPE;
   };
-  reactIs_production.isSuspenseList = function(object) {
-    return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+  reactIs_production.isSuspenseList = function(object2) {
+    return typeOf(object2) === REACT_SUSPENSE_LIST_TYPE;
   };
   reactIs_production.isValidElementType = function(type) {
     return "string" === typeof type || "function" === typeof type || type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || "object" === typeof type && null !== type && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_CONSUMER_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_CLIENT_REFERENCE || void 0 !== type.getModuleId) ? true : false;
@@ -762,7 +896,7 @@ function getChildren(arg, children = []) {
   }
   return children;
 }
-function getType(element) {
+function getType$1(element) {
   const type = element.type;
   if (typeof type === "string") {
     return type;
@@ -801,18 +935,18 @@ function getPropKeys$1(element) {
   const { props } = element;
   return Object.keys(props).filter((key) => key !== "children" && props[key] !== void 0).sort();
 }
-const serialize$1 = (element, config, indentation, depth, refs, printer2) => ++depth > config.maxDepth ? printElementAsLeaf(getType(element), config) : printElement(getType(element), printProps(getPropKeys$1(element), element.props, config, indentation + config.indent, depth, refs, printer2), printChildren(getChildren(element.props.children), config, indentation + config.indent, depth, refs, printer2), config, indentation);
+const serialize$1 = (element, config, indentation, depth, refs, printer2) => ++depth > config.maxDepth ? printElementAsLeaf(getType$1(element), config) : printElement(getType$1(element), printProps(getPropKeys$1(element), element.props, config, indentation + config.indent, depth, refs, printer2), printChildren(getChildren(element.props.children), config, indentation + config.indent, depth, refs, printer2), config, indentation);
 const test$1 = (val) => val != null && ReactIs.isElement(val);
 const plugin$1 = {
   serialize: serialize$1,
   test: test$1
 };
 const testSymbol = typeof Symbol === "function" && Symbol.for ? Symbol.for("react.test.json") : 245830487;
-function getPropKeys(object) {
-  const { props } = object;
+function getPropKeys(object2) {
+  const { props } = object2;
   return props ? Object.keys(props).filter((key) => props[key] !== void 0).sort() : [];
 }
-const serialize = (object, config, indentation, depth, refs, printer2) => ++depth > config.maxDepth ? printElementAsLeaf(object.type, config) : printElement(object.type, object.props ? printProps(getPropKeys(object), object.props, config, indentation + config.indent, depth, refs, printer2) : "", object.children ? printChildren(object.children, config, indentation + config.indent, depth, refs, printer2) : "", config, indentation);
+const serialize = (object2, config, indentation, depth, refs, printer2) => ++depth > config.maxDepth ? printElementAsLeaf(object2.type, config) : printElement(object2.type, object2.props ? printProps(getPropKeys(object2), object2.props, config, indentation + config.indent, depth, refs, printer2) : "", object2.children ? printChildren(object2.children, config, indentation + config.indent, depth, refs, printer2) : "", config, indentation);
 const test = (val) => val && val.$$typeof === testSymbol;
 const plugin = {
   serialize,
@@ -1070,7 +1204,7 @@ function getEscapeRegex(options) {
 function getEscapeString(options) {
   return (options == null ? void 0 : options.escapeString) ?? DEFAULT_OPTIONS.escapeString;
 }
-function getConfig$1(options) {
+function getConfig(options) {
   return {
     callToJSON: (options == null ? void 0 : options.callToJSON) ?? DEFAULT_OPTIONS.callToJSON,
     colors: (options == null ? void 0 : options.highlight) ? getColorsHighlight() : getColorsEmpty(),
@@ -1100,7 +1234,7 @@ function format$1(val, options) {
   if (options) {
     validateOptions(options);
   }
-  const config = getConfig$1(options);
+  const config = getConfig(options);
   const plugin2 = findPlugin(config.plugins, val);
   if (plugin2 !== null) {
     return printPlugin(plugin2, val, config, "", 0, []);
@@ -1128,7 +1262,7 @@ const PLUGINS = [
   Immutable,
   AsymmetricMatcher
 ];
-function stringify(object, maxDepth = 10, { maxLength, filterNode, ...options } = {}) {
+function stringify(object2, maxDepth = 10, { maxLength, filterNode, ...options } = {}) {
   const MAX_LENGTH = maxLength ?? 1e4;
   let result;
   const filterFn = typeof filterNode === "string" ? createNodeFilterFromSelector(filterNode) : filterNode;
@@ -1141,14 +1275,14 @@ function stringify(object, maxDepth = 10, { maxLength, filterNode, ...options }
     AsymmetricMatcher
   ] : PLUGINS;
   try {
-    result = format$1(object, {
+    result = format$1(object2, {
       maxDepth,
       escapeString: false,
       plugins: plugins2,
       ...options
     });
   } catch {
-    result = format$1(object, {
+    result = format$1(object2, {
       callToJSON: false,
       maxDepth,
       escapeString: false,
@@ -1156,7 +1290,7 @@ function stringify(object, maxDepth = 10, { maxLength, filterNode, ...options }
       ...options
     });
   }
-  return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
+  return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object2, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
     maxLength,
     filterNode,
     ...options
@@ -1321,17 +1455,17 @@ function truncateString(string, maxLength) {
   }
   return `${string.slice(0, end)}…`;
 }
-function stringifyByMaxWidth(object, threshold, options) {
+function stringifyByMaxWidth(object2, threshold, options) {
   function evaluate(x) {
-    return stringify(object, void 0, {
+    return stringify(object2, void 0, {
       ...options,
       maxWidth: x
     });
   }
-  const opt = binarySearch(0, threshold, (x) => evaluate(x).length <= threshold);
+  const opt = binarySearch$1(0, threshold, (x) => evaluate(x).length <= threshold);
   return evaluate(opt);
 }
-function binarySearch(x0, x1, f) {
+function binarySearch$1(x0, x1, f) {
   while (x0 + 1 < x1) {
     const x = Math.floor((x0 + x1) / 2);
     if (f(x)) {
@@ -1461,18 +1595,18 @@ function normalizeWindowsPath$1(input = "") {
   return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE$1, (r) => r.toUpperCase());
 }
 const _IS_ABSOLUTE_RE$1 = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-function cwd$1() {
+function cwd() {
   if (typeof process !== "undefined" && typeof process.cwd === "function") {
     return process.cwd().replace(/\\/g, "/");
   }
   return "/";
 }
-const resolve$1 = function(...arguments_) {
+const resolve = function(...arguments_) {
   arguments_ = arguments_.map((argument) => normalizeWindowsPath$1(argument));
   let resolvedPath = "";
   let resolvedAbsolute = false;
   for (let index2 = arguments_.length - 1; index2 >= -1 && !resolvedAbsolute; index2--) {
-    const path = index2 >= 0 ? arguments_[index2] : cwd$1();
+    const path = index2 >= 0 ? arguments_[index2] : cwd();
     if (!path || path.length === 0) {
       continue;
     }
@@ -1548,19 +1682,19 @@ function normalizeString$1(path, allowAboveRoot) {
 const isAbsolute$1 = function(p) {
   return _IS_ABSOLUTE_RE$1.test(p);
 };
-var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var intToChar = new Uint8Array(64);
-var charToInt = new Uint8Array(128);
-for (let i2 = 0; i2 < chars.length; i2++) {
-  const c = chars.charCodeAt(i2);
-  intToChar[i2] = c;
-  charToInt[c] = i2;
-}
-const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
-const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
-const NOW_LENGTH = Date.now().toString().length;
-const REGEXP_VITEST = new RegExp(`vitest=\\d{${NOW_LENGTH}}`);
-function extractLocation(urlLike) {
+var chars$2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar$2 = new Uint8Array(64);
+var charToInt$2 = new Uint8Array(128);
+for (let i2 = 0; i2 < chars$2.length; i2++) {
+  const c = chars$2.charCodeAt(i2);
+  intToChar$2[i2] = c;
+  charToInt$2[c] = i2;
+}
+const CHROME_IE_STACK_REGEXP$1 = /^\s*at .*(?:\S:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP$1 = /^(?:eval@)?(?:\[native code\])?$/;
+const NOW_LENGTH$1 = Date.now().toString().length;
+const REGEXP_VITEST$1 = new RegExp(`vitest=\\d{${NOW_LENGTH$1}}`);
+function extractLocation$1(urlLike) {
   if (!urlLike.includes(":")) {
     return [urlLike];
   }
@@ -1569,32 +1703,32 @@ function extractLocation(urlLike) {
   if (!parts) {
     return [urlLike];
   }
-  let url = parts[1];
-  if (url.startsWith("async ")) {
-    url = url.slice(6);
+  let url2 = parts[1];
+  if (url2.startsWith("async ")) {
+    url2 = url2.slice(6);
   }
-  if (url.startsWith("http:") || url.startsWith("https:")) {
-    const urlObj = new URL(url);
+  if (url2.startsWith("http:") || url2.startsWith("https:")) {
+    const urlObj = new URL(url2);
     urlObj.searchParams.delete("import");
     urlObj.searchParams.delete("browserv");
-    url = urlObj.pathname + urlObj.hash + urlObj.search;
+    url2 = urlObj.pathname + urlObj.hash + urlObj.search;
   }
-  if (url.startsWith("/@fs/")) {
-    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url);
-    url = url.slice(isWindows ? 5 : 4);
+  if (url2.startsWith("/@fs/")) {
+    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url2);
+    url2 = url2.slice(isWindows ? 5 : 4);
   }
-  if (url.includes("vitest=")) {
-    url = url.replace(REGEXP_VITEST, "").replace(/[?&]$/, "");
+  if (url2.includes("vitest=")) {
+    url2 = url2.replace(REGEXP_VITEST$1, "").replace(/[?&]$/, "");
   }
   return [
-    url,
+    url2,
     parts[2] || void 0,
     parts[3] || void 0
   ];
 }
-function parseSingleFFOrSafariStack(raw) {
+function parseSingleFFOrSafariStack$1(raw) {
   let line = raw.trim();
-  if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
+  if (SAFARI_NATIVE_CODE_REGEXP$1.test(line)) {
     return null;
   }
   if (line.includes(" > eval")) {
@@ -1620,12 +1754,12 @@ function parseSingleFFOrSafariStack(raw) {
   if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) {
     return null;
   }
-  const [url, lineNumber, columnNumber] = extractLocation(locationPart);
-  if (!url || !lineNumber || !columnNumber) {
+  const [url2, lineNumber, columnNumber] = extractLocation$1(locationPart);
+  if (!url2 || !lineNumber || !columnNumber) {
     return null;
   }
   return {
-    file: url,
+    file: url2,
     method: functionName || "",
     line: Number.parseInt(lineNumber),
     column: Number.parseInt(columnNumber)
@@ -1633,25 +1767,25 @@ function parseSingleFFOrSafariStack(raw) {
 }
 function parseSingleStack(raw) {
   const line = raw.trim();
-  if (!CHROME_IE_STACK_REGEXP.test(line)) {
-    return parseSingleFFOrSafariStack(line);
+  if (!CHROME_IE_STACK_REGEXP$1.test(line)) {
+    return parseSingleFFOrSafariStack$1(line);
   }
-  return parseSingleV8Stack(line);
+  return parseSingleV8Stack$1(line);
 }
-function parseSingleV8Stack(raw) {
+function parseSingleV8Stack$1(raw) {
   let line = raw.trim();
-  if (!CHROME_IE_STACK_REGEXP.test(line)) {
+  if (!CHROME_IE_STACK_REGEXP$1.test(line)) {
     return null;
   }
   if (line.includes("(eval ")) {
     line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
   }
   let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
-  const location = sanitizedLine.match(/ (\(.+\)$)/);
-  sanitizedLine = location ? sanitizedLine.replace(location[0], "") : sanitizedLine;
-  const [url, lineNumber, columnNumber] = extractLocation(location ? location[1] : sanitizedLine);
-  let method = location && sanitizedLine || "";
-  let file = url && ["eval", "<anonymous>"].includes(url) ? void 0 : url;
+  const location2 = sanitizedLine.match(/ (\(.+\)$)/);
+  sanitizedLine = location2 ? sanitizedLine.replace(location2[0], "") : sanitizedLine;
+  const [url2, lineNumber, columnNumber] = extractLocation$1(location2 ? location2[1] : sanitizedLine);
+  let method = location2 && sanitizedLine || "";
+  let file = url2 && ["eval", "<anonymous>"].includes(url2) ? void 0 : url2;
   if (!file || !lineNumber || !columnNumber) {
     return null;
   }
@@ -1661,7 +1795,7 @@ function parseSingleV8Stack(raw) {
   if (file.startsWith("file://")) {
     file = file.slice(7);
   }
-  file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve$1(file);
+  file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve(file);
   if (method) {
     method = method.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
   }
@@ -1672,118 +1806,6 @@ function parseSingleV8Stack(raw) {
     column: Number.parseInt(columnNumber)
   };
 }
-const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-function normalizeWindowsPath(input = "") {
-  if (!input) {
-    return input;
-  }
-  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
-}
-const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
-function cwd() {
-  if (typeof process !== "undefined" && typeof process.cwd === "function") {
-    return process.cwd().replace(/\\/g, "/");
-  }
-  return "/";
-}
-const resolve = function(...arguments_) {
-  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let index2 = arguments_.length - 1; index2 >= -1 && !resolvedAbsolute; index2--) {
-    const path = index2 >= 0 ? arguments_[index2] : cwd();
-    if (!path || path.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-function normalizeString(path, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let index2 = 0; index2 <= path.length; ++index2) {
-    if (index2 < path.length) {
-      char = path[index2];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === index2 - 1 || dots === 1) ;
-      else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = index2;
-            dots = 0;
-            continue;
-          } else if (res.length > 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = index2;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path.slice(lastSlash + 1, index2)}`;
-        } else {
-          res = path.slice(lastSlash + 1, index2);
-        }
-        lastSegmentLength = index2 - lastSlash - 1;
-      }
-      lastSlash = index2;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-}
-const isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
-};
-const relative = function(from, to) {
-  const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
-  const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
-  if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
-    return _to.join("/");
-  }
-  const _fromCopy = [..._from];
-  for (const segment of _fromCopy) {
-    if (_to[0] !== segment) {
-      break;
-    }
-    _from.shift();
-    _to.shift();
-  }
-  return [..._from.map(() => ".."), ..._to].join("/");
-};
 class PendingError extends Error {
   code = "VITEST_PENDING";
   taskId;
@@ -2276,7 +2298,7 @@ const kChainableContext = Symbol("kChainableContext");
 function getChainableContext(chainable) {
   return chainable == null ? void 0 : chainable[kChainableContext];
 }
-function createChainable(keys, fn, context) {
+function createChainable(keys2, fn, context) {
   function create(context2) {
     const chain2 = function(...args) {
       return fn.apply(context2, args);
@@ -2295,7 +2317,7 @@ function createChainable(keys, fn, context) {
       },
       enumerable: false
     });
-    for (const key of keys) {
+    for (const key of keys2) {
       Object.defineProperty(chain2, key, { get() {
         return create({
           ...context2,
@@ -2402,23 +2424,6 @@ function withSuiteFixtures(suiteHook, fn, context, stackTraceError, contextIndex
     return fixtured();
   };
 }
-// @__NO_SIDE_EFFECTS__
-function generateHash(str) {
-  let hash = 0;
-  if (str.length === 0) {
-    return `${hash}`;
-  }
-  for (let i2 = 0; i2 < str.length; i2++) {
-    const char = str.charCodeAt(i2);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return `${hash}`;
-}
-// @__NO_SIDE_EFFECTS__
-function generateFileHash(file, projectName) {
-  return /* @__PURE__ */ generateHash(`${file}${projectName || ""}`);
-}
 function findTestFileStackTrace(testFilePath, error) {
   const lines = error.split("\n").slice(1);
   for (const line of lines) {
@@ -2533,7 +2538,7 @@ function createSuiteCollector(name, factory = () => {
   let suite2;
   initSuite();
   const task = function(name2 = "", options = {}) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
     const currentSuite = (_a = collectorContext.currentSuite) == null ? void 0 : _a.suite;
     const parentTask = currentSuite ?? ((_b = collectorContext.currentSuite) == null ? void 0 : _b.file);
     const parentTags = (parentTask == null ? void 0 : parentTask.tags) || [];
@@ -2554,7 +2559,9 @@ function createSuiteCollector(name, factory = () => {
       return acc;
     }, {});
     const testOwnMeta = options.meta;
+    const parentOptions = (_c = collectorContext.currentSuite) == null ? void 0 : _c.options;
     options = {
+      ...parentOptions,
       ...tagsOptions,
       ...options
     };
@@ -2574,14 +2581,14 @@ function createSuiteCollector(name, factory = () => {
     const task2 = {
       id: "",
       name: name2,
-      fullName: createTaskName([(currentSuite == null ? void 0 : currentSuite.fullName) ?? ((_d = (_c = collectorContext.currentSuite) == null ? void 0 : _c.file) == null ? void 0 : _d.fullName), name2]),
+      fullName: createTaskName([(currentSuite == null ? void 0 : currentSuite.fullName) ?? ((_e = (_d = collectorContext.currentSuite) == null ? void 0 : _d.file) == null ? void 0 : _e.fullName), name2]),
       fullTestName: createTaskName([currentSuite == null ? void 0 : currentSuite.fullTestName, name2]),
       suite: currentSuite,
       each: options.each,
       fails: options.fails,
       context: void 0,
       type: "test",
-      file: (currentSuite == null ? void 0 : currentSuite.file) ?? ((_e = collectorContext.currentSuite) == null ? void 0 : _e.file),
+      file: (currentSuite == null ? void 0 : currentSuite.file) ?? ((_f = collectorContext.currentSuite) == null ? void 0 : _f.file),
       timeout,
       retry: options.retry ?? runner.config.retry,
       repeats: options.repeats,
@@ -2595,7 +2602,7 @@ function createSuiteCollector(name, factory = () => {
     if (task2.mode === "run" && !handler) {
       task2.mode = "todo";
     }
-    if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) {
+    if (options.concurrent ?? runner.config.sequence.concurrent) {
       task2.concurrent = true;
     }
     task2.shuffle = suiteOptions == null ? void 0 : suiteOptions.shuffle;
@@ -2626,18 +2633,11 @@ function createSuiteCollector(name, factory = () => {
     return task2;
   };
   const test2 = createTest(function(name2, optionsOrFn, timeoutOrTest) {
-    let { options, handler } = parseArguments(optionsOrFn, timeoutOrTest);
-    if (typeof suiteOptions === "object") {
-      options = Object.assign({}, suiteOptions, options);
-    }
-    const concurrent = this.concurrent ?? (!this.sequential && (options == null ? void 0 : options.concurrent));
-    if (options.concurrent != null && concurrent != null) {
+    const { options, handler } = parseArguments(optionsOrFn, timeoutOrTest);
+    const concurrent = this.concurrent ?? (options == null ? void 0 : options.concurrent);
+    if (concurrent != null) {
       options.concurrent = concurrent;
     }
-    const sequential = this.sequential ?? (!this.concurrent && (options == null ? void 0 : options.sequential));
-    if (options.sequential != null && sequential != null) {
-      options.sequential = sequential;
-    }
     const test3 = task(formatName(name2), {
       ...this,
       ...options,
@@ -2728,8 +2728,6 @@ function createSuite() {
     var _a;
     const currentSuite = collectorContext.currentSuite || defaultSuite;
     let { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);
-    const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;
-    const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;
     const { meta: parentMeta, ...parentOptions } = (currentSuite == null ? void 0 : currentSuite.options) || {};
     options = {
       ...parentOptions,
@@ -2743,13 +2741,9 @@ function createSuite() {
     if (mode === "run" && !factory) {
       mode = "todo";
     }
-    const isConcurrent = isConcurrentSpecified || options.concurrent && !isSequentialSpecified;
-    const isSequential = isSequentialSpecified || options.sequential && !isConcurrentSpecified;
-    if (isConcurrent != null) {
-      options.concurrent = isConcurrent && !isSequential;
-    }
-    if (isSequential != null) {
-      options.sequential = isSequential && !isConcurrent;
+    const concurrent = this.concurrent ?? options.concurrent;
+    if (concurrent != null) {
+      options.concurrent = concurrent;
     }
     if (parentMeta) {
       options.meta = Object.assign(/* @__PURE__ */ Object.create(null), parentMeta, options.meta);
@@ -2788,6 +2782,8 @@ function createSuite() {
     };
   };
   suiteFn.for = function(cases, ...args) {
+    const context = getChainableContext(this);
+    const suite2 = context.withContext();
     if (Array.isArray(cases) && args.length) {
       cases = formatTemplateString(cases, args);
     }
@@ -2795,7 +2791,7 @@ function createSuite() {
       const name_ = formatName(name);
       const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
       cases.forEach((item, idx) => {
-        suite(formatTitle(name_, toArray(item), idx), options, handler ? () => handler(item) : void 0);
+        suite2(formatTitle(name_, toArray(item), idx), options, handler ? () => handler(item) : void 0);
       });
     };
   };
@@ -2803,7 +2799,6 @@ function createSuite() {
   suiteFn.runIf = (condition) => condition ? suite : suite.skip;
   return createChainable([
     "concurrent",
-    "sequential",
     "shuffle",
     "skip",
     "only",
@@ -2892,17 +2887,17 @@ function createTaskCollector(fn) {
     if (typeof fixtureValue === "function") {
       const builderFn = fixtureValue;
       const fixture = async (ctx, use) => {
-        let cleanup;
+        let cleanup2;
         const onCleanup = (fn2) => {
-          if (cleanup !== void 0) {
+          if (cleanup2 !== void 0) {
             throw new Error(`onCleanup can only be called once per fixture. Define separate fixtures if you need multiple cleanup functions.`);
           }
-          cleanup = fn2;
+          cleanup2 = fn2;
         };
         const value = await builderFn(ctx, { onCleanup });
         await use(value);
-        if (cleanup) {
-          await cleanup();
+        if (cleanup2) {
+          await cleanup2();
         }
       };
       configureProps(fixture, { original: builderFn });
@@ -2944,7 +2939,6 @@ function createTaskCollector(fn) {
   taskFn.aroundAll = aroundAll;
   const _test = createChainable([
     "concurrent",
-    "sequential",
     "skip",
     "only",
     "todo",
@@ -3327,53 +3321,2268 @@ function manageArtifactAttachment(attachment) {
     attachment.bodyEncoding ?? (attachment.bodyEncoding = "base64");
   }
 }
-async function importId(id) {
-  const name = `/@id/${id}`.replace(/\\/g, "/");
-  return (/* @__PURE__ */ getBrowserState()).wrapModule(() => import(
-    /* @vite-ignore */
-    name
-  ));
+var comma = ",".charCodeAt(0);
+var chars$1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar$1 = new Uint8Array(64);
+var charToInt$1 = new Uint8Array(128);
+for (let i2 = 0; i2 < chars$1.length; i2++) {
+  const c = chars$1.charCodeAt(i2);
+  intToChar$1[i2] = c;
+  charToInt$1[c] = i2;
+}
+function decodeInteger(reader, relative) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt$1[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  return relative + value;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max) return false;
+  return reader.peek() !== comma;
+}
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn);
+      if (genColumn < lastCol) sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex = decodeInteger(reader, sourcesIndex);
+        sourceLine = decodeInteger(reader, sourceLine);
+        sourceColumn = decodeInteger(reader, sourceColumn);
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex = decodeInteger(reader, namesIndex);
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted) sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator);
+}
+function sortComparator(a, b2) {
+  return a[0] - b2[0];
+}
+var resolveUri_umd$1 = { exports: {} };
+var resolveUri_umd = resolveUri_umd$1.exports;
+var hasRequiredResolveUri_umd;
+function requireResolveUri_umd() {
+  if (hasRequiredResolveUri_umd) return resolveUri_umd$1.exports;
+  hasRequiredResolveUri_umd = 1;
+  (function(module, exports$1) {
+    (function(global, factory) {
+      module.exports = factory();
+    })(resolveUri_umd, (function() {
+      const schemeRegex = /^[\w+.-]+:\/\//;
+      const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+      const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+      function isAbsoluteUrl(input) {
+        return schemeRegex.test(input);
+      }
+      function isSchemeRelativeUrl(input) {
+        return input.startsWith("//");
+      }
+      function isAbsolutePath(input) {
+        return input.startsWith("/");
+      }
+      function isFileUrl(input) {
+        return input.startsWith("file:");
+      }
+      function isRelative(input) {
+        return /^[.?#]/.test(input);
+      }
+      function parseAbsoluteUrl(input) {
+        const match = urlRegex.exec(input);
+        return makeUrl(match[1], match[2] || "", match[3], match[4] || "", match[5] || "/", match[6] || "", match[7] || "");
+      }
+      function parseFileUrl(input) {
+        const match = fileRegex.exec(input);
+        const path = match[2];
+        return makeUrl("file:", "", match[1] || "", "", isAbsolutePath(path) ? path : "/" + path, match[3] || "", match[4] || "");
+      }
+      function makeUrl(scheme, user, host, port, path, query, hash) {
+        return {
+          scheme,
+          user,
+          host,
+          port,
+          path,
+          query,
+          hash,
+          type: 7
+        };
+      }
+      function parseUrl(input) {
+        if (isSchemeRelativeUrl(input)) {
+          const url3 = parseAbsoluteUrl("http:" + input);
+          url3.scheme = "";
+          url3.type = 6;
+          return url3;
+        }
+        if (isAbsolutePath(input)) {
+          const url3 = parseAbsoluteUrl("http://foo.com" + input);
+          url3.scheme = "";
+          url3.host = "";
+          url3.type = 5;
+          return url3;
+        }
+        if (isFileUrl(input))
+          return parseFileUrl(input);
+        if (isAbsoluteUrl(input))
+          return parseAbsoluteUrl(input);
+        const url2 = parseAbsoluteUrl("http://foo.com/" + input);
+        url2.scheme = "";
+        url2.host = "";
+        url2.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+        return url2;
+      }
+      function stripPathFilename(path) {
+        if (path.endsWith("/.."))
+          return path;
+        const index2 = path.lastIndexOf("/");
+        return path.slice(0, index2 + 1);
+      }
+      function mergePaths(url2, base) {
+        normalizePath(base, base.type);
+        if (url2.path === "/") {
+          url2.path = base.path;
+        } else {
+          url2.path = stripPathFilename(base.path) + url2.path;
+        }
+      }
+      function normalizePath(url2, type) {
+        const rel = type <= 4;
+        const pieces = url2.path.split("/");
+        let pointer = 1;
+        let positive = 0;
+        let addTrailingSlash = false;
+        for (let i2 = 1; i2 < pieces.length; i2++) {
+          const piece = pieces[i2];
+          if (!piece) {
+            addTrailingSlash = true;
+            continue;
+          }
+          addTrailingSlash = false;
+          if (piece === ".")
+            continue;
+          if (piece === "..") {
+            if (positive) {
+              addTrailingSlash = true;
+              positive--;
+              pointer--;
+            } else if (rel) {
+              pieces[pointer++] = piece;
+            }
+            continue;
+          }
+          pieces[pointer++] = piece;
+          positive++;
+        }
+        let path = "";
+        for (let i2 = 1; i2 < pointer; i2++) {
+          path += "/" + pieces[i2];
+        }
+        if (!path || addTrailingSlash && !path.endsWith("/..")) {
+          path += "/";
+        }
+        url2.path = path;
+      }
+      function resolve2(input, base) {
+        if (!input && !base)
+          return "";
+        const url2 = parseUrl(input);
+        let inputType = url2.type;
+        if (base && inputType !== 7) {
+          const baseUrl = parseUrl(base);
+          const baseType = baseUrl.type;
+          switch (inputType) {
+            case 1:
+              url2.hash = baseUrl.hash;
+            // fall through
+            case 2:
+              url2.query = baseUrl.query;
+            // fall through
+            case 3:
+            case 4:
+              mergePaths(url2, baseUrl);
+            // fall through
+            case 5:
+              url2.user = baseUrl.user;
+              url2.host = baseUrl.host;
+              url2.port = baseUrl.port;
+            // fall through
+            case 6:
+              url2.scheme = baseUrl.scheme;
+          }
+          if (baseType > inputType)
+            inputType = baseType;
+        }
+        normalizePath(url2, inputType);
+        const queryHash = url2.query + url2.hash;
+        switch (inputType) {
+          // This is impossible, because of the empty checks at the start of the function.
+          // case UrlType.Empty:
+          case 2:
+          case 3:
+            return queryHash;
+          case 4: {
+            const path = url2.path.slice(1);
+            if (!path)
+              return queryHash || ".";
+            if (isRelative(base || input) && !isRelative(path)) {
+              return "./" + path + queryHash;
+            }
+            return path + queryHash;
+          }
+          case 5:
+            return url2.path + queryHash;
+          default:
+            return url2.scheme + "//" + url2.user + url2.host + url2.port + url2.path + queryHash;
+        }
+      }
+      return resolve2;
+    }));
+  })(resolveUri_umd$1);
+  return resolveUri_umd$1.exports;
+}
+requireResolveUri_umd();
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index2) {
+  for (let i2 = index2 + 1; i2 < haystack.length; index2 = i2++) {
+    if (haystack[i2][COLUMN] !== needle) break;
+  }
+  return index2;
 }
-async function importFs(id) {
-  const name = `/@fs/${id}`.replace(/\\/g, "/");
-  return (/* @__PURE__ */ getBrowserState()).wrapModule(() => import(
-    /* @vite-ignore */
-    name
-  ));
+function lowerBound(haystack, needle, index2) {
+  for (let i2 = index2 - 1; i2 >= 0; index2 = i2--) {
+    if (haystack[i2][COLUMN] !== needle) break;
+  }
+  return index2;
 }
-const moduleRunner = {
-  isBrowser: true,
-  import: (id) => {
-    if (id[0] === "/" || id[1] === ":") {
-      return importFs(id);
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
     }
-    return importId(id);
   }
-};
-const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
-function getConfig() {
-  return (/* @__PURE__ */ getBrowserState()).config;
-}
-// @__NO_SIDE_EFFECTS__
-function getBrowserState() {
-  return window.__vitest_browser_runner__;
-}
-// @__NO_SIDE_EFFECTS__
-function getWorkerState() {
-  const state = window.__vitest_worker__;
-  if (!state) {
-    throw new Error("Worker state is not found. This is an issue with Vitest. Please, open an issue.");
-  }
-  return state;
-}
-export {
-  getConfig as a,
-  generateFileHash as b,
-  resolve as c,
-  getWorkerState as d,
-  getTestName as e,
-  getBrowserState as g,
-  moduleRunner as m,
-  now as n,
-  relative as r
-};
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0) throw new Error(LINE_GTR_ZERO);
+  if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length) return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index2 = traceSegmentInternal(
+    segments,
+    cast(map)._decodedMemo,
+    line,
+    column,
+    bias || GREATEST_LOWER_BOUND
+  );
+  if (index2 === -1) return OMapping(null, null, null, null);
+  const segment = segments[index2];
+  if (segment.length === 1) return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(
+    resolvedSources[segment[SOURCES_INDEX]],
+    segment[SOURCE_LINE] + 1,
+    segment[SOURCE_COLUMN],
+    segment.length === 5 ? names[segment[NAMES_INDEX]] : null
+  );
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index2 = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index2 = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index2);
+  } else if (bias === LEAST_UPPER_BOUND) index2++;
+  if (index2 === -1 || index2 === segments.length) return -1;
+  return index2;
+}
+function notNullish(v) {
+  return v != null;
+}
+const CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+const SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+const stackIgnorePatterns = [
+  "node:internal",
+  /\/packages\/\w+\/dist\//,
+  /\/@vitest\/\w+\/dist\//,
+  "/vitest/dist/",
+  "/vitest/src/",
+  "/node_modules/chai/",
+  "/node_modules/tinyspy/",
+  "/vite/dist/node/module-runner",
+  "/rolldown-vite/dist/node/module-runner",
+  // browser related deps
+  "/deps/chunk-",
+  "/deps/@vitest",
+  "/deps/loupe",
+  "/deps/chai",
+  "/browser-playwright/dist/locators.js",
+  "/browser-webdriverio/dist/locators.js",
+  "/browser-preview/dist/locators.js",
+  /node:\w+/,
+  /__vitest_test__/,
+  /__vitest_browser__/,
+  "/@id/__x00__vitest/browser",
+  /\/deps\/vitest_/
+];
+const NOW_LENGTH = Date.now().toString().length;
+const REGEXP_VITEST = new RegExp(`vitest=\\d{${NOW_LENGTH}}`);
+function extractLocation(urlLike) {
+  if (!urlLike.includes(":")) {
+    return [urlLike];
+  }
+  const regExp = /(.+?)(?::(\d+))?(?::(\d+))?$/;
+  const parts = regExp.exec(urlLike.replace(/^\(|\)$/g, ""));
+  if (!parts) {
+    return [urlLike];
+  }
+  let url2 = parts[1];
+  if (url2.startsWith("async ")) {
+    url2 = url2.slice(6);
+  }
+  if (url2.startsWith("http:") || url2.startsWith("https:")) {
+    const urlObj = new URL(url2);
+    urlObj.searchParams.delete("import");
+    urlObj.searchParams.delete("browserv");
+    url2 = urlObj.pathname + urlObj.hash + urlObj.search;
+  }
+  if (url2.startsWith("/@fs/")) {
+    const isWindows = /^\/@fs\/[a-zA-Z]:\//.test(url2);
+    url2 = url2.slice(isWindows ? 5 : 4);
+  }
+  if (url2.includes("vitest=")) {
+    url2 = url2.replace(REGEXP_VITEST, "").replace(/[?&]$/, "");
+  }
+  return [url2, parts[2] || void 0, parts[3] || void 0];
+}
+function parseSingleFFOrSafariStack(raw) {
+  let line = raw.trim();
+  if (SAFARI_NATIVE_CODE_REGEXP.test(line)) {
+    return null;
+  }
+  if (line.includes(" > eval")) {
+    line = line.replace(
+      / line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,
+      ":$1"
+    );
+  }
+  if (!line.includes("@")) {
+    return null;
+  }
+  let atIndex = -1;
+  let locationPart = "";
+  let functionName;
+  for (let i2 = 0; i2 < line.length; i2++) {
+    if (line[i2] === "@") {
+      const candidateLocation = line.slice(i2 + 1);
+      if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
+        atIndex = i2;
+        locationPart = candidateLocation;
+        functionName = i2 > 0 ? line.slice(0, i2) : void 0;
+        break;
+      }
+    }
+  }
+  if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) {
+    return null;
+  }
+  const [url2, lineNumber, columnNumber] = extractLocation(locationPart);
+  if (!url2 || !lineNumber || !columnNumber) {
+    return null;
+  }
+  return {
+    file: url2,
+    method: functionName || "",
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+function parseSingleV8Stack(raw) {
+  let line = raw.trim();
+  if (!CHROME_IE_STACK_REGEXP.test(line)) {
+    return null;
+  }
+  if (line.includes("(eval ")) {
+    line = line.replace(/eval code/g, "eval").replace(/(\(eval at [^()]*)|(,.*$)/g, "");
+  }
+  let sanitizedLine = line.replace(/^\s+/, "").replace(/\(eval code/g, "(").replace(/^.*?\s+/, "");
+  const location2 = sanitizedLine.match(/ (\(.+\)$)/);
+  sanitizedLine = location2 ? sanitizedLine.replace(location2[0], "") : sanitizedLine;
+  const [url2, lineNumber, columnNumber] = extractLocation(
+    location2 ? location2[1] : sanitizedLine
+  );
+  let method = location2 && sanitizedLine || "";
+  let file = url2 && ["eval", "<anonymous>"].includes(url2) ? void 0 : url2;
+  if (!file || !lineNumber || !columnNumber) {
+    return null;
+  }
+  if (method.startsWith("async ")) {
+    method = method.slice(6);
+  }
+  if (file.startsWith("file://")) {
+    file = file.slice(7);
+  }
+  file = file.startsWith("node:") || file.startsWith("internal:") ? file : resolve$1(file);
+  if (method) {
+    method = method.replace(/\(0\s?,\s?__vite_ssr_import_\d+__.(\w+)\)/g, "$1").replace(/__(vite_ssr_import|vi_import)_\d+__\./g, "").replace(/(Object\.)?__vite_ssr_export_default__\s?/g, "");
+  }
+  return {
+    method,
+    file,
+    line: Number.parseInt(lineNumber),
+    column: Number.parseInt(columnNumber)
+  };
+}
+function createStackString(stacks) {
+  return stacks.map((stack) => {
+    const line = `${stack.file}:${stack.line}:${stack.column}`;
+    if (stack.method) {
+      return `    at ${stack.method}(${line})`;
+    }
+    return `    at ${line}`;
+  }).join("\n");
+}
+function parseStacktrace(stack, options = {}) {
+  const { ignoreStackEntries = stackIgnorePatterns } = options;
+  let stacks = !CHROME_IE_STACK_REGEXP.test(stack) ? parseFFOrSafariStackTrace(stack) : parseV8Stacktrace(stack);
+  const helperIndex = stacks.findLastIndex(
+    (s) => (
+      // this covers cases such as
+      //   "__VITEST_HELPER__"
+      //   "__VITEST_HELPER__ [as <object method name>]"
+      //   "async*__VITEST_HELPER__" (firefox)
+      //   "async __VITEST_HELPER__" (webkit)
+      s.method.includes("__VITEST_HELPER__")
+    )
+  );
+  if (helperIndex >= 0) {
+    stacks = stacks.slice(helperIndex + 1);
+  }
+  return stacks.map((stack2) => {
+    var _a;
+    if (options.getUrlId) {
+      stack2.file = options.getUrlId(stack2.file);
+    }
+    const map = (_a = options.getSourceMap) == null ? void 0 : _a.call(options, stack2.file);
+    if (!map || typeof map !== "object" || !map.version) {
+      return shouldFilter(ignoreStackEntries, stack2.file) ? null : stack2;
+    }
+    const traceMap = new DecodedMap(map, stack2.file);
+    const position = getOriginalPosition(traceMap, stack2);
+    if (!position) {
+      return stack2;
+    }
+    const { line, column, source, name } = position;
+    let file = source || stack2.file;
+    if (file.match(/\/\w:\//)) {
+      file = file.slice(1);
+    }
+    if (shouldFilter(ignoreStackEntries, file)) {
+      return null;
+    }
+    if (line != null && column != null) {
+      return {
+        line,
+        column,
+        file,
+        method: name || stack2.method
+      };
+    }
+    return stack2;
+  }).filter((s) => s != null);
+}
+function shouldFilter(ignoreStackEntries, file) {
+  return ignoreStackEntries.some((p) => file.match(p));
+}
+function parseFFOrSafariStackTrace(stack) {
+  return stack.split("\n").map((line) => parseSingleFFOrSafariStack(line)).filter(notNullish);
+}
+function parseV8Stacktrace(stack) {
+  return stack.split("\n").map((line) => parseSingleV8Stack(line)).filter(notNullish);
+}
+class DecodedMap {
+  constructor(map, from) {
+    this.map = map;
+    const { mappings, names, sources } = map;
+    this.version = map.version;
+    this.names = names || [];
+    this._encoded = mappings || "";
+    this._decodedMemo = memoizedState();
+    this.url = from;
+    this.resolvedSources = (sources || []).map(
+      (s) => resolve$1(from, "..", s || "")
+    );
+  }
+  _encoded;
+  _decoded;
+  _decodedMemo;
+  url;
+  version;
+  names = [];
+  resolvedSources;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function getOriginalPosition(map, needle) {
+  const result = originalPositionFor(map, needle);
+  if (result.column == null) {
+    return null;
+  }
+  return result;
+}
+class VitestBrowserSnapshotEnvironment {
+  sourceMaps = /* @__PURE__ */ new Map();
+  traceMaps = /* @__PURE__ */ new Map();
+  addSourceMap(filepath, map) {
+    this.sourceMaps.set(filepath, map);
+  }
+  getVersion() {
+    return "1";
+  }
+  getHeader() {
+    return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
+  }
+  readSnapshotFile(filepath) {
+    return rpc$1().readSnapshotFile(filepath);
+  }
+  saveSnapshotFile(filepath, snapshot) {
+    return rpc$1().saveSnapshotFile(filepath, snapshot);
+  }
+  resolvePath(filepath) {
+    return rpc$1().resolveSnapshotPath(filepath);
+  }
+  resolveRawPath(testPath, rawPath) {
+    return rpc$1().resolveSnapshotRawPath(testPath, rawPath);
+  }
+  removeSnapshotFile(filepath) {
+    return rpc$1().removeSnapshotFile(filepath);
+  }
+  processStackTrace(stack) {
+    const map = this.sourceMaps.get(stack.file);
+    if (!map) {
+      return stack;
+    }
+    let traceMap = this.traceMaps.get(stack.file);
+    if (!traceMap) {
+      traceMap = new DecodedMap$1(map, stack.file);
+      this.traceMaps.set(stack.file, traceMap);
+    }
+    const position = getOriginalPosition$1(traceMap, stack);
+    if (position) {
+      return { ...stack, line: position.line, column: position.column };
+    }
+    return stack;
+  }
+}
+function rpc$1() {
+  return globalThis.__vitest_worker__.rpc;
+}
+const PSEUDO_CLASS_NAMES = [
+  ":hover",
+  ":active",
+  ":focus",
+  ":focus-visible",
+  ":focus-within"
+];
+function getBrowserTraceState() {
+  var _a;
+  return (_a = getBrowserState()).browserTraceState ?? (_a.browserTraceState = {});
+}
+function getTraceStateKey(testId, repeats, retry) {
+  return `${testId}:${repeats}:${retry}`;
+}
+function recordBrowserTraceEntry(task, options) {
+  const attemptInfo = getBrowserState().browserTraceAttempts.get(task.id);
+  const relativeStartTime = (options.startTime ?? now$1()) - attemptInfo.startTime;
+  const snapshot = takeSnapshot(options.element);
+  const entry = {
+    ...options,
+    startTime: relativeStartTime,
+    snapshot
+  };
+  const { retry, repeats } = attemptInfo;
+  const { recordCanvas } = getBrowserState().config.browser.traceView;
+  const state = getBrowserTraceState();
+  const traceKey = getTraceStateKey(task.id, repeats, retry);
+  state[traceKey] ?? (state[traceKey] = { retry, repeats, recordCanvas, entries: [] });
+  state[traceKey].entries.push(entry);
+}
+function takeSnapshot(serializedLocator) {
+  const { snapshot, createMirror } = getBrowserState().browserTraceDomSnapshot;
+  const traceView = getBrowserState().config.browser.traceView;
+  const engine = getBrowserState().selectorEngine;
+  const mirror = createMirror();
+  const serialized = snapshot(document, {
+    mirror,
+    inlineImages: traceView.inlineImages,
+    recordCanvas: traceView.recordCanvas
+  });
+  const result = {
+    serialized,
+    viewport: {
+      width: window.innerWidth,
+      height: window.innerHeight
+    },
+    scroll: {
+      x: window.scrollX,
+      y: window.scrollY
+    },
+    pseudoClassIds: {}
+  };
+  for (const className of PSEUDO_CLASS_NAMES) {
+    const elements = document.querySelectorAll(className);
+    const ids = Array.from(elements, (el) => mirror.getId(el)).filter((id) => id !== -1);
+    result.pseudoClassIds[className] = ids;
+  }
+  if (serializedLocator) {
+    try {
+      const el = engine.querySelector(
+        engine.parseSelector(serializedLocator._pwSelector ?? serializedLocator.selector),
+        document.documentElement,
+        false
+      );
+      if (!el) {
+        result.selectorResolution = "missing";
+      } else {
+        const id = mirror.getId(el);
+        if (id !== -1) {
+          result.selectorId = id;
+          result.selectorResolution = "matched";
+        } else {
+          result.selectorResolution = "missing";
+        }
+      }
+    } catch (error) {
+      result.selectorResolution = "error";
+      result.selectorError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  return result;
+}
+function getBrowserTrace(testId, repeats, retry) {
+  const state = getBrowserTraceState();
+  const traceKey = getTraceStateKey(testId, repeats, retry);
+  const result = state[traceKey];
+  if (result) {
+    delete state[traceKey];
+    return result;
+  }
+}
+const browserHashMap = /* @__PURE__ */ new Map();
+function createBrowserRunner(runnerClass, mocker, state, coverageModule) {
+  return class BrowserTestRunner extends runnerClass {
+    config;
+    hashMap = browserHashMap;
+    sourceMapCache = /* @__PURE__ */ new Map();
+    method = "run";
+    commands;
+    _otel;
+    constructor(options) {
+      super(options.config);
+      this.config = options.config;
+      this.commands = getBrowserState().commands;
+      this.viteEnvironment = "__browser__";
+      this._otel = getBrowserState().traces;
+    }
+    setMethod(method) {
+      this.method = method;
+    }
+    traces = /* @__PURE__ */ new Map();
+    onBeforeTryTask = async (...args) => {
+      var _a;
+      await userEvent.cleanup();
+      await ((_a = super.onBeforeTryTask) == null ? void 0 : _a.call(this, ...args));
+      const trace = this.config.browser.trace;
+      const test2 = args[0];
+      const { retry, repeats } = args[1];
+      const shouldTrace = trace !== "off" && !(trace === "on-all-retries" && retry === 0) && !(trace === "on-first-retry" && retry !== 1);
+      const shouldTraceView = this.config.browser.traceView.enabled;
+      if (!shouldTraceView && !shouldTrace) {
+        getBrowserState().activeTraceTaskIds.delete(test2.id);
+        getBrowserState().browserTraceAttempts.delete(test2.id);
+        return;
+      }
+      if (shouldTraceView) {
+        getBrowserState().browserTraceDomSnapshot = await __vitePreload(() => import("./rrweb-snapshot-xhvrgOHx.js"), true ? [] : void 0);
+        getBrowserState().browserTraceAttempts.set(test2.id, { retry, repeats, startTime: now$1() });
+      } else {
+        getBrowserState().browserTraceAttempts.delete(test2.id);
+      }
+      if (!shouldTrace) {
+        getBrowserState().activeTraceTaskIds.delete(test2.id);
+        return;
+      }
+      getBrowserState().activeTraceTaskIds.add(test2.id);
+      let title = getTestName(test2);
+      if (retry) {
+        title += ` (retry x${retry})`;
+      }
+      if (repeats) {
+        title += ` (repeat x${repeats})`;
+      }
+      const name = getTraceName(test2, retry, repeats);
+      await this.commands.triggerCommand(
+        "__vitest_startChunkTrace",
+        [{ name, title }]
+      );
+    };
+    onAfterRetryTask = async (test2, { retry, repeats }) => {
+      var _a, _b, _c, _d, _e, _f;
+      const hasActiveTraceView = getBrowserState().browserTraceAttempts.has(test2.id);
+      if (hasActiveTraceView) {
+        const status = (_a = test2.result) == null ? void 0 : _a.state;
+        const stack = status === "fail" ? (_c = (_b = test2.result) == null ? void 0 : _b.errors) == null ? void 0 : _c[0].stack : void 0;
+        const location2 = test2.location ? { ...test2.location, file: test2.file.filepath } : void 0;
+        recordBrowserTraceEntry(test2, {
+          name: `vitest:onAfterRetryTask`,
+          kind: "lifecycle",
+          ...status === "pass" || status === "fail" ? { status } : {},
+          ...stack ? { stack } : location2 ? { location: location2 } : {}
+        });
+        const traceData = getBrowserTrace(test2.id, repeats, retry);
+        if (traceData) {
+          await this.commands.triggerCommand(
+            "__vitest_recordBrowserTrace",
+            [{ testId: test2.id, data: traceData }]
+          );
+        }
+        getBrowserState().browserTraceAttempts.delete(test2.id);
+      }
+      const hasActiveTrace = getBrowserState().activeTraceTaskIds.has(test2.id);
+      if (!hasActiveTrace) {
+        return;
+      }
+      await this.commands.triggerCommand("__vitest_markTrace", [{
+        name: `onAfterRetryTask [${(_d = test2.result) == null ? void 0 : _d.state}]`,
+        stack: (_f = (_e = test2.result) == null ? void 0 : _e.errors) == null ? void 0 : _f[0].stack
+      }]);
+      const name = getTraceName(test2, retry, repeats);
+      if (!this.traces.has(test2.id)) {
+        this.traces.set(test2.id, []);
+      }
+      const traces2 = this.traces.get(test2.id);
+      const { tracePath } = await this.commands.triggerCommand(
+        "__vitest_stopChunkTrace",
+        [{ name }]
+      );
+      traces2.push(tracePath);
+    };
+    onAfterRunTask = async (task) => {
+      var _a, _b, _c;
+      await ((_a = super.onAfterRunTask) == null ? void 0 : _a.call(this, task));
+      const trace = this.config.browser.trace;
+      const traces2 = this.traces.get(task.id) || [];
+      if (traces2.length) {
+        if (trace === "retain-on-failure" && ((_b = task.result) == null ? void 0 : _b.state) === "pass") {
+          await this.commands.triggerCommand(
+            "__vitest_deleteTracing",
+            [{ traces: traces2 }]
+          );
+        } else {
+          await this.commands.triggerCommand(
+            "__vitest_annotateTraces",
+            [{ testId: task.id, traces: traces2 }]
+          );
+        }
+      }
+      if (this.config.bail && ((_c = task.result) == null ? void 0 : _c.state) === "fail") {
+        const previousFailures = await rpc$2().getCountOfFailedTests();
+        const currentFailures = 1 + previousFailures;
+        if (currentFailures >= this.config.bail) {
+          rpc$2().cancelCurrentRun("test-failure");
+          this.cancel("test-failure");
+        }
+      }
+    };
+    onTaskFinished = async (task) => {
+      var _a, _b, _c, _d, _e, _f;
+      const lastErrorContext = (_c = (_b = (_a = task.result) == null ? void 0 : _a.errors) == null ? void 0 : _b.at(-1)) == null ? void 0 : _c.__vitest_error_context__;
+      if (this.config.browser.screenshotFailures && document.body.clientHeight > 0 && ((_d = task.result) == null ? void 0 : _d.state) === "fail" && task.type === "test" && !(lastErrorContext && Reflect.get(lastErrorContext, "assertionName") === "toMatchScreenshot" && ((_e = Reflect.get(lastErrorContext, "meta")) == null ? void 0 : _e.outcome) !== "unstable-screenshot")) {
+        const screenshot = await page.screenshot(
+          {
+            timeout: ((_f = this.config.browser.providerOptions) == null ? void 0 : _f.actionTimeout) ?? 5e3
+          }
+          /** TODO */
+        ).catch((err) => {
+          console.error("[vitest] Failed to take a screenshot", err);
+        });
+        if (screenshot) {
+          await recordArtifact$1(task, {
+            type: "internal:failureScreenshot",
+            attachments: [{ contentType: "image/png", path: screenshot, originalPath: screenshot }]
+          });
+        }
+      }
+    };
+    cancel = (reason) => {
+      var _a;
+      (_a = super.cancel) == null ? void 0 : _a.call(this, reason);
+      globalChannel.postMessage({ type: "cancel", reason });
+    };
+    onBeforeRunSuite = async (suite2) => {
+      var _a;
+      await Promise.all([
+        (_a = super.onBeforeRunSuite) == null ? void 0 : _a.call(this, suite2),
+        (async () => {
+          if (!("filepath" in suite2)) {
+            return;
+          }
+          const map = await rpc$2().getBrowserFileSourceMap(suite2.filepath);
+          this.sourceMapCache.set(suite2.filepath, map);
+          const snapshotEnvironment = this.config.snapshotOptions.snapshotEnvironment;
+          if (snapshotEnvironment instanceof VitestBrowserSnapshotEnvironment) {
+            snapshotEnvironment.addSourceMap(suite2.filepath, map);
+          }
+        })()
+      ]);
+    };
+    onAfterRunFiles = async (files) => {
+      var _a, _b;
+      const [coverage] = await Promise.all([
+        (_a = coverageModule == null ? void 0 : coverageModule.takeCoverage) == null ? void 0 : _a.call(coverageModule),
+        mocker.invalidate(),
+        (_b = super.onAfterRunFiles) == null ? void 0 : _b.call(this, files)
+      ]);
+      if (coverage) {
+        await rpc$2().onAfterSuiteRun({
+          coverage,
+          testFiles: files.map((file) => file.name),
+          environment: "__browser__",
+          projectName: this.config.name
+        });
+      }
+    };
+    onCollectStart = (file) => {
+      return rpc$2().onQueued(this.method, file);
+    };
+    onCollected = async (files) => {
+      files.forEach((file) => {
+        file.prepareDuration = state.durations.prepare;
+        file.environmentLoad = state.durations.environment;
+        state.durations.prepare = 0;
+        state.durations.environment = 0;
+      });
+      if (this.config.includeTaskLocation) {
+        try {
+          await updateTestFilesLocations(files, this.sourceMapCache);
+        } catch {
+        }
+      }
+      return rpc$2().onCollected(this.method, files);
+    };
+    onTestAnnotate = (test2, annotation) => {
+      const artifact = { type: "internal:annotation", annotation, location: annotation.location };
+      return this.onTestArtifactRecord(test2, artifact).then(({ annotation: annotation2 }) => annotation2);
+    };
+    onTestArtifactRecord = (test2, artifact) => {
+      if (artifact.location) {
+        const map = this.sourceMapCache.get(artifact.location.file);
+        if (!map) {
+          return rpc$2().onTaskArtifactRecord(test2.id, artifact);
+        }
+        const traceMap = new DecodedMap$1(map, artifact.location.file);
+        const position = getOriginalPosition$1(traceMap, artifact.location);
+        if (position) {
+          const { source, column, line } = position;
+          const file = source || artifact.location.file;
+          artifact.location = {
+            line,
+            column: column + 1,
+            // if the file path is on windows, we need to remove the starting slash
+            file: file.match(/\/\w:\//) ? file.slice(1) : file
+          };
+          if (artifact.type === "internal:annotation") {
+            artifact.annotation.location = artifact.location;
+          }
+        }
+      }
+      return rpc$2().onTaskArtifactRecord(test2.id, artifact);
+    };
+    onTaskUpdate = (task, events) => {
+      return rpc$2().onTaskUpdate(this.method, task, events);
+    };
+    importFile = async (filepath, mode) => {
+      let hash = this.hashMap.get(filepath);
+      if (mode === "setup" || !hash) {
+        hash = Date.now().toString();
+        this.hashMap.set(filepath, hash);
+      }
+      const prefix = `/${/^\w:/.test(filepath) ? "@fs/" : ""}`;
+      const query = `browserv=${hash}`;
+      const importpath = `${prefix}${filepath}?${query}`.replace(/\/+/g, "/");
+      const trace = this.config.browser.trace;
+      if (mode === "collect" && trace !== "off") {
+        await this.commands.triggerCommand("__vitest_startTracing", []);
+      }
+      try {
+        await import(
+          /* @vite-ignore */
+          importpath
+        );
+      } catch (err) {
+        throw new Error(`Failed to import test file ${filepath}`, { cause: err });
+      }
+    };
+    trace = (name, attributes, cb) => {
+      const options = typeof attributes === "object" ? { attributes } : {};
+      return this._otel.$(`vitest.test.runner.${name}`, options, cb || attributes);
+    };
+  };
+}
+let cachedRunner = null;
+function getBrowserRunner() {
+  return cachedRunner;
+}
+async function initiateRunner(state, mocker, config) {
+  if (cachedRunner) {
+    return cachedRunner;
+  }
+  const runnerClass = config.mode === "test" ? TestRunner : BenchmarkRunner;
+  const BrowserRunner = createBrowserRunner(runnerClass, mocker, state, {
+    takeCoverage: () => takeCoverageInsideWorker(config.coverage, moduleRunner)
+  });
+  if (!config.snapshotOptions.snapshotEnvironment) {
+    config.snapshotOptions.snapshotEnvironment = new VitestBrowserSnapshotEnvironment();
+  }
+  const runner2 = new BrowserRunner({
+    config
+  });
+  cachedRunner = runner2;
+  onCancel((reason) => {
+    var _a;
+    (_a = runner2.cancel) == null ? void 0 : _a.call(runner2, reason);
+  });
+  const [diffOptions] = await Promise.all([
+    loadDiffConfig(config, moduleRunner),
+    loadSnapshotSerializers(config, moduleRunner)
+  ]);
+  runner2.config.diffOptions = diffOptions;
+  getWorkerState().onFilterStackTrace = (stack) => {
+    const stacks = parseStacktrace(stack, {
+      getSourceMap(file) {
+        return runner2.sourceMapCache.get(file);
+      }
+    });
+    return createStackString(stacks);
+  };
+  return runner2;
+}
+async function getTraceMap(file, sourceMaps) {
+  const result = sourceMaps.get(file) || await rpc$2().getBrowserFileSourceMap(file).then((map) => {
+    sourceMaps.set(file, map);
+    return map;
+  });
+  if (!result) {
+    return null;
+  }
+  return new DecodedMap$1(result, file);
+}
+async function updateTestFilesLocations(files, sourceMaps) {
+  const promises2 = files.map(async (file) => {
+    const traceMap = await getTraceMap(file.filepath, sourceMaps);
+    if (!traceMap) {
+      return null;
+    }
+    const updateLocation = (task) => {
+      if (task.location) {
+        const position = getOriginalPosition$1(traceMap, task.location);
+        if (position) {
+          const { line, column } = position;
+          task.location = { line, column: task.each ? column : column + 1 };
+        }
+      }
+      if ("tasks" in task) {
+        task.tasks.forEach(updateLocation);
+      }
+    };
+    file.tasks.forEach(updateLocation);
+    return null;
+  });
+  await Promise.all(promises2);
+}
+function getTraceName(task, retryCount, repeatsCount) {
+  const name = getTestName(task, "-").replace(/[^a-z0-9]/gi, "-");
+  return `${name}-${repeatsCount}-${retryCount}`;
+}
+const { Date: Date$1, console: console$1, performance: performance$1 } = globalThis;
+function setupConsoleLogSpy() {
+  const {
+    log,
+    info,
+    error,
+    dir,
+    dirxml,
+    trace,
+    time,
+    timeEnd,
+    timeLog,
+    warn,
+    debug: debug2,
+    count,
+    countReset
+  } = console$1;
+  console$1.log = stdout(log);
+  console$1.debug = stdout(debug2);
+  console$1.info = stdout(info);
+  console$1.error = stderr(error);
+  console$1.warn = stderr(warn);
+  console$1.dir = (item, options) => {
+    dir(item, options);
+    sendLog("stdout", processLog([item]));
+  };
+  console$1.dirxml = (...args) => {
+    dirxml(...args);
+    sendLog("stdout", processLog(args));
+  };
+  console$1.trace = (...args) => {
+    var _a;
+    trace(...args);
+    const content = processLog(args);
+    const error2 = new Error("$$Trace");
+    const processor = ((_a = globalThis.__vitest_worker__) == null ? void 0 : _a.onFilterStackTrace) || ((s) => s || "");
+    const stack = processor(error2.stack || "");
+    sendLog("stderr", `${content}
+${stack}`, true);
+  };
+  const timeLabels = {};
+  console$1.time = (label = "default") => {
+    time(label);
+    const now2 = performance$1.now();
+    timeLabels[label] = now2;
+  };
+  console$1.timeLog = (label = "default") => {
+    timeLog(label);
+    if (!(label in timeLabels)) {
+      sendLog("stderr", `Timer "${label}" does not exist`);
+    } else {
+      sendLog("stdout", `${label}: ${timeLabels[label]} ms`);
+    }
+  };
+  console$1.timeEnd = (label = "default") => {
+    timeEnd(label);
+    const end = performance$1.now();
+    const start = timeLabels[label];
+    if (!(label in timeLabels)) {
+      sendLog("stderr", `Timer "${label}" does not exist`);
+    } else if (typeof start !== "undefined") {
+      const duration = end - start;
+      sendLog("stdout", `${label}: ${duration} ms`);
+    }
+  };
+  const countLabels = {};
+  console$1.count = (label = "default") => {
+    count(label);
+    const counter = (countLabels[label] ?? 0) + 1;
+    countLabels[label] = counter;
+    sendLog("stdout", `${label}: ${counter}`);
+  };
+  console$1.countReset = (label = "default") => {
+    countReset(label);
+    countLabels[label] = 0;
+  };
+}
+function stdout(base) {
+  return (...args) => {
+    base(...args);
+    if (args[0] === "[WDIO]") {
+      if (args[1] === "newShadowRoot" || args[1] === "removeShadowRoot") {
+        return;
+      }
+    }
+    sendLog("stdout", processLog(args));
+  };
+}
+function stderr(base) {
+  return (...args) => {
+    base(...args);
+    sendLog("stderr", processLog(args));
+  };
+}
+function processLog(args) {
+  return format$2(args, { multiline: true });
+}
+function sendLog(type, content, disableStack) {
+  var _a, _b, _c;
+  if (content.startsWith("[vite]")) {
+    return;
+  }
+  const unknownTestId = "__vitest__unknown_test__";
+  const taskId = ((_b = (_a = globalThis.__vitest_worker__) == null ? void 0 : _a.current) == null ? void 0 : _b.id) ?? unknownTestId;
+  const origin = getConfig$1().printConsoleTrace && !disableStack ? (_c = new Error("STACK_TRACE").stack) == null ? void 0 : _c.split("\n").slice(1).join("\n") : void 0;
+  const runner2 = getBrowserRunner();
+  rpc$2().sendLog((runner2 == null ? void 0 : runner2.method) || "run", {
+    origin,
+    content,
+    browser: true,
+    time: Date$1.now(),
+    taskId,
+    type,
+    size: content.length
+  });
+}
+class MockerRegistry {
+  registryByUrl = /* @__PURE__ */ new Map();
+  registryById = /* @__PURE__ */ new Map();
+  clear() {
+    this.registryByUrl.clear();
+    this.registryById.clear();
+  }
+  keys() {
+    return this.registryByUrl.keys();
+  }
+  add(mock) {
+    this.registryByUrl.set(mock.url, mock);
+    this.registryById.set(mock.id, mock);
+  }
+  register(typeOrEvent, raw, id, url2, factoryOrRedirect) {
+    const type = typeof typeOrEvent === "object" ? typeOrEvent.type : typeOrEvent;
+    if (typeof typeOrEvent === "object") {
+      const event = typeOrEvent;
+      if (event instanceof AutomockedModule || event instanceof AutospiedModule || event instanceof ManualMockedModule || event instanceof RedirectedModule) {
+        throw new TypeError(`[vitest] Cannot register a mock that is already defined. Expected a JSON representation from \`MockedModule.toJSON\`, instead got "${event.type}". Use "registry.add()" to update a mock instead.`);
+      }
+      if (event.type === "automock") {
+        const module = AutomockedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "autospy") {
+        const module = AutospiedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "redirect") {
+        const module = RedirectedModule.fromJSON(event);
+        this.add(module);
+        return module;
+      } else if (event.type === "manual") {
+        throw new Error(`Cannot set serialized manual mock. Define a factory function manually with \`ManualMockedModule.fromJSON()\`.`);
+      } else {
+        throw new Error(`Unknown mock type: ${event.type}`);
+      }
+    }
+    if (typeof raw !== "string") {
+      throw new TypeError("[vitest] Mocks require a raw string.");
+    }
+    if (typeof url2 !== "string") {
+      throw new TypeError("[vitest] Mocks require a url string.");
+    }
+    if (typeof id !== "string") {
+      throw new TypeError("[vitest] Mocks require an id string.");
+    }
+    if (type === "manual") {
+      if (typeof factoryOrRedirect !== "function") {
+        throw new TypeError("[vitest] Manual mocks require a factory function.");
+      }
+      const mock = new ManualMockedModule(raw, id, url2, factoryOrRedirect);
+      this.add(mock);
+      return mock;
+    } else if (type === "automock" || type === "autospy") {
+      const mock = type === "automock" ? new AutomockedModule(raw, id, url2) : new AutospiedModule(raw, id, url2);
+      this.add(mock);
+      return mock;
+    } else if (type === "redirect") {
+      if (typeof factoryOrRedirect !== "string") {
+        throw new TypeError("[vitest] Redirect mocks require a redirect string.");
+      }
+      const mock = new RedirectedModule(raw, id, url2, factoryOrRedirect);
+      this.add(mock);
+      return mock;
+    } else {
+      throw new Error(`[vitest] Unknown mock type: ${type}`);
+    }
+  }
+  delete(id) {
+    this.registryByUrl.delete(id);
+  }
+  deleteById(id) {
+    this.registryById.delete(id);
+  }
+  get(id) {
+    return this.registryByUrl.get(id);
+  }
+  getById(id) {
+    return this.registryById.get(id);
+  }
+  has(id) {
+    return this.registryByUrl.has(id);
+  }
+}
+class AutomockedModule {
+  type = "automock";
+  constructor(raw, id, url2) {
+    this.raw = raw;
+    this.id = id;
+    this.url = url2;
+  }
+  static fromJSON(data) {
+    return new AutomockedModule(data.raw, data.id, data.url);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw,
+      id: this.id
+    };
+  }
+}
+class AutospiedModule {
+  type = "autospy";
+  constructor(raw, id, url2) {
+    this.raw = raw;
+    this.id = id;
+    this.url = url2;
+  }
+  static fromJSON(data) {
+    return new AutospiedModule(data.raw, data.id, data.url);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      id: this.id,
+      raw: this.raw
+    };
+  }
+}
+class RedirectedModule {
+  type = "redirect";
+  constructor(raw, id, url2, redirect) {
+    this.raw = raw;
+    this.id = id;
+    this.url = url2;
+    this.redirect = redirect;
+  }
+  static fromJSON(data) {
+    return new RedirectedModule(data.raw, data.id, data.url, data.redirect);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      raw: this.raw,
+      id: this.id,
+      redirect: this.redirect
+    };
+  }
+}
+class ManualMockedModule {
+  cache;
+  type = "manual";
+  constructor(raw, id, url2, factory) {
+    this.raw = raw;
+    this.id = id;
+    this.url = url2;
+    this.factory = factory;
+  }
+  resolve() {
+    if (this.cache) {
+      return this.cache;
+    }
+    let exports$1;
+    try {
+      exports$1 = this.factory();
+    } catch (err) {
+      throw createHelpfulError(err);
+    }
+    if (typeof exports$1 === "object" && typeof (exports$1 == null ? void 0 : exports$1.then) === "function") {
+      return exports$1.then((result) => {
+        assertValidExports(this.raw, result);
+        return this.cache = result;
+      }, (error) => {
+        throw createHelpfulError(error);
+      });
+    }
+    assertValidExports(this.raw, exports$1);
+    return this.cache = exports$1;
+  }
+  static fromJSON(data, factory) {
+    return new ManualMockedModule(data.raw, data.id, data.url, factory);
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      url: this.url,
+      id: this.id,
+      raw: this.raw
+    };
+  }
+}
+function createHelpfulError(cause) {
+  const error = new Error('[vitest] There was an error when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/vi.html#vi-mock');
+  error.cause = cause;
+  return error;
+}
+function assertValidExports(raw, exports$1) {
+  if (exports$1 === null || typeof exports$1 !== "object" || Array.isArray(exports$1)) {
+    throw new TypeError(`[vitest] vi.mock("${raw}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`);
+  }
+}
+function mockObject(options, object2, mockExports = {}) {
+  const finalizers = new Array();
+  const refs = new RefTracker();
+  const define = (container, key, value) => {
+    try {
+      container[key] = value;
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const createMock = (currentValue) => {
+    if (!options.createMockInstance) {
+      throw new Error("[@vitest/mocker] `createMockInstance` is not defined. This is a Vitest error. Please open a new issue with reproduction.");
+    }
+    const createMockInstance = options.createMockInstance;
+    const prototypeMembers = currentValue.prototype ? collectFunctionProperties(currentValue.prototype) : [];
+    return createMockInstance({
+      name: currentValue.name,
+      prototypeMembers,
+      originalImplementation: options.type === "autospy" ? currentValue : void 0,
+      keepMembersImplementation: options.type === "autospy"
+    });
+  };
+  const mockPropertiesOf = (container, newContainer) => {
+    const containerType = getType(container);
+    const isModule = containerType === "Module" || !!container.__esModule;
+    for (const { key: property, descriptor } of getAllMockableProperties(container, isModule, options.globalConstructors)) {
+      if (!isModule && descriptor.get) {
+        try {
+          if (options.type === "autospy") {
+            Object.defineProperty(newContainer, property, descriptor);
+          } else {
+            Object.defineProperty(newContainer, property, {
+              configurable: descriptor.configurable,
+              enumerable: descriptor.enumerable,
+              get: () => {
+              },
+              set: descriptor.set ? () => {
+              } : void 0
+            });
+          }
+        } catch {
+        }
+        continue;
+      }
+      if (isReadonlyProp(container[property], property)) {
+        continue;
+      }
+      const value = container[property];
+      const refId = refs.getId(value);
+      if (refId !== void 0) {
+        finalizers.push(() => define(newContainer, property, refs.getMockedValue(refId)));
+        continue;
+      }
+      const type = getType(value);
+      if (Array.isArray(value)) {
+        if (options.type === "automock") {
+          define(newContainer, property, []);
+        } else {
+          const array = value.map((value2) => {
+            if (value2 && typeof value2 === "object") {
+              const newObject = {};
+              mockPropertiesOf(value2, newObject);
+              return newObject;
+            }
+            if (typeof value2 === "function") {
+              return createMock(value2);
+            }
+            return value2;
+          });
+          define(newContainer, property, array);
+        }
+        continue;
+      }
+      const isFunction = type.includes("Function") && typeof value === "function";
+      if ((!isFunction || value._isMockFunction) && type !== "Object" && type !== "Module") {
+        define(newContainer, property, value);
+        continue;
+      }
+      if (options.type === "autospy" && type === "Module") {
+        const exports$1 = /* @__PURE__ */ Object.create(null);
+        Object.defineProperty(exports$1, Symbol.toStringTag, {
+          value: "Module",
+          configurable: true,
+          writable: true
+        });
+        try {
+          newContainer[property] = exports$1;
+        } catch {
+          continue;
+        }
+      } else if (!define(newContainer, property, isFunction || options.type === "autospy" ? value : {})) {
+        continue;
+      }
+      if (isFunction) {
+        const mock = createMock(newContainer[property]);
+        newContainer[property] = mock;
+      }
+      refs.track(value, newContainer[property]);
+      mockPropertiesOf(value, newContainer[property]);
+    }
+  };
+  const mockedObject = mockExports;
+  mockPropertiesOf(object2, mockedObject);
+  for (const finalizer of finalizers) {
+    finalizer();
+  }
+  return mockedObject;
+}
+class RefTracker {
+  idMap = /* @__PURE__ */ new Map();
+  mockedValueMap = /* @__PURE__ */ new Map();
+  getId(value) {
+    return this.idMap.get(value);
+  }
+  getMockedValue(id) {
+    return this.mockedValueMap.get(id);
+  }
+  track(originalValue, mockedValue) {
+    const newId = this.idMap.size;
+    this.idMap.set(originalValue, newId);
+    this.mockedValueMap.set(newId, mockedValue);
+    return newId;
+  }
+}
+function getType(value) {
+  return Object.prototype.toString.apply(value).slice(8, -1);
+}
+function isReadonlyProp(object2, prop) {
+  if (prop === "arguments" || prop === "caller" || prop === "callee" || prop === "name" || prop === "length") {
+    const typeName = getType(object2);
+    return typeName === "Function" || typeName === "AsyncFunction" || typeName === "GeneratorFunction" || typeName === "AsyncGeneratorFunction";
+  }
+  if (prop === "source" || prop === "global" || prop === "ignoreCase" || prop === "multiline") {
+    return getType(object2) === "RegExp";
+  }
+  return false;
+}
+function getAllMockableProperties(obj, isModule, constructors) {
+  const { Map: Map2, Object: Object2, Function: Function2, RegExp: RegExp2, Array: Array2 } = constructors;
+  const allProps = new Map2();
+  let curr = obj;
+  do {
+    if (curr === Object2.prototype || curr === Function2.prototype || curr === RegExp2.prototype) {
+      break;
+    }
+    collectOwnProperties(curr, (key) => {
+      const descriptor = Object2.getOwnPropertyDescriptor(curr, key);
+      if (descriptor) {
+        allProps.set(key, {
+          key,
+          descriptor
+        });
+      }
+    });
+  } while (curr = Object2.getPrototypeOf(curr));
+  if (isModule && !allProps.has("default") && "default" in obj) {
+    const descriptor = Object2.getOwnPropertyDescriptor(obj, "default");
+    if (descriptor) {
+      allProps.set("default", {
+        key: "default",
+        descriptor
+      });
+    }
+  }
+  return Array2.from(allProps.values());
+}
+function collectOwnProperties(obj, collector) {
+  const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+  Object.getOwnPropertyNames(obj).forEach(collect);
+  Object.getOwnPropertySymbols(obj).forEach(collect);
+}
+function collectFunctionProperties(prototype) {
+  const properties = /* @__PURE__ */ new Set();
+  collectOwnProperties(prototype, (prop) => {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, prop);
+    if (!descriptor || descriptor.get) {
+      return;
+    }
+    const type = getType(descriptor.value);
+    if (type.includes("Function") && !isReadonlyProp(descriptor.value, prop)) {
+      properties.add(prop);
+    }
+  });
+  return Array.from(properties);
+}
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+  let path = "";
+  for (const seg of segments) {
+    if (!seg) {
+      continue;
+    }
+    if (path.length > 0) {
+      const pathTrailing = path[path.length - 1] === "/";
+      const segLeading = seg[0] === "/";
+      const both = pathTrailing && segLeading;
+      if (both) {
+        path += seg.slice(1);
+      } else {
+        path += pathTrailing || segLeading ? seg : `/${seg}`;
+      }
+    } else {
+      path += seg;
+    }
+  }
+  return normalize(path);
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index2 = 0; index2 <= path.length; ++index2) {
+    if (index2 < path.length) {
+      char = path[index2];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index2 - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index2;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index2;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index2)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index2);
+        }
+        lastSegmentLength = index2 - lastSlash - 1;
+      }
+      lastSlash = index2;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+const isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+const extname = function(p) {
+  if (p === "..") return "";
+  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+  return match && match[1] || "";
+};
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i2 = 0; i2 < chars.length; i2++) {
+  const c = chars.charCodeAt(i2);
+  intToChar[i2] = c;
+  charToInt[c] = i2;
+}
+Date.now().toString().length;
+const { now } = Date;
+class ModuleMocker {
+  registry = new MockerRegistry();
+  queue = /* @__PURE__ */ new Set();
+  mockedIds = /* @__PURE__ */ new Set();
+  constructor(interceptor, rpc2, createMockInstance, config) {
+    this.interceptor = interceptor;
+    this.rpc = rpc2;
+    this.createMockInstance = createMockInstance;
+    this.config = config;
+  }
+  async prepare() {
+    if (!this.queue.size) {
+      return;
+    }
+    await Promise.all([...this.queue.values()]);
+  }
+  async resolveFactoryModule(id) {
+    const mock = this.registry.get(id);
+    if (!mock || mock.type !== "manual") {
+      throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+    }
+    const result = await mock.resolve();
+    return result;
+  }
+  getFactoryModule(id) {
+    const mock = this.registry.get(id);
+    if (!mock || mock.type !== "manual") {
+      throw new Error(`Mock ${id} wasn't registered. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+    }
+    if (!mock.cache) {
+      throw new Error(`Mock ${id} wasn't resolved. This is probably a Vitest error. Please, open a new issue with reproduction.`);
+    }
+    return mock.cache;
+  }
+  async invalidate() {
+    const ids = Array.from(this.mockedIds);
+    if (!ids.length) {
+      return;
+    }
+    await this.rpc.invalidate(ids);
+    await this.interceptor.invalidate();
+    this.registry.clear();
+  }
+  async importActual(id, importer) {
+    const resolved = await this.rpc.resolveId(id, importer);
+    if (resolved == null) {
+      throw new Error(`[vitest] Cannot resolve "${id}" imported from "${importer}"`);
+    }
+    const ext = extname(resolved.id);
+    const url2 = new URL(resolved.url, this.getBaseUrl());
+    const query = `_vitest_original&ext${ext}`;
+    const actualUrl = `${url2.pathname}${url2.search ? `${url2.search}&${query}` : `?${query}`}${url2.hash}`;
+    return this.wrapDynamicImport(() => import(
+      /* @vite-ignore */
+      actualUrl
+    )).then((mod) => {
+      if (!resolved.optimized || typeof mod.default === "undefined") {
+        return mod;
+      }
+      const m = mod.default;
+      return (m == null ? void 0 : m.__esModule) ? m : {
+        ...typeof m === "object" && !Array.isArray(m) || typeof m === "function" ? m : {},
+        default: m
+      };
+    });
+  }
+  getBaseUrl() {
+    return location.href;
+  }
+  async importMock(rawId, importer) {
+    await this.prepare();
+    const { resolvedId, resolvedUrl, redirectUrl } = await this.rpc.resolveMock(rawId, importer, { mock: "auto" });
+    const mockUrl = this.resolveMockPath(cleanVersion(resolvedUrl));
+    let mock = this.registry.get(mockUrl);
+    if (!mock) {
+      if (redirectUrl) {
+        const resolvedRedirect = new URL(this.resolveMockPath(cleanVersion(redirectUrl)), this.getBaseUrl()).toString();
+        mock = new RedirectedModule(rawId, resolvedId, mockUrl, resolvedRedirect);
+      } else {
+        mock = new AutomockedModule(rawId, resolvedId, mockUrl);
+      }
+    }
+    if (mock.type === "manual") {
+      return await mock.resolve();
+    }
+    if (mock.type === "automock" || mock.type === "autospy") {
+      const url2 = new URL(`/@id/${resolvedId}`, this.getBaseUrl());
+      const query = url2.search ? `${url2.search}&t=${now()}` : `?t=${now()}`;
+      const moduleObject = await __vitePreload(() => import(
+        /* @vite-ignore */
+        `${url2.pathname}${query}&mock=${mock.type}${url2.hash}`
+      ), true ? [] : void 0);
+      return this.mockObject(moduleObject, mock.type);
+    }
+    return import(
+      /* @vite-ignore */
+      mock.redirect
+    );
+  }
+  mockObject(object2, mockExportsOrModuleType, moduleType) {
+    let mockExports;
+    if (mockExportsOrModuleType === "automock" || mockExportsOrModuleType === "autospy") {
+      moduleType = mockExportsOrModuleType;
+      mockExports = void 0;
+    } else {
+      mockExports = mockExportsOrModuleType;
+    }
+    moduleType ?? (moduleType = "automock");
+    const result = mockObject({
+      globalConstructors: {
+        Object,
+        Function,
+        Array,
+        Map,
+        RegExp
+      },
+      createMockInstance: this.createMockInstance,
+      type: moduleType
+    }, object2, mockExports);
+    return result;
+  }
+  getMockContext() {
+    return { callstack: null };
+  }
+  queueMock(rawId, importer, factoryOrOptions) {
+    const promise = this.rpc.resolveMock(rawId, importer, { mock: typeof factoryOrOptions === "function" ? "factory" : (factoryOrOptions == null ? void 0 : factoryOrOptions.spy) ? "spy" : "auto" }).then(async ({ redirectUrl, resolvedId, resolvedUrl, needsInterop, mockType }) => {
+      const mockUrl = this.resolveMockPath(cleanVersion(resolvedUrl));
+      this.mockedIds.add(resolvedId);
+      const factory = typeof factoryOrOptions === "function" ? async () => {
+        const data = await factoryOrOptions();
+        return needsInterop ? { default: data } : data;
+      } : void 0;
+      const mockRedirect = typeof redirectUrl === "string" ? new URL(this.resolveMockPath(cleanVersion(redirectUrl)), this.getBaseUrl()).toString() : null;
+      let module;
+      if (mockType === "manual") {
+        module = this.registry.register("manual", rawId, resolvedId, mockUrl, factory);
+      } else if (mockType === "autospy") {
+        module = this.registry.register("autospy", rawId, resolvedId, mockUrl);
+      } else if (mockType === "redirect") {
+        module = this.registry.register("redirect", rawId, resolvedId, mockUrl, mockRedirect);
+      } else {
+        module = this.registry.register("automock", rawId, resolvedId, mockUrl);
+      }
+      await this.interceptor.register(module);
+    }).finally(() => {
+      this.queue.delete(promise);
+    });
+    this.queue.add(promise);
+  }
+  queueUnmock(id, importer) {
+    const promise = this.rpc.resolveId(id, importer).then(async (resolved) => {
+      if (!resolved) {
+        return;
+      }
+      const mockUrl = this.resolveMockPath(cleanVersion(resolved.url));
+      this.mockedIds.add(resolved.id);
+      this.registry.delete(mockUrl);
+      await this.interceptor.delete(mockUrl);
+    }).finally(() => {
+      this.queue.delete(promise);
+    });
+    this.queue.add(promise);
+  }
+  // We need to await mock registration before importing the actual module
+  // In case there is a mocked module in the import chain
+  wrapDynamicImport(moduleFactory) {
+    if (typeof moduleFactory === "function") {
+      const promise = new Promise((resolve2, reject) => {
+        this.prepare().finally(() => {
+          moduleFactory().then(resolve2, reject);
+        });
+      });
+      return promise;
+    }
+    return moduleFactory;
+  }
+  getMockedModuleById(id) {
+    return this.registry.getById(id);
+  }
+  reset() {
+    this.registry.clear();
+    this.mockedIds.clear();
+    this.queue.clear();
+  }
+  resolveMockPath(path) {
+    const config = this.config;
+    const fsRoot = join("/@fs/", config.root);
+    if (path.startsWith(config.root)) {
+      return path.slice(config.root.length);
+    }
+    if (path.startsWith(fsRoot)) {
+      return path.slice(fsRoot.length);
+    }
+    return path;
+  }
+}
+const versionRegexp = /(\?|&)v=\w{8}/;
+function cleanVersion(url2) {
+  return url2.replace(versionRegexp, "");
+}
+class VitestBrowserClientMocker extends ModuleMocker {
+  // default "vi" utility tries to access mock context to avoid circular dependencies
+  getMockContext() {
+    return { callstack: null };
+  }
+  wrapDynamicImport(moduleFactory) {
+    return getBrowserState().wrapModule(moduleFactory);
+  }
+}
+function createModuleMockerInterceptor() {
+  return {
+    async register(module) {
+      const state = getBrowserState();
+      await rpc().registerMock(state.sessionId, module.toJSON());
+    },
+    async delete(id) {
+      const state = getBrowserState();
+      await rpc().unregisterMock(state.sessionId, id);
+    },
+    async invalidate() {
+      const state = getBrowserState();
+      await rpc().clearMocks(state.sessionId);
+    }
+  };
+}
+function rpc() {
+  return getWorkerState().rpc;
+}
+const ACTION_TRACE_COMMANDS = /* @__PURE__ */ new Set([
+  "__vitest_click",
+  "__vitest_dblClick",
+  "__vitest_tripleClick",
+  "__vitest_wheel",
+  "__vitest_type",
+  "__vitest_clear",
+  "__vitest_fill",
+  "__vitest_selectOptions",
+  "__vitest_dragAndDrop",
+  "__vitest_hover",
+  "__vitest_upload",
+  "__vitest_tab",
+  "__vitest_keyboard",
+  "__vitest_takeScreenshot"
+]);
+class CommandsManager {
+  _listeners = [];
+  onCommand(listener) {
+    this._listeners.push(listener);
+  }
+  async triggerCommand(command, args, clientError = new Error("empty")) {
+    var _a, _b;
+    const state = getWorkerState();
+    const rpc2 = state.rpc;
+    const { sessionId, traces: traces2 } = getBrowserState();
+    const filepath = state.filepath || ((_b = (_a = state.current) == null ? void 0 : _a.file) == null ? void 0 : _b.filepath);
+    args = args.filter((arg) => arg !== void 0);
+    const actionTraceGroupName = ACTION_TRACE_COMMANDS.has(command) ? `vitest:${command.slice("__vitest_".length)}` : void 0;
+    const currentTest = getWorkerState().current;
+    const hasActiveTrace = !!actionTraceGroupName && !!currentTest && getBrowserState().activeTraceTaskIds.has(currentTest.id);
+    const hasActiveTraceView = !!actionTraceGroupName && !!currentTest && getBrowserState().browserTraceAttempts.has(currentTest.id);
+    if (this._listeners.length) {
+      await Promise.all(this._listeners.map((listener) => listener(command, args)));
+    }
+    return traces2.$(
+      "vitest.browser.tester.command",
+      {
+        attributes: {
+          "vitest.browser.command": command,
+          "code.file.path": filepath
+        }
+      },
+      async () => {
+        var _a2;
+        if (hasActiveTrace) {
+          await rpc2.triggerCommand(
+            sessionId,
+            "__vitest_groupTraceStart",
+            filepath,
+            [{
+              name: actionTraceGroupName,
+              stack: clientError.stack
+            }]
+          );
+        }
+        let status = "pass";
+        const startTime = now$1();
+        try {
+          return await rpc2.triggerCommand(sessionId, command, filepath, args);
+        } catch (err) {
+          status = "fail";
+          clientError.message = err.message;
+          clientError.name = err.name;
+          clientError.stack = (_a2 = clientError.stack) == null ? void 0 : _a2.replace(clientError.message, err.message);
+          throw clientError;
+        } finally {
+          if (hasActiveTraceView) {
+            recordBrowserTraceEntry(currentTest, {
+              name: actionTraceGroupName,
+              kind: "action",
+              status,
+              startTime,
+              duration: now$1() - startTime,
+              element: typeof args[0] === "object" && "selector" in args[0] && "locator" in args[0] ? args[0] : void 0,
+              stack: clientError.stack
+            });
+          }
+          if (hasActiveTrace) {
+            await rpc2.triggerCommand(
+              sessionId,
+              "__vitest_groupTraceEnd",
+              filepath,
+              []
+            );
+          }
+        }
+      }
+    );
+  }
+}
+getBrowserState().provider;
+const debugVar = getConfig$1().env.VITEST_BROWSER_DEBUG;
+const debug = debugVar && debugVar !== "false" ? (...args) => {
+  var _a, _b;
+  return (_b = (_a = client.rpc).debug) == null ? void 0 : _b.call(_a, ...args.map(String));
+} : void 0;
+const otelConfig = getConfig$1().experimental.openTelemetry;
+const traces = new Traces({
+  enabled: !!((otelConfig == null ? void 0 : otelConfig.enabled) && (otelConfig == null ? void 0 : otelConfig.browserSdkPath)),
+  sdkPath: `/@fs/${otelConfig == null ? void 0 : otelConfig.browserSdkPath}`
+});
+let rootTesterSpan;
+getBrowserState().traces = traces;
+channel.addEventListener("message", async (e) => {
+  await client.waitForConnection();
+  const data = e.data;
+  debug == null ? void 0 : debug("event from orchestrator", JSON.stringify(e.data));
+  if (!isEvent(data)) {
+    const error = new Error(`Unknown message: ${JSON.stringify(e.data)}`);
+    unhandledError(error, "Unknown Iframe Message");
+    return;
+  }
+  if (!("iframeId" in data) || data.iframeId !== getBrowserState().iframeId) {
+    return;
+  }
+  switch (data.event) {
+    case "execute": {
+      const { method, files, context } = data;
+      const state = getWorkerState();
+      const parsedContext = parse(context);
+      state.ctx.providedContext = parsedContext;
+      state.providedContext = parsedContext;
+      if (method === "collect") {
+        await executeTests("collect", files).catch((err) => unhandledError(err, "Collect Error"));
+      } else {
+        await executeTests("run", files).catch((err) => unhandledError(err, "Run Error"));
+      }
+      break;
+    }
+    case "cleanup": {
+      await cleanup().catch((err) => unhandledError(err, "Cleanup Error"));
+      rootTesterSpan == null ? void 0 : rootTesterSpan.span.end();
+      await traces.finish();
+      break;
+    }
+    case "prepare": {
+      await traces.waitInit();
+      const tracesContext = traces.getContextFromCarrier(data.otelCarrier);
+      traces.recordInitSpan(tracesContext);
+      rootTesterSpan = traces.startContextSpan(
+        `vitest.browser.tester.run`,
+        tracesContext
+      );
+      traces.bind(rootTesterSpan.context);
+      await prepare(data).catch((err) => unhandledError(err, "Prepare Error"));
+      break;
+    }
+    case "viewport:done":
+    case "viewport:fail":
+    case "viewport": {
+      break;
+    }
+    default: {
+      const error = new Error(`Unknown event: ${data.event}`);
+      unhandledError(error, "Unknown Event");
+    }
+  }
+  channel.postMessage({
+    event: `response:${data.event}`,
+    iframeId: getBrowserState().iframeId
+  });
+});
+const url = new URL(location.href);
+const iframeId = url.searchParams.get("iframeId");
+const commands = new CommandsManager();
+getBrowserState().commands = commands;
+getBrowserState().activeTraceTaskIds = /* @__PURE__ */ new Set();
+getBrowserState().browserTraceAttempts = /* @__PURE__ */ new Map();
+getBrowserState().iframeId = iframeId;
+let contextSwitched = false;
+async function prepareTestEnvironment(options) {
+  debug == null ? void 0 : debug("trying to resolve the runner");
+  const config = getConfig$1();
+  const rpc2 = createSafeRpc(client);
+  const state = getWorkerState();
+  state.metaEnv = __vitest_browser_import_meta_env_init__;
+  state.onCancel = onCancel;
+  state.ctx.rpc = rpc2;
+  state.rpc = rpc2;
+  const interceptor = createModuleMockerInterceptor();
+  const mocker = new VitestBrowserClientMocker(
+    interceptor,
+    rpc2,
+    SpyModule.createMockInstance,
+    {
+      root: getBrowserState().viteConfig.root
+    }
+  );
+  globalThis.__vitest_mocker__ = mocker;
+  setupConsoleLogSpy();
+  setupDialogsSpy();
+  const runner2 = await initiateRunner(state, mocker, config);
+  getBrowserState().runner = runner2;
+  if (server.provider === "webdriverio") {
+    let switchPromise = null;
+    commands.onCommand(async () => {
+      if (switchPromise) {
+        await switchPromise;
+      }
+      if (!contextSwitched) {
+        switchPromise = rpc2.wdioSwitchContext("iframe").finally(() => {
+          switchPromise = null;
+          contextSwitched = true;
+        });
+        await switchPromise;
+      }
+    });
+  }
+  state.durations.prepare = performance.now() - options.startTime;
+  return {
+    runner: runner2,
+    config,
+    state
+  };
+}
+let preparedData;
+async function executeTests(method, specifications) {
+  if (!preparedData) {
+    throw new Error(`Data was not properly initialized. This is a bug in Vitest. Please, open a new issue with reproduction.`);
+  }
+  debug == null ? void 0 : debug("runner resolved successfully");
+  const { runner: runner2, state } = preparedData;
+  state.ctx.files = specifications;
+  runner2.setMethod(method);
+  const version = url.searchParams.get("browserv") || "";
+  specifications.forEach(({ filepath }) => {
+    const currentVersion = browserHashMap.get(filepath);
+    if (!currentVersion || currentVersion[1] !== version) {
+      browserHashMap.set(filepath, version);
+    }
+  });
+  for (const file of specifications) {
+    state.filepath = file.filepath;
+    debug == null ? void 0 : debug("running test file", file.filepath);
+    await traces.$(
+      `vitest.test.runner.${method}.module`,
+      {
+        attributes: { "code.file.path": file.filepath }
+      },
+      async () => {
+        if (method === "run") {
+          await startTests([file], runner2);
+        } else {
+          await collectTests([file], runner2);
+        }
+      }
+    );
+  }
+}
+async function prepare(options) {
+  preparedData = await prepareTestEnvironment(options);
+  debug == null ? void 0 : debug("runner resolved successfully");
+  const { config, state } = preparedData;
+  state.durations.prepare = performance.now() - state.durations.prepare;
+  debug == null ? void 0 : debug("prepare time", state.durations.prepare, "ms");
+  await Promise.all([
+    setupCommonEnv(config),
+    startCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.browser.isolate }),
+    (async () => {
+      const VitestIndex = await __vitePreload(() => import("vitest"), true ? [] : void 0);
+      Object.defineProperty(window, "__vitest_index__", {
+        value: VitestIndex,
+        enumerable: false
+      });
+    })()
+  ]);
+  if (!config.browser.trackUnhandledErrors) {
+    getBrowserState().disposeExceptionTracker();
+  }
+}
+async function cleanup() {
+  const state = getWorkerState();
+  const config = getConfig$1();
+  const rpc2 = state.rpc;
+  const cleanupSymbol = Symbol.for("vitest:component-cleanup");
+  if (cleanupSymbol in page) {
+    try {
+      await page[cleanupSymbol]();
+    } catch (error) {
+      await unhandledError(error, "Cleanup Error");
+    }
+  }
+  await userEvent.cleanup().catch((error) => unhandledError(error, "Cleanup Error"));
+  await Promise.all(
+    getBrowserState().cleanups.map((fn) => fn())
+  ).catch((error) => unhandledError(error, "Cleanup Error"));
+  if (contextSwitched) {
+    await rpc2.wdioSwitchContext("parent").catch((error) => unhandledError(error, "Cleanup Error"));
+  }
+  await stopCoverageInsideWorker(config.coverage, moduleRunner, { isolate: config.browser.isolate }).catch((error) => {
+    return unhandledError(error, "Coverage Error");
+  });
+}
+function unhandledError(e, type) {
+  return client.rpc.onUnhandledError({
+    name: e.name,
+    message: e.message,
+    stack: e.stack
+  }, type).catch(() => {
+  });
+}
+function isEvent(data) {
+  return typeof data === "object" && !!data && "event" in data;
+}