@venos-inc/venos 0.1.4 → 0.1.6

package/etc/mcp-server/node_modules/vitest/dist/chunks/execute.B7h3T_Hc.js

@@ -0,0 +1,708 @@
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import vm from 'node:vm';
+import { processError } from '@vitest/utils/error';
+import { normalize as normalize$1 } from 'pathe';
+import { ViteNodeRunner, DEFAULT_REQUEST_STUBS } from 'vite-node/client';
+import { isInternalRequest, isNodeBuiltin as isNodeBuiltin$1, isPrimitive, toFilePath } from 'vite-node/utils';
+import { distDir } from '../path.js';
+import { resolve as resolve$1, isAbsolute as isAbsolute$1 } from 'node:path';
+import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
+import { builtinModules } from 'node:module';
+import { highlight } from '@vitest/utils';
+
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			const both = pathTrailing && segLeading;
+			if (both) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let 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;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const basename = function(p, extension) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
+		}
+	}
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+
+const { existsSync, readdirSync, statSync } = fs;
+function findMockRedirect(root, mockPath, external) {
+	const path = external || mockPath;
+	// it's a node_module alias
+	// all mocks should be inside <root>/__mocks__
+	if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
+		const mockDirname = dirname(path);
+		const mockFolder = join(root, "__mocks__", mockDirname);
+		if (!existsSync(mockFolder)) return null;
+		const baseOriginal = basename(path);
+		function findFile(mockFolder, baseOriginal) {
+			const files = readdirSync(mockFolder);
+			for (const file of files) {
+				const baseFile = basename(file, extname(file));
+				if (baseFile === baseOriginal) {
+					const path = resolve(mockFolder, file);
+					// if the same name, return the file
+					if (statSync(path).isFile()) return path;
+					else {
+						// find folder/index.{js,ts}
+						const indexFile = findFile(path, "index");
+						if (indexFile) return indexFile;
+					}
+				}
+			}
+			return null;
+		}
+		return findFile(mockFolder, baseOriginal);
+	}
+	const dir = dirname(path);
+	const baseId = basename(path);
+	const fullPath = resolve(dir, "__mocks__", baseId);
+	return existsSync(fullPath) ? fullPath : null;
+}
+const builtins = new Set([
+	...builtinModules,
+	"assert/strict",
+	"diagnostics_channel",
+	"dns/promises",
+	"fs/promises",
+	"path/posix",
+	"path/win32",
+	"readline/promises",
+	"stream/consumers",
+	"stream/promises",
+	"stream/web",
+	"timers/promises",
+	"util/types",
+	"wasi"
+]);
+// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
+const prefixedBuiltins = new Set([
+	"node:sea",
+	"node:sqlite",
+	"node:test",
+	"node:test/reporters"
+]);
+const NODE_BUILTIN_NAMESPACE = "node:";
+function isNodeBuiltin(id) {
+	if (prefixedBuiltins.has(id)) return true;
+	return builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(NODE_BUILTIN_NAMESPACE.length) : id);
+}
+
+const spyModulePath = resolve$1(distDir, "spy.js");
+class VitestMocker {
+	static pendingIds = [];
+	spyModule;
+	primitives;
+	filterPublicKeys;
+	registries = /* @__PURE__ */ new Map();
+	mockContext = { callstack: null };
+	constructor(executor) {
+		this.executor = executor;
+		const context = this.executor.options.context;
+		if (context) this.primitives = vm.runInContext("({ Object, Error, Function, RegExp, Symbol, Array, Map })", context);
+		else this.primitives = {
+			Object,
+			Error,
+			Function,
+			RegExp,
+			Symbol: globalThis.Symbol,
+			Array,
+			Map
+		};
+		const Symbol = this.primitives.Symbol;
+		this.filterPublicKeys = [
+			"__esModule",
+			Symbol.asyncIterator,
+			Symbol.hasInstance,
+			Symbol.isConcatSpreadable,
+			Symbol.iterator,
+			Symbol.match,
+			Symbol.matchAll,
+			Symbol.replace,
+			Symbol.search,
+			Symbol.split,
+			Symbol.species,
+			Symbol.toPrimitive,
+			Symbol.toStringTag,
+			Symbol.unscopables
+		];
+	}
+	get root() {
+		return this.executor.options.root;
+	}
+	get moduleCache() {
+		return this.executor.moduleCache;
+	}
+	get moduleDirectories() {
+		return this.executor.options.moduleDirectories || [];
+	}
+	async initializeSpyModule() {
+		this.spyModule = await this.executor.executeId(spyModulePath);
+	}
+	getMockerRegistry() {
+		const suite = this.getSuiteFilepath();
+		if (!this.registries.has(suite)) this.registries.set(suite, new MockerRegistry());
+		return this.registries.get(suite);
+	}
+	reset() {
+		this.registries.clear();
+	}
+	deleteCachedItem(id) {
+		const mockId = this.getMockPath(id);
+		if (this.moduleCache.has(mockId)) this.moduleCache.delete(mockId);
+	}
+	isModuleDirectory(path) {
+		return this.moduleDirectories.some((dir) => path.includes(dir));
+	}
+	getSuiteFilepath() {
+		return this.executor.state.filepath || "global";
+	}
+	createError(message, codeFrame) {
+		const Error = this.primitives.Error;
+		const error = new Error(message);
+		Object.assign(error, { codeFrame });
+		return error;
+	}
+	async resolvePath(rawId, importer) {
+		let id;
+		let fsPath;
+		try {
+			[id, fsPath] = await this.executor.originalResolveUrl(rawId, importer);
+		} catch (error) {
+			// it's allowed to mock unresolved modules
+			if (error.code === "ERR_MODULE_NOT_FOUND") {
+				const { id: unresolvedId } = error[Symbol.for("vitest.error.not_found.data")];
+				id = unresolvedId;
+				fsPath = unresolvedId;
+			} else throw error;
+		}
+		// external is node_module or unresolved module
+		// for example, some people mock "vscode" and don't have it installed
+		const external = !isAbsolute$1(fsPath) || this.isModuleDirectory(fsPath) ? rawId : null;
+		return {
+			id,
+			fsPath,
+			external: external ? this.normalizePath(external) : external
+		};
+	}
+	async resolveMocks() {
+		if (!VitestMocker.pendingIds.length) return;
+		await Promise.all(VitestMocker.pendingIds.map(async (mock) => {
+			const { fsPath, external } = await this.resolvePath(mock.id, mock.importer);
+			if (mock.action === "unmock") this.unmockPath(fsPath);
+			if (mock.action === "mock") this.mockPath(mock.id, fsPath, external, mock.type, mock.factory);
+		}));
+		VitestMocker.pendingIds = [];
+	}
+	async callFunctionMock(dep, mock) {
+		const cached = this.moduleCache.get(dep)?.exports;
+		if (cached) return cached;
+		const exports = await mock.resolve();
+		const moduleExports = new Proxy(exports, { get: (target, prop) => {
+			const val = target[prop];
+			// 'then' can exist on non-Promise objects, need nested instanceof check for logic to work
+			if (prop === "then") {
+				if (target instanceof Promise) return target.then.bind(target);
+			} else if (!(prop in target)) {
+				if (this.filterPublicKeys.includes(prop)) return void 0;
+				throw this.createError(`[vitest] No "${String(prop)}" export is defined on the "${mock.raw}" mock. Did you forget to return it from "vi.mock"?
+If you need to partially mock a module, you can use "importOriginal" helper inside:
+`, highlight(`vi.mock(import("${mock.raw}"), async (importOriginal) => {
+  const actual = await importOriginal()
+  return {
+    ...actual,
+    // your mocked methods
+  }
+})`));
+			}
+			return val;
+		} });
+		this.moduleCache.set(dep, { exports: moduleExports });
+		return moduleExports;
+	}
+	// public method to avoid circular dependency
+	getMockContext() {
+		return this.mockContext;
+	}
+	// path used to store mocked dependencies
+	getMockPath(dep) {
+		return `mock:${dep}`;
+	}
+	getDependencyMock(id) {
+		const registry = this.getMockerRegistry();
+		return registry.get(id);
+	}
+	normalizePath(path) {
+		return this.moduleCache.normalizePath(path);
+	}
+	resolveMockPath(mockPath, external) {
+		return findMockRedirect(this.root, mockPath, external);
+	}
+	mockObject(object, mockExports = {}, behavior = "automock") {
+		const spyOn = this.spyModule?.spyOn;
+		if (!spyOn) throw this.createError("[vitest] `spyModule` is not defined. This is a Vitest error. Please open a new issue with reproduction.");
+		return mockObject({
+			globalConstructors: this.primitives,
+			spyOn,
+			type: behavior
+		}, object, mockExports);
+	}
+	unmockPath(path) {
+		const registry = this.getMockerRegistry();
+		const id = this.normalizePath(path);
+		registry.delete(id);
+		this.deleteCachedItem(id);
+	}
+	mockPath(originalId, path, external, mockType, factory) {
+		const registry = this.getMockerRegistry();
+		const id = this.normalizePath(path);
+		if (mockType === "manual") registry.register("manual", originalId, id, id, factory);
+		else if (mockType === "autospy") registry.register("autospy", originalId, id, id);
+		else {
+			const redirect = this.resolveMockPath(id, external);
+			if (redirect) registry.register("redirect", originalId, id, id, redirect);
+			else registry.register("automock", originalId, id, id);
+		}
+		// every time the mock is registered, we remove the previous one from the cache
+		this.deleteCachedItem(id);
+	}
+	async importActual(rawId, importer, callstack) {
+		const { id, fsPath } = await this.resolvePath(rawId, importer);
+		const result = await this.executor.cachedRequest(id, fsPath, callstack || [importer]);
+		return result;
+	}
+	async importMock(rawId, importee) {
+		const { id, fsPath, external } = await this.resolvePath(rawId, importee);
+		const normalizedId = this.normalizePath(fsPath);
+		let mock = this.getDependencyMock(normalizedId);
+		if (!mock) {
+			const redirect = this.resolveMockPath(normalizedId, external);
+			if (redirect) mock = new RedirectedModule(rawId, normalizedId, normalizedId, redirect);
+			else mock = new AutomockedModule(rawId, normalizedId, normalizedId);
+		}
+		if (mock.type === "automock" || mock.type === "autospy") {
+			const mod = await this.executor.cachedRequest(id, fsPath, [importee]);
+			return this.mockObject(mod, {}, mock.type);
+		}
+		if (mock.type === "manual") return this.callFunctionMock(fsPath, mock);
+		return this.executor.dependencyRequest(mock.redirect, mock.redirect, [importee]);
+	}
+	async requestWithMock(url, callstack) {
+		const id = this.normalizePath(url);
+		const mock = this.getDependencyMock(id);
+		if (!mock) return;
+		const mockPath = this.getMockPath(id);
+		if (mock.type === "automock" || mock.type === "autospy") {
+			const cache = this.moduleCache.get(mockPath);
+			if (cache.exports) return cache.exports;
+			const exports = {};
+			// Assign the empty exports object early to allow for cycles to work. The object will be filled by mockObject()
+			this.moduleCache.set(mockPath, { exports });
+			const mod = await this.executor.directRequest(url, url, callstack);
+			this.mockObject(mod, exports, mock.type);
+			return exports;
+		}
+		if (mock.type === "manual" && !callstack.includes(mockPath) && !callstack.includes(url)) try {
+			callstack.push(mockPath);
+			// this will not work if user does Promise.all(import(), import())
+			// we can also use AsyncLocalStorage to store callstack, but this won't work in the browser
+			// maybe we should improve mock API in the future?
+			this.mockContext.callstack = callstack;
+			return await this.callFunctionMock(mockPath, mock);
+		} finally {
+			this.mockContext.callstack = null;
+			const indexMock = callstack.indexOf(mockPath);
+			callstack.splice(indexMock, 1);
+		}
+		else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) return mock.redirect;
+	}
+	queueMock(id, importer, factoryOrOptions) {
+		const mockType = getMockType(factoryOrOptions);
+		VitestMocker.pendingIds.push({
+			action: "mock",
+			id,
+			importer,
+			factory: typeof factoryOrOptions === "function" ? factoryOrOptions : void 0,
+			type: mockType
+		});
+	}
+	queueUnmock(id, importer) {
+		VitestMocker.pendingIds.push({
+			action: "unmock",
+			id,
+			importer
+		});
+	}
+}
+function getMockType(factoryOrOptions) {
+	if (!factoryOrOptions) return "automock";
+	if (typeof factoryOrOptions === "function") return "manual";
+	return factoryOrOptions.spy ? "autospy" : "automock";
+}
+
+const normalizedDistDir = normalize$1(distDir);
+const { readFileSync } = fs;
+async function createVitestExecutor(options) {
+	const runner = new VitestExecutor(options);
+	await runner.executeId("/@vite/env");
+	await runner.mocker.initializeSpyModule();
+	return runner;
+}
+const externalizeMap = /* @__PURE__ */ new Map();
+const bareVitestRegexp = /^@?vitest(?:\/|$)/;
+const dispose = [];
+function listenForErrors(state) {
+	dispose.forEach((fn) => fn());
+	dispose.length = 0;
+	function catchError(err, type, event) {
+		const worker = state();
+		const listeners = process.listeners(event);
+		// if there is another listener, assume that it's handled by user code
+		// one is Vitest's own listener
+		if (listeners.length > 1) return;
+		const error = processError(err);
+		if (!isPrimitive(error)) {
+			error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : void 0;
+			if (worker.filepath) error.VITEST_TEST_PATH = worker.filepath;
+			error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
+		}
+		state().rpc.onUnhandledError(error, type);
+	}
+	const uncaughtException = (e) => catchError(e, "Uncaught Exception", "uncaughtException");
+	const unhandledRejection = (e) => catchError(e, "Unhandled Rejection", "unhandledRejection");
+	process.on("uncaughtException", uncaughtException);
+	process.on("unhandledRejection", unhandledRejection);
+	dispose.push(() => {
+		process.off("uncaughtException", uncaughtException);
+		process.off("unhandledRejection", unhandledRejection);
+	});
+}
+const relativeIds = {};
+function getVitestImport(id, state) {
+	if (externalizeMap.has(id)) return { externalize: externalizeMap.get(id) };
+	// always externalize Vitest because we import from there before running tests
+	// so we already have it cached by Node.js
+	const root = state().config.root;
+	const relativeRoot = relativeIds[root] ?? (relativeIds[root] = normalizedDistDir.slice(root.length));
+	if (id.includes(distDir) || id.includes(normalizedDistDir) || relativeRoot && relativeRoot !== "/" && id.startsWith(relativeRoot)) {
+		const { path } = toFilePath(id, root);
+		const externalize = pathToFileURL(path).toString();
+		externalizeMap.set(id, externalize);
+		return { externalize };
+	}
+	if (bareVitestRegexp.test(id)) {
+		externalizeMap.set(id, id);
+		return { externalize: id };
+	}
+	return null;
+}
+async function startVitestExecutor(options) {
+	const state = () => globalThis.__vitest_worker__ || options.state;
+	const rpc = () => state().rpc;
+	process.exit = (code = process.exitCode || 0) => {
+		throw new Error(`process.exit unexpectedly called with "${code}"`);
+	};
+	listenForErrors(state);
+	const getTransformMode = () => {
+		return state().environment.transformMode ?? "ssr";
+	};
+	return await createVitestExecutor({
+		async fetchModule(id) {
+			const vitest = getVitestImport(id, state);
+			if (vitest) return vitest;
+			const result = await rpc().fetch(id, getTransformMode());
+			if (result.id && !result.externalize) {
+				const code = readFileSync(result.id, "utf-8");
+				return { code };
+			}
+			return result;
+		},
+		resolveId(id, importer) {
+			return rpc().resolveId(id, importer, getTransformMode());
+		},
+		get moduleCache() {
+			return state().moduleCache;
+		},
+		get moduleExecutionInfo() {
+			return state().moduleExecutionInfo;
+		},
+		get interopDefault() {
+			return state().config.deps.interopDefault;
+		},
+		get moduleDirectories() {
+			return state().config.deps.moduleDirectories;
+		},
+		get root() {
+			return state().config.root;
+		},
+		get base() {
+			return state().config.base;
+		},
+		...options
+	});
+}
+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");
+	const 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);
+}
+function getDefaultRequestStubs(context) {
+	if (!context) {
+		const clientStub = {
+			...DEFAULT_REQUEST_STUBS["@vite/client"],
+			updateStyle,
+			removeStyle
+		};
+		return {
+			"/@vite/client": clientStub,
+			"@vite/client": clientStub
+		};
+	}
+	const clientStub = vm.runInContext(`(defaultClient) => ({ ...defaultClient, updateStyle: ${updateStyle.toString()}, removeStyle: ${removeStyle.toString()} })`, context)(DEFAULT_REQUEST_STUBS["@vite/client"]);
+	return {
+		"/@vite/client": clientStub,
+		"@vite/client": clientStub
+	};
+}
+class VitestExecutor extends ViteNodeRunner {
+	mocker;
+	externalModules;
+	primitives;
+	constructor(options) {
+		super({
+			...options,
+			interopDefault: options.context ? false : options.interopDefault
+		});
+		this.options = options;
+		this.mocker = new VitestMocker(this);
+		if (!options.context) {
+			Object.defineProperty(globalThis, "__vitest_mocker__", {
+				value: this.mocker,
+				writable: true,
+				configurable: true
+			});
+			this.primitives = {
+				Object,
+				Reflect,
+				Symbol
+			};
+		} else if (options.externalModulesExecutor) {
+			this.primitives = vm.runInContext("({ Object, Reflect, Symbol })", options.context);
+			this.externalModules = options.externalModulesExecutor;
+		} else throw new Error("When context is provided, externalModulesExecutor must be provided as well.");
+	}
+	getContextPrimitives() {
+		return this.primitives;
+	}
+	get state() {
+		// @ts-expect-error injected untyped global
+		return globalThis.__vitest_worker__ || this.options.state;
+	}
+	get moduleExecutionInfo() {
+		return this.options.moduleExecutionInfo;
+	}
+	shouldResolveId(id, _importee) {
+		if (isInternalRequest(id) || id.startsWith("data:")) return false;
+		const transformMode = this.state.environment?.transformMode ?? "ssr";
+		// do not try and resolve node builtins in Node
+		// import('url') returns Node internal even if 'url' package is installed
+		return transformMode === "ssr" ? !isNodeBuiltin$1(id) : !id.startsWith("node:");
+	}
+	async originalResolveUrl(id, importer) {
+		return super.resolveUrl(id, importer);
+	}
+	async resolveUrl(id, importer) {
+		if (VitestMocker.pendingIds.length) await this.mocker.resolveMocks();
+		if (importer && importer.startsWith("mock:")) importer = importer.slice(5);
+		try {
+			return await super.resolveUrl(id, importer);
+		} catch (error) {
+			if (error.code === "ERR_MODULE_NOT_FOUND") {
+				const { id } = error[Symbol.for("vitest.error.not_found.data")];
+				const path = this.mocker.normalizePath(id);
+				const mock = this.mocker.getDependencyMock(path);
+				if (mock !== void 0) return [id, id];
+			}
+			throw error;
+		}
+	}
+	async runModule(context, transformed) {
+		const vmContext = this.options.context;
+		if (!vmContext || !this.externalModules) return super.runModule(context, transformed);
+		// add 'use strict' since ESM enables it by default
+		const codeDefinition = `'use strict';async (${Object.keys(context).join(",")})=>{{`;
+		const code = `${codeDefinition}${transformed}\n}}`;
+		const options = {
+			filename: context.__filename,
+			lineOffset: 0,
+			columnOffset: -codeDefinition.length
+		};
+		const finishModuleExecutionInfo = this.startCalculateModuleExecutionInfo(options.filename, codeDefinition.length);
+		try {
+			const fn = vm.runInContext(code, vmContext, {
+				...options,
+				importModuleDynamically: this.externalModules.importModuleDynamically
+			});
+			await fn(...Object.values(context));
+		} finally {
+			this.options.moduleExecutionInfo?.set(options.filename, finishModuleExecutionInfo());
+		}
+	}
+	async importExternalModule(path) {
+		if (this.externalModules) return this.externalModules.import(path);
+		return super.importExternalModule(path);
+	}
+	async dependencyRequest(id, fsPath, callstack) {
+		const mocked = await this.mocker.requestWithMock(fsPath, callstack);
+		if (typeof mocked === "string") return super.dependencyRequest(mocked, mocked, callstack);
+		if (mocked && typeof mocked === "object") return mocked;
+		return super.dependencyRequest(id, fsPath, callstack);
+	}
+	prepareContext(context) {
+		// support `import.meta.vitest` for test entry
+		if (this.state.filepath && normalize$1(this.state.filepath) === normalize$1(context.__filename)) {
+			const globalNamespace = this.options.context || globalThis;
+			Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", { get: () => globalNamespace.__vitest_index__ });
+		}
+		if (this.options.context && this.externalModules) context.require = this.externalModules.createRequire(context.__filename);
+		return context;
+	}
+}
+
+export { VitestExecutor as V, getDefaultRequestStubs as g, startVitestExecutor as s };