vite-node 5.1.0 → 5.3.0

package/dist/{source-map.d.ts → source-map.d.mts}

@@ -1,15 +1,16 @@
-import { TransformResult } from 'vite';
-import { E as EncodedSourceMap } from './trace-mapping.d-BWFx6tPc.js';
+import { s as EncodedSourceMap } from "./types-EZz9rsDw.mjs";
+import { TransformResult } from "vite";
 
+//#region src/source-map.d.ts
 interface InstallSourceMapSupportOptions {
-	getSourceMap: (source: string) => EncodedSourceMap | null | undefined;
+  getSourceMap: (source: string) => EncodedSourceMap | null | undefined;
 }
 declare function withInlineSourcemap(result: TransformResult, options: {
-	root: string;
-	filepath: string;
-	noFirstLineMapping?: boolean;
+  root: string;
+  filepath: string;
+  noFirstLineMapping?: boolean;
 }): TransformResult;
 declare function extractSourceMap(code: string): EncodedSourceMap | null;
 declare function installSourcemapsSupport(options: InstallSourceMapSupportOptions): void;
-
-export { extractSourceMap, installSourcemapsSupport, withInlineSourcemap };
+//#endregion
+export { extractSourceMap, installSourcemapsSupport, withInlineSourcemap };

package/dist/source-map.mjs

@@ -0,0 +1,4 @@
+import "./utils-ExLpYVUV.mjs";
+import { n as installSourcemapsSupport, r as withInlineSourcemap, t as extractSourceMap } from "./source-map-CysB5F9m.mjs";
+
+export { extractSourceMap, installSourcemapsSupport, withInlineSourcemap };

package/dist/types-55T_-8KG.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/types-EZz9rsDw.d.mts

