vite-node 5.1.0 → 5.2.0

package/dist/cli.d.mts

@@ -0,0 +1,21 @@
+import { b as ViteNodeServerOptions } from "./types-Dtew7m7O.mjs";
+
+//#region src/cli.d.ts
+interface CliOptions {
+  "root"?: string;
+  "script"?: boolean;
+  "config"?: string;
+  "mode"?: string;
+  "watch"?: boolean;
+  "inspect"?: boolean;
+  "inspectAddr"?: string;
+  "options"?: ViteNodeServerOptionsCLI;
+  "version"?: boolean;
+  "help"?: boolean;
+  "--"?: string[];
+}
+type Optional<T> = T | undefined;
+type ComputeViteNodeServerOptionsCLI<T extends Record<string, any>> = { [K in keyof T]: T[K] extends Optional<RegExp[]> ? string | string[] : T[K] extends Optional<(string | RegExp)[]> ? string | string[] : T[K] extends Optional<(string | RegExp)[] | true> ? string | string[] | true : T[K] extends Optional<Record<string, any>> ? ComputeViteNodeServerOptionsCLI<T[K]> : T[K] };
+type ViteNodeServerOptionsCLI = ComputeViteNodeServerOptionsCLI<ViteNodeServerOptions>;
+//#endregion
+export { CliOptions, ViteNodeServerOptionsCLI };

