vitest 4.0.0-beta.1 → 4.0.0-beta.10

package/dist/index.d.ts

@@ -1,28 +1,26 @@
-import { S as SerializedTestSpecification } from './chunks/browser.d.q8Z0P0q1.js';
-export { B as BrowserTesterOptions } from './chunks/browser.d.q8Z0P0q1.js';
-import './chunks/global.d.CVbXEflG.js';
+import { S as SerializedTestSpecification } from './chunks/browser.d.yFAklsD1.js';
+export { B as BrowserTesterOptions } from './chunks/browser.d.yFAklsD1.js';
+import './chunks/global.d.BK3X7FW1.js';
 import { File, TestAnnotation, TaskResultPack, TaskEventPack, TaskPopulated } from '@vitest/runner';
-export { CancelReason, ExtendedContext, HookCleanupCallback, HookListener, ImportDuration, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Custom as RunnerCustomCase, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskEventPack as RunnerTaskEventPack, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, TaskContext, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestAnnotation, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
-import { a as BirpcReturn } from './chunks/worker.d.DoNjFAiv.js';
-export { C as ContextRPC, c as ContextTestEnvironment, b as RunnerRPC, R as RuntimeRPC, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.DoNjFAiv.js';
-import { a as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.d.HJdfX-8k.js';
-export { b as RuntimeConfig, S as SerializedCoverageConfig } from './chunks/config.d.HJdfX-8k.js';
-import { b as Awaitable, U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, P as ProvidedContext } from './chunks/environment.d.CUq4cUgQ.js';
-export { A as AfterSuiteRunMeta } from './chunks/environment.d.CUq4cUgQ.js';
+export { CancelReason, HookCleanupCallback, HookListener, ImportDuration, OnTestFailedHandler, OnTestFinishedHandler, RunMode, Task as RunnerTask, TaskBase as RunnerTaskBase, TaskEventPack as RunnerTaskEventPack, TaskResult as RunnerTaskResult, TaskResultPack as RunnerTaskResultPack, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, SuiteAPI, SuiteCollector, SuiteFactory, TaskCustomOptions, TaskMeta, TaskState, TestAPI, TestAnnotation, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+import { a as BirpcReturn } from './chunks/worker.d.BDsXGkwh.js';
+export { C as ContextRPC, c as ContextTestEnvironment, b as RunnerRPC, R as RuntimeRPC, T as TestExecutionMethod, W as WorkerGlobalState } from './chunks/worker.d.BDsXGkwh.js';
+import { a as SerializedConfig, F as FakeTimerInstallOpts, R as RuntimeOptions } from './chunks/config.d.B_LthbQq.js';
+export { b as RuntimeConfig, S as SerializedCoverageConfig } from './chunks/config.d.B_LthbQq.js';
+import { b as Awaitable, U as UserConsoleLog, L as LabelColor, M as ModuleGraphData, P as ProvidedContext } from './chunks/environment.d.BsToaxti.js';
+export { A as AfterSuiteRunMeta } from './chunks/environment.d.BsToaxti.js';
 import { ExpectStatic } from '@vitest/expect';
-export { Assertion, AsymmetricMatchersContaining, DeeplyAllowMatchers, ExpectPollOptions, ExpectStatic, JestAssertion, Matchers } from '@vitest/expect';
+export { Assertion, AsymmetricMatchersContaining, DeeplyAllowMatchers, ExpectPollOptions, ExpectStatic, JestAssertion, Matchers, chai } from '@vitest/expect';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
 export { Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject } from '@vitest/spy';
 import { M as MockFactoryWithHelper, a as MockOptions } from './chunks/mocker.d.BE_2ls6u.js';
-export { b as bench } from './chunks/suite.d.FvehnV49.js';
-export { a as BenchFunction, b as Benchmark, c as BenchmarkAPI, B as BenchmarkResult } from './chunks/benchmark.d.BwvBVTda.js';
+export { b as bench } from './chunks/suite.d.BJWk38HB.js';
+export { a as BenchFunction, b as Benchmark, c as BenchmarkAPI, B as BenchmarkResult } from './chunks/benchmark.d.DAaHLpsq.js';
 export { ExpectTypeOf, expectTypeOf } from 'expect-type';
 export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotSerializer, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
 export { ParsedStack, SerializedError, TestError } from '@vitest/utils';
 export { DiffOptions } from '@vitest/utils/diff';
-import * as chai from 'chai';
-export { chai };
-export { assert, should } from 'chai';
+export { EvaluatedModules } from 'vite/module-runner';
 export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
 import '@vitest/pretty-format';
 import '@vitest/mocker';
@@ -41,7 +39,7 @@ interface SourceMap {
 interface TransformResultWithSource {
 	code: string;
 	map: SourceMap | {
-		mappings: ""
+		mappings: "";
 	} | null;
 	etag?: string;
 	deps?: string[];
@@ -54,12 +52,9 @@ interface WebSocketHandlers {
 	getTestFiles: () => Promise<SerializedTestSpecification[]>;
 	getPaths: () => string[];
 	getConfig: () => SerializedConfig;
-	// TODO: Remove in v4
-	/** @deprecated -- Use `getResolvedProjectLabels` instead */
-	getResolvedProjectNames: () => string[];
 	getResolvedProjectLabels: () => {
-		name: string
-		color?: LabelColor
+		name: string;
+		color?: LabelColor;
 	}[];
 	getModuleGraph: (projectName: string, id: string, browser?: boolean) => Promise<ModuleGraphData>;
 	getTransformResult: (projectName: string, id: string, browser?: boolean) => Promise<TransformResultWithSource | undefined>;
@@ -84,6 +79,8 @@ type WebSocketRPC = BirpcReturn<WebSocketEvents, WebSocketHandlers>;
 
 declare function createExpect(test?: TaskPopulated): ExpectStatic;
 declare const globalExpect: ExpectStatic;
+declare const assert: Chai.Assert;
+declare const should: () => Chai.Should;
 
 /**
 * Gives access to injected context provided from the main thread.
@@ -91,7 +88,6 @@ declare const globalExpect: ExpectStatic;
 */
 declare function inject<T extends keyof ProvidedContext & string>(key: T): ProvidedContext[T];
 
-// The waitFor function was inspired by https://github.com/testing-library/web-testing-library/pull/2
 type WaitForCallback<T> = () => T | Promise<T>;
 interface WaitForOptions {
 	/**
@@ -280,13 +276,11 @@ interface VitestUtils {
 	* The call to `vi.mock` is hoisted to the top of the file, so you don't have access to variables declared in the global file scope
 	* unless they are defined with [`vi.hoisted`](https://vitest.dev/api/vi#vi-hoisted) before this call.
 	*
-	* Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking#modules).
+	* Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking/modules).
 	* @param path Path to the module. Can be aliased, if your Vitest config supports it
 	* @param factory Mocked module factory. The result of this function will be an exports object
 	*/
-	// eslint-disable-next-line ts/method-signature-style
 	mock(path: string, factory?: MockFactoryWithHelper | MockOptions): void;
-	// eslint-disable-next-line ts/method-signature-style
 	mock<T>(module: Promise<T>, factory?: MockFactoryWithHelper<T> | MockOptions): void;
 	/**
 	* Removes module from mocked registry. All calls to import will return the original module even if it was mocked before.
@@ -294,22 +288,18 @@ interface VitestUtils {
 	* This call is hoisted to the top of the file, so it will only unmock modules that were defined in `setupFiles`, for example.
 	* @param path Path to the module. Can be aliased, if your Vitest config supports it
 	*/
-	// eslint-disable-next-line ts/method-signature-style
 	unmock(path: string): void;
-	// eslint-disable-next-line ts/method-signature-style
 	unmock(module: Promise<unknown>): void;
 	/**
 	* Mocks every subsequent [dynamic import](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/import) call.
 	*
 	* Unlike [`vi.mock`](https://vitest.dev/api/vi#vi-mock), this method will not mock statically imported modules because it is not hoisted to the top of the file.
 	*
-	* Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking#modules).
+	* Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking/modules).
 	* @param path Path to the module. Can be aliased, if your Vitest config supports it
 	* @param factory Mocked module factory. The result of this function will be an exports object
 	*/
-	// eslint-disable-next-line ts/method-signature-style
 	doMock(path: string, factory?: MockFactoryWithHelper | MockOptions): void;
-	// eslint-disable-next-line ts/method-signature-style
 	doMock<T>(module: Promise<T>, factory?: MockFactoryWithHelper<T> | MockOptions): void;
 	/**
 	* Removes module from mocked registry. All subsequent calls to import will return original module.
@@ -317,9 +307,7 @@ interface VitestUtils {
 	* Unlike [`vi.unmock`](https://vitest.dev/api/vi#vi-unmock), this method is not hoisted to the top of the file.
 	* @param path Path to the module. Can be aliased, if your Vitest config supports it
 	*/
-	// eslint-disable-next-line ts/method-signature-style
 	doUnmock(path: string): void;
-	// eslint-disable-next-line ts/method-signature-style
 	doUnmock(module: Promise<unknown>): void;
 	/**
 	* Imports module, bypassing all checks if it should be mocked.
@@ -338,7 +326,7 @@ interface VitestUtils {
 	/**
 	* Imports a module with all of its properties and nested properties mocked.
 	*
-	* Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking#modules).
+	* Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking/modules).
 	* @example
 	* ```ts
 	* const example = await vi.importMock<typeof import('./example.js')>('./example.js')
@@ -373,12 +361,17 @@ interface VitestUtils {
 	*
 	* expect(mocked.simple()).toBe('mocked')
 	* expect(mocked.nested.method()).toBe('mocked nested')
+	*
+	* const spied = vi.mockObject(original, { spy: true })
+	* expect(spied.simple()).toBe('value')
+	* expect(spied.simple).toHaveBeenCalled()
+	* expect(spied.simple.mock.results[0]).toEqual({ type: 'return', value: 'value' })
 	* ```
 	*
 	* @param value - The object to be mocked
 	* @returns A deeply mocked version of the input object
 	*/
-	mockObject: <T>(value: T) => MaybeMockedDeep<T>;
+	mockObject: <T>(value: T, options?: MockOptions) => MaybeMockedDeep<T>;
 	/**
 	* Type helper for TypeScript. Just returns the object that was passed.
 	*
@@ -399,17 +392,17 @@ interface VitestUtils {
 	* @param options If the object is partially or deeply mocked
 	*/
 	mocked: (<T>(item: T, deep?: false) => MaybeMocked<T>) & (<T>(item: T, deep: true) => MaybeMockedDeep<T>) & (<T>(item: T, options: {
-		partial?: false
-		deep?: false
+		partial?: false;
+		deep?: false;
 	}) => MaybeMocked<T>) & (<T>(item: T, options: {
-		partial?: false
-		deep: true
+		partial?: false;
+		deep: true;
 	}) => MaybeMockedDeep<T>) & (<T>(item: T, options: {
-		partial: true
-		deep?: false
+		partial: true;
+		deep?: false;
 	}) => MaybePartiallyMocked<T>) & (<T>(item: T, options: {
-		partial: true
-		deep: true
+		partial: true;
+		deep: true;
 	}) => MaybePartiallyMockedDeep<T>) & (<T>(item: T) => MaybeMocked<T>);
 	/**
 	* Checks that a given parameter is a mock function. If you are using TypeScript, it will also narrow down its type.
@@ -476,7 +469,7 @@ interface VitestUtils {
 	*/
 	setConfig: (config: RuntimeOptions) => void;
 	/**
-	* If config was changed with `vi.setConfig`, this will reset it to the original state.
+	* If config was changed with `vi.setConfig`, this will reset it to the original state().
 	*/
 	resetConfig: () => void;
 }
@@ -493,5 +486,5 @@ interface BrowserUI {
 	setIframeViewport: (width: number, height: number) => Promise<void>;
 }
 
-export { LabelColor, ModuleGraphData, ProvidedContext, SerializedConfig, SerializedTestSpecification, UserConsoleLog, assertType, createExpect, globalExpect as expect, inject, vi, vitest };
+export { LabelColor, ModuleGraphData, ProvidedContext, SerializedConfig, SerializedTestSpecification, UserConsoleLog, assert, assertType, createExpect, globalExpect as expect, inject, should, vi, vitest };
 export type { AssertType, BrowserUI, TransformResultWithSource, VitestUtils, WebSocketEvents, WebSocketHandlers, WebSocketRPC };

package/dist/index.js

@@ -1,18 +1,16 @@
-export { c as createExpect, a as expect, i as inject, v as vi, b as vitest } from './chunks/vi.bdSIJ99Y.js';
-export { b as bench } from './chunks/benchmark.CYdenmiT.js';
-export { a as assertType } from './chunks/index.BWf_gE5n.js';
+export { b as assert, c as createExpect, g as expect, i as inject, s as should, v as vi, d as vitest } from './chunks/vi.ZPgvtBao.js';
+export { b as bench } from './chunks/benchmark.CJUa-Hsa.js';
+export { a as assertType } from './chunks/index.CMfqw92x.js';
 export { expectTypeOf } from 'expect-type';
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
-import * as chai from 'chai';
-export { chai };
-export { assert, should } from 'chai';
-import '@vitest/expect';
+export { EvaluatedModules } from 'vite/module-runner';
+export { chai } from '@vitest/expect';
 import '@vitest/runner/utils';
-import './chunks/utils.XdZDrNZV.js';
+import './chunks/utils.D2R2NiOH.js';
 import '@vitest/utils';
 import './chunks/_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
 import '@vitest/spy';
 import '@vitest/utils/source-map';
-import './chunks/date.Bq6ZW5rf.js';
+import './chunks/date.-jtEtIeV.js';

package/dist/module-evaluator.d.ts

@@ -0,0 +1,13 @@
+import 'vite/module-runner';
+export { b as VitestModuleEvaluator, a as VitestModuleEvaluatorOptions, c as createImportMetaEnvProxy, g as getDefaultRequestStubs, i as isPrimitive, u as unwrapId, w as wrapId } from './chunks/moduleRunner.d.D9nBoC4p.js';
+import 'node:vm';
+import '@vitest/spy';
+import './chunks/worker.d.BDsXGkwh.js';
+import '@vitest/runner';
+import './chunks/config.d.B_LthbQq.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/utils/diff';
+import './chunks/environment.d.BsToaxti.js';
+import '@vitest/mocker';
+import './chunks/mocker.d.BE_2ls6u.js';

package/dist/module-evaluator.js

@@ -0,0 +1,276 @@
+import { isBuiltin, createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import vm from 'node:vm';
+import { isAbsolute } from 'pathe';
+import { ssrModuleExportsKey, ssrImportMetaKey, ssrImportKey, ssrDynamicImportKey, ssrExportAllKey } from 'vite/module-runner';
+
+const performanceNow = performance.now.bind(performance);
+class ModuleDebug {
+	executionStack = [];
+	startCalculateModuleExecutionInfo(filename, startOffset) {
+		const startTime = performanceNow();
+		return this.executionStack.push({
+			filename,
+			startTime,
+			subImportTime: 0
+		}), () => {
+			const duration = performanceNow() - startTime, currentExecution = this.executionStack.pop();
+			if (currentExecution == null) throw new Error("Execution stack is empty, this should never happen");
+			const selfTime = duration - currentExecution.subImportTime;
+			if (this.executionStack.length > 0) this.executionStack.at(-1).subImportTime += duration;
+			return {
+				startOffset,
+				duration,
+				selfTime
+			};
+		};
+	}
+}
+
+const isWindows = process.platform === "win32";
+class VitestModuleEvaluator {
+	stubs = {};
+	env = createImportMetaEnvProxy();
+	vm;
+	compiledFunctionArgumentsNames;
+	compiledFunctionArgumentsValues = [];
+	primitives;
+	debug = new ModuleDebug();
+	constructor(vmOptions, options = {}) {
+		if (this.options = options, this.vm = vmOptions, this.stubs = getDefaultRequestStubs(vmOptions?.context), options.compiledFunctionArgumentsNames) this.compiledFunctionArgumentsNames = options.compiledFunctionArgumentsNames;
+		if (options.compiledFunctionArgumentsValues) this.compiledFunctionArgumentsValues = options.compiledFunctionArgumentsValues;
+		if (vmOptions) this.primitives = vm.runInContext("({ Object, Proxy, Reflect })", vmOptions.context);
+		else this.primitives = {
+			Object,
+			Proxy,
+			Reflect
+		};
+	}
+	convertIdToImportUrl(id) {
+		// TODO: vitest returns paths for external modules, but Vite returns file://
+		// unfortunetly, there is a bug in Vite where ID is resolved incorrectly, so we can't return files until the fix is merged
+		// https://github.com/vitejs/vite/pull/20449
+		if (!isWindows || isBuiltin(id) || /^(?:node:|data:|http:|https:|file:)/.test(id)) return id;
+		const [filepath, query] = id.split("?");
+		return query ? `${pathToFileURL(filepath).toString()}?${query}` : pathToFileURL(filepath).toString();
+	}
+	async runExternalModule(id) {
+		if (id in this.stubs) return this.stubs[id];
+		const file = this.convertIdToImportUrl(id), namespace = this.vm ? await this.vm.externalModulesExecutor.import(file) : await import(file);
+		if (!this.shouldInterop(file, namespace)) return namespace;
+		const { mod, defaultExport } = interopModule(namespace), { Proxy, Reflect } = this.primitives, proxy = new Proxy(mod, {
+			get(mod, prop) {
+				return prop === "default" ? defaultExport : mod[prop] ?? defaultExport?.[prop];
+			},
+			has(mod, prop) {
+				return prop === "default" ? defaultExport !== void 0 : prop in mod || defaultExport && prop in defaultExport;
+			},
+			getOwnPropertyDescriptor(mod, prop) {
+				const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
+				if (descriptor) return descriptor;
+				if (prop === "default" && defaultExport !== void 0) return {
+					value: defaultExport,
+					enumerable: true,
+					configurable: true
+				};
+			}
+		});
+		return proxy;
+	}
+	async runInlinedModule(context, code, module) {
+		context.__vite_ssr_import_meta__.env = this.env;
+		const { Reflect, Proxy, Object } = this.primitives, exportsObject = context[ssrModuleExportsKey], SYMBOL_NOT_DEFINED = Symbol("not defined");
+		let moduleExports = SYMBOL_NOT_DEFINED;
+		// this proxy is triggered only on exports.{name} and module.exports access
+		// inside the module itself. imported module is always "exports"
+		const cjsExports = new Proxy(exportsObject, {
+			get: (target, p, receiver) => {
+				return Reflect.has(target, p) ? Reflect.get(target, p, receiver) : Reflect.get(Object.prototype, p, receiver);
+			},
+			getPrototypeOf: () => Object.prototype,
+			set: (_, p, value) => {
+				// treat "module.exports =" the same as "exports.default =" to not have nested "default.default",
+				// so "exports.default" becomes the actual module
+				if (p === "default" && this.shouldInterop(module.file, { default: value }) && cjsExports !== value) return exportAll(cjsExports, value), exportsObject.default = value, true;
+				if (!Reflect.has(exportsObject, "default")) exportsObject.default = {};
+				// returns undefined, when accessing named exports, if default is not an object
+				// but is still present inside hasOwnKeys, this is Node behaviour for CJS
+				if (moduleExports !== SYMBOL_NOT_DEFINED && isPrimitive(moduleExports)) return defineExport(exportsObject, p, () => void 0), true;
+				if (!isPrimitive(exportsObject.default)) exportsObject.default[p] = value;
+				if (p !== "default") defineExport(exportsObject, p, () => value);
+				return true;
+			}
+		}), moduleProxy = {
+			set exports(value) {
+				exportAll(cjsExports, value), exportsObject.default = value, moduleExports = value;
+			},
+			get exports() {
+				return cjsExports;
+			}
+		}, meta = context[ssrImportMetaKey], testFilepath = this.options.getCurrentTestFilepath?.();
+		if (testFilepath === module.file) {
+			const globalNamespace = this.vm?.context || globalThis;
+			Object.defineProperty(meta, "vitest", { get: () => globalNamespace.__vitest_index__ });
+		}
+		const filename = meta.filename, dirname = meta.dirname, require = this.createRequire(filename), argumentsList = [
+			ssrModuleExportsKey,
+			ssrImportMetaKey,
+			ssrImportKey,
+			ssrDynamicImportKey,
+			ssrExportAllKey,
+			"__vite_ssr_exportName__",
+			"__filename",
+			"__dirname",
+			"module",
+			"exports",
+			"require"
+		];
+		if (this.compiledFunctionArgumentsNames) argumentsList.push(...this.compiledFunctionArgumentsNames);
+		// add 'use strict' since ESM enables it by default
+		const codeDefinition = `'use strict';async (${argumentsList.join(",")})=>{{`, wrappedCode = `${codeDefinition}${code}\n}}`, options = {
+			filename: module.id,
+			lineOffset: 0,
+			columnOffset: -codeDefinition.length
+		}, finishModuleExecutionInfo = this.debug.startCalculateModuleExecutionInfo(options.filename, codeDefinition.length);
+		try {
+			const initModule = this.vm ? vm.runInContext(wrappedCode, this.vm.context, options) : vm.runInThisContext(wrappedCode, options), dynamicRequest = async (dep, options) => {
+				return dep = String(dep), dep[0] === "#" ? context[ssrDynamicImportKey](wrapId(dep), options) : context[ssrDynamicImportKey](dep, options);
+			};
+			await initModule(
+				context[ssrModuleExportsKey],
+				context[ssrImportMetaKey],
+				context[ssrImportKey],
+				dynamicRequest,
+				context[ssrExportAllKey],
+				// vite 7 support, remove when vite 7+ is supported
+				context.__vite_ssr_exportName__ || ((name, getter) => Object.defineProperty(exportsObject, name, {
+					enumerable: true,
+					configurable: true,
+					get: getter
+				})),
+				filename,
+				dirname,
+				moduleProxy,
+				cjsExports,
+				require,
+				...this.compiledFunctionArgumentsValues
+			);
+		} finally {
+			// moduleExecutionInfo needs to use Node filename instead of the normalized one
+			// because we rely on this behaviour in coverage-v8, for example
+			this.options.moduleExecutionInfo?.set(options.filename, finishModuleExecutionInfo());
+		}
+	}
+	createRequire(filename) {
+		return filename.startsWith("\0") || !isAbsolute(filename) ? () => ({}) : this.vm ? this.vm.externalModulesExecutor.createRequire(filename) : createRequire(filename);
+	}
+	shouldInterop(path, mod) {
+		// never interop ESM modules
+		// TODO: should also skip for `.js` with `type="module"`
+		return this.options.interopDefault === false ? false : !path.endsWith(".mjs") && "default" in mod;
+	}
+}
+function createImportMetaEnvProxy() {
+	// packages/vitest/src/node/plugins/index.ts:146
+	const booleanKeys = [
+		"DEV",
+		"PROD",
+		"SSR"
+	];
+	return new Proxy(process.env, {
+		get(_, key) {
+			return typeof key === "string" ? booleanKeys.includes(key) ? !!process.env[key] : process.env[key] : void 0;
+		},
+		set(_, key, value) {
+			if (typeof key !== "string") return true;
+			if (booleanKeys.includes(key)) process.env[key] = value ? "1" : "";
+			else process.env[key] = value;
+			return true;
+		}
+	});
+}
+function updateStyle(id, css) {
+	if (typeof document === "undefined") return;
+	const element = document.querySelector(`[data-vite-dev-id="${id}"]`);
+	if (element) {
+		element.textContent = css;
+		return;
+	}
+	const head = document.querySelector("head"), style = document.createElement("style");
+	style.setAttribute("type", "text/css"), style.setAttribute("data-vite-dev-id", id), style.textContent = css, head?.appendChild(style);
+}
+function removeStyle(id) {
+	if (typeof document === "undefined") return;
+	const sheet = document.querySelector(`[data-vite-dev-id="${id}"]`);
+	if (sheet) document.head.removeChild(sheet);
+}
+const defaultClientStub = {
+	injectQuery: (id) => id,
+	createHotContext: () => {
+		return {
+			accept: () => {},
+			prune: () => {},
+			dispose: () => {},
+			decline: () => {},
+			invalidate: () => {},
+			on: () => {},
+			send: () => {}
+		};
+	},
+	updateStyle: () => {},
+	removeStyle: () => {}
+};
+function getDefaultRequestStubs(context) {
+	if (!context) {
+		const clientStub = {
+			...defaultClientStub,
+			updateStyle,
+			removeStyle
+		};
+		return { "/@vite/client": clientStub };
+	}
+	const clientStub = vm.runInContext(`(defaultClient) => ({ ...defaultClient, updateStyle: ${updateStyle.toString()}, removeStyle: ${removeStyle.toString()} })`, context)(defaultClientStub);
+	return { "/@vite/client": clientStub };
+}
+function exportAll(exports, sourceModule) {
+	if (exports !== sourceModule && !(isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise)) {
+		for (const key in sourceModule) if (key !== "default" && !(key in exports)) try {
+			defineExport(exports, key, () => sourceModule[key]);
+		} catch {}
+	}
+}
+// keep consistency with Vite on how exports are defined
+function defineExport(exports, key, value) {
+	Object.defineProperty(exports, key, {
+		enumerable: true,
+		configurable: true,
+		get: value
+	});
+}
+function isPrimitive(v) {
+	const isObject = typeof v === "object" || typeof v === "function";
+	return !isObject || v == null;
+}
+function interopModule(mod) {
+	if (isPrimitive(mod)) return {
+		mod: { default: mod },
+		defaultExport: mod
+	};
+	let defaultExport = "default" in mod ? mod.default : mod;
+	if (!isPrimitive(defaultExport) && "__esModule" in defaultExport) {
+		if (mod = defaultExport, "default" in defaultExport) defaultExport = defaultExport.default;
+	}
+	return {
+		mod,
+		defaultExport
+	};
+}
+const VALID_ID_PREFIX = `/@id/`, NULL_BYTE_PLACEHOLDER = `__x00__`;
+function wrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+function unwrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id.slice(VALID_ID_PREFIX.length).replace(NULL_BYTE_PLACEHOLDER, "\0") : id;
+}
+
+export { VitestModuleEvaluator, createImportMetaEnvProxy, getDefaultRequestStubs, isPrimitive, unwrapId, wrapId };

package/dist/module-runner.js

@@ -0,0 +1,15 @@
+export { VitestModuleEvaluator } from './module-evaluator.js';
+export { a as VITEST_VM_CONTEXT_SYMBOL, V as VitestModuleRunner, s as startVitestModuleRunner } from './chunks/startModuleRunner.p67gbNo9.js';
+export { g as getWorkerState } from './chunks/utils.D2R2NiOH.js';
+import 'node:module';
+import 'node:url';
+import 'node:vm';
+import 'pathe';
+import 'vite/module-runner';
+import 'node:fs';
+import '@vitest/utils';
+import './path.js';
+import 'node:path';
+import '@vitest/utils/error';
+import '@vitest/mocker';
+import './chunks/moduleTransport.I-bgQy0S.js';