@@ -0,0 +1,217 @@
+import * as _jridgewell_trace_mapping0 from "@jridgewell/trace-mapping";
+import { DecodedSourceMap, EncodedSourceMap, EncodedSourceMap as EncodedSourceMap$1, SourceMapInput } from "@jridgewell/trace-mapping";
+import { ViteHotContext } from "vite/types/hot.js";
+
+//#region src/client.d.ts
+declare const DEFAULT_REQUEST_STUBS: Record<string, Record<string, unknown>>;
+declare class ModuleCacheMap extends Map<string, ModuleCache> {
+  normalizePath(fsPath: string): string;
+  /**
+  * Assign partial data to the map
+  */
+  update(fsPath: string, mod: ModuleCache): this;
+  setByModuleId(modulePath: string, mod: ModuleCache): this;
+  set(fsPath: string, mod: ModuleCache): this;
+  getByModuleId(modulePath: string): ModuleCache & Required<Pick<ModuleCache, "imports" | "importers">>;
+  get(fsPath: string): ModuleCache & Required<Pick<ModuleCache, "importers" | "imports">>;
+  deleteByModuleId(modulePath: string): boolean;
+  delete(fsPath: string): boolean;
+  invalidateModule(mod: ModuleCache): boolean;
+  /**
+  * Invalidate modules that dependent on the given modules, up to the main entry
+  */
+  invalidateDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+  /**
+  * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+  */
+  invalidateSubDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+  /**
+  * Return parsed source map based on inlined source map of the module
+  */
+  getSourceMap(id: string): _jridgewell_trace_mapping0.EncodedSourceMap | null;
+}
+type ModuleExecutionInfo = Map<string, ModuleExecutionInfoEntry>;
+interface ModuleExecutionInfoEntry {
+  startOffset: number;
+  /** The duration that was spent executing the module. */
+  duration: number;
+  /** The time that was spent executing the module itself and externalized imports. */
+  selfTime: number;
+}
+declare class ViteNodeRunner {
+  options: ViteNodeRunnerOptions;
+  root: string;
+  debug: boolean;
+  /**
+  * Holds the cache of modules
+  * Keys of the map are filepaths, or plain package names
+  */
+  moduleCache: ModuleCacheMap;
+  /**
+  * Tracks the stack of modules being executed for the purpose of calculating import self-time.
+  *
+  * Note that while in most cases, imports are a linear stack of modules,
+  * this is occasionally not the case, for example when you have parallel top-level dynamic imports like so:
+  *
+  * ```ts
+  * await Promise.all([
+  *  import('./module1'),
+  *  import('./module2'),
+  * ]);
+  * ```
+  *
+  * In this case, the self time will be reported incorrectly for one of the modules (could go negative).
+  * As top-level awaits with dynamic imports like this are uncommon, we don't handle this case specifically.
+  */
+  private executionStack;
+  private performanceNow;
+  constructor(options: ViteNodeRunnerOptions);
+  executeFile(file: string): Promise<any>;
+  executeId(rawId: string): Promise<any>;
+  shouldResolveId(id: string, _importee?: string): boolean;
+  private _resolveUrl;
+  resolveUrl(id: string, importee?: string): Promise<[url: string, fsPath: string]>;
+  private _fetchModule;
+  protected getContextPrimitives(): {
+    Object: ObjectConstructor;
+    Reflect: typeof Reflect;
+    Symbol: SymbolConstructor;
+  };
+  protected runModule(context: Record<string, any>, transformed: string): Promise<void>;
+  /**
+  * mutate the given error to have fixed stacktraces based on source maps
+  * Does the same thing as Vite's ssrFixStacktrace
+  */
+  ssrFixStacktrace(error: Error): Promise<Error>;
+  /**
+  * Starts calculating the module execution info such as the total duration and self time spent on executing the module.
+  * Returns a function to call once the module has finished executing.
+  */
+  protected startCalculateModuleExecutionInfo(filename: string, startOffset: number): () => ModuleExecutionInfoEntry;
+  prepareContext(context: Record<string, any>): Record<string, any>;
+  /**
+  * Define if a module should be interop-ed
+  * This function mostly for the ability to override by subclass
+  */
+  shouldInterop(path: string, mod: any): boolean;
+  protected importExternalModule(path: string): Promise<any>;
+  /**
+  * Import a module and interop it
+  */
+  interopedImport(path: string): Promise<any>;
+}
+//#endregion
+//#region src/types.d.ts
+type Nullable<T> = T | null | undefined;
+type Arrayable<T> = T | Array<T>;
+type Awaitable<T> = T | PromiseLike<T>;
+interface DepsHandlingOptions {
+  external?: (string | RegExp)[];
+  inline?: (string | RegExp)[] | true;
+  inlineFiles?: string[];
+  /**
+  * A list of directories that are considered to hold Node.js modules
+  * Have to include "/" at the start and end of the path
+  *
+  * Vite-Node checks the whole absolute path of the import, so make sure you don't include
+  * unwanted files accidentally
+  * @default ['/node_modules/']
+  */
+  moduleDirectories?: string[];
+  cacheDir?: string;
+  /**
+  * Try to guess the CJS version of a package when it's invalid ESM
+  * @default false
+  */
+  fallbackCJS?: boolean;
+}
+interface StartOfSourceMap {
+  file?: string;
+  sourceRoot?: string;
+}
+interface RawSourceMap extends StartOfSourceMap {
+  version: number;
+  sources: string[];
+  names: string[];
+  sourcesContent?: (string | null)[];
+  mappings: string;
+}
+interface FetchResult {
+  code?: string;
+  externalize?: string;
+  map?: EncodedSourceMap | null;
+}
+type HotContext = Omit<ViteHotContext, "acceptDeps" | "decline">;
+type FetchFunction = (id: string) => Promise<FetchResult>;
+type ResolveIdFunction = (id: string, importer?: string) => Awaitable<ViteNodeResolveId | null | undefined | void>;
+type CreateHotContextFunction = (runner: ViteNodeRunner, url: string) => HotContext;
+interface ModuleCache {
+  promise?: Promise<any>;
+  exports?: any;
+  evaluated?: boolean;
+  resolving?: boolean;
+  code?: string;
+  map?: EncodedSourceMap;
+  /**
+  * Module ids that imports this module
+  */
+  importers?: Set<string>;
+  imports?: Set<string>;
+}
+interface ViteNodeRunnerOptions {
+  root: string;
+  fetchModule: FetchFunction;
+  resolveId?: ResolveIdFunction;
+  createHotContext?: CreateHotContextFunction;
+  base?: string;
+  moduleCache?: ModuleCacheMap;
+  moduleExecutionInfo?: ModuleExecutionInfo;
+  interopDefault?: boolean;
+  requestStubs?: Record<string, any>;
+  debug?: boolean;
+}
+interface ViteNodeResolveId {
+  external?: boolean | "absolute" | "relative";
+  id: string;
+  meta?: Record<string, any> | null;
+  moduleSideEffects?: boolean | "no-treeshake" | null;
+  syntheticNamedExports?: boolean | string | null;
+}
+interface ViteNodeResolveModule {
+  external: string | null;
+  id: string;
+  fsPath: string;
+}
+interface ViteNodeServerOptions {
+  /**
+  * Inject inline sourcemap to modules
+  * @default 'inline'
+  */
+  sourcemap?: "inline" | boolean;
+  /**
+  * Deps handling
+  */
+  deps?: DepsHandlingOptions;
+  /**
+  * Transform method for modules
+  */
+  transformMode?: {
+    ssr?: RegExp[];
+    web?: RegExp[];
+  };
+  debug?: DebuggerOptions;
+}
+interface DebuggerOptions {
+  /**
+  * Dump the transformed module to filesystem
+  * Passing a string will dump to the specified path
+  */
+  dumpModules?: boolean | string;
+  /**
+  * Read dumpped module from filesystem whenever exists.
+  * Useful for debugging by modifying the dump result from the filesystem.
+  */
+  loadDumppedModules?: boolean;
+}
+//#endregion
+export { ModuleExecutionInfo as C, ModuleCacheMap as S, ViteNodeRunner as T, ViteNodeResolveId as _, DecodedSourceMap as a, ViteNodeServerOptions as b, FetchFunction as c, ModuleCache as d, Nullable as f, StartOfSourceMap as g, SourceMapInput as h, DebuggerOptions as i, FetchResult as l, ResolveIdFunction as m, Awaitable as n, DepsHandlingOptions as o, RawSourceMap as p, CreateHotContextFunction as r, EncodedSourceMap$1 as s, Arrayable as t, HotContext as u, ViteNodeResolveModule as v, ModuleExecutionInfoEntry as w, DEFAULT_REQUEST_STUBS as x, ViteNodeRunnerOptions as y };

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { C as ModuleExecutionInfo, S as ModuleCacheMap, _ as ViteNodeResolveId, a as DecodedSourceMap, b as ViteNodeServerOptions, c as FetchFunction, d as ModuleCache, f as Nullable, g as StartOfSourceMap, h as SourceMapInput, i as DebuggerOptions, l as FetchResult, m as ResolveIdFunction, n as Awaitable, o as DepsHandlingOptions, p as RawSourceMap, r as CreateHotContextFunction, s as EncodedSourceMap, t as Arrayable, u as HotContext, v as ViteNodeResolveModule, y as ViteNodeRunnerOptions } from "./types-EZz9rsDw.mjs";
+export { Arrayable, Awaitable, CreateHotContextFunction, DebuggerOptions, DecodedSourceMap, DepsHandlingOptions, EncodedSourceMap, FetchFunction, FetchResult, HotContext, ModuleCache, ModuleCacheMap, ModuleExecutionInfo, Nullable, RawSourceMap, ResolveIdFunction, SourceMapInput, StartOfSourceMap, ViteNodeResolveId, ViteNodeResolveModule, ViteNodeRunnerOptions, ViteNodeServerOptions };