package/dist/cli.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import { t as C } from "./dist-B2ebky9O.mjs";
+import { t as ViteNodeServer } from "./server-BWywEVuB.mjs";
+import "./constants-DRkacFwN.mjs";
+import { h as toArray } from "./utils-ExLpYVUV.mjs";
+import { n as installSourcemapsSupport } from "./source-map-DQLD3K8K.mjs";
+import { r as ViteNodeRunner } from "./client-CyS7w_FB.mjs";
+import { r as handleMessage, s as viteNodeHmrPlugin, t as createHotContext } from "./hmr-qEG3qSgW.mjs";
+import process from "node:process";
+import { createServer, loadEnv, version } from "vite";
+import { resolve } from "node:path";
+import cac from "cac";
+
+//#region package.json
+var version$1 = "5.2.0";
+
+//#endregion
+//#region src/cli.ts
+const cli = cac("vite-node");
+cli.option("-r, --root <path>", "Use specified root directory").option("-c, --config <path>", "Use specified config file").option("-m, --mode <mode>", "Set env mode").option("-w, --watch", "Restart on file changes, similar to \"nodemon\"").option("--inspect", "Enable Node.js inspector").option("--inspect-addr [host:port]", "Enable Node.js inspector with specified address").option("--script", "Use vite-node as a script runner").option("--options <options>", "Use specified Vite server options").option("-v, --version", "Output the version number").option("-h, --help", "Display help for command");
+cli.command("[...files]").allowUnknownOptions().action(run);
+cli.parse(process.argv, { run: false });
+if (cli.args.length === 0) cli.runMatchedCommand();
+else {
+	const i = cli.rawArgs.indexOf(cli.args[0]) + 1;
+	const scriptArgs = cli.rawArgs.slice(i).filter((it) => it !== "--");
+	const executeArgs = [
+		...cli.rawArgs.slice(0, i),
+		"--",
+		...scriptArgs
+	];
+	cli.parse(executeArgs);
+}
+async function run(files, options = {}) {
+	if (options.inspect || options.inspectAddr) {
+		const { open } = await import("node:inspector");
+		const [host, port] = options.inspectAddr?.split(":") || ["127.0.0.1", "9229"];
+		open(Number(port), host, false);
+	}
+	if (options.script) {
+		files = [files[0]];
+		options = {};
+		process.argv = [
+			process.argv[0],
+			resolve(files[0]),
+			...process.argv.slice(2).filter((arg) => arg !== "--script" && arg !== files[0])
+		];
+	} else process.argv = [...process.argv.slice(0, 2), ...options["--"] || []];
+	if (options.version) {
+		cli.version(version$1);
+		cli.outputVersion();
+		process.exit(0);
+	}
+	if (options.help) {
+		cli.version(version$1).outputHelp();
+		process.exit(0);
+	}
+	if (!files.length) {
+		console.error(C.red("No files specified."));
+		cli.version(version$1).outputHelp();
+		process.exit(1);
+	}
+	const serverOptions = options.options ? parseServerOptions(options.options) : {};
+	const server = await createServer({
+		logLevel: "error",
+		configFile: options.config,
+		root: options.root,
+		mode: options.mode,
+		server: {
+			hmr: !!options.watch,
+			watch: options.watch ? void 0 : null
+		},
+		plugins: [options.watch && viteNodeHmrPlugin()]
+	});
+	if (Number(version.split(".")[0]) < 6) await server.pluginContainer.buildStart({});
+	else await server.environments.client.pluginContainer.buildStart({});
+	const env = loadEnv(server.config.mode, server.config.envDir, "");
+	for (const key in env) process.env[key] ??= env[key];
+	const node = new ViteNodeServer(server, serverOptions);
+	installSourcemapsSupport({ getSourceMap: (source) => node.getSourceMap(source) });
+	const runner = new ViteNodeRunner({
+		root: server.config.root,
+		base: server.config.base,
+		fetchModule(id) {
+			return node.fetchModule(id);
+		},
+		resolveId(id, importer) {
+			return node.resolveId(id, importer);
+		},
+		createHotContext(runner$1, url) {
+			return createHotContext(runner$1, server.emitter, files, url);
+		}
+	});
+	await runner.executeId("/@vite/env");
+	for (const file of files) await runner.executeFile(file);
+	if (!options.watch) await server.close();
+	server.emitter?.on("message", (payload) => {
+		handleMessage(runner, server.emitter, files, payload);
+	});
+	if (options.watch) {
+		process.on("uncaughtException", (err) => {
+			console.error(C.red("[vite-node] Failed to execute file: \n"), err);
+		});
+		if (process.env.VITE_TEST_WATCHER_DEBUG) {
+			const nodePath = await import("node:path");
+			async function waitForWatched(files$1) {
+				while (!files$1.every((file) => isWatched(file))) await new Promise((resolve$1) => setTimeout(resolve$1, 20));
+			}
+			function isWatched(file) {
+				const watched = server.watcher.getWatched();
+				const resolved = nodePath.resolve(file);
+				const dir = nodePath.dirname(resolved);
+				const base = nodePath.basename(resolved);
+				return watched[dir]?.includes(base);
+			}
+			await waitForWatched(files);
+			console.log("[debug] watcher is ready");
+		}
+	}
+}
+function parseServerOptions(serverOptions) {
+	const inlineOptions = serverOptions.deps?.inline === true ? true : toArray(serverOptions.deps?.inline);
+	return {
+		...serverOptions,
+		deps: {
+			...serverOptions.deps,
+			inlineFiles: toArray(serverOptions.deps?.inlineFiles),
+			inline: inlineOptions !== true ? inlineOptions.map((dep) => {
+				return dep.startsWith("/") && dep.endsWith("/") ? new RegExp(dep) : dep;
+			}) : true,
+			external: toArray(serverOptions.deps?.external).map((dep) => {
+				return dep.startsWith("/") && dep.endsWith("/") ? new RegExp(dep) : dep;
+			}),
+			moduleDirectories: serverOptions.deps?.moduleDirectories ? toArray(serverOptions.deps?.moduleDirectories) : void 0
+		},
+		transformMode: {
+			...serverOptions.transformMode,
+			ssr: toArray(serverOptions.transformMode?.ssr).map((dep) => new RegExp(dep)),
+			web: toArray(serverOptions.transformMode?.web).map((dep) => new RegExp(dep))
+		}
+	};
+}
+
+//#endregion
+export {  };

package/dist/{client.js → client-CyS7w_FB.mjs}

@@ -1,15 +1,13 @@
-import { createRequire } from 'node:module';
-import { resolve, dirname } from 'node:path';
-import process from 'node:process';
-import { pathToFileURL, fileURLToPath } from 'node:url';
-import vm from 'node:vm';
-import createDebug from 'debug';
-import { extractSourceMap } from './source-map.js';
-import { createImportMetaEnvProxy, slash, isInternalRequest, isNodeBuiltin, normalizeRequestId, toFilePath, normalizeModuleId, cleanUrl, isPrimitive, isBareImport } from './utils.js';
-import 'node:buffer';
-import 'pathe';
-import 'node:fs';
+import { c as isNodeBuiltin, d as normalizeModuleId, f as normalizeRequestId, g as toFilePath, l as isPrimitive, m as slash, n as cleanUrl, o as isBareImport, r as createImportMetaEnvProxy, s as isInternalRequest } from "./utils-ExLpYVUV.mjs";
+import { t as extractSourceMap } from "./source-map-DQLD3K8K.mjs";
+import { createRequire } from "node:module";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createDebug } from "obug";
+import { dirname, resolve } from "node:path";
+import vm from "node:vm";
 
