vitest 0.18.1 → 0.19.0

package/dist/{chunk-vite-node-externalize.6956d2d9.mjs → chunk-vite-node-externalize.a2813ad7.mjs}

@@ -1,32 +1,30 @@
-import { p as pLimit, c as configDefaults, r as resolveC8Options, a as cleanCoverage, b as reportCoverage, e as envPackageNames } from './chunk-env-node.bbba78e5.mjs';
-import { j as join, o as basename, d as dirname, q as resolve, A as AggregateErrorPonyfill, p as picocolors, t as isAbsolute, u as relative, s as slash$2, v as isNode, x as getTests, e as getFullName, y as hasFailed, z as hasFailedSnapshot, B as safeSetInterval, C as safeClearInterval, D as getSuites, f as safeSetTimeout, E as shuffle, F as toArray$1, G as normalize, n as noop$1, h as safeClearTimeout, H as deepMerge, I as toNamespacedPath, g as getCallLastIndex, l as notNullish, J as ensurePackageInstalled, K as stdout } from './chunk-utils-global.0a7416cf.mjs';
+import { j as join, D as basename, d as dirname, C as resolve, E as AggregateErrorPonyfill, p as picocolors, F as isAbsolute, G as relative, c as slash$2, t as isNode, v as relativePath, H as getTests, h as getFullName, B as hasFailed, I as hasFailedSnapshot, J as safeSetInterval, K as safeClearInterval, L as getSuites, s as safeSetTimeout, z as shuffle, u as toArray$1, M as normalize, n as noop$1, k as safeClearTimeout, N as deepMerge, O as toNamespacedPath, b as getCallLastIndex, l as notNullish, P as ensurePackageInstalled, Q as stdout } from './chunk-utils-global.2aa95025.mjs';
+import { p as pLimit, c as configDefaults, r as resolveC8Options, a as cleanCoverage, b as reportCoverage, d as envPackageNames } from './chunk-defaults.408a0cfe.mjs';
 import { loadConfigFromFile, createServer, mergeConfig } from 'vite';
 import path$a from 'path';
-import url, { fileURLToPath, pathToFileURL } from 'url';
+import _url, { fileURLToPath } from 'url';
 import process$1 from 'process';
 import fs$8, { promises, existsSync, readFileSync } from 'fs';
-import { d as distDir, c as configFiles, a as defaultPort } from './chunk-constants.d4406290.mjs';
-import require$$0, { cpus, hostname, constants as constants$5 } from 'os';
-import require$$0$1 from 'util';
-import require$$0$2 from 'stream';
+import { d as distDir, c as configFiles, a as defaultPort } from './chunk-constants.38b43a44.mjs';
+import require$$0, { cpus, hostname } from 'os';
+import util$2 from 'util';
+import require$$0$1 from 'stream';
 import require$$2 from 'events';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
-import { i as isNodeBuiltin, a as isValidNodeImport, s as slash$1, t as toArray, b as toFilePath, w as withInlineSourcemap, c as createBirpc, V as ViteNodeRunner } from './chunk-vite-node-utils.8077cd3c.mjs';
+import { i as isNodeBuiltin, a as isValidNodeImport, s as slash$1, t as toArray, b as toFilePath, w as withInlineSourcemap, c as createBirpc, V as ViteNodeRunner } from './chunk-vite-node-utils.ad73f2ab.mjs';
 import createDebug from 'debug';
 import { MessageChannel } from 'worker_threads';
 import { Tinypool } from 'tinypool';
 import { performance } from 'perf_hooks';
-import { c as stripAnsi, d as cliTruncate, b as parseStacktrace, e as stringWidth, h as ansiStyles, i as sliceAnsi, j as interpretSourcePos, s as stringify$5, u as unifiedDiff, a as posToNumber, l as lineSplitRE } from './chunk-utils-source-map.c03f8bc4.mjs';
+import { c as stripAnsi, d as cliTruncate, p as parseStacktrace, e as stringWidth, h as ansiStyles, i as sliceAnsi, j as interpretSourcePos, s as stringify$5, u as unifiedDiff, b as posToNumber, l as lineSplitRE } from './chunk-utils-source-map.8b066ce2.mjs';
 import { resolveModule } from 'local-pkg';
 import { createHash } from 'crypto';
-import { Buffer } from 'buffer';
-import childProcess from 'child_process';
-import { s as signalExit, m as mergeStream, g as getStream, c as crossSpawn, o as onetime$1 } from './vendor-index.4bf9c627.mjs';
+import { o as onetime, s as signalExit } from './vendor-index.61438b77.mjs';
 import MagicString from './chunk-magic-string.efe26975.mjs';
-import require$$0$3 from 'readline';
+import require$$0$2 from 'readline';
 import { p as prompts } from './vendor-index.de788b6a.mjs';
 
-var version$1 = "0.18.1";
+var version$1 = "0.19.0";
 
 class EndError extends Error {
 	constructor(value) {
@@ -935,7 +933,7 @@ var toRegexRange_1 = toRegexRange$1;
  * Licensed under the MIT License.
  */
 
-const util$1 = require$$0$1;
+const util$1 = util$2;
 const toRegexRange = toRegexRange_1;
 
 const isObject$1 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
@@ -3972,7 +3970,7 @@ var picomatch_1 = picomatch$1;
 	module.exports = picomatch_1;
 } (picomatch$2));
 
-const util = require$$0$1;
+const util = util$2;
 const braces = braces_1;
 const picomatch = picomatch$2.exports;
 const utils$b = utils$f;
@@ -4616,7 +4614,7 @@ var stream$4 = {};
  * Copyright (c) 2014-2020 Teambition
  * Licensed under the MIT license.
  */
-const Stream = require$$0$2;
+const Stream = require$$0$1;
 const PassThrough = Stream.PassThrough;
 const slice = Array.prototype.slice;
 