package/dist/types.mjs

@@ -0,0 +1,3 @@
+import "./types-55T_-8KG.mjs";
+
+export {  };

package/dist/{utils.js → utils-ExLpYVUV.mjs}

@@ -1,9 +1,10 @@
-import { existsSync, promises } from 'node:fs';
-import { builtinModules } from 'node:module';
-import process from 'node:process';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { resolve, join, dirname } from 'pathe';
+import { builtinModules } from "node:module";
+import { existsSync, promises } from "node:fs";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, join, resolve } from "pathe";
 
+//#region src/utils.ts
 const isWindows = process.platform === "win32";
 const drive = isWindows ? process.cwd()[0] : null;
 const driveOpposite = drive ? drive === drive.toUpperCase() ? drive.toLowerCase() : drive.toUpperCase() : null;
@@ -19,12 +20,8 @@ function isBareImport(id) {
 const VALID_ID_PREFIX = "/@id/";
 function normalizeRequestId(id, base) {
 	if (base && id.startsWith(withTrailingSlash(base))) id = `/${id.slice(base.length)}`;
-	// keep drive the same as in process cwd. ideally, this should be resolved on Vite side
-	// Vite always resolves drive letters to the upper case because of the use of `realpathSync`
-	// https://github.com/vitejs/vite/blob/0ab20a3ee26eacf302415b3087732497d0a2f358/packages/vite/src/node/utils.ts#L635
-	if (driveRegexp && !(driveRegexp === null || driveRegexp === void 0 ? void 0 : driveRegexp.test(id)) && (driveOppositeRegext === null || driveOppositeRegext === void 0 ? void 0 : driveOppositeRegext.test(id))) id = id.replace(driveOppositeRegext, `${drive}$1`);
+	if (driveRegexp && !driveRegexp?.test(id) && driveOppositeRegext?.test(id)) id = id.replace(driveOppositeRegext, `${drive}$1`);
 	if (id.startsWith("file://")) {
-		// preserve hash/query
 		const { file, postfix } = splitFileAndPostfix(id);
 		return fileURLToPath(file) + postfix;
 	}
@@ -45,7 +42,6 @@ const internalRequestRegexp = /* @__PURE__ */ new RegExp(`^/?(?:${["@vite/client
 function isInternalRequest(id) {
 	return internalRequestRegexp.test(id);
 }
-// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
 const prefixedBuiltins = new Set([
 	"node:sea",
 	"node:sqlite",
@@ -69,7 +65,6 @@ const builtins = new Set([
 	"wasi"
 ]);
 function normalizeModuleId(id) {
-	// unique id that is not available as "test"
 	if (prefixedBuiltins.has(id)) return id;
 	if (id.startsWith("file://")) return fileURLToPath(id);
 	return id.replace(/\\/g, "/").replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/");
@@ -83,7 +78,6 @@ function toFilePath(id, root) {
 			absolute: id.slice(4),
 			exists: true
 		};
-		// check if /src/module.js -> <root>/src/module.js
 		if (!id.startsWith(withTrailingSlash(root)) && id.startsWith("/")) {
 			const resolved = resolve(root, id.slice(1));
 			if (existsSync(cleanUrl(resolved))) return {
@@ -100,7 +94,6 @@ function toFilePath(id, root) {
 		};
 	})();
 	if (absolute.startsWith("//")) absolute = absolute.slice(1);
-	// disambiguate the `<UNIT>:/` on windows: see nodejs/node#31710
 	return {
 		path: isWindows && absolute.startsWith("/") ? slash(fileURLToPath(pathToFileURL(absolute.slice(1)).href)) : absolute,
 		exists
@@ -155,7 +148,6 @@ function withTrailingSlash(path) {
 	return path;
 }
 function createImportMetaEnvProxy() {
-	// packages/vitest/src/node/plugins/index.ts:146
 	const booleanKeys = [
 		"DEV",
 		"PROD",
@@ -179,11 +171,10 @@ const packageCache = /* @__PURE__ */ new Map();
 async function findNearestPackageData(basedir) {
 	const originalBasedir = basedir;
 	while (basedir) {
-		var _await$fsp$stat$catch;
 		const cached = getCachedData(packageCache, basedir, originalBasedir);
 		if (cached) return cached;
 		const pkgPath = join(basedir, "package.json");
-		if ((_await$fsp$stat$catch = await promises.stat(pkgPath).catch(() => {})) === null || _await$fsp$stat$catch === void 0 ? void 0 : _await$fsp$stat$catch.isFile()) {
+		if ((await promises.stat(pkgPath).catch(() => {}))?.isFile()) {
 			const pkgData = JSON.parse(await promises.readFile(pkgPath, "utf8"));
 			if (packageCache) setCacheData(packageCache, pkgData, basedir, originalBasedir);
 			return pkgData;
@@ -195,4 +186,5 @@ async function findNearestPackageData(basedir) {
 	return {};
 }
 
-export { VALID_ID_PREFIX, cleanUrl, createImportMetaEnvProxy, findNearestPackageData, getCachedData, isBareImport, isInternalRequest, isNodeBuiltin, isPrimitive, isWindows, normalizeModuleId, normalizeRequestId, setCacheData, slash, toArray, toFilePath, withTrailingSlash };
+//#endregion
+export { withTrailingSlash as _, getCachedData as a, isNodeBuiltin as c, normalizeModuleId as d, normalizeRequestId as f, toFilePath as g, toArray as h, findNearestPackageData as i, isPrimitive as l, slash as m, cleanUrl as n, isBareImport as o, setCacheData as p, createImportMetaEnvProxy as r, isInternalRequest as s, VALID_ID_PREFIX as t, isWindows as u };

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

@@ -1,6 +1,6 @@
-import { N as Nullable, A as Arrayable } from './index.d-D6Pqey3g.js';
-import './trace-mapping.d-BWFx6tPc.js';
+import { f as Nullable, t as Arrayable } from "./types-EZz9rsDw.mjs";
 
+//#region src/utils.d.ts
 declare const isWindows: boolean;
 declare function slash(str: string): string;
 declare function isBareImport(id: string): boolean;
@@ -11,8 +11,8 @@ declare function isInternalRequest(id: string): boolean;
 declare function normalizeModuleId(id: string): string;
 declare function isPrimitive(v: any): boolean;
 declare function toFilePath(id: string, root: string): {
-	path: string;
-	exists: boolean;
+  path: string;
+  exists: boolean;
 };
 declare function isNodeBuiltin(id: string): boolean;
 /**
@@ -26,7 +26,7 @@ declare function setCacheData<T>(cache: Map<string, T>, data: T, basedir: string
 declare function withTrailingSlash(path: string): string;
 declare function createImportMetaEnvProxy(): NodeJS.ProcessEnv;
 declare function findNearestPackageData(basedir: string): Promise<{
-	type?: "module" | "commonjs";
+  type?: "module" | "commonjs";
 }>;
-
-export { VALID_ID_PREFIX, cleanUrl, createImportMetaEnvProxy, findNearestPackageData, getCachedData, isBareImport, isInternalRequest, isNodeBuiltin, isPrimitive, isWindows, normalizeModuleId, normalizeRequestId, setCacheData, slash, toArray, toFilePath, withTrailingSlash };
+//#endregion
+export { VALID_ID_PREFIX, cleanUrl, createImportMetaEnvProxy, findNearestPackageData, getCachedData, isBareImport, isInternalRequest, isNodeBuiltin, isPrimitive, isWindows, normalizeModuleId, normalizeRequestId, setCacheData, slash, toArray, toFilePath, withTrailingSlash };

package/dist/utils.mjs

@@ -0,0 +1,3 @@
+import { _ as withTrailingSlash, a as getCachedData, c as isNodeBuiltin, d as normalizeModuleId, f as normalizeRequestId, g as toFilePath, h as toArray, i as findNearestPackageData, l as isPrimitive, m as slash, n as cleanUrl, o as isBareImport, p as setCacheData, r as createImportMetaEnvProxy, s as isInternalRequest, t as VALID_ID_PREFIX, u as isWindows } from "./utils-ExLpYVUV.mjs";
+
+export { VALID_ID_PREFIX, cleanUrl, createImportMetaEnvProxy, findNearestPackageData, getCachedData, isBareImport, isInternalRequest, isNodeBuiltin, isPrimitive, isWindows, normalizeModuleId, normalizeRequestId, setCacheData, slash, toArray, toFilePath, withTrailingSlash };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vite-node",
   "type": "module",
-  "version": "5.1.0",
+  "version": "5.3.0",
   "description": "Vite as Node.js runtime",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -16,60 +16,53 @@
   },
   "sideEffects": false,
   "exports": {
-    ".": "./dist/index.js",
-    "./client": "./dist/client.js",
-    "./server": "./dist/server.js",
-    "./utils": "./dist/utils.js",
-    "./hmr": "./dist/hmr.js",
-    "./source-map": "./dist/source-map.js",
-    "./constants": "./dist/constants.js",
-    "./*": "./*"
+    ".": "./dist/index.mjs",
+    "./cli": "./dist/cli.mjs",
+    "./client": "./dist/client.mjs",
+    "./constants": "./dist/constants.mjs",
+    "./hmr": "./dist/hmr.mjs",
+    "./server": "./dist/server.mjs",
+    "./source-map": "./dist/source-map.mjs",
+    "./types": "./dist/types.mjs",
+    "./utils": "./dist/utils.mjs",
+    "./package.json": "./package.json"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "bin": {
-    "vite-node": "./vite-node.js"
+    "vite-node": "./dist/cli.mjs"
   },
   "files": [
-    "dist",
-    "vite-node.js"
+    "dist"
   ],
   "engines": {
-    "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+    "node": "^20.19.0 || >=22.12.0"
   },
   "dependencies": {
     "cac": "^6.7.14",
-    "debug": "^4.4.3",
-    "es-module-lexer": "^1.7.0",
+    "es-module-lexer": "^2.0.0",
+    "obug": "^2.1.1",
     "pathe": "^2.0.3",
-    "vite": "^7.2.0"
+    "vite": "^7.3.1"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^6.2.0",
+    "@antfu/eslint-config": "^7.0.1",
     "@jridgewell/trace-mapping": "^0.3.31",
-    "@rollup/plugin-commonjs": "^29.0.0",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.3",
-    "@types/debug": "^4.1.12",
-    "@types/node": "^24.10.0",
-    "bumpp": "^10.3.1",
-    "eslint": "^9.39.1",
-    "inquirer": "^12.10.0",
-    "rimraf": "^6.1.0",
-    "rollup": "^4.52.5",
-    "rollup-plugin-dts": "^6.2.3",
+    "@types/node": "^25.0.9",
+    "bumpp": "^10.4.0",
+    "eslint": "^9.39.2",
+    "inquirer": "^13.2.0",
     "tinyexec": "^1.0.2",
     "tinyrainbow": "^3.0.3",
+    "tsdown": "^0.16.8",
     "typescript": "^5.9.3",
-    "unplugin-isolated-decl": "^0.15.3",
-    "unplugin-oxc": "^0.5.3",
-    "vitest": "^4.0.7"
+    "vitest": "^4.0.17"
   },
   "scripts": {
     "lint": "eslint",
-    "build": "rimraf dist && rollup -c",
-    "dev": "rollup -c --watch --watch.include 'src/**' -m inline",
+    "build": "tsdown",
+    "dev": "tsdown -w",
     "typecheck": "tsc --noEmit",
     "test": "vitest",
     "release": "bumpp"

package/dist/chunk-index.js

@@ -1,82 +0,0 @@
-// src/index.ts
-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();
-
-export { C };

package/dist/cli.d.ts

@@ -1,21 +0,0 @@
-import { V as ViteNodeServerOptions } from './index.d-D6Pqey3g.js';
-import './trace-mapping.d-BWFx6tPc.js';
-
-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>;
-
-export type { CliOptions, ViteNodeServerOptionsCLI };