@vitest/browser 5.0.0-beta.4 → 5.0.0-beta.5

package/dist/client/__vitest_browser__/tester-C1kIlbPd.js

@@ -0,0 +1,2099 @@
+import { a as moduleRunner, d as resolve, i as getWorkerState, l as getTestName, n as getBrowserState, o as now$1, r as getConfig, s as __vitePreload, t as _defineProperty } from "./defineProperty-WHpdAQXR.js";
+import { channel, client, globalChannel, onCancel, registerPageMarkHandler } from "@vitest/browser/client";
+import { Traces } from "vitest/internal/traces";
+import { page, server, userEvent } from "vitest/browser";
+import { DecodedMap, SpyModule, collectTests, format, getOriginalPosition, getSafeTimers, loadDiffConfig, loadSnapshotSerializers, setupCommonEnv, startCoverageInsideWorker, startTests, stopCoverageInsideWorker, takeCoverageInsideWorker } from "vitest/internal/browser";
+import { TestRunner, recordArtifact } from "vitest";
+
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region ../../node_modules/.pnpm/flatted@3.4.2/node_modules/flatted/esm/index.js
+var { parse: $parse, stringify: $stringify } = JSON;
+var { keys } = Object;
+var Primitive = String;
+var primitive = "string";
+var ignore = {};
+var object = "object";
+var noop = (_, value) => value;
+var primitives = (value) => value instanceof Primitive ? Primitive(value) : value;
+var Primitives = (_, value) => typeof value === primitive ? new Primitive(value) : value;
+var resolver = (input, lazy, parsed, $) => (output) => {
+	for (let ke = keys(output), { length } = ke, y = 0; y < length; y++) {
+		const k = ke[y];
+		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;
+};
+/**
+* Converts a specialized flatted string into a JS value.
+* @param {string} text
+* @param {(this: any, key: string, value: any) => any} [reviver]
+* @returns {any}
+*/
+var parse = (text, reviver) => {
+	const input = $parse(text, Primitives).map(primitives);
+	const $ = reviver || noop;
+	let value = input[0];
+	if (typeof value === object && value) {
+		const lazy = [];
+		const revive = resolver(input, lazy, /* @__PURE__ */ new Set(), $);
+		value = revive(value);
+		let i = 0;
+		while (i < lazy.length) {
+			const { o, k, r } = lazy[i++];
+			o[k] = $.call(o, k, revive(r));
+		}
+	}
+	return $.call({ "": value }, "", value);
+};
+
+//#endregion
+//#region src/client/tester/dialog.ts
+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");
+}
+
+//#endregion
+//#region src/client/tester/rpc.ts
+var { 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;
+		return fn();
+	} finally {
+		globalThis.setTimeout = currentSetTimeout;
+		globalThis.clearTimeout = currentClearTimeout;
+	}
+}
+var promises = /* @__PURE__ */ new Set();
+function createSafeRpc(client) {
+	return new Proxy(client.rpc, { get(target, p, handler) {
+		if (p === "then") return;
+		const sendCall = get(target, p, handler);
+		const safeSendCall = (...args) => withSafeTimers(getSafeTimers, async () => {
+			const result = sendCall(...args);
+			promises.add(result);
+			try {
+				return await result;
+			} finally {
+				promises.delete(result);
+			}
+		});
+		safeSendCall.asEvent = sendCall.asEvent;
+		return safeSendCall;
+	} });
+}
+function rpc$2() {
+	return globalThis.__vitest_worker__.rpc;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars$1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar$1 = new Uint8Array(64);
+var charToInt$1 = new Uint8Array(128);
+for (let i = 0; i < chars$1.length; i++) {
+	const c = chars$1.charCodeAt(i);
+	intToChar$1[i] = c;
+	charToInt$1[c] = i;
+}
+function decodeInteger(reader, relative) {
+	let value = 0;
+	let shift = 0;
+	let integer = 0;
+	do {
+		integer = charToInt$1[reader.next()];
+		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, b) {
+	return a[0] - b[0];
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+resolve-uri@3.1.2/node_modules/@jridgewell/resolve-uri/dist/resolve-uri.umd.js
+var require_resolve_uri_umd = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(global, factory) {
+		typeof exports === "object" && typeof module !== "undefined" ? module.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, global.resolveURI = factory());
+	})(exports, (function() {
+		"use strict";
+		const schemeRegex = /^[\w+.-]+:\/\//;
+		/**
+		* Matches the parts of a URL:
+		* 1. Scheme, including ":", guaranteed.
+		* 2. User/password, including "@", optional.
+		* 3. Host, guaranteed.
+		* 4. Port, including ":", optional.
+		* 5. Path, including "/", optional.
+		* 6. Query, including "?", optional.
+		* 7. Hash, including "#", optional.
+		*/
+		const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+		/**
+		* File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+		* with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+		*
+		* 1. Host, optional.
+		* 2. Path, which may include "/", guaranteed.
+		* 3. Query, including "?", optional.
+		* 4. Hash, including "#", optional.
+		*/
+		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 url = parseAbsoluteUrl("http:" + input);
+				url.scheme = "";
+				url.type = 6;
+				return url;
+			}
+			if (isAbsolutePath(input)) {
+				const url = parseAbsoluteUrl("http://foo.com" + input);
+				url.scheme = "";
+				url.host = "";
+				url.type = 5;
+				return url;
+			}
+			if (isFileUrl(input)) return parseFileUrl(input);
+			if (isAbsoluteUrl(input)) return parseAbsoluteUrl(input);
+			const url = parseAbsoluteUrl("http://foo.com/" + input);
+			url.scheme = "";
+			url.host = "";
+			url.type = input ? input.startsWith("?") ? 3 : input.startsWith("#") ? 2 : 4 : 1;
+			return url;
+		}
+		function stripPathFilename(path) {
+			if (path.endsWith("/..")) return path;
+			const index = path.lastIndexOf("/");
+			return path.slice(0, index + 1);
+		}
+		function mergePaths(url, base) {
+			normalizePath(base, base.type);
+			if (url.path === "/") url.path = base.path;
+			else url.path = stripPathFilename(base.path) + url.path;
+		}
+		/**
+		* The path can have empty directories "//", unneeded parents "foo/..", or current directory
+		* "foo/.". We need to normalize to a standard representation.
+		*/
+		function normalizePath(url, type) {
+			const rel = type <= 4;
+			const pieces = url.path.split("/");
+			let pointer = 1;
+			let positive = 0;
+			let addTrailingSlash = false;
+			for (let i = 1; i < pieces.length; i++) {
+				const piece = pieces[i];
+				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 i = 1; i < pointer; i++) path += "/" + pieces[i];
+			if (!path || addTrailingSlash && !path.endsWith("/..")) path += "/";
+			url.path = path;
+		}
+		/**
+		* Attempts to resolve `input` URL/path relative to `base`.
+		*/
+		function resolve(input, base) {
+			if (!input && !base) return "";
+			const url = parseUrl(input);
+			let inputType = url.type;
+			if (base && inputType !== 7) {
+				const baseUrl = parseUrl(base);
+				const baseType = baseUrl.type;
+				switch (inputType) {
+					case 1: url.hash = baseUrl.hash;
+					case 2: url.query = baseUrl.query;
+					case 3:
+					case 4: mergePaths(url, baseUrl);
+					case 5:
+						url.user = baseUrl.user;
+						url.host = baseUrl.host;
+						url.port = baseUrl.port;
+					case 6: url.scheme = baseUrl.scheme;
+				}
+				if (baseType > inputType) inputType = baseType;
+			}
+			normalizePath(url, inputType);
+			const queryHash = url.query + url.hash;
+			switch (inputType) {
+				case 2:
+				case 3: return queryHash;
+				case 4: {
+					const path = url.path.slice(1);
+					if (!path) return queryHash || ".";
+					if (isRelative(base || input) && !isRelative(path)) return "./" + path + queryHash;
+					return path + queryHash;
+				}
+				case 5: return url.path + queryHash;
+				default: return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
+			}
+		}
+		return resolve;
+	}));
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+trace-mapping@0.3.31/node_modules/@jridgewell/trace-mapping/dist/trace-mapping.mjs
+var import_resolve_uri_umd = /* @__PURE__ */ __toESM(require_resolve_uri_umd(), 1);
+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, index) {
+	for (let i = index + 1; i < haystack.length; index = i++) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+function lowerBound(haystack, needle, index) {
+	for (let i = index - 1; i >= 0; index = i--) if (haystack[i][COLUMN] !== needle) break;
+	return index;
+}
+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;
+	}
+	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 index = traceSegmentInternal(segments, cast(map)._decodedMemo, line, column, bias || 1);
+	if (index === -1) return OMapping(null, null, null, null);
+	const segment = segments[index];
+	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 index = memoizedBinarySearch(segments, column, memo, line);
+	if (found) index = (bias === -1 ? upperBound : lowerBound)(segments, column, index);
+	else if (bias === -1) index++;
+	if (index === -1 || index === segments.length) return -1;
+	return index;
+}
+
+//#endregion
+//#region ../utils/src/helpers.ts
+function notNullish(v) {
+	return v != null;
+}
+
+//#endregion
+//#region ../utils/src/source-map.ts
+var CHROME_IE_STACK_REGEXP = /^\s*at .*(?:\S:\d+|\(native\))/m;
+var SAFARI_NATIVE_CODE_REGEXP = /^(?:eval@)?(?:\[native code\])?$/;
+var stackIgnorePatterns = [
+	"node:internal",
+	/\/packages\/\w+\/dist\//,
+	/\/@vitest\/\w+\/dist\//,
+	"/vitest/dist/",
+	"/vitest/src/",
+	"/packages/expect/src/",
+	"/packages/snapshot/src/",
+	"/node_modules/chai/",
+	"/node_modules/tinyspy/",
+	"/vite/dist/node/module-runner",
+	"/rolldown-vite/dist/node/module-runner",
+	"/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_/
+];
+var NOW_LENGTH$1 = Date.now().toString().length;
+var REGEXP_VITEST$1 = new RegExp(`vitest=\\d{${NOW_LENGTH$1}}`);
+function extractLocation(urlLike) {
+	if (!urlLike.includes(":")) return [urlLike];
+	const parts = /(.+?)(?::(\d+))?(?::(\d+))?$/.exec(urlLike.replace(/^\(|\)$/g, ""));
+	if (!parts) return [urlLike];
+	let url = parts[1];
+	if (url.startsWith("async ")) url = url.slice(6);
+	if (url.startsWith("http:") || url.startsWith("https:")) {
+		const urlObj = new URL(url);
+		urlObj.searchParams.delete("import");
+		urlObj.searchParams.delete("browserv");
+		url = 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 (url.includes("vitest=")) url = url.replace(REGEXP_VITEST$1, "").replace(/[?&]$/, "");
+	return [
+		url,
+		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 i = 0; i < line.length; i++) if (line[i] === "@") {
+		const candidateLocation = line.slice(i + 1);
+		if (candidateLocation.includes(":") && candidateLocation.length >= 3) {
+			atIndex = i;
+			locationPart = candidateLocation;
+			functionName = i > 0 ? line.slice(0, i) : void 0;
+			break;
+		}
+	}
+	if (atIndex === -1 || !locationPart.includes(":") || locationPart.length < 3) return null;
+	const [url, lineNumber, columnNumber] = extractLocation(locationPart);
+	if (!url || !lineNumber || !columnNumber) return null;
+	return {
+		file: url,
+		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 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;
+	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(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) => s.method.includes("__VITEST_HELPER__"));
+	if (helperIndex >= 0) stacks = stacks.slice(helperIndex + 1);
+	return stacks.map((stack) => {
+		var _options$getSourceMap;
+		if (options.getUrlId) stack.file = options.getUrlId(stack.file);
+		const map = (_options$getSourceMap = options.getSourceMap) === null || _options$getSourceMap === void 0 ? void 0 : _options$getSourceMap.call(options, stack.file);
+		if (!map || typeof map !== "object" || !map.version) return shouldFilter(ignoreStackEntries, stack.file) ? null : stack;
+		const position = getOriginalPosition$1(new DecodedMap$1(map, stack.file), stack);
+		if (!position) return stack;
+		const { line, column, source, name } = position;
+		let file = source || stack.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 || stack.method
+		};
+		return stack;
+	}).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);
+}
+var DecodedMap$1 = class {
+	constructor(map, from) {
+		_defineProperty(this, "_encoded", void 0);
+		_defineProperty(this, "_decoded", void 0);
+		_defineProperty(this, "_decodedMemo", void 0);
+		_defineProperty(this, "url", void 0);
+		_defineProperty(this, "version", void 0);
+		_defineProperty(this, "names", []);
+		_defineProperty(this, "resolvedSources", void 0);
+		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(from, "..", s || ""));
+	}
+};
+function memoizedState() {
+	return {
+		lastKey: -1,
+		lastNeedle: -1,
+		lastIndex: -1
+	};
+}
+function getOriginalPosition$1(map, needle) {
+	const result = originalPositionFor(map, needle);
+	if (result.column == null) return null;
+	return result;
+}
+
+//#endregion
+//#region src/client/tester/snapshot.ts
+var VitestBrowserSnapshotEnvironment = class {
+	constructor() {
+		_defineProperty(this, "sourceMaps", /* @__PURE__ */ new Map());
+		_defineProperty(this, "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(map, stack.file);
+			this.traceMaps.set(stack.file, traceMap);
+		}
+		const position = getOriginalPosition(traceMap, stack);
+		if (position) return {
+			...stack,
+			line: position.line,
+			column: position.column
+		};
+		return stack;
+	}
+};
+function rpc$1() {
+	return globalThis.__vitest_worker__.rpc;
+}
+
+//#endregion
+//#region src/client/tester/trace.ts
+var PSEUDO_CLASS_NAMES = [
+	":hover",
+	":active",
+	":focus",
+	":focus-visible",
+	":focus-within"
+];
+function createBrowserTraceRangeId() {
+	return Math.random().toString(36).slice(2);
+}
+async function recordBrowserTraceEntry(task, options) {
+	const attemptInfo = (/* @__PURE__ */ getBrowserState()).browserTraceAttempts.get(task.id);
+	const relativeStartTime = now$1() - attemptInfo.startTime;
+	const snapshot = takeSnapshot(options.element);
+	const entry = {
+		...options,
+		startTime: relativeStartTime,
+		snapshot
+	};
+	const { retry, repeats } = attemptInfo;
+	const { recordCanvas } = (/* @__PURE__ */ getBrowserState()).config.browser.traceView;
+	const data = {
+		retry,
+		repeats,
+		recordCanvas,
+		entries: [entry]
+	};
+	await (/* @__PURE__ */ getWorkerState()).rpc.triggerCommand((/* @__PURE__ */ getBrowserState()).sessionId, "__vitest_recordBrowserTrace", void 0, [{
+		testId: task.id,
+		data
+	}]);
+}
+function takeSnapshot(serializedLocator) {
+	const { snapshot, createMirror } = (/* @__PURE__ */ getBrowserState()).browserTraceDomSnapshot;
+	const traceView = (/* @__PURE__ */ getBrowserState()).config.browser.traceView;
+	const engine = (/* @__PURE__ */ getBrowserState()).selectorEngine;
+	const mirror = createMirror();
+	const result = {
+		serialized: snapshot(document, {
+			mirror,
+			inlineImages: traceView.inlineImages,
+			recordCanvas: traceView.recordCanvas
+		}),
+		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;
+}
+
+//#endregion
+//#region src/client/tester/runner.ts
+var browserHashMap = /* @__PURE__ */ new Map();
+function createBrowserRunner(mocker, state, coverageModule) {
+	return class BrowserTestRunner extends TestRunner {
+		constructor(options) {
+			super(options.config);
+			_defineProperty(this, "config", void 0);
+			_defineProperty(this, "hashMap", browserHashMap);
+			_defineProperty(this, "sourceMapCache", /* @__PURE__ */ new Map());
+			_defineProperty(this, "method", "run");
+			_defineProperty(this, "commands", void 0);
+			_defineProperty(this, "traces", /* @__PURE__ */ new Map());
+			_defineProperty(this, "onAfterRetryTask", async (test, { retry, repeats }) => {
+				var _test$result3, _test$result4;
+				if ((/* @__PURE__ */ getBrowserState()).browserTraceAttempts.has(test.id)) {
+					var _test$result, _test$result2;
+					const status = (_test$result = test.result) === null || _test$result === void 0 ? void 0 : _test$result.state;
+					const stack = status === "fail" ? (_test$result2 = test.result) === null || _test$result2 === void 0 || (_test$result2 = _test$result2.errors) === null || _test$result2 === void 0 ? void 0 : _test$result2[0].stack : void 0;
+					const location = test.location ? {
+						...test.location,
+						file: test.file.filepath
+					} : void 0;
+					await recordBrowserTraceEntry(test, {
+						name: `vitest:onAfterRetryTask`,
+						kind: "lifecycle",
+						...status === "pass" || status === "fail" ? { status } : {},
+						...stack ? { stack } : location ? { location } : {}
+					});
+					(/* @__PURE__ */ getBrowserState()).browserTraceAttempts.delete(test.id);
+				}
+				if (!(/* @__PURE__ */ getBrowserState()).activeTraceTaskIds.has(test.id)) return;
+				await this.commands.triggerCommand("__vitest_markTrace", [{
+					name: `onAfterRetryTask [${(_test$result3 = test.result) === null || _test$result3 === void 0 ? void 0 : _test$result3.state}]`,
+					stack: (_test$result4 = test.result) === null || _test$result4 === void 0 || (_test$result4 = _test$result4.errors) === null || _test$result4 === void 0 ? void 0 : _test$result4[0].stack
+				}]);
+				const name = getTraceName(test, retry, repeats);
+				if (!this.traces.has(test.id)) this.traces.set(test.id, []);
+				const traces = this.traces.get(test.id);
+				const { tracePath } = await this.commands.triggerCommand("__vitest_stopChunkTrace", [{ name }]);
+				traces.push(tracePath);
+			});
+			_defineProperty(this, "onAfterRunTask", async (task) => {
+				var _super$onAfterRunTask, _task$result2;
+				(_super$onAfterRunTask = super.onAfterRunTask) === null || _super$onAfterRunTask === void 0 || _super$onAfterRunTask.call(this, task);
+				const trace = this.config.browser.trace;
+				const traces = this.traces.get(task.id) || [];
+				if (traces.length) {
+					var _task$result;
+					if (trace === "retain-on-failure" && ((_task$result = task.result) === null || _task$result === void 0 ? void 0 : _task$result.state) === "pass") await this.commands.triggerCommand("__vitest_deleteTracing", [{ traces }]);
+					else await this.commands.triggerCommand("__vitest_annotateTraces", [{
+						testId: task.id,
+						traces
+					}]);
+				}
+				if (this.config.bail && ((_task$result2 = task.result) === null || _task$result2 === void 0 ? void 0 : _task$result2.state) === "fail") {
+					if (1 + await rpc$2().getCountOfFailedTests() >= this.config.bail) {
+						rpc$2().cancelCurrentRun("test-failure");
+						this.cancel("test-failure");
+					}
+				}
+			});
+			_defineProperty(this, "onTaskFinished", async (task) => {
+				var _task$result3, _task$result4, _Reflect$get;
+				const lastErrorContext = (_task$result3 = task.result) === null || _task$result3 === void 0 || (_task$result3 = _task$result3.errors) === null || _task$result3 === void 0 || (_task$result3 = _task$result3.at(-1)) === null || _task$result3 === void 0 ? void 0 : _task$result3.__vitest_error_context__;
+				if (this.config.browser.screenshotFailures && document.body.clientHeight > 0 && ((_task$result4 = task.result) === null || _task$result4 === void 0 ? void 0 : _task$result4.state) === "fail" && task.type === "test" && !(lastErrorContext && Reflect.get(lastErrorContext, "assertionName") === "toMatchScreenshot" && ((_Reflect$get = Reflect.get(lastErrorContext, "meta")) === null || _Reflect$get === void 0 ? void 0 : _Reflect$get.outcome) !== "unstable-screenshot")) {
+					var _this$config$browser$;
+					const screenshot = await page.screenshot(
+						{ timeout: ((_this$config$browser$ = this.config.browser.providerOptions) === null || _this$config$browser$ === void 0 ? void 0 : _this$config$browser$.actionTimeout) ?? 5e3 }
+						/** TODO */
+					).catch((err) => {
+						console.error("[vitest] Failed to take a screenshot", err);
+					});
+					if (screenshot) await recordArtifact(task, {
+						type: "internal:failureScreenshot",
+						attachments: [{
+							contentType: "image/png",
+							path: screenshot,
+							originalPath: screenshot
+						}]
+					});
+				}
+			});
+			_defineProperty(this, "cancel", (reason) => {
+				var _super$cancel;
+				(_super$cancel = super.cancel) === null || _super$cancel === void 0 || _super$cancel.call(this, reason);
+				globalChannel.postMessage({
+					type: "cancel",
+					reason
+				});
+			});
+			_defineProperty(this, "onBeforeRunSuite", async (suite) => {
+				var _super$onBeforeRunSui;
+				await Promise.all([(_super$onBeforeRunSui = super.onBeforeRunSuite) === null || _super$onBeforeRunSui === void 0 ? void 0 : _super$onBeforeRunSui.call(this, suite), (async () => {
+					if (!("filepath" in suite)) return;
+					const map = await rpc$2().getBrowserFileSourceMap(suite.filepath);
+					this.sourceMapCache.set(suite.filepath, map);
+					const snapshotEnvironment = this.config.snapshotOptions.snapshotEnvironment;
+					if (snapshotEnvironment instanceof VitestBrowserSnapshotEnvironment) snapshotEnvironment.addSourceMap(suite.filepath, map);
+				})()]);
+			});
+			_defineProperty(this, "onAfterRunFiles", async (files) => {
+				super.onAfterRunFiles(files);
+				const [coverage] = await Promise.all([coverageModule.takeCoverage(), mocker.invalidate()]);
+				if (coverage) await rpc$2().onAfterSuiteRun({
+					coverage,
+					testFiles: files.map((file) => file.name),
+					environment: "__browser__",
+					projectName: this.config.name
+				});
+			});
+			_defineProperty(this, "onCollectStart", (file) => {
+				return rpc$2().onQueued(this.method, file);
+			});
+			_defineProperty(this, "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);
+			});
+			_defineProperty(this, "onTestAnnotate", (test, annotation) => {
+				const artifact = {
+					type: "internal:annotation",
+					annotation,
+					location: annotation.location
+				};
+				return this.onTestArtifactRecord(test, artifact).then(({ annotation }) => annotation);
+			});
+			_defineProperty(this, "onTestArtifactRecord", (test, artifact) => {
+				if (artifact.location) {
+					const map = this.sourceMapCache.get(artifact.location.file);
+					if (!map) return rpc$2().onTaskArtifactRecord(test.id, artifact);
+					const position = getOriginalPosition(new DecodedMap(map, artifact.location.file), artifact.location);
+					if (position) {
+						const { source, column, line } = position;
+						const file = source || artifact.location.file;
+						artifact.location = {
+							line,
+							column: column + 1,
+							file: file.match(/\/\w:\//) ? file.slice(1) : file
+						};
+						if (artifact.type === "internal:annotation") artifact.annotation.location = artifact.location;
+					}
+				}
+				return rpc$2().onTaskArtifactRecord(test.id, artifact);
+			});
+			_defineProperty(this, "onTaskUpdate", (task, events) => {
+				return rpc$2().onTaskUpdate(this.method, task, events);
+			});
+			_defineProperty(this, "importFile", async (filepath, mode) => {
+				let hash = this.hashMap.get(filepath);
+				if (mode === "setup" || !hash) {
+					hash = Date.now().toString();
+					this.hashMap.set(filepath, hash);
+				}
+				const importpath = `${`/${/^\w:/.test(filepath) ? "@fs/" : ""}`}${filepath}?${`browserv=${hash}`}`.replace(/\/+/g, "/");
+				const trace = this.config.browser.trace;
+				if (mode === "collect" && trace !== "off") await this.commands.triggerCommand("__vitest_startTracing", []);
+				try {
+					await __vitePreload(() => import(
+						/* @vite-ignore */
+						importpath
+), []);
+				} catch (err) {
+					throw new Error(`Failed to import test file ${filepath}`, { cause: err });
+				}
+			});
+			_defineProperty(this, "trace", (name, attributes, cb) => {
+				const options = typeof attributes === "object" ? { attributes } : {};
+				return this._otel.$(`vitest.test.runner.${name}`, options, cb || attributes);
+			});
+			this.config = options.config;
+			this.commands = (/* @__PURE__ */ getBrowserState()).commands;
+			this.viteEnvironment = "__browser__";
+			this._otel = (/* @__PURE__ */ getBrowserState()).traces;
+		}
+		setMethod(method) {
+			this.method = method;
+		}
+		async onBeforeTryTask(test, options) {
+			var _super$onBeforeTryTas;
+			await userEvent.cleanup();
+			(_super$onBeforeTryTas = super.onBeforeTryTask) === null || _super$onBeforeTryTas === void 0 || _super$onBeforeTryTas.call(this, test, options);
+			const trace = this.config.browser.trace;
+			const { retry, repeats } = options;
+			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) {
+				(/* @__PURE__ */ getBrowserState()).activeTraceTaskIds.delete(test.id);
+				(/* @__PURE__ */ getBrowserState()).browserTraceAttempts.delete(test.id);
+				return;
+			}
+			if (shouldTraceView) {
+				(/* @__PURE__ */ getBrowserState()).browserTraceDomSnapshot = await __vitePreload(() => import("./rrweb-snapshot-iZCFA2to.js"), []);
+				(/* @__PURE__ */ getBrowserState()).browserTraceAttempts.set(test.id, {
+					retry,
+					repeats,
+					startTime: now$1()
+				});
+			} else (/* @__PURE__ */ getBrowserState()).browserTraceAttempts.delete(test.id);
+			if (!shouldTrace) {
+				(/* @__PURE__ */ getBrowserState()).activeTraceTaskIds.delete(test.id);
+				return;
+			}
+			(/* @__PURE__ */ getBrowserState()).activeTraceTaskIds.add(test.id);
+			let title = /* @__PURE__ */ getTestName(test);
+			if (retry) title += ` (retry x${retry})`;
+			if (repeats) title += ` (repeat x${repeats})`;
+			const name = getTraceName(test, retry, repeats);
+			await this.commands.triggerCommand("__vitest_startChunkTrace", [{
+				name,
+				title
+			}]);
+		}
+	};
+}
+var cachedRunner = null;
+function getBrowserRunner() {
+	return cachedRunner;
+}
+async function initiateRunner(state, mocker, config) {
+	if (cachedRunner) return cachedRunner;
+	const BrowserRunner = createBrowserRunner(mocker, state, { takeCoverage: () => takeCoverageInsideWorker(config.coverage, moduleRunner) });
+	if (!config.snapshotOptions.snapshotEnvironment) config.snapshotOptions.snapshotEnvironment = new VitestBrowserSnapshotEnvironment();
+	const runner = new BrowserRunner({ config });
+	cachedRunner = runner;
+	onCancel((reason) => {
+		var _runner$cancel;
+		(_runner$cancel = runner.cancel) === null || _runner$cancel === void 0 || _runner$cancel.call(runner, reason);
+	});
+	const [diffOptions] = await Promise.all([loadDiffConfig(config, moduleRunner), loadSnapshotSerializers(config, moduleRunner)]);
+	runner.config._diffOptions = diffOptions;
+	(/* @__PURE__ */ getWorkerState()).onFilterStackTrace = (stack) => {
+		return createStackString(parseStacktrace(stack, { getSourceMap(file) {
+			return runner.sourceMapCache.get(file);
+		} }));
+	};
+	return runner;
+}
+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(result, file);
+}
+async function updateTestFilesLocations(files, sourceMaps) {
+	const promises = files.map(async (file) => {
+		const traceMap = await getTraceMap(file.filepath, sourceMaps);
+		if (!traceMap) return null;
+		const updateLocation = (task) => {
+			if (task.location) {
+				const position = getOriginalPosition(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(promises);
+}
+function getTraceName(task, retryCount, repeatsCount) {
+	return `${(/* @__PURE__ */ getTestName(task, "-")).replace(/[^a-z0-9]/gi, "-")}-${repeatsCount}-${retryCount}`;
+}
+
+//#endregion
+//#region src/client/tester/logger.ts
+var { Date: Date$1, console: console$1, performance: performance$1 } = globalThis;
+function setupConsoleLogSpy() {
+	const { log, info, error, dir, dirxml, trace, time, timeEnd, timeLog, warn, debug, count, countReset } = console$1;
+	console$1.log = stdout(log);
+	console$1.debug = stdout(debug);
+	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 _globalThis$__vitest_;
+		trace(...args);
+		const content = processLog(args);
+		const error = /* @__PURE__ */ new Error("$$Trace");
+		sendLog("stderr", `${content}\n${(((_globalThis$__vitest_ = globalThis.__vitest_worker__) === null || _globalThis$__vitest_ === void 0 ? void 0 : _globalThis$__vitest_.onFilterStackTrace) || ((s) => s || ""))(error.stack || "")}`, true);
+	};
+	const timeLabels = {};
+	console$1.time = (label = "default") => {
+		time(label);
+		timeLabels[label] = performance$1.now();
+	};
+	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") sendLog("stdout", `${label}: ${end - start} 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(args, { multiline: true });
+}
+function sendLog(type, content, disableStack) {
+	var _globalThis$__vitest_2, _Error$stack;
+	if (content.startsWith("[vite]")) return;
+	const taskId = ((_globalThis$__vitest_2 = globalThis.__vitest_worker__) === null || _globalThis$__vitest_2 === void 0 || (_globalThis$__vitest_2 = _globalThis$__vitest_2.current) === null || _globalThis$__vitest_2 === void 0 ? void 0 : _globalThis$__vitest_2.id) ?? "__vitest__unknown_test__";
+	const origin = getConfig().printConsoleTrace && !disableStack ? (_Error$stack = (/* @__PURE__ */ new Error("STACK_TRACE")).stack) === null || _Error$stack === void 0 ? void 0 : _Error$stack.split("\n").slice(1).join("\n") : void 0;
+	const runner = getBrowserRunner();
+	rpc$2().sendLog((runner === null || runner === void 0 ? void 0 : runner.method) || "run", {
+		origin,
+		content,
+		browser: true,
+		time: Date$1.now(),
+		taskId,
+		type,
+		size: content.length
+	});
+}
+
+//#endregion
+//#region ../mocker/dist/chunk-registry.js
+var MockerRegistry = class {
+	constructor() {
+		_defineProperty(this, "registryByUrl", /* @__PURE__ */ new Map());
+		_defineProperty(this, "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, url, 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 url !== "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, url, factoryOrRedirect);
+			this.add(mock);
+			return mock;
+		} else if (type === "automock" || type === "autospy") {
+			const mock = type === "automock" ? new AutomockedModule(raw, id, url) : new AutospiedModule(raw, id, url);
+			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, url, 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);
+	}
+};
+var AutomockedModule = class AutomockedModule {
+	constructor(raw, id, url) {
+		_defineProperty(this, "type", "automock");
+		this.raw = raw;
+		this.id = id;
+		this.url = url;
+	}
+	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
+		};
+	}
+};
+var AutospiedModule = class AutospiedModule {
+	constructor(raw, id, url) {
+		_defineProperty(this, "type", "autospy");
+		this.raw = raw;
+		this.id = id;
+		this.url = url;
+	}
+	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
+		};
+	}
+};
+var RedirectedModule = class RedirectedModule {
+	constructor(raw, id, url, redirect) {
+		_defineProperty(this, "type", "redirect");
+		this.raw = raw;
+		this.id = id;
+		this.url = url;
+		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
+		};
+	}
+};
+var ManualMockedModule = class ManualMockedModule {
+	constructor(raw, id, url, factory) {
+		_defineProperty(this, "cache", void 0);
+		_defineProperty(this, "type", "manual");
+		this.raw = raw;
+		this.id = id;
+		this.url = url;
+		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 || exports$1 === void 0 ? 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 = /* @__PURE__ */ 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?`);
+}
+
+//#endregion
+//#region ../mocker/dist/index.js
+function mockObject(options, object, 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 isModule = getType(container) === "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 define(newContainer, property, value.map((value) => {
+					if (value && typeof value === "object") {
+						const newObject = {};
+						mockPropertiesOf(value, newObject);
+						return newObject;
+					}
+					if (typeof value === "function") return createMock(value);
+					return value;
+				}));
+				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 = 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) newContainer[property] = createMock(newContainer[property]);
+			refs.track(value, newContainer[property]);
+			mockPropertiesOf(value, newContainer[property]);
+		}
+	};
+	const mockedObject = mockExports;
+	mockPropertiesOf(object, mockedObject);
+	for (const finalizer of finalizers) finalizer();
+	return mockedObject;
+}
+var RefTracker = class {
+	constructor() {
+		_defineProperty(this, "idMap", /* @__PURE__ */ new Map());
+		_defineProperty(this, "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(object, prop) {
+	if (prop === "arguments" || prop === "caller" || prop === "callee" || prop === "name" || prop === "length") {
+		const typeName = getType(object);
+		return typeName === "Function" || typeName === "AsyncFunction" || typeName === "GeneratorFunction" || typeName === "AsyncGeneratorFunction";
+	}
+	if (prop === "source" || prop === "global" || prop === "ignoreCase" || prop === "multiline") return getType(object) === "RegExp";
+	return false;
+}
+function getAllMockableProperties(obj, isModule, constructors) {
+	const { Map, Object, Function, RegExp, Array } = constructors;
+	const allProps = new Map();
+	let curr = obj;
+	do {
+		if (curr === Object.prototype || curr === Function.prototype || curr === RegExp.prototype) break;
+		collectOwnProperties(curr, (key) => {
+			const descriptor = Object.getOwnPropertyDescriptor(curr, key);
+			if (descriptor) allProps.set(key, {
+				key,
+				descriptor
+			});
+		});
+	} while (curr = Object.getPrototypeOf(curr));
+	if (isModule && !allProps.has("default") && "default" in obj) {
+		const descriptor = Object.getOwnPropertyDescriptor(obj, "default");
+		if (descriptor) allProps.set("default", {
+			key: "default",
+			descriptor
+		});
+	}
+	return Array.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;
+		if (getType(descriptor.value).includes("Function") && !isReadonlyProp(descriptor.value, prop)) properties.add(prop);
+	});
+	return Array.from(properties);
+}
+
+//#endregion
+//#region ../mocker/dist/chunk-pathe.M-eThtNZ.js
+var _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());
+}
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+var 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;
+};
+var 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] === "/";
+			if (pathTrailing && segLeading) 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 index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 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 = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+var isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+var extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+
+//#endregion
+//#region ../mocker/dist/chunk-mocker.js
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+var NOW_LENGTH = Date.now().toString().length;
+var REGEXP_VITEST = new RegExp(`vitest=\\d{${NOW_LENGTH}}`);
+var { now } = Date;
+var ModuleMocker = class {
+	constructor(interceptor, rpc, createMockInstance, config) {
+		_defineProperty(this, "registry", new MockerRegistry());
+		_defineProperty(this, "queue", /* @__PURE__ */ new Set());
+		_defineProperty(this, "mockedIds", /* @__PURE__ */ new Set());
+		this.interceptor = interceptor;
+		this.rpc = rpc;
+		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.`);
+		return await mock.resolve();
+	}
+	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 url = new URL(resolved.url, this.getBaseUrl());
+		const query = `_vitest_original&ext${ext}`;
+		const actualUrl = `${url.pathname}${url.search ? `${url.search}&${query}` : `?${query}`}${url.hash}`;
+		return this.wrapDynamicImport(() => __vitePreload(() => import(
+			/* @vite-ignore */
+			actualUrl
+), [])).then((mod) => {
+			if (!resolved.optimized || typeof mod.default === "undefined") return mod;
+			const m = mod.default;
+			return (m === null || m === void 0 ? 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) mock = new RedirectedModule(rawId, resolvedId, mockUrl, new URL(this.resolveMockPath(cleanVersion(redirectUrl)), this.getBaseUrl()).toString());
+		else mock = new AutomockedModule(rawId, resolvedId, mockUrl);
+		if (mock.type === "manual") return await mock.resolve();
+		if (mock.type === "automock" || mock.type === "autospy") {
+			const url = new URL(`/@id/${resolvedId}`, this.getBaseUrl());
+			const query = url.search ? `${url.search}&t=${now()}` : `?t=${now()}`;
+			const moduleObject = await __vitePreload(() => import(
+				/* @vite-ignore */
+				`${url.pathname}${query}&mock=${mock.type}${url.hash}`
+), []);
+			return this.mockObject(moduleObject, mock.type);
+		}
+		return __vitePreload(() => import(
+			/* @vite-ignore */
+			mock.redirect
+), []);
+	}
+	mockObject(object, mockExportsOrModuleType, moduleType) {
+		let mockExports;
+		if (mockExportsOrModuleType === "automock" || mockExportsOrModuleType === "autospy") {
+			moduleType = mockExportsOrModuleType;
+			mockExports = void 0;
+		} else mockExports = mockExportsOrModuleType;
+		moduleType ?? (moduleType = "automock");
+		return mockObject({
+			globalConstructors: {
+				Object,
+				Function,
+				Array,
+				Map,
+				RegExp
+			},
+			createMockInstance: this.createMockInstance,
+			type: moduleType
+		}, object, mockExports);
+	}
+	getMockContext() {
+		return { callstack: null };
+	}
+	queueMock(rawId, importer, factoryOrOptions) {
+		const promise = this.rpc.resolveMock(rawId, importer, { mock: typeof factoryOrOptions === "function" ? "factory" : (factoryOrOptions === null || factoryOrOptions === void 0 ? 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);
+	}
+	wrapDynamicImport(moduleFactory) {
+		if (typeof moduleFactory === "function") return new Promise((resolve, reject) => {
+			this.prepare().finally(() => {
+				moduleFactory().then(resolve, reject);
+			});
+		});
+		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;
+	}
+};
+var versionRegexp = /(\?|&)v=\w{8}/;
+function cleanVersion(url) {
+	return url.replace(versionRegexp, "");
+}
+
+//#endregion
+//#region src/client/tester/mocker.ts
+var VitestBrowserClientMocker = class extends ModuleMocker {
+	getMockContext() {
+		return { callstack: null };
+	}
+	wrapDynamicImport(moduleFactory) {
+		return (/* @__PURE__ */ getBrowserState()).wrapModule(moduleFactory);
+	}
+};
+
+//#endregion
+//#region src/client/tester/mocker-interceptor.ts
+function createModuleMockerInterceptor() {
+	return {
+		async register(module) {
+			const state = /* @__PURE__ */ getBrowserState();
+			await rpc().registerMock(state.sessionId, module.toJSON());
+		},
+		async delete(id) {
+			const state = /* @__PURE__ */ getBrowserState();
+			await rpc().unregisterMock(state.sessionId, id);
+		},
+		async invalidate() {
+			const state = /* @__PURE__ */ getBrowserState();
+			await rpc().clearMocks(state.sessionId);
+		}
+	};
+}
+function rpc() {
+	return (/* @__PURE__ */ getWorkerState()).rpc;
+}
+
+//#endregion
+//#region src/client/tester/tester-utils.ts
+var ACTION_TRACE_COMMANDS = 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"
+]);
+var CommandsManager = class {
+	constructor() {
+		_defineProperty(this, "_listeners", []);
+	}
+	onCommand(listener) {
+		this._listeners.push(listener);
+	}
+	async triggerCommand(command, args, clientError = /* @__PURE__ */ new Error("empty")) {
+		var _state$current;
+		const state = /* @__PURE__ */ getWorkerState();
+		const rpc = state.rpc;
+		const { sessionId, traces } = /* @__PURE__ */ getBrowserState();
+		const filepath = state.filepath || ((_state$current = state.current) === null || _state$current === void 0 || (_state$current = _state$current.file) === null || _state$current === void 0 ? void 0 : _state$current.filepath);
+		args = args.filter((arg) => arg !== void 0);
+		const actionTraceGroupName = ACTION_TRACE_COMMANDS.has(command) ? `vitest:${command.slice(9)}` : void 0;
+		const currentTest = (/* @__PURE__ */ getWorkerState()).current;
+		const hasActiveTrace = !!actionTraceGroupName && !!currentTest && (/* @__PURE__ */ getBrowserState()).activeTraceTaskIds.has(currentTest.id);
+		const hasActiveTraceView = !!actionTraceGroupName && !!currentTest && (/* @__PURE__ */ getBrowserState()).browserTraceAttempts.has(currentTest.id);
+		if (this._listeners.length) await Promise.all(this._listeners.map((listener) => listener(command, args)));
+		return traces.$("vitest.browser.tester.command", { attributes: {
+			"vitest.browser.command": command,
+			"code.file.path": filepath
+		} }, async () => {
+			if (hasActiveTrace) await rpc.triggerCommand(sessionId, "__vitest_groupTraceStart", filepath, [{
+				name: actionTraceGroupName,
+				stack: clientError.stack
+			}]);
+			let status = "pass";
+			const traceRangeId = hasActiveTraceView ? createBrowserTraceRangeId() : void 0;
+			const element = typeof args[0] === "object" && "selector" in args[0] && "locator" in args[0] ? args[0] : void 0;
+			if (hasActiveTraceView) await recordBrowserTraceEntry(currentTest, {
+				name: actionTraceGroupName,
+				kind: "action",
+				range: {
+					id: traceRangeId,
+					phase: "start"
+				},
+				element,
+				stack: clientError.stack
+			});
+			try {
+				return await rpc.triggerCommand(sessionId, command, filepath, args);
+			} catch (err) {
+				var _clientError$stack;
+				status = "fail";
+				clientError.message = err.message;
+				clientError.name = err.name;
+				clientError.stack = (_clientError$stack = clientError.stack) === null || _clientError$stack === void 0 ? void 0 : _clientError$stack.replace(clientError.message, err.message);
+				throw clientError;
+			} finally {
+				if (hasActiveTraceView) await recordBrowserTraceEntry(currentTest, {
+					name: actionTraceGroupName,
+					kind: "action",
+					range: {
+						id: traceRangeId,
+						phase: "end"
+					},
+					status,
+					element,
+					stack: clientError.stack
+				});
+				if (hasActiveTrace) await rpc.triggerCommand(sessionId, "__vitest_groupTraceEnd", filepath, []);
+			}
+		});
+	}
+};
+var provider = (/* @__PURE__ */ getBrowserState()).provider;
+
+//#endregion
+//#region src/client/tester/tester.ts
+var debugVar = getConfig().env.VITEST_BROWSER_DEBUG;
+var debug = debugVar && debugVar !== "false" ? (...args) => {
+	var _client$rpc$debug, _client$rpc;
+	return (_client$rpc$debug = (_client$rpc = client.rpc).debug) === null || _client$rpc$debug === void 0 ? void 0 : _client$rpc$debug.call(_client$rpc, ...args.map(String));
+} : void 0;
+var otelConfig = getConfig().experimental.openTelemetry;
+var traces = new Traces({
+	enabled: !!((otelConfig === null || otelConfig === void 0 ? void 0 : otelConfig.enabled) && (otelConfig === null || otelConfig === void 0 ? void 0 : otelConfig.browserSdkPath)),
+	sdkPath: `/@fs/${otelConfig === null || otelConfig === void 0 ? void 0 : otelConfig.browserSdkPath}`
+});
+var rootTesterSpan;
+(/* @__PURE__ */ getBrowserState()).traces = traces;
+channel.addEventListener("message", async (e) => {
+	await client.waitForConnection();
+	const data = e.data;
+	debug === null || debug === void 0 || debug("event from orchestrator", JSON.stringify(e.data));
+	if (!isEvent(data)) {
+		unhandledError(/* @__PURE__ */ new Error(`Unknown message: ${JSON.stringify(e.data)}`), "Unknown Iframe Message");
+		return;
+	}
+	if (!("iframeId" in data) || data.iframeId !== (/* @__PURE__ */ getBrowserState()).iframeId) return;
+	switch (data.event) {
+		case "execute": {
+			const { method, files, context, concurrencyId, workerId } = data;
+			const state = /* @__PURE__ */ getWorkerState();
+			const parsedContext = parse(context);
+			state.ctx.concurrencyId = concurrencyId;
+			state.ctx.workerId = workerId;
+			state.ctx.providedContext = parsedContext;
+			state.providedContext = parsedContext;
+			state.metaEnv.VITEST_POOL_ID = String(concurrencyId);
+			state.metaEnv.VITEST_WORKER_ID = String(workerId);
+			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 || rootTesterSpan === 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: unhandledError(/* @__PURE__ */ new Error(`Unknown event: ${data.event}`), "Unknown Event");
+	}
+	channel.postMessage({
+		event: `response:${data.event}`,
+		iframeId: (/* @__PURE__ */ getBrowserState()).iframeId
+	});
+});
+var url = new URL(location.href);
+var iframeId = url.searchParams.get("iframeId");
+var commands = new CommandsManager();
+(/* @__PURE__ */ getBrowserState()).commands = commands;
+(/* @__PURE__ */ getBrowserState()).activeTraceTaskIds = /* @__PURE__ */ new Set();
+(/* @__PURE__ */ getBrowserState()).browserTraceAttempts = /* @__PURE__ */ new Map();
+(/* @__PURE__ */ getBrowserState()).iframeId = iframeId;
+registerPageMarkHandler((name, options) => page.mark(name, options));
+channel.postMessage({
+	event: "ready",
+	iframeId
+});
+var contextSwitched = false;
+async function prepareTestEnvironment(options) {
+	debug === null || debug === void 0 || debug("trying to resolve the runner");
+	const config = getConfig();
+	const rpc = createSafeRpc(client);
+	const state = /* @__PURE__ */ getWorkerState();
+	state.metaEnv = __vitest_browser_import_meta_env_init__;
+	state.onCancel = onCancel;
+	state.ctx.rpc = rpc;
+	state.rpc = rpc;
+	const mocker = new VitestBrowserClientMocker(createModuleMockerInterceptor(), rpc, SpyModule.createMockInstance, { root: (/* @__PURE__ */ getBrowserState()).viteConfig.root });
+	globalThis.__vitest_mocker__ = mocker;
+	if (!config.disableConsoleIntercept) setupConsoleLogSpy();
+	setupDialogsSpy();
+	const runner = await initiateRunner(state, mocker, config);
+	(/* @__PURE__ */ getBrowserState()).runner = runner;
+	if (server.provider === "webdriverio") {
+		let switchPromise = null;
+		commands.onCommand(async () => {
+			if (switchPromise) await switchPromise;
+			if (!contextSwitched) {
+				switchPromise = rpc.wdioSwitchContext("iframe").finally(() => {
+					switchPromise = null;
+					contextSwitched = true;
+				});
+				await switchPromise;
+			}
+		});
+	}
+	state.durations.prepare = performance.now() - options.startTime;
+	return {
+		runner,
+		config,
+		state
+	};
+}
+var 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 || debug === void 0 || debug("runner resolved successfully");
+	const { runner, state } = preparedData;
+	state.ctx.files = specifications;
+	runner.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 || debug === 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], runner);
+			else await collectTests([file], runner);
+		});
+	}
+}
+async function prepare(options) {
+	preparedData = await prepareTestEnvironment(options);
+	debug === null || debug === void 0 || debug("runner resolved successfully");
+	const { config, state } = preparedData;
+	state.durations.prepare = performance.now() - state.durations.prepare;
+	debug === null || debug === 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"), []);
+			Object.defineProperty(window, "__vitest_index__", {
+				value: VitestIndex,
+				enumerable: false
+			});
+		})()
+	]);
+	if (!config.browser.trackUnhandledErrors) (/* @__PURE__ */ getBrowserState()).disposeExceptionTracker();
+}
+async function cleanup() {
+	const state = /* @__PURE__ */ getWorkerState();
+	const config = getConfig();
+	const rpc = 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((/* @__PURE__ */ getBrowserState()).cleanups.map((fn) => fn())).catch((error) => unhandledError(error, "Cleanup Error"));
+	if (contextSwitched) await rpc.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;
+}
+
+//#endregion