+//#region src/client.ts
 const { setTimeout, clearTimeout } = globalThis;
 const debugExecute = createDebug("vite-node:client:execute");
 const debugNative = createDebug("vite-node:client:native");
@@ -34,7 +32,7 @@ const DEFAULT_REQUEST_STUBS = {
 	"/@vite/client": clientStub,
 	"@vite/client": clientStub
 };
-class ModuleCacheMap extends Map {
+var ModuleCacheMap = class extends Map {
 	normalizePath(fsPath) {
 		return normalizeModuleId(fsPath);
 	}
@@ -72,13 +70,12 @@ class ModuleCacheMap extends Map {
 		return this.deleteByModuleId(this.normalizePath(fsPath));
 	}
 	invalidateModule(mod) {
-		var _mod$importers, _mod$imports;
 		delete mod.evaluated;
 		delete mod.resolving;
 		delete mod.promise;
 		delete mod.exports;
-		(_mod$importers = mod.importers) === null || _mod$importers === void 0 || _mod$importers.clear();
-		(_mod$imports = mod.imports) === null || _mod$imports === void 0 || _mod$imports.clear();
+		mod.importers?.clear();
+		mod.imports?.clear();
 		return true;
 	}
 	/**
@@ -90,7 +87,7 @@ class ModuleCacheMap extends Map {
 			if (invalidated.has(id)) continue;
 			invalidated.add(id);
 			const mod = super.get(id);
-			if (mod === null || mod === void 0 ? void 0 : mod.importers) this.invalidateDepTree(mod.importers, invalidated);
+			if (mod?.importers) this.invalidateDepTree(mod.importers, invalidated);
 			super.delete(id);
 		}
 		return invalidated;
@@ -103,10 +100,7 @@ class ModuleCacheMap extends Map {
 			const id = this.normalizePath(_id);
 			if (invalidated.has(id)) continue;
 			invalidated.add(id);
-			const subIds = Array.from(super.entries()).filter(([, mod]) => {
-				var _mod$importers2;
-				return (_mod$importers2 = mod.importers) === null || _mod$importers2 === void 0 ? void 0 : _mod$importers2.has(id);
-			}).map(([key]) => key);
+			const subIds = Array.from(super.entries()).filter(([, mod]) => mod.importers?.has(id)).map(([key]) => key);
 			if (subIds.length) this.invalidateSubDepTree(subIds, invalidated);
 			super.delete(id);
 		}
@@ -125,8 +119,8 @@ class ModuleCacheMap extends Map {
 		}
 		return null;
 	}
-}
-class ViteNodeRunner {
+};
+var ViteNodeRunner = class {
 	root;
 	debug;
 	/**
@@ -151,7 +145,6 @@ class ViteNodeRunner {
 	* As top-level awaits with dynamic imports like this are uncommon, we don't handle this case specifically.
 	*/
 	executionStack = [];
-	// `performance` can be mocked, so make sure we're using the original function
 	performanceNow = performance.now.bind(performance);
 	constructor(options) {
 		this.options = options;
@@ -174,14 +167,12 @@ class ViteNodeRunner {
 		const { imports, importers } = mod;
 		if (importee) importers.add(importee);
 		const getStack = () => `stack:\n${[...callstack, fsPath].reverse().map((p) => `  - ${p}`).join("\n")}`;
-		// check circular dependency
 		if (callstack.includes(fsPath) || Array.from(imports.values()).some((i) => importers.has(i))) {
 			if (mod.exports) return mod.exports;
 		}
 		let debugTimer;
 		if (this.debug) debugTimer = setTimeout(() => console.warn(`[vite-node] module ${fsPath} takes over 2s to load.\n${getStack()}`), 2e3);
 		try {
-			// cached module
 			if (mod.promise) return await mod.promise;
 			const promise = this.directRequest(id, fsPath, callstack);
 			Object.assign(mod, {
@@ -198,14 +189,12 @@ class ViteNodeRunner {
 		return !isInternalRequest(id) && !isNodeBuiltin(id) && !id.startsWith("data:");
 	}
 	async _resolveUrl(id, importer) {
-		var _resolved$meta;
 		const dep = normalizeRequestId(id, this.options.base);
 		if (!this.shouldResolveId(dep)) return [dep, dep];
-		const { path, exists } = toFilePath(dep, this.root);
-		if (!this.options.resolveId || exists) return [dep, path];
+		const { path: path$1, exists } = toFilePath(dep, this.root);
+		if (!this.options.resolveId || exists) return [dep, path$1];
 		const resolved = await this.options.resolveId(dep, importer);
-		// supported since Vite 5-beta.19
-		if (resolved === null || resolved === void 0 || (_resolved$meta = resolved.meta) === null || _resolved$meta === void 0 || (_resolved$meta = _resolved$meta["vite:alias"]) === null || _resolved$meta === void 0 ? void 0 : _resolved$meta.noResolved) {
+		if (resolved?.meta?.["vite:alias"]?.noResolved) {
 			const error = /* @__PURE__ */ new Error(`Cannot find module '${id}'${importer ? ` imported from '${importer}'` : ""}.
 
 - If you rely on tsconfig.json's "paths" to resolve modules, please install "vite-tsconfig-paths" plugin to handle module resolution.
@@ -228,7 +217,6 @@ class ViteNodeRunner {
 	}
 	async resolveUrl(id, importee) {
 		const resolveKey = `resolve:${id}`;
-		// put info about new import as soon as possible, so we can start tracking it
 		this.moduleCache.setByModuleId(resolveKey, { resolving: true });
 		try {
 			return await this._resolveUrl(id, importee);
@@ -244,8 +232,7 @@ class ViteNodeRunner {
 		try {
 			return await this.options.fetchModule(id);
 		} catch (cause) {
-			// rethrow vite error if it cannot load the module because it's not resolved
-			if (typeof cause === "object" && cause.code === "ERR_LOAD_URL" || typeof (cause === null || cause === void 0 ? void 0 : cause.message) === "string" && cause.message.includes("Failed to load url")) {
+			if (typeof cause === "object" && cause.code === "ERR_LOAD_URL" || typeof cause?.message === "string" && cause.message.includes("Failed to load url")) {
 				const error = new Error(`Cannot find ${isBareImport(id) ? "package" : "module"} '${id}'${importer ? ` imported from '${importer}'` : ""}`, { cause });
 				error.code = "ERR_MODULE_NOT_FOUND";
 				throw error;
@@ -259,24 +246,23 @@ class ViteNodeRunner {
 		const callstack = [..._callstack, moduleId];
 		const mod = this.moduleCache.getByModuleId(moduleId);
 		const request = async (dep) => {
-			const [id, depFsPath] = await this.resolveUrl(String(dep), fsPath);
+			const [id$1, depFsPath] = await this.resolveUrl(String(dep), fsPath);
 			this.moduleCache.getByModuleId(depFsPath).importers.add(moduleId);
 			mod.imports.add(depFsPath);
-			return this.dependencyRequest(id, depFsPath, callstack);
+			return this.dependencyRequest(id$1, depFsPath, callstack);
 		};
 		const requestStubs = this.options.requestStubs || DEFAULT_REQUEST_STUBS;
 		if (id in requestStubs) return requestStubs[id];
 		let { code: transformed, externalize } = await this._fetchModule(id, callstack[callstack.length - 2]);
 		if (externalize) {
 			debugNative(externalize);
-			const exports = await this.interopedImport(externalize);
-			mod.exports = exports;
-			return exports;
+			const exports$1 = await this.interopedImport(externalize);
+			mod.exports = exports$1;
+			return exports$1;
 		}
 		if (transformed == null) throw new Error(`[vite-node] Failed to load "${id}" imported from ${callstack[callstack.length - 2]}`);
-		const { Object, Reflect, Symbol } = this.getContextPrimitives();
+		const { Object: Object$1, Reflect: Reflect$1, Symbol: Symbol$1 } = this.getContextPrimitives();
 		const modulePath = cleanUrl(moduleId);
-		// disambiguate the `<UNIT>:/` on windows: see nodejs/node#31710
 		const href = pathToFileURL(modulePath).href;
 		const __filename = fileURLToPath(href);
 		const __dirname = dirname(__filename);
@@ -286,33 +272,27 @@ class ViteNodeRunner {
 			filename: __filename,
 			dirname: __dirname
 		};
-		const exports = Object.create(null);
-		Object.defineProperty(exports, Symbol.toStringTag, {
+		const exports = Object$1.create(null);
+		Object$1.defineProperty(exports, Symbol$1.toStringTag, {
 			value: "Module",
 			enumerable: false,
 			configurable: false
 		});
-		const SYMBOL_NOT_DEFINED = Symbol("not defined");
+		const SYMBOL_NOT_DEFINED = Symbol$1("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(exports, {
 			get: (target, p, receiver) => {
-				if (Reflect.has(target, p)) return Reflect.get(target, p, receiver);
-				return Reflect.get(Object.prototype, p, receiver);
+				if (Reflect$1.has(target, p)) return Reflect$1.get(target, p, receiver);
+				return Reflect$1.get(Object$1.prototype, p, receiver);
 			},
-			getPrototypeOf: () => Object.prototype,
+			getPrototypeOf: () => Object$1.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(modulePath, { default: value }) && cjsExports !== value) {
 					exportAll(cjsExports, value);
 					exports.default = value;
 					return true;
 				}
-				if (!Reflect.has(exports, "default")) exports.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 (!Reflect$1.has(exports, "default")) exports.default = {};
 				if (moduleExports !== SYMBOL_NOT_DEFINED && isPrimitive(moduleExports)) {
 					defineExport(exports, p, () => void 0);
 					return true;
@@ -322,7 +302,7 @@ class ViteNodeRunner {
 				return true;
 			}
 		});
-		Object.assign(mod, {
+		Object$1.assign(mod, {
 			code: transformed,
 			exports
 		});
@@ -336,29 +316,23 @@ class ViteNodeRunner {
 				return cjsExports;
 			}
 		};
-		// Vite hot context
 		let hotContext;
-		if (this.options.createHotContext) Object.defineProperty(meta, "hot", {
+		if (this.options.createHotContext) Object$1.defineProperty(meta, "hot", {
 			enumerable: true,
 			get: () => {
-				var _this$options$createH, _this$options;
-				hotContext || (hotContext = (_this$options$createH = (_this$options = this.options).createHotContext) === null || _this$options$createH === void 0 ? void 0 : _this$options$createH.call(_this$options, this, moduleId));
+				hotContext ||= this.options.createHotContext?.(this, moduleId);
 				return hotContext;
 			},
 			set: (value) => {
 				hotContext = value;
 			}
 		});
-		// Be careful when changing this
-		// changing context will change amount of code added on line :114 (vm.runInThisContext)
-		// this messes up sourcemaps for coverage
-		// adjust `WRAPPER_LENGTH` variable in packages/coverage-v8/src/provider.ts if you do change this
 		const context = this.prepareContext({
 			__vite_ssr_import__: request,
 			__vite_ssr_dynamic_import__: request,
 			__vite_ssr_exports__: exports,
 			__vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
-			__vite_ssr_exportName__: (name, getter) => Object.defineProperty(exports, name, {
+			__vite_ssr_exportName__: (name, getter) => Object$1.defineProperty(exports, name, {
 				enumerable: true,
 				configurable: true,
 				get: getter
@@ -371,7 +345,6 @@ class ViteNodeRunner {
 			__dirname
 		});
 		debugExecute(__filename);
-		// remove shebang
 		if (transformed[0] === "#") transformed = transformed.replace(/^#!.*/, (s) => " ".repeat(s.length));
 		await this.runModule(context, transformed);
 		return exports;
@@ -384,7 +357,6 @@ class ViteNodeRunner {
 		};
 	}
 	async 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 = {
@@ -396,8 +368,7 @@ class ViteNodeRunner {
 		try {
 			await vm.runInThisContext(code, options)(...Object.values(context));
 		} finally {
-			var _this$options$moduleE;
-			(_this$options$moduleE = this.options.moduleExecutionInfo) === null || _this$options$moduleE === void 0 || _this$options$moduleE.set(options.filename, finishModuleExecutionInfo());
+			this.options.moduleExecutionInfo?.set(options.filename, finishModuleExecutionInfo());
 		}
 	}
 	/**
@@ -431,36 +402,34 @@ class ViteNodeRunner {
 	* Define if a module should be interop-ed
 	* This function mostly for the ability to override by subclass
 	*/
-	shouldInterop(path, mod) {
+	shouldInterop(path$1, mod) {
 		if (this.options.interopDefault === false) return false;
-		// never interop ESM modules
-		// TODO: should also skip for `.js` with `type="module"`
-		return !path.endsWith(".mjs") && "default" in mod;
+		return !path$1.endsWith(".mjs") && "default" in mod;
 	}
-	importExternalModule(path) {
+	importExternalModule(path$1) {
 		return import(
 			/* @vite-ignore */
-			path
+			path$1
 );
 	}
 	/**
 	* Import a module and interop it
 	*/
-	async interopedImport(path) {
-		const importedModule = await this.importExternalModule(path);
-		if (!this.shouldInterop(path, importedModule)) return importedModule;
+	async interopedImport(path$1) {
+		const importedModule = await this.importExternalModule(path$1);
+		if (!this.shouldInterop(path$1, importedModule)) return importedModule;
 		const { mod, defaultExport } = interopModule(importedModule);
 		return new Proxy(mod, {
-			get(mod, prop) {
+			get(mod$1, prop) {
 				if (prop === "default") return defaultExport;
-				return mod[prop] ?? (defaultExport === null || defaultExport === void 0 ? void 0 : defaultExport[prop]);
+				return mod$1[prop] ?? defaultExport?.[prop];
 			},
-			has(mod, prop) {
+			has(mod$1, prop) {
 				if (prop === "default") return defaultExport !== void 0;
-				return prop in mod || defaultExport && prop in defaultExport;
+				return prop in mod$1 || defaultExport && prop in defaultExport;
 			},
-			getOwnPropertyDescriptor(mod, prop) {
-				const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
+			getOwnPropertyDescriptor(mod$1, prop) {
+				const descriptor = Reflect.getOwnPropertyDescriptor(mod$1, prop);
 				if (descriptor) return descriptor;
 				if (prop === "default" && defaultExport !== void 0) return {
 					value: defaultExport,
@@ -470,7 +439,7 @@ class ViteNodeRunner {
 			}
 		});
 	}
-}
+};
 function interopModule(mod) {
 	if (isPrimitive(mod)) return {
 		mod: { default: mod },
@@ -486,7 +455,6 @@ function interopModule(mod) {
 		defaultExport
 	};
 }
-// keep consistency with Vite on how exports are defined
 function defineExport(exports, key, value) {
 	Object.defineProperty(exports, key, {
 		enumerable: true,
@@ -495,8 +463,6 @@ function defineExport(exports, key, value) {
 	});
 }
 function exportAll(exports, sourceModule) {
-	// #1120 when a module exports itself it causes
-	// call stack error
 	if (exports === sourceModule) return;
 	if (isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise) return;
 	for (const key in sourceModule) if (key !== "default" && !(key in exports)) try {
@@ -504,4 +470,5 @@ function exportAll(exports, sourceModule) {
 	} catch {}
 }
 
-export { DEFAULT_REQUEST_STUBS, ModuleCacheMap, ViteNodeRunner };
+//#endregion
+export { ModuleCacheMap as n, ViteNodeRunner as r, DEFAULT_REQUEST_STUBS as t };

package/dist/client.d.mts

@@ -0,0 +1,2 @@
+import { C as ModuleExecutionInfo, S as ModuleCacheMap, T as ViteNodeRunner, w as ModuleExecutionInfoEntry, x as DEFAULT_REQUEST_STUBS } from "./types-Dtew7m7O.mjs";
+export { DEFAULT_REQUEST_STUBS, ModuleCacheMap, ModuleExecutionInfo, ModuleExecutionInfoEntry, ViteNodeRunner };

package/dist/client.mjs

@@ -0,0 +1,5 @@
+import "./utils-ExLpYVUV.mjs";
+import "./source-map-DQLD3K8K.mjs";
+import { n as ModuleCacheMap, r as ViteNodeRunner, t as DEFAULT_REQUEST_STUBS } from "./client-CyS7w_FB.mjs";
+
+export { DEFAULT_REQUEST_STUBS, ModuleCacheMap, ViteNodeRunner };

package/dist/{constants.js → constants-DRkacFwN.mjs}

@@ -1,3 +1,4 @@
+//#region src/constants.ts
 const KNOWN_ASSET_TYPES = [
 	"apng",
 	"bmp",
@@ -29,4 +30,5 @@ const KNOWN_ASSET_TYPES = [
 const KNOWN_ASSET_RE = /* @__PURE__ */ new RegExp(`\\.(${KNOWN_ASSET_TYPES.join("|")})$`);
 const CSS_LANGS_RE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
 
-export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES };
+//#endregion
+export { KNOWN_ASSET_RE as n, KNOWN_ASSET_TYPES as r, CSS_LANGS_RE as t };

package/dist/{constants.d.ts → constants.d.mts}

@@ -1,5 +1,6 @@
+//#region src/constants.d.ts
 declare const KNOWN_ASSET_TYPES: string[];
 declare const KNOWN_ASSET_RE: RegExp;
 declare const CSS_LANGS_RE: RegExp;
-
-export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES };
+//#endregion
+export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES };

package/dist/constants.mjs

@@ -0,0 +1,3 @@
+import { n as KNOWN_ASSET_RE, r as KNOWN_ASSET_TYPES, t as CSS_LANGS_RE } from "./constants-DRkacFwN.mjs";
+
+export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES };

package/dist/dist-B2ebky9O.mjs

@@ -0,0 +1,85 @@
+//#region node_modules/.pnpm/tinyrainbow@3.0.3/node_modules/tinyrainbow/dist/index.js
+var d = {
+	reset: [0, 0],
+	bold: [
+		1,
+		22,
+		"\x1B[22m\x1B[1m"
+	],
+	dim: [
+		2,
+		22,
+		"\x1B[22m\x1B[2m"
+	],
+	italic: [3, 23],
+	underline: [4, 24],
+	inverse: [7, 27],
+	hidden: [8, 28],
+	strikethrough: [9, 29],
+	black: [30, 39],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	blue: [34, 39],
+	magenta: [35, 39],
+	cyan: [36, 39],
+	white: [37, 39],
+	gray: [90, 39],
+	bgBlack: [40, 49],
+	bgRed: [41, 49],
+	bgGreen: [42, 49],
+	bgYellow: [43, 49],
+	bgBlue: [44, 49],
+	bgMagenta: [45, 49],
+	bgCyan: [46, 49],
+	bgWhite: [47, 49],
+	blackBright: [90, 39],
+	redBright: [91, 39],
+	greenBright: [92, 39],
+	yellowBright: [93, 39],
+	blueBright: [94, 39],
+	magentaBright: [95, 39],
+	cyanBright: [96, 39],
+	whiteBright: [97, 39],
+	bgBlackBright: [100, 49],
+	bgRedBright: [101, 49],
+	bgGreenBright: [102, 49],
+	bgYellowBright: [103, 49],
+	bgBlueBright: [104, 49],
+	bgMagentaBright: [105, 49],
+	bgCyanBright: [106, 49],
+	bgWhiteBright: [107, 49]
+};
+function g(e) {
+	return String(e);
+}
+g.open = "";
+g.close = "";
+function h() {
+	let e = typeof process != "undefined" ? process : void 0, n = (e == null ? void 0 : e.env) || {}, a = n.FORCE_TTY !== "false", i = (e == null ? void 0 : e.argv) || [];
+	return !("NO_COLOR" in n || i.includes("--no-color")) && ("FORCE_COLOR" in n || i.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || a && n.TERM !== "dumb" || "CI" in n) || typeof window != "undefined" && !!window.chrome;
+}
+function f() {
+	let e = h(), n = (r, t, u, o) => {
+		let l = "", s = 0;
+		do
+			l += r.substring(s, o) + u, s = o + t.length, o = r.indexOf(t, s);
+		while (~o);
+		return l + r.substring(s);
+	}, a = (r, t, u = r) => {
+		let o = (l) => {
+			let s = String(l), b = s.indexOf(t, r.length);
+			return ~b ? r + n(s, t, u, b) + t : r + s + t;
+		};
+		return o.open = r, o.close = t, o;
+	}, i = { isColorSupported: e }, c = (r) => `\x1B[${r}m`;
+	for (let r in d) {
+		let t = d[r];
+		i[r] = e ? a(c(t[0]), c(t[1]), t[2]) : g;
+	}
+	return i;
+}
+var C = f();
+
+//#endregion
+export { C as t };