@@ -5900,7 +5898,7 @@ function callSuccessCallback(callback, entries) {
 var stream$1 = {};
 
 Object.defineProperty(stream$1, "__esModule", { value: true });
-const stream_1$5 = require$$0$2;
+const stream_1$5 = require$$0$1;
 const async_1$2 = async$2;
 class StreamProvider {
     constructor(_root, _settings) {
@@ -6108,7 +6106,7 @@ class Reader {
 reader.default = Reader;
 
 Object.defineProperty(stream$2, "__esModule", { value: true });
-const stream_1$3 = require$$0$2;
+const stream_1$3 = require$$0$1;
 const fsStat$1 = out$3;
 const fsWalk$1 = out$2;
 const reader_1$1 = reader;
@@ -6506,7 +6504,7 @@ async$6.default = ProviderAsync;
 var stream = {};
 
 Object.defineProperty(stream, "__esModule", { value: true });
-const stream_1$1 = require$$0$2;
+const stream_1$1 = require$$0$1;
 const stream_2 = stream$2;
 const provider_1$1 = provider;
 class ProviderStream extends provider_1$1.default {
@@ -6739,7 +6737,7 @@ const ESM_EXT_RE = /\.(es|esm|esm-browser|esm-bundler|es6|module)\.js$/;
 const ESM_FOLDER_RE = /\/(es|esm)\/(.*\.js)$/;
 const defaultInline = [
   /virtual:/,
-  /\.ts$/
+  /\.[mc]?ts$/
 ];
 const depsExternal = [
   /\.cjs\.js$/,
@@ -6980,7 +6978,7 @@ function addSnapshotResult(summary, result) {
   summary.total += result.added + result.matched + result.unmatched + result.updated;
 }
 
-const workerPath = pathToFileURL(resolve(distDir, "./worker.mjs")).href;
+const workerPath = _url.pathToFileURL(resolve(distDir, "./worker.mjs")).href;
 function createPool(ctx) {
   var _a;
   const threadsCount = ctx.config.watch ? Math.max(Math.floor(cpus().length / 2), 1) : Math.max(cpus().length - 1, 1);
@@ -7084,6 +7082,10 @@ function createChannel(ctx) {
     resolveId(id, importer) {
       return ctx.vitenode.resolveId(id, importer);
     },
+    onPathsCollected(paths) {
+      ctx.state.collectPaths(paths);
+      ctx.report("onPathsCollected", paths);
+    },
     onCollected(files) {
       ctx.state.collectFiles(files);
       ctx.report("onCollected", files);
@@ -7287,7 +7289,7 @@ class BaseReporter {
     this.start = performance.now();
   }
   relative(path) {
-    return relative(this.ctx.config.root, path);
+    return relativePath(this.ctx.config.root, path);
   }
   async onFinished(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
     this.end = performance.now();
@@ -7817,7 +7819,8 @@ class JsonReporter {
           status: StatusMap[((_a2 = t.result) == null ? void 0 : _a2.state) || t.mode] || "skipped",
           title: t.name,
           duration: (_b2 = t.result) == null ? void 0 : _b2.duration,
-          failureMessages: ((_d = (_c = t.result) == null ? void 0 : _c.error) == null ? void 0 : _d.message) == null ? [] : [t.result.error.message]
+          failureMessages: ((_d = (_c = t.result) == null ? void 0 : _c.error) == null ? void 0 : _d.message) == null ? [] : [t.result.error.message],
+          location: this.getFailureLocation(t)
         };
       });
       if (tests2.some((t) => {
@@ -7870,6 +7873,18 @@ class JsonReporter {
       this.ctx.logger.log(report);
     }
   }
+  getFailureLocation(test) {
+    var _a;
+    const error = (_a = test.result) == null ? void 0 : _a.error;
+    if (!error)
+      return;
+    const stack = parseStacktrace(error);
+    const frame = stack[stack.length - 1];
+    if (!frame)
+      return;
+    const pos = frame.sourcePos || frame;
+    return { line: pos.line, column: pos.column };
+  }
 }
 
 class VerboseReporter extends DefaultReporter {
@@ -8196,6 +8211,7 @@ function createReporters(reporterReferences, runner) {
 class StateManager {
   constructor() {
     this.filesMap = /* @__PURE__ */ new Map();
+    this.pathsSet = /* @__PURE__ */ new Set();
     this.idMap = /* @__PURE__ */ new Map();
     this.taskFileMap = /* @__PURE__ */ new WeakMap();
     this.errorsSet = /* @__PURE__ */ new Set();
@@ -8210,6 +8226,9 @@ class StateManager {
   getUnhandledErrors() {
     return Array.from(this.errorsSet.values());
   }
+  getPaths() {
+    return Array.from(this.pathsSet);
+  }
   getFiles(keys) {
     if (keys)
       return keys.map((key) => this.filesMap.get(key)).filter(Boolean);
@@ -8224,6 +8243,11 @@ class StateManager {
       return ((_a = i.result) == null ? void 0 : _a.state) === "fail";
     }).map((i) => i.filepath);
   }
+  collectPaths(paths = []) {
+    paths.forEach((path) => {
+      this.pathsSet.add(path);
+    });
+  }
   collectFiles(files = []) {
     files.forEach((file) => {
       this.filesMap.set(file.filepath, file);
@@ -8430,7 +8454,7 @@ const extraInlineDeps = [
 ];
 function resolveApiConfig(options) {
   let api;
-  if (options.ui && !options.api)
+  if ((options.ui || options.browser) && !options.api)
     api = { port: defaultPort };
   else if (options.api === true)
     api = { port: defaultPort };
@@ -8531,1126 +8555,6 @@ function resolveConfig(options, viteConfig) {
   return resolved;
 }
 
-function stripFinalNewline(input) {
-	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
-	const CR = typeof input === 'string' ? '\r' : '\r'.charCodeAt();
-
-	if (input[input.length - 1] === LF) {
-		input = input.slice(0, -1);
-	}
-
-	if (input[input.length - 1] === CR) {
-		input = input.slice(0, -1);
-	}
-
-	return input;
-}
-
-function pathKey(options = {}) {
-	const {
-		env = process.env,
-		platform = process.platform
-	} = options;
-
-	if (platform !== 'win32') {
-		return 'PATH';
-	}
-
-	return Object.keys(env).reverse().find(key => key.toUpperCase() === 'PATH') || 'Path';
-}
-
-function npmRunPath(options = {}) {
-	const {
-		cwd = process$1.cwd(),
-		path: path_ = process$1.env[pathKey()],
-		execPath = process$1.execPath,
-	} = options;
-
-	let previous;
-	const cwdString = cwd instanceof URL ? url.fileURLToPath(cwd) : cwd;
-	let cwdPath = path$a.resolve(cwdString);
-	const result = [];
-
-	while (previous !== cwdPath) {
-		result.push(path$a.join(cwdPath, 'node_modules/.bin'));
-		previous = cwdPath;
-		cwdPath = path$a.resolve(cwdPath, '..');
-	}
-
-	// Ensure the running `node` binary is used.
-	result.push(path$a.resolve(cwdString, execPath, '..'));
-
-	return [...result, path_].join(path$a.delimiter);
-}
-
-function npmRunPathEnv({env = process$1.env, ...options} = {}) {
-	env = {...env};
-
-	const path = pathKey({env});
-	options.path = env[path];
-	env[path] = npmRunPath(options);
-
-	return env;
-}
-
-const copyProperty = (to, from, property, ignoreNonConfigurable) => {
-	// `Function#length` should reflect the parameters of `to` not `from` since we keep its body.
-	// `Function#prototype` is non-writable and non-configurable so can never be modified.
-	if (property === 'length' || property === 'prototype') {
-		return;
-	}
-
-	// `Function#arguments` and `Function#caller` should not be copied. They were reported to be present in `Reflect.ownKeys` for some devices in React Native (#41), so we explicitly ignore them here.
-	if (property === 'arguments' || property === 'caller') {
-		return;
-	}
-
-	const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
-	const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
-
-	if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
-		return;
-	}
-
-	Object.defineProperty(to, property, fromDescriptor);
-};
-
-// `Object.defineProperty()` throws if the property exists, is not configurable and either:
-// - one its descriptors is changed
-// - it is non-writable and its value is changed
-const canCopyProperty = function (toDescriptor, fromDescriptor) {
-	return toDescriptor === undefined || toDescriptor.configurable || (
-		toDescriptor.writable === fromDescriptor.writable &&
-		toDescriptor.enumerable === fromDescriptor.enumerable &&
-		toDescriptor.configurable === fromDescriptor.configurable &&
-		(toDescriptor.writable || toDescriptor.value === fromDescriptor.value)
-	);
-};
-
-const changePrototype = (to, from) => {
-	const fromPrototype = Object.getPrototypeOf(from);
-	if (fromPrototype === Object.getPrototypeOf(to)) {
-		return;
-	}
-
-	Object.setPrototypeOf(to, fromPrototype);
-};
-
-const wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/\n${fromBody}`;
-
-const toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, 'toString');
-const toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, 'name');
-
-// We call `from.toString()` early (not lazily) to ensure `from` can be garbage collected.
-// We use `bind()` instead of a closure for the same reason.
-// Calling `from.toString()` early also allows caching it in case `to.toString()` is called several times.
-const changeToString = (to, from, name) => {
-	const withName = name === '' ? '' : `with ${name.trim()}() `;
-	const newToString = wrappedToString.bind(null, withName, from.toString());
-	// Ensure `to.toString.toString` is non-enumerable and has the same `same`
-	Object.defineProperty(newToString, 'name', toStringName);
-	Object.defineProperty(to, 'toString', {...toStringDescriptor, value: newToString});
-};
-
-function mimicFunction(to, from, {ignoreNonConfigurable = false} = {}) {
-	const {name} = to;
-
-	for (const property of Reflect.ownKeys(from)) {
-		copyProperty(to, from, property, ignoreNonConfigurable);
-	}
-
-	changePrototype(to, from);
-	changeToString(to, from, name);
-
-	return to;
-}
-
-const calledFunctions = new WeakMap();
-
-const onetime = (function_, options = {}) => {
-	if (typeof function_ !== 'function') {
-		throw new TypeError('Expected a function');
-	}
-
-	let returnValue;
-	let callCount = 0;
-	const functionName = function_.displayName || function_.name || '<anonymous>';
-
-	const onetime = function (...arguments_) {
-		calledFunctions.set(onetime, ++callCount);
-
-		if (callCount === 1) {
-			returnValue = function_.apply(this, arguments_);
-			function_ = null;
-		} else if (options.throw === true) {
-			throw new Error(`Function \`${functionName}\` can only be called once`);
-		}
-
-		return returnValue;
-	};
-
-	mimicFunction(onetime, function_);
-	calledFunctions.set(onetime, callCount);
-
-	return onetime;
-};
-
-onetime.callCount = function_ => {
-	if (!calledFunctions.has(function_)) {
-		throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
-	}
-
-	return calledFunctions.get(function_);
-};
-
-const getRealtimeSignals=function(){
-const length=SIGRTMAX-SIGRTMIN+1;
-return Array.from({length},getRealtimeSignal);
-};
-
-const getRealtimeSignal=function(value,index){
-return {
-name:`SIGRT${index+1}`,
-number:SIGRTMIN+index,
-action:"terminate",
-description:"Application-specific signal (realtime)",
-standard:"posix"};
-
-};
-
-const SIGRTMIN=34;
-const SIGRTMAX=64;
-
-const SIGNALS=[
-{
-name:"SIGHUP",
-number:1,
-action:"terminate",
-description:"Terminal closed",
-standard:"posix"},
-
-{
-name:"SIGINT",
-number:2,
-action:"terminate",
-description:"User interruption with CTRL-C",
-standard:"ansi"},
-
-{
-name:"SIGQUIT",
-number:3,
-action:"core",
-description:"User interruption with CTRL-\\",
-standard:"posix"},
-
-{
-name:"SIGILL",
-number:4,
-action:"core",
-description:"Invalid machine instruction",
-standard:"ansi"},
-
-{
-name:"SIGTRAP",
-number:5,
-action:"core",
-description:"Debugger breakpoint",
-standard:"posix"},
-
-{
-name:"SIGABRT",
-number:6,
-action:"core",
-description:"Aborted",
-standard:"ansi"},
-
-{
-name:"SIGIOT",
-number:6,
-action:"core",
-description:"Aborted",
-standard:"bsd"},
-
-{
-name:"SIGBUS",
-number:7,
-action:"core",
-description:
-"Bus error due to misaligned, non-existing address or paging error",
-standard:"bsd"},
-
-{
-name:"SIGEMT",
-number:7,
-action:"terminate",
-description:"Command should be emulated but is not implemented",
-standard:"other"},
-
-{
-name:"SIGFPE",
-number:8,
-action:"core",
-description:"Floating point arithmetic error",
-standard:"ansi"},
-
-{
-name:"SIGKILL",
-number:9,
-action:"terminate",
-description:"Forced termination",
-standard:"posix",
-forced:true},
-
-{
-name:"SIGUSR1",
-number:10,
-action:"terminate",
-description:"Application-specific signal",
-standard:"posix"},
-
-{
-name:"SIGSEGV",
-number:11,
-action:"core",
-description:"Segmentation fault",
-standard:"ansi"},
-
-{
-name:"SIGUSR2",
-number:12,
-action:"terminate",
-description:"Application-specific signal",
-standard:"posix"},
-
-{
-name:"SIGPIPE",
-number:13,
-action:"terminate",
-description:"Broken pipe or socket",
-standard:"posix"},
-
-{
-name:"SIGALRM",
-number:14,
-action:"terminate",
-description:"Timeout or timer",
-standard:"posix"},
-
-{
-name:"SIGTERM",
-number:15,
-action:"terminate",
-description:"Termination",
-standard:"ansi"},
-
-{
-name:"SIGSTKFLT",
-number:16,
-action:"terminate",
-description:"Stack is empty or overflowed",
-standard:"other"},
-
-{
-name:"SIGCHLD",
-number:17,
-action:"ignore",
-description:"Child process terminated, paused or unpaused",
-standard:"posix"},
-
-{
-name:"SIGCLD",
-number:17,
-action:"ignore",
-description:"Child process terminated, paused or unpaused",
-standard:"other"},
-
-{
-name:"SIGCONT",
-number:18,
-action:"unpause",
-description:"Unpaused",
-standard:"posix",
-forced:true},
-
-{
-name:"SIGSTOP",
-number:19,
-action:"pause",
-description:"Paused",
-standard:"posix",
-forced:true},
-
-{
-name:"SIGTSTP",
-number:20,
-action:"pause",
-description:"Paused using CTRL-Z or \"suspend\"",
-standard:"posix"},
-
-{
-name:"SIGTTIN",
-number:21,
-action:"pause",
-description:"Background process cannot read terminal input",
-standard:"posix"},
-
-{
-name:"SIGBREAK",
-number:21,
-action:"terminate",
-description:"User interruption with CTRL-BREAK",
-standard:"other"},
-
-{
-name:"SIGTTOU",
-number:22,
-action:"pause",
-description:"Background process cannot write to terminal output",
-standard:"posix"},
-
-{
-name:"SIGURG",
-number:23,
-action:"ignore",
-description:"Socket received out-of-band data",
-standard:"bsd"},
-
-{
-name:"SIGXCPU",
-number:24,
-action:"core",
-description:"Process timed out",
-standard:"bsd"},
-
-{
-name:"SIGXFSZ",
-number:25,
-action:"core",
-description:"File too big",
-standard:"bsd"},
-
-{
-name:"SIGVTALRM",
-number:26,
-action:"terminate",
-description:"Timeout or timer",
-standard:"bsd"},
-
-{
-name:"SIGPROF",
-number:27,
-action:"terminate",
-description:"Timeout or timer",
-standard:"bsd"},
-
-{
-name:"SIGWINCH",
-number:28,
-action:"ignore",
-description:"Terminal window size changed",
-standard:"bsd"},
-
-{
-name:"SIGIO",
-number:29,
-action:"terminate",
-description:"I/O is available",
-standard:"other"},
-
-{
-name:"SIGPOLL",
-number:29,
-action:"terminate",
-description:"Watched event",
-standard:"other"},
-
-{
-name:"SIGINFO",
-number:29,
-action:"ignore",
-description:"Request for process information",
-standard:"other"},
-
-{
-name:"SIGPWR",
-number:30,
-action:"terminate",
-description:"Device running out of power",
-standard:"systemv"},
-
-{
-name:"SIGSYS",
-number:31,
-action:"core",
-description:"Invalid system call",
-standard:"other"},
-
-{
-name:"SIGUNUSED",
-number:31,
-action:"terminate",
-description:"Invalid system call",
-standard:"other"}];
-
-const getSignals=function(){
-const realtimeSignals=getRealtimeSignals();
-const signals=[...SIGNALS,...realtimeSignals].map(normalizeSignal);
-return signals;
-};
-
-
-
-
-
-
-
-const normalizeSignal=function({
-name,
-number:defaultNumber,
-description,
-action,
-forced=false,
-standard})
-{
-const{
-signals:{[name]:constantSignal}}=
-constants$5;
-const supported=constantSignal!==undefined;
-const number=supported?constantSignal:defaultNumber;
-return {name,number,description,supported,action,forced,standard};
-};
-
-const getSignalsByName=function(){
-const signals=getSignals();
-return signals.reduce(getSignalByName,{});
-};
-
-const getSignalByName=function(
-signalByNameMemo,
-{name,number,description,supported,action,forced,standard})
-{
-return {
-...signalByNameMemo,
-[name]:{name,number,description,supported,action,forced,standard}};
-
-};
-
-const signalsByName=getSignalsByName();
-
-
-
-
-const getSignalsByNumber=function(){
-const signals=getSignals();
-const length=SIGRTMAX+1;
-const signalsA=Array.from({length},(value,number)=>
-getSignalByNumber(number,signals));
-
-return Object.assign({},...signalsA);
-};
-
-const getSignalByNumber=function(number,signals){
-const signal=findSignalByNumber(number,signals);
-
-if(signal===undefined){
-return {};
-}
-
-const{name,description,supported,action,forced,standard}=signal;
-return {
-[number]:{
-name,
-number,
-description,
-supported,
-action,
-forced,
-standard}};
-
-
-};
-
-
-
-const findSignalByNumber=function(number,signals){
-const signal=signals.find(({name})=>constants$5.signals[name]===number);
-
-if(signal!==undefined){
-return signal;
-}
-
-return signals.find((signalA)=>signalA.number===number);
-};
-
-getSignalsByNumber();
-
-const getErrorPrefix = ({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled}) => {
-	if (timedOut) {
-		return `timed out after ${timeout} milliseconds`;
-	}
-
-	if (isCanceled) {
-		return 'was canceled';
-	}
-
-	if (errorCode !== undefined) {
-		return `failed with ${errorCode}`;
-	}
-
-	if (signal !== undefined) {
-		return `was killed with ${signal} (${signalDescription})`;
-	}
-
-	if (exitCode !== undefined) {
-		return `failed with exit code ${exitCode}`;
-	}
-
-	return 'failed';
-};
-
-const makeError = ({
-	stdout,
-	stderr,
-	all,
-	error,
-	signal,
-	exitCode,
-	command,
-	escapedCommand,
-	timedOut,
-	isCanceled,
-	killed,
-	parsed: {options: {timeout}},
-}) => {
-	// `signal` and `exitCode` emitted on `spawned.on('exit')` event can be `null`.
-	// We normalize them to `undefined`
-	exitCode = exitCode === null ? undefined : exitCode;
-	signal = signal === null ? undefined : signal;
-	const signalDescription = signal === undefined ? undefined : signalsByName[signal].description;
-
-	const errorCode = error && error.code;
-
-	const prefix = getErrorPrefix({timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled});
-	const execaMessage = `Command ${prefix}: ${command}`;
-	const isError = Object.prototype.toString.call(error) === '[object Error]';
-	const shortMessage = isError ? `${execaMessage}\n${error.message}` : execaMessage;
-	const message = [shortMessage, stderr, stdout].filter(Boolean).join('\n');
-
-	if (isError) {
-		error.originalMessage = error.message;
-		error.message = message;
-	} else {
-		error = new Error(message);
-	}
-
-	error.shortMessage = shortMessage;
-	error.command = command;
-	error.escapedCommand = escapedCommand;
-	error.exitCode = exitCode;
-	error.signal = signal;
-	error.signalDescription = signalDescription;
-	error.stdout = stdout;
-	error.stderr = stderr;
-
-	if (all !== undefined) {
-		error.all = all;
-	}
-
-	if ('bufferedData' in error) {
-		delete error.bufferedData;
-	}
-
-	error.failed = true;
-	error.timedOut = Boolean(timedOut);
-	error.isCanceled = isCanceled;
-	error.killed = killed && !timedOut;
-
-	return error;
-};
-
-const aliases = ['stdin', 'stdout', 'stderr'];
-
-const hasAlias = options => aliases.some(alias => options[alias] !== undefined);
-
-const normalizeStdio = options => {
-	if (!options) {
-		return;
-	}
-
-	const {stdio} = options;
-
-	if (stdio === undefined) {
-		return aliases.map(alias => options[alias]);
-	}
-
-	if (hasAlias(options)) {
-		throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map(alias => `\`${alias}\``).join(', ')}`);
-	}
-
-	if (typeof stdio === 'string') {
-		return stdio;
-	}
-
-	if (!Array.isArray(stdio)) {
-		throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
-	}
-
-	const length = Math.max(stdio.length, aliases.length);
-	return Array.from({length}, (value, index) => stdio[index]);
-};
-
-const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
-
-// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
-const spawnedKill = (kill, signal = 'SIGTERM', options = {}) => {
-	const killResult = kill(signal);
-	setKillTimeout(kill, signal, options, killResult);
-	return killResult;
-};
-
-const setKillTimeout = (kill, signal, options, killResult) => {
-	if (!shouldForceKill(signal, options, killResult)) {
-		return;
-	}
-
-	const timeout = getForceKillAfterTimeout(options);
-	const t = setTimeout(() => {
-		kill('SIGKILL');
-	}, timeout);
-
-	// Guarded because there's no `.unref()` when `execa` is used in the renderer
-	// process in Electron. This cannot be tested since we don't run tests in
-	// Electron.
-	// istanbul ignore else
-	if (t.unref) {
-		t.unref();
-	}
-};
-
-const shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
-
-const isSigterm = signal => signal === require$$0.constants.signals.SIGTERM
-		|| (typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');
-
-const getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {
-	if (forceKillAfterTimeout === true) {
-		return DEFAULT_FORCE_KILL_TIMEOUT;
-	}
-
-	if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
-		throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
-	}
-
-	return forceKillAfterTimeout;
-};
-
-// `childProcess.cancel()`
-const spawnedCancel = (spawned, context) => {
-	const killResult = spawned.kill();
-
-	if (killResult) {
-		context.isCanceled = true;
-	}
-};
-
-const timeoutKill = (spawned, signal, reject) => {
-	spawned.kill(signal);
-	reject(Object.assign(new Error('Timed out'), {timedOut: true, signal}));
-};
-
-// `timeout` option handling
-const setupTimeout = (spawned, {timeout, killSignal = 'SIGTERM'}, spawnedPromise) => {
-	if (timeout === 0 || timeout === undefined) {
-		return spawnedPromise;
-	}
-
-	let timeoutId;
-	const timeoutPromise = new Promise((resolve, reject) => {
-		timeoutId = setTimeout(() => {
-			timeoutKill(spawned, killSignal, reject);
-		}, timeout);
-	});
-
-	const safeSpawnedPromise = spawnedPromise.finally(() => {
-		clearTimeout(timeoutId);
-	});
-
-	return Promise.race([timeoutPromise, safeSpawnedPromise]);
-};
-
-const validateTimeout = ({timeout}) => {
-	if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
-		throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
-	}
-};
-
-// `cleanup` option handling
-const setExitHandler = async (spawned, {cleanup, detached}, timedPromise) => {
-	if (!cleanup || detached) {
-		return timedPromise;
-	}
-
-	const removeExitHandler = signalExit.exports(() => {
-		spawned.kill();
-	});
-
-	return timedPromise.finally(() => {
-		removeExitHandler();
-	});
-};
-
-function isStream(stream) {
-	return stream !== null
-		&& typeof stream === 'object'
-		&& typeof stream.pipe === 'function';
-}
-
-// `input` option
-const handleInput = (spawned, input) => {
-	// Checking for stdin is workaround for https://github.com/nodejs/node/issues/26852
-	// @todo remove `|| spawned.stdin === undefined` once we drop support for Node.js <=12.2.0
-	if (input === undefined || spawned.stdin === undefined) {
-		return;
-	}
-
-	if (isStream(input)) {
-		input.pipe(spawned.stdin);
-	} else {
-		spawned.stdin.end(input);
-	}
-};
-
-// `all` interleaves `stdout` and `stderr`
-const makeAllStream = (spawned, {all}) => {
-	if (!all || (!spawned.stdout && !spawned.stderr)) {
-		return;
-	}
-
-	const mixed = mergeStream();
-
-	if (spawned.stdout) {
-		mixed.add(spawned.stdout);
-	}
-
-	if (spawned.stderr) {
-		mixed.add(spawned.stderr);
-	}
-
-	return mixed;
-};
-
-// On failure, `result.stdout|stderr|all` should contain the currently buffered stream
-const getBufferedData = async (stream, streamPromise) => {
-	if (!stream) {
-		return;
-	}
-
-	stream.destroy();
-
-	try {
-		return await streamPromise;
-	} catch (error) {
-		return error.bufferedData;
-	}
-};
-
-const getStreamPromise = (stream, {encoding, buffer, maxBuffer}) => {
-	if (!stream || !buffer) {
-		return;
-	}
-
-	if (encoding) {
-		return getStream.exports(stream, {encoding, maxBuffer});
-	}
-
-	return getStream.exports.buffer(stream, {maxBuffer});
-};
-
-// Retrieve result of child process: exit code, signal, error, streams (stdout/stderr/all)
-const getSpawnedResult = async ({stdout, stderr, all}, {encoding, buffer, maxBuffer}, processDone) => {
-	const stdoutPromise = getStreamPromise(stdout, {encoding, buffer, maxBuffer});
-	const stderrPromise = getStreamPromise(stderr, {encoding, buffer, maxBuffer});
-	const allPromise = getStreamPromise(all, {encoding, buffer, maxBuffer: maxBuffer * 2});
-
-	try {
-		return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
-	} catch (error) {
-		return Promise.all([
-			{error, signal: error.signal, timedOut: error.timedOut},
-			getBufferedData(stdout, stdoutPromise),
-			getBufferedData(stderr, stderrPromise),
-			getBufferedData(all, allPromise),
-		]);
-	}
-};
-
-const nativePromisePrototype = (async () => {})().constructor.prototype;
-const descriptors = ['then', 'catch', 'finally'].map(property => [
-	property,
-	Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property),
-]);
-
-// The return value is a mixin of `childProcess` and `Promise`
-const mergePromise = (spawned, promise) => {
-	for (const [property, descriptor] of descriptors) {
-		// Starting the main `promise` is deferred to avoid consuming streams
-		const value = typeof promise === 'function'
-			? (...args) => Reflect.apply(descriptor.value, promise(), args)
-			: descriptor.value.bind(promise);
-
-		Reflect.defineProperty(spawned, property, {...descriptor, value});
-	}
-
-	return spawned;
-};
-
-// Use promises instead of `child_process` events
-const getSpawnedPromise = spawned => new Promise((resolve, reject) => {
-	spawned.on('exit', (exitCode, signal) => {
-		resolve({exitCode, signal});
-	});
-
-	spawned.on('error', error => {
-		reject(error);
-	});
-
-	if (spawned.stdin) {
-		spawned.stdin.on('error', error => {
-			reject(error);
-		});
-	}
-});
-
-const normalizeArgs = (file, args = []) => {
-	if (!Array.isArray(args)) {
-		return [file];
-	}
-
-	return [file, ...args];
-};
-
-const NO_ESCAPE_REGEXP = /^[\w.-]+$/;
-const DOUBLE_QUOTES_REGEXP = /"/g;
-
-const escapeArg = arg => {
-	if (typeof arg !== 'string' || NO_ESCAPE_REGEXP.test(arg)) {
-		return arg;
-	}
-
-	return `"${arg.replace(DOUBLE_QUOTES_REGEXP, '\\"')}"`;
-};
-
-const joinCommand = (file, args) => normalizeArgs(file, args).join(' ');
-
-const getEscapedCommand = (file, args) => normalizeArgs(file, args).map(arg => escapeArg(arg)).join(' ');
-
-const DEFAULT_MAX_BUFFER = 1000 * 1000 * 100;
-
-const getEnv = ({env: envOption, extendEnv, preferLocal, localDir, execPath}) => {
-	const env = extendEnv ? {...process$1.env, ...envOption} : envOption;
-
-	if (preferLocal) {
-		return npmRunPathEnv({env, cwd: localDir, execPath});
-	}
-
-	return env;
-};
-
-const handleArguments = (file, args, options = {}) => {
-	const parsed = crossSpawn.exports._parse(file, args, options);
-	file = parsed.command;
-	args = parsed.args;
-	options = parsed.options;
-
-	options = {
-		maxBuffer: DEFAULT_MAX_BUFFER,
-		buffer: true,
-		stripFinalNewline: true,
-		extendEnv: true,
-		preferLocal: false,
-		localDir: options.cwd || process$1.cwd(),
-		execPath: process$1.execPath,
-		encoding: 'utf8',
-		reject: true,
-		cleanup: true,
-		all: false,
-		windowsHide: true,
-		...options,
-	};
-
-	options.env = getEnv(options);
-
-	options.stdio = normalizeStdio(options);
-
-	if (process$1.platform === 'win32' && path$a.basename(file, '.exe') === 'cmd') {
-		// #116
-		args.unshift('/q');
-	}
-
-	return {file, args, options, parsed};
-};
-
-const handleOutput = (options, value, error) => {
-	if (typeof value !== 'string' && !Buffer.isBuffer(value)) {
-		// When `execaSync()` errors, we normalize it to '' to mimic `execa()`
-		return error === undefined ? undefined : '';
-	}
-
-	if (options.stripFinalNewline) {
-		return stripFinalNewline(value);
-	}
-
-	return value;
-};
-
-function execa(file, args, options) {
-	const parsed = handleArguments(file, args, options);
-	const command = joinCommand(file, args);
-	const escapedCommand = getEscapedCommand(file, args);
-
-	validateTimeout(parsed.options);
-
-	let spawned;
-	try {
-		spawned = childProcess.spawn(parsed.file, parsed.args, parsed.options);
-	} catch (error) {
-		// Ensure the returned error is always both a promise and a child process
-		const dummySpawned = new childProcess.ChildProcess();
-		const errorPromise = Promise.reject(makeError({
-			error,
-			stdout: '',
-			stderr: '',
-			all: '',
-			command,
-			escapedCommand,
-			parsed,
-			timedOut: false,
-			isCanceled: false,
-			killed: false,
-		}));
-		return mergePromise(dummySpawned, errorPromise);
-	}
-
-	const spawnedPromise = getSpawnedPromise(spawned);
-	const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
-	const processDone = setExitHandler(spawned, parsed.options, timedPromise);
-
-	const context = {isCanceled: false};
-
-	spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
-	spawned.cancel = spawnedCancel.bind(null, spawned, context);
-
-	const handlePromise = async () => {
-		const [{error, exitCode, signal, timedOut}, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
-		const stdout = handleOutput(parsed.options, stdoutResult);
-		const stderr = handleOutput(parsed.options, stderrResult);
-		const all = handleOutput(parsed.options, allResult);
-
-		if (error || exitCode !== 0 || signal !== null) {
-			const returnedError = makeError({
-				error,
-				exitCode,
-				signal,
-				stdout,
-				stderr,
-				all,
-				command,
-				escapedCommand,
-				parsed,
-				timedOut,
-				isCanceled: context.isCanceled || (parsed.options.signal ? parsed.options.signal.aborted : false),
-				killed: spawned.killed,
-			});
-
-			if (!parsed.options.reject) {
-				return returnedError;
-			}
-
-			throw returnedError;
-		}
-
-		return {
-			command,
-			escapedCommand,
-			exitCode: 0,
-			stdout,
-			stderr,
-			all,
-			failed: false,
-			timedOut: false,
-			isCanceled: false,
-			killed: false,
-		};
-	};
-
-	const handlePromiseOnce = onetime(handlePromise);
-
-	handleInput(spawned, parsed.options.input);
-
-	spawned.all = makeAllStream(spawned, parsed.options);
-
-	return mergePromise(spawned, handlePromiseOnce);
-}
-
-class VitestGit {
-  constructor(cwd) {
-    this.cwd = cwd;
-  }
-  async resolveFilesWithGitCommand(args) {
-    let result;
-    try {
-      result = await execa("git", args, { cwd: this.root });
-    } catch (e) {
-      e.message = e.stderr;
-      throw e;
-    }
-    return result.stdout.split("\n").filter((s) => s !== "").map((changedPath) => resolve(this.root, changedPath));
-  }
-  async findChangedFiles(options) {
-    const root = await this.getRoot(this.cwd);
-    if (!root)
-      return null;
-    this.root = root;
-    const changedSince = options.changedSince;
-    if (typeof changedSince === "string") {
-      const [committed, staged2, unstaged2] = await Promise.all([
-        this.getFilesSince(changedSince),
-        this.getStagedFiles(),
-        this.getUnstagedFiles()
-      ]);
-      return [...committed, ...staged2, ...unstaged2];
-    }
-    const [staged, unstaged] = await Promise.all([
-      this.getStagedFiles(),
-      this.getUnstagedFiles()
-    ]);
-    return [...staged, ...unstaged];
-  }
-  getFilesSince(hash) {
-    return this.resolveFilesWithGitCommand(["diff", "--name-only", `${hash}...HEAD`]);
-  }
-  getStagedFiles() {
-    return this.resolveFilesWithGitCommand(["diff", "--cached", "--name-only"]);
-  }
-  getUnstagedFiles() {
-    return this.resolveFilesWithGitCommand([
-      "ls-files",
-      "--other",
-      "--modified",
-      "--exclude-standard"
-    ]);
-  }
-  async getRoot(cwd) {
-    const options = ["rev-parse", "--show-cdup"];
-    try {
-      const result = await execa("git", options, { cwd });
-      return resolve(cwd, result.stdout);
-    } catch {
-      return null;
-    }
-  }
-}
-
 const ESC = '\u001B[';
 const OSC = '\u001B]';
 const BEL = '\u0007';
@@ -9806,7 +8710,7 @@ ansiEscapes.iTerm = {
 	}
 };
 
-const restoreCursor = onetime$1.exports(() => {
+const restoreCursor = onetime.exports(() => {
 	signalExit.exports(() => {
 		process$1.stderr.write('\u001B[?25h');
 	}, {alwaysLast: true});
@@ -10137,7 +9041,7 @@ createLogUpdate(process$1.stdout);
 
 createLogUpdate(process$1.stderr);
 
-var version = "0.18.1";
+var version = "0.19.0";
 
 function fileFromParsedStack(stack) {
   var _a, _b;
@@ -10288,7 +9192,7 @@ function generateCodeFrame(source, indent = 0, start = 0, end, range = 2) {
         const lineLength = lines[j].length;
         if (lineLength > 200)
           return "";
-        res.push(lineNo(j + 1) + cliTruncate(lines[j], columns - 5 - indent));
+        res.push(lineNo(j + 1) + cliTruncate(lines[j].replace(/\t/g, " "), columns - 5 - indent));
         if (j === i) {
           const pad = start - (count - lineLength);
           const length = Math.max(1, end > count ? lineLength - pad : end - start);
@@ -10369,15 +9273,17 @@ class Logger {
       this.error(picocolors.exports.red("\nNo test files found, exiting with code 1"));
   }
   printBanner() {
-    var _a, _b;
+    var _a, _b, _c;
     this.log();
     const versionTest = this.ctx.config.watch ? picocolors.exports.blue(`v${version}`) : picocolors.exports.cyan(`v${version}`);
     const mode = this.ctx.config.watch ? picocolors.exports.blue(" DEV ") : picocolors.exports.cyan(" RUN ");
     this.log(`${picocolors.exports.inverse(picocolors.exports.bold(mode))} ${versionTest} ${picocolors.exports.gray(this.ctx.config.root)}`);
-    if (this.ctx.config.ui)
-      this.log(picocolors.exports.dim(picocolors.exports.green(`      UI started at http://${((_a = this.ctx.config.api) == null ? void 0 : _a.host) || "localhost"}:${picocolors.exports.bold(`${this.ctx.server.config.server.port}`)}${this.ctx.config.uiBase}`)));
+    if (this.ctx.config.browser)
+      this.log(picocolors.exports.dim(picocolors.exports.green(`      Browser runner started at http://${((_a = this.ctx.config.api) == null ? void 0 : _a.host) || "localhost"}:${picocolors.exports.bold(`${this.ctx.server.config.server.port}`)}`)));
+    else if (this.ctx.config.ui)
+      this.log(picocolors.exports.dim(picocolors.exports.green(`      UI started at http://${((_b = this.ctx.config.api) == null ? void 0 : _b.host) || "localhost"}:${picocolors.exports.bold(`${this.ctx.server.config.server.port}`)}${this.ctx.config.uiBase}`)));
     else if (this.ctx.config.api)
-      this.log(picocolors.exports.dim(picocolors.exports.green(`      API started at http://${((_b = this.ctx.config.api) == null ? void 0 : _b.host) || "localhost"}:${picocolors.exports.bold(`${this.ctx.config.api.port}`)}`)));
+      this.log(picocolors.exports.dim(picocolors.exports.green(`      API started at http://${((_c = this.ctx.config.api) == null ? void 0 : _c.host) || "localhost"}:${picocolors.exports.bold(`${this.ctx.config.api.port}`)}`)));
     this.log();
   }
   async printUnhandledErrors(errors) {
@@ -10394,7 +9300,6 @@ Please, resolve all the errors to make sure your tests are not affected.`));
 }
 
 const WATCHER_DEBOUNCE = 100;
-const CLOSE_TIMEOUT = 1e3;
 class Vitest {
   constructor() {
     this.config = void 0;
@@ -10479,7 +9384,7 @@ class Vitest {
     await this.runFiles(files);
     if (this.config.coverage.enabled)
       await reportCoverage(this);
-    if (this.config.watch)
+    if (this.config.watch && !this.config.browser)
       await this.report("onWatcherStart");
   }
   async getTestDependencies(filepath) {
@@ -10503,6 +9408,7 @@ class Vitest {
   }
   async filterTestsBySource(tests) {
     if (this.config.changed && !this.config.related) {
+      const { VitestGit } = await import('./chunk-node-git.9058b82a.mjs');
       const vitestGit = new VitestGit(this.config.root);
       const related2 = await vitestGit.findChangedFiles({
         changedSince: this.config.changed
@@ -10549,7 +9455,8 @@ class Vitest {
       const files = this.state.getFiles();
       if (hasFailed(files))
         process.exitCode = 1;
-      await this.report("onFinished", files, this.state.getUnhandledErrors());
+      if (!this.config.browser)
+        await this.report("onFinished", files, this.state.getUnhandledErrors());
       this.cache.results.updateResults(files);
       await this.cache.results.writeToCache();
     })().finally(() => {
@@ -10560,7 +9467,8 @@ class Vitest {
   async rerunFiles(files = this.state.getFilepaths(), trigger) {
     await this.report("onWatcherRerun", files, trigger);
     await this.runFiles(files);
-    await this.report("onWatcherStart");
+    if (!this.config.browser)
+      await this.report("onWatcherStart");
   }
   async changeNamePattern(pattern, files = this.state.getFilepaths(), trigger) {
     this.config.testNamePattern = pattern ? new RegExp(pattern) : void 0;
@@ -10609,7 +9517,8 @@ class Vitest {
       await this.runFiles(files);
       if (this.config.coverage.enabled)
         await reportCoverage(this);
-      await this.report("onWatcherStart");
+      if (!this.config.browser)
+        await this.report("onWatcherStart");
     }, WATCHER_DEBOUNCE);
   }
   registerWatcher() {
@@ -10693,9 +9602,9 @@ class Vitest {
   }
   async exit(force = false) {
     safeSetTimeout(() => {
-      console.warn(`close timed out after ${CLOSE_TIMEOUT}ms`);
+      console.warn(`close timed out after ${this.config.teardownTimeout}ms`);
       process.exit();
-    }, CLOSE_TIMEOUT).unref();
+    }, this.config.teardownTimeout).unref();
     await this.close();
     if (force)
       process.exit();
@@ -10986,9 +9895,15 @@ function CSSEnablerPlugin(ctx) {
 async function VitestPlugin(options = {}, ctx = new Vitest()) {
   let haveStarted = false;
   async function UIPlugin() {
-    await ensurePackageInstalled("@vitest/ui");
+    var _a;
+    await ensurePackageInstalled("@vitest/ui", ((_a = ctx.config) == null ? void 0 : _a.root) || options.root || process.cwd());
     return (await import('@vitest/ui')).default(options.uiBase);
   }
+  async function BrowserPlugin() {
+    var _a;
+    await ensurePackageInstalled("@vitest/browser", ((_a = ctx.config) == null ? void 0 : _a.root) || options.root || process.cwd());
+    return (await import('@vitest/browser')).default("/");
+  }
   return [
     {
       name: "vitest",
@@ -11023,10 +9938,15 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
           }
         }
         options.defines = defines;
-        const open = preOptions.ui && preOptions.open ? preOptions.uiBase ?? "/__vitest__/" : void 0;
+        let open;
+        if (preOptions.ui && preOptions.open)
+          open = preOptions.uiBase ?? "/__vitest__/";
+        else if (preOptions.browser)
+          open = "/";
         const config = {
           resolve: {
-            mainFields: []
+            mainFields: [],
+            alias: preOptions.alias
           },
           server: {
             ...preOptions.api,
@@ -11036,13 +9956,17 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
             open,
             hmr: false,
             preTransformRequests: false
-          },
-          cacheDir: void 0,
-          optimizeDeps: {
-            disabled: true,
-            entries: []
           }
         };
+        if (!options.browser) {
+          Object.assign(config, {
+            cacheDir: void 0,
+            optimizeDeps: {
+              disabled: true,
+              entries: []
+            }
+          });
+        }
         return config;
       },
       async configResolved(viteConfig) {
@@ -11050,6 +9974,8 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
         const viteConfigTest = viteConfig.test || {};
         if (viteConfigTest.watch === false)
           viteConfigTest.run = true;
+        if ("alias" in viteConfigTest)
+          delete viteConfigTest.alias;
         options = deepMerge({}, configDefaults, viteConfigTest, options);
         options.api = resolveApiConfig(options);
         const { PROD, DEV, ...envs } = viteConfig.env;
@@ -11066,7 +9992,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
           await ctx.setServer(options, server);
           haveStarted = true;
           if (options.api && options.watch)
-            (await import('./chunk-api-setup.9d3f7670.mjs')).setup(ctx);
+            (await import('./chunk-api-setup.0cf2c96a.mjs')).setup(ctx);
         } catch (err) {
           ctx.logger.printError(err, true);
           process.exit(1);
@@ -11078,6 +10004,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest()) {
     EnvReplacerPlugin(),
     MocksPlugin(),
     GlobalSetupPlugin(ctx),
+    ...options.browser ? await BrowserPlugin() : [],
     CSSEnablerPlugin(ctx),
     options.ui ? await UIPlugin() : null
   ].filter(notNullish);
@@ -11152,8 +10079,8 @@ function registerConsoleShortcuts(ctx) {
   let rl;
   function on() {
     off();
-    rl = require$$0$3.createInterface({ input: process.stdin, escapeCodeTimeout: 50 });
-    require$$0$3.emitKeypressEvents(process.stdin, rl);
+    rl = require$$0$2.createInterface({ input: process.stdin, escapeCodeTimeout: 50 });
+    require$$0$2.emitKeypressEvents(process.stdin, rl);
     if (process.stdin.isTTY)
       process.stdin.setRawMode(true);
     process.stdin.on("keypress", keypressHandler);
@@ -11175,7 +10102,10 @@ async function startVitest(cliFilters, options, viteOverrides) {
   (_a = process.env).NODE_ENV ?? (_a.NODE_ENV = options.mode || "test");
   if (options.run)
     options.watch = false;
-  if (!await ensurePackageInstalled("vite")) {
+  if (options.browser)
+    options.threads = false;
+  const root = resolve(options.root || process.cwd());
+  if (!await ensurePackageInstalled("vite", root)) {
     process.exitCode = 1;
     return false;
   }
@@ -11183,14 +10113,14 @@ async function startVitest(cliFilters, options, viteOverrides) {
     options.coverage = { enabled: options.coverage };
   const ctx = await createVitest(options, viteOverrides);
   if (ctx.config.coverage.enabled) {
-    if (!await ensurePackageInstalled("c8")) {
+    if (!await ensurePackageInstalled("c8", root)) {
       process.exitCode = 1;
       return false;
     }
   }
   if (ctx.config.environment && ctx.config.environment !== "node") {
     const packageName = envPackageNames[ctx.config.environment];
-    if (!await ensurePackageInstalled(packageName)) {
+    if (!await ensurePackageInstalled(packageName, root)) {
       process.exitCode = 1;
       return false;
     }