vite-node 3.0.8 → 3.0.9

package/dist/cli.cjs

@@ -21,7 +21,7 @@ require('es-module-lexer');
 require('./constants.cjs');
 require('node:events');
 
-var version = "3.0.8";
+var version = "3.0.9";
 
 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("--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");
@@ -76,6 +76,8 @@ async function run(files, options = {}) {
   });
   if (Number(vite.version.split(".")[0]) < 6) {
     await server$1.pluginContainer.buildStart({});
+  } else {
+    await server$1.environments.client.pluginContainer.buildStart({});
   }
   const env = vite.loadEnv(server$1.config.mode, server$1.config.envDir, "");
   for (const key in env) {

package/dist/cli.d.ts

@@ -1,21 +1,19 @@
-import { V as ViteNodeServerOptions } from './index-LQxw79Gm.js';
+import { V as ViteNodeServerOptions } from './index.d-CvjHzhRV.js';
 import './trace-mapping.d-DLVdEqOp.js';
 
 interface CliOptions {
-    'root'?: string;
-    'script'?: boolean;
-    'config'?: string;
-    'mode'?: string;
-    'watch'?: boolean;
-    'options'?: ViteNodeServerOptionsCLI;
-    'version'?: boolean;
-    'help'?: boolean;
-    '--'?: string[];
+	"root"?: string;
+	"script"?: boolean;
+	"config"?: string;
+	"mode"?: string;
+	"watch"?: boolean;
+	"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 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 };

package/dist/cli.mjs

@@ -19,7 +19,7 @@ import 'es-module-lexer';
 import './constants.mjs';
 import 'node:events';
 
-var version = "3.0.8";
+var version = "3.0.9";
 
 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("--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");
@@ -74,6 +74,8 @@ async function run(files, options = {}) {
   });
   if (Number(version$1.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) {

package/dist/client.cjs

@@ -416,7 +416,10 @@ ${getStack()}`
     return !path.endsWith(".mjs") && "default" in mod;
   }
   importExternalModule(path) {
-    return import(path);
+    return import(
+      /* @vite-ignore */
+      path
+    );
   }
   /**
    * Import a module and interop it

package/dist/client.d.ts

@@ -1,2 +1,2 @@
 import './trace-mapping.d-DLVdEqOp.js';
-export { e as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, f as ModuleExecutionInfo, a as ViteNodeRunner } from './index-LQxw79Gm.js';
+export { e as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, f as ModuleExecutionInfo, a as ViteNodeRunner } from './index.d-CvjHzhRV.js';

package/dist/client.mjs

@@ -414,7 +414,10 @@ ${getStack()}`
     return !path.endsWith(".mjs") && "default" in mod;
   }
   importExternalModule(path) {
-    return import(path);
+    return import(
+      /* @vite-ignore */
+      path
+    );
   }
   /**
    * Import a module and interop it

package/dist/hmr.d.ts

@@ -1,49 +1,49 @@
 import { HMRPayload, Plugin } from 'vite';
 import { EventEmitter } from 'node:events';
-import { C as CustomEventMap, a as ViteNodeRunner, H as HMRPayload$1, b as HotContext } from './index-LQxw79Gm.js';
+import { C as CustomEventMap, a as ViteNodeRunner, H as HMRPayload$1, b as HotContext } from './index.d-CvjHzhRV.js';
 import './trace-mapping.d-DLVdEqOp.js';
 
 type EventType = string | symbol;
 type Handler<T = unknown> = (event: T) => void;
 interface Emitter<Events extends Record<EventType, unknown>> {
-    on: <Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>) => void;
-    off: <Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>) => void;
-    emit: (<Key extends keyof Events>(type: Key, event: Events[Key]) => void) & (<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never) => void);
+	on: <Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>) => void;
+	off: <Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>) => void;
+	emit: (<Key extends keyof Events>(type: Key, event: Events[Key]) => void) & (<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never) => void);
 }
 type HMREmitter = Emitter<{
-    message: HMRPayload;
+	message: HMRPayload
 }> & EventEmitter;
-declare module 'vite' {
-    interface ViteDevServer {
-        emitter: HMREmitter;
-    }
+declare module "vite" {
+	interface ViteDevServer {
+		emitter: HMREmitter;
+	}
 }
 declare function createHmrEmitter(): HMREmitter;
 declare function viteNodeHmrPlugin(): Plugin;
 
 type ModuleNamespace = Record<string, any> & {
-    [Symbol.toStringTag]: 'Module';
+	[Symbol.toStringTag]: "Module"
 };
 type InferCustomEventPayload<T extends string> = T extends keyof CustomEventMap ? CustomEventMap[T] : any;
 interface HotModule {
-    id: string;
-    callbacks: HotCallback[];
+	id: string;
+	callbacks: HotCallback[];
 }
 interface HotCallback {
-    deps: string[];
-    fn: (modules: (ModuleNamespace | undefined)[]) => void;
+	deps: string[];
+	fn: (modules: (ModuleNamespace | undefined)[]) => void;
 }
 interface CacheData {
-    hotModulesMap: Map<string, HotModule>;
-    dataMap: Map<string, any>;
-    disposeMap: Map<string, (data: any) => void | Promise<void>>;
-    pruneMap: Map<string, (data: any) => void | Promise<void>>;
-    customListenersMap: Map<string, ((data: any) => void)[]>;
-    ctxToListenersMap: Map<string, Map<string, ((data: any) => void)[]>>;
-    messageBuffer: string[];
-    isFirstUpdate: boolean;
-    pending: boolean;
-    queued: Promise<(() => void) | undefined>[];
+	hotModulesMap: Map<string, HotModule>;
+	dataMap: Map<string, any>;
+	disposeMap: Map<string, (data: any) => void | Promise<void>>;
+	pruneMap: Map<string, (data: any) => void | Promise<void>>;
+	customListenersMap: Map<string, ((data: any) => void)[]>;
+	ctxToListenersMap: Map<string, Map<string, ((data: any) => void)[]>>;
+	messageBuffer: string[];
+	isFirstUpdate: boolean;
+	pending: boolean;
+	queued: Promise<(() => void) | undefined>[];
 }
 declare function getCache(runner: ViteNodeRunner): CacheData;
 declare function sendMessageBuffer(runner: ViteNodeRunner, emitter: HMREmitter): void;

package/dist/index.d-CvjHzhRV.d.ts

@@ -0,0 +1,321 @@
+import { E as EncodedSourceMap } from './trace-mapping.d-DLVdEqOp.js';
+
+/** @deprecated use HotPayload */
+type HMRPayload = HotPayload
+type HotPayload =
+  | ConnectedPayload
+  | PingPayload
+  | UpdatePayload
+  | FullReloadPayload
+  | CustomPayload
+  | ErrorPayload
+  | PrunePayload
+
+interface ConnectedPayload {
+  type: 'connected'
+}
+
+interface PingPayload {
+  type: 'ping'
+}
+
+interface UpdatePayload {
+  type: 'update'
+  updates: Update[]
+}
+
+interface Update {
+  type: 'js-update' | 'css-update'
+  path: string
+  acceptedPath: string
+  timestamp: number
+  /** @internal */
+  explicitImportRequired?: boolean
+  /** @internal */
+  isWithinCircularImport?: boolean
+  /** @internal */
+  invalidates?: string[]
+}
+
+interface PrunePayload {
+  type: 'prune'
+  paths: string[]
+}
+
+interface FullReloadPayload {
+  type: 'full-reload'
+  path?: string
+  /** @internal */
+  triggeredBy?: string
+}
+
+interface CustomPayload {
+  type: 'custom'
+  event: string
+  data?: any
+}
+
+interface ErrorPayload {
+  type: 'error'
+  err: {
+    [name: string]: any
+    message: string
+    stack: string
+    id?: string
+    frame?: string
+    plugin?: string
+    pluginCode?: string
+    loc?: {
+      file?: string
+      line: number
+      column: number
+    }
+  }
+}
+
+interface CustomEventMap {
+  'vite:beforeUpdate': UpdatePayload
+  'vite:afterUpdate': UpdatePayload
+  'vite:beforePrune': PrunePayload
+  'vite:beforeFullReload': FullReloadPayload
+  'vite:error': ErrorPayload
+  'vite:invalidate': InvalidatePayload
+  'vite:ws:connect': WebSocketConnectionPayload
+  'vite:ws:disconnect': WebSocketConnectionPayload
+}
+
+interface WebSocketConnectionPayload {
+  /**
+   * @experimental
+   * We expose this instance experimentally to see potential usage.
+   * This might be removed in the future if we didn't find reasonable use cases.
+   * If you find this useful, please open an issue with details so we can discuss and make it stable API.
+   */
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins
+  webSocket: WebSocket
+}
+
+interface InvalidatePayload {
+  path: string
+  message: string | undefined
+}
+
+/**
+ * provides types for built-in Vite events
+ */
+type InferCustomEventPayload<T extends string> =
+  T extends keyof CustomEventMap ? CustomEventMap[T] : any
+
+type ModuleNamespace = Record<string, any> & {
+  [Symbol.toStringTag]: 'Module'
+}
+
+interface ViteHotContext {
+  readonly data: any
+
+  accept(): void
+  accept(cb: (mod: ModuleNamespace | undefined) => void): void
+  accept(dep: string, cb: (mod: ModuleNamespace | undefined) => void): void
+  accept(
+    deps: readonly string[],
+    cb: (mods: Array<ModuleNamespace | undefined>) => void,
+  ): void
+
+  acceptExports(
+    exportNames: string | readonly string[],
+    cb?: (mod: ModuleNamespace | undefined) => void,
+  ): void
+
+  dispose(cb: (data: any) => void): void
+  prune(cb: (data: any) => void): void
+  invalidate(message?: string): void
+
+  on<T extends string>(
+    event: T,
+    cb: (payload: InferCustomEventPayload<T>) => void,
+  ): void
+  off<T extends string>(
+    event: T,
+    cb: (payload: InferCustomEventPayload<T>) => void,
+  ): void
+  send<T extends string>(event: T, data?: InferCustomEventPayload<T>): void
+}
+
+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): EncodedSourceMap | null;
+}
+type ModuleExecutionInfo = Map<string, {
+	startOffset: 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;
+	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]>;
+	protected getContextPrimitives(): {
+		Object: ObjectConstructor
+		Reflect: typeof Reflect
+		Symbol: SymbolConstructor
+	};
+	protected runModule(context: Record<string, any>, transformed: string): Promise<void>;
+	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>;
+}
+
+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;
+}
+
+export { type Arrayable as A, type CustomEventMap as C, type DebuggerOptions as D, type FetchResult as F, type HMRPayload as H, ModuleCacheMap as M, type Nullable as N, type RawSourceMap as R, type StartOfSourceMap as S, type ViteNodeServerOptions as V, ViteNodeRunner as a, type HotContext as b, type DepsHandlingOptions as c, type ViteNodeResolveId as d, DEFAULT_REQUEST_STUBS as e, type ModuleExecutionInfo as f, type Awaitable as g, type FetchFunction as h, type ResolveIdFunction as i, type CreateHotContextFunction as j, type ModuleCache as k, type ViteNodeRunnerOptions as l, type ViteNodeResolveModule as m };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { A as Arrayable, g as Awaitable, j as CreateHotContextFunction, D as DebuggerOptions, c as DepsHandlingOptions, h as FetchFunction, F as FetchResult, b as HotContext, k as ModuleCache, M as ModuleCacheMap, f as ModuleExecutionInfo, N as Nullable, R as RawSourceMap, i as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, m as ViteNodeResolveModule, l as ViteNodeRunnerOptions, V as ViteNodeServerOptions } from './index-LQxw79Gm.js';
+export { A as Arrayable, g as Awaitable, j as CreateHotContextFunction, D as DebuggerOptions, c as DepsHandlingOptions, h as FetchFunction, F as FetchResult, b as HotContext, k as ModuleCache, M as ModuleCacheMap, f as ModuleExecutionInfo, N as Nullable, R as RawSourceMap, i as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, m as ViteNodeResolveModule, l as ViteNodeRunnerOptions, V as ViteNodeServerOptions } from './index.d-CvjHzhRV.js';
 export { D as DecodedSourceMap, E as EncodedSourceMap, S as SourceMapInput } from './trace-mapping.d-DLVdEqOp.js';

package/dist/server.cjs

@@ -566,7 +566,7 @@ class ViteNodeServer {
       result = await this.server.transformRequest(id, { ssr: true });
     }
     const sourcemap = this.options.sourcemap ?? "inline";
-    if (sourcemap === "inline" && result && !id.includes("node_modules")) {
+    if (sourcemap === "inline" && result) {
       result = await this.processTransformResult(filepath, result);
     }
     if ((_c = this.options.debug) == null ? void 0 : _c.dumpModules) {

package/dist/server.d.ts

@@ -1,58 +1,58 @@
 import { TransformResult, ViteDevServer } from 'vite';
-import { D as DebuggerOptions, c as DepsHandlingOptions, V as ViteNodeServerOptions, F as FetchResult, d as ViteNodeResolveId } from './index-LQxw79Gm.js';
+import { D as DebuggerOptions, c as DepsHandlingOptions, V as ViteNodeServerOptions, F as FetchResult, d as ViteNodeResolveId } from './index.d-CvjHzhRV.js';
 import { E as EncodedSourceMap } from './trace-mapping.d-DLVdEqOp.js';
 
 declare class Debugger {
-    options: DebuggerOptions;
-    dumpDir: string | undefined;
-    initPromise: Promise<void> | undefined;
-    externalizeMap: Map<string, string>;
-    constructor(root: string, options: DebuggerOptions);
-    clearDump(): Promise<void>;
-    encodeId(id: string): string;
-    recordExternalize(id: string, path: string): Promise<void>;
-    dumpFile(id: string, result: TransformResult | null): Promise<void>;
-    loadDump(id: string): Promise<TransformResult | null>;
-    writeInfo(): Promise<void>;
+	options: DebuggerOptions;
+	dumpDir: string | undefined;
+	initPromise: Promise<void> | undefined;
+	externalizeMap: Map<string, string>;
+	constructor(root: string, options: DebuggerOptions);
+	clearDump(): Promise<void>;
+	encodeId(id: string): string;
+	recordExternalize(id: string, path: string): Promise<void>;
+	dumpFile(id: string, result: TransformResult | null): Promise<void>;
+	loadDump(id: string): Promise<TransformResult | null>;
+	writeInfo(): Promise<void>;
 }
 
 declare function guessCJSversion(id: string): string | undefined;
 declare function shouldExternalize(id: string, options?: DepsHandlingOptions, cache?: Map<string, Promise<string | false>>): Promise<string | false>;
 
 interface FetchCache {
-    duration?: number;
-    timestamp: number;
-    result: FetchResult;
+	duration?: number;
+	timestamp: number;
+	result: FetchResult;
 }
 declare class ViteNodeServer {
-    server: ViteDevServer;
-    options: ViteNodeServerOptions;
-    private fetchPromiseMap;
-    private transformPromiseMap;
-    private durations;
-    private existingOptimizedDeps;
-    fetchCaches: Record<'ssr' | 'web', Map<string, FetchCache>>;
-    fetchCache: Map<string, FetchCache>;
-    externalizeCache: Map<string, Promise<string | false>>;
-    debugger?: Debugger;
-    constructor(server: ViteDevServer, options?: ViteNodeServerOptions);
-    shouldExternalize(id: string): Promise<string | false>;
-    getTotalDuration(): number;
-    private ensureExists;
-    resolveId(id: string, importer?: string, transformMode?: 'web' | 'ssr'): Promise<ViteNodeResolveId | null>;
-    getSourceMap(source: string): EncodedSourceMap | null;
-    private assertMode;
-    fetchModule(id: string, transformMode?: 'web' | 'ssr'): Promise<FetchResult>;
-    fetchResult(id: string, mode: 'web' | 'ssr'): Promise<FetchResult>;
-    transformRequest(id: string, filepath?: string, transformMode?: 'web' | 'ssr'): Promise<TransformResult | null | undefined>;
-    transformModule(id: string, transformMode?: 'web' | 'ssr'): Promise<{
-        code: string | undefined;
-    }>;
-    getTransformMode(id: string): 'ssr' | 'web';
-    private getChangedModule;
-    private _fetchModule;
-    protected processTransformResult(filepath: string, result: TransformResult): Promise<TransformResult>;
-    private _transformRequest;
+	server: ViteDevServer;
+	options: ViteNodeServerOptions;
+	private fetchPromiseMap;
+	private transformPromiseMap;
+	private durations;
+	private existingOptimizedDeps;
+	fetchCaches: Record<"ssr" | "web", Map<string, FetchCache>>;
+	fetchCache: Map<string, FetchCache>;
+	externalizeCache: Map<string, Promise<string | false>>;
+	debugger?: Debugger;
+	constructor(server: ViteDevServer, options?: ViteNodeServerOptions);
+	shouldExternalize(id: string): Promise<string | false>;
+	getTotalDuration(): number;
+	private ensureExists;
+	resolveId(id: string, importer?: string, transformMode?: "web" | "ssr"): Promise<ViteNodeResolveId | null>;
+	getSourceMap(source: string): EncodedSourceMap | null;
+	private assertMode;
+	fetchModule(id: string, transformMode?: "web" | "ssr"): Promise<FetchResult>;
+	fetchResult(id: string, mode: "web" | "ssr"): Promise<FetchResult>;
+	transformRequest(id: string, filepath?: string, transformMode?: "web" | "ssr"): Promise<TransformResult | null | undefined>;
+	transformModule(id: string, transformMode?: "web" | "ssr"): Promise<{
+		code: string | undefined
+	}>;
+	getTransformMode(id: string): "ssr" | "web";
+	private getChangedModule;
+	private _fetchModule;
+	protected processTransformResult(filepath: string, result: TransformResult): Promise<TransformResult>;
+	private _transformRequest;
 }
 
 export { ViteNodeServer, guessCJSversion, shouldExternalize };

package/dist/server.mjs

@@ -545,7 +545,7 @@ class ViteNodeServer {
       result = await this.server.transformRequest(id, { ssr: true });
     }
     const sourcemap = this.options.sourcemap ?? "inline";
-    if (sourcemap === "inline" && result && !id.includes("node_modules")) {
+    if (sourcemap === "inline" && result) {
       result = await this.processTransformResult(filepath, result);
     }
     if ((_c = this.options.debug) == null ? void 0 : _c.dumpModules) {

package/dist/source-map.cjs

@@ -882,7 +882,7 @@ function prepareStackTrace(error, stack) {
 }
 retrieveFileHandlers.slice(0);
 retrieveMapHandlers.slice(0);
-const install = function(options) {
+function install(options) {
   options = options || {};
   if (options.retrieveFile) {
     if (options.overrideRetrieveFile) {
@@ -900,7 +900,7 @@ const install = function(options) {
     errorFormatterInstalled = true;
     Error.prepareStackTrace = prepareStackTrace;
   }
-};
+}
 
 let SOURCEMAPPING_URL = "sourceMa";
 SOURCEMAPPING_URL += "ppingURL";

package/dist/source-map.d.ts

@@ -2,12 +2,12 @@ import { TransformResult } from 'vite';
 import { E as EncodedSourceMap } from './trace-mapping.d-DLVdEqOp.js';
 
 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;

package/dist/source-map.mjs

@@ -880,7 +880,7 @@ function prepareStackTrace(error, stack) {
 }
 retrieveFileHandlers.slice(0);
 retrieveMapHandlers.slice(0);
-const install = function(options) {
+function install(options) {
   options = options || {};
   if (options.retrieveFile) {
     if (options.overrideRetrieveFile) {
@@ -898,7 +898,7 @@ const install = function(options) {
     errorFormatterInstalled = true;
     Error.prepareStackTrace = prepareStackTrace;
   }
-};
+}
 
 let SOURCEMAPPING_URL = "sourceMa";
 SOURCEMAPPING_URL += "ppingURL";

package/dist/types.d.ts

@@ -1,2 +1,2 @@
 export { D as DecodedSourceMap, E as EncodedSourceMap, S as SourceMapInput } from './trace-mapping.d-DLVdEqOp.js';
-export { A as Arrayable, g as Awaitable, j as CreateHotContextFunction, D as DebuggerOptions, c as DepsHandlingOptions, h as FetchFunction, F as FetchResult, b as HotContext, k as ModuleCache, M as ModuleCacheMap, f as ModuleExecutionInfo, N as Nullable, R as RawSourceMap, i as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, m as ViteNodeResolveModule, l as ViteNodeRunnerOptions, V as ViteNodeServerOptions } from './index-LQxw79Gm.js';
+export { A as Arrayable, g as Awaitable, j as CreateHotContextFunction, D as DebuggerOptions, c as DepsHandlingOptions, h as FetchFunction, F as FetchResult, b as HotContext, k as ModuleCache, M as ModuleCacheMap, f as ModuleExecutionInfo, N as Nullable, R as RawSourceMap, i as ResolveIdFunction, S as StartOfSourceMap, d as ViteNodeResolveId, m as ViteNodeResolveModule, l as ViteNodeRunnerOptions, V as ViteNodeServerOptions } from './index.d-CvjHzhRV.js';

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { N as Nullable, A as Arrayable } from './index-LQxw79Gm.js';
+import { N as Nullable, A as Arrayable } from './index.d-CvjHzhRV.js';
 import './trace-mapping.d-DLVdEqOp.js';
 
 declare const isWindows: boolean;
@@ -10,22 +10,22 @@ 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;
 /**
- * Convert `Arrayable<T>` to `Array<T>`
- *
- * @category Array
- */
+* Convert `Arrayable<T>` to `Array<T>`
+*
+* @category Array
+*/
 declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
 declare function getCachedData<T>(cache: Map<string, T>, basedir: string, originalBasedir: string): NonNullable<T> | undefined;
 declare function setCacheData<T>(cache: Map<string, T>, data: T, basedir: string, originalBasedir: string): void;
 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, isInternalRequest, isNodeBuiltin, isPrimitive, isWindows, normalizeModuleId, normalizeRequestId, setCacheData, slash, toArray, toFilePath, withTrailingSlash };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vite-node",
   "type": "module",
-  "version": "3.0.8",
+  "version": "3.0.9",
   "description": "Vite as Node.js runtime",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",

package/dist/index-LQxw79Gm.d.ts

@@ -1,321 +0,0 @@
-import { E as EncodedSourceMap } from './trace-mapping.d-DLVdEqOp.js';
-
-/** @deprecated use HotPayload */
-type HMRPayload = HotPayload
-type HotPayload =
-  | ConnectedPayload
-  | PingPayload
-  | UpdatePayload
-  | FullReloadPayload
-  | CustomPayload
-  | ErrorPayload
-  | PrunePayload
-
-interface ConnectedPayload {
-  type: 'connected'
-}
-
-interface PingPayload {
-  type: 'ping'
-}
-
-interface UpdatePayload {
-  type: 'update'
-  updates: Update[]
-}
-
-interface Update {
-  type: 'js-update' | 'css-update'
-  path: string
-  acceptedPath: string
-  timestamp: number
-  /** @internal */
-  explicitImportRequired?: boolean
-  /** @internal */
-  isWithinCircularImport?: boolean
-  /** @internal */
-  invalidates?: string[]
-}
-
-interface PrunePayload {
-  type: 'prune'
-  paths: string[]
-}
-
-interface FullReloadPayload {
-  type: 'full-reload'
-  path?: string
-  /** @internal */
-  triggeredBy?: string
-}
-
-interface CustomPayload {
-  type: 'custom'
-  event: string
-  data?: any
-}
-
-interface ErrorPayload {
-  type: 'error'
-  err: {
-    [name: string]: any
-    message: string
-    stack: string
-    id?: string
-    frame?: string
-    plugin?: string
-    pluginCode?: string
-    loc?: {
-      file?: string
-      line: number
-      column: number
-    }
-  }
-}
-
-interface CustomEventMap {
-  'vite:beforeUpdate': UpdatePayload
-  'vite:afterUpdate': UpdatePayload
-  'vite:beforePrune': PrunePayload
-  'vite:beforeFullReload': FullReloadPayload
-  'vite:error': ErrorPayload
-  'vite:invalidate': InvalidatePayload
-  'vite:ws:connect': WebSocketConnectionPayload
-  'vite:ws:disconnect': WebSocketConnectionPayload
-}
-
-interface WebSocketConnectionPayload {
-  /**
-   * @experimental
-   * We expose this instance experimentally to see potential usage.
-   * This might be removed in the future if we didn't find reasonable use cases.
-   * If you find this useful, please open an issue with details so we can discuss and make it stable API.
-   */
-  // eslint-disable-next-line n/no-unsupported-features/node-builtins
-  webSocket: WebSocket
-}
-
-interface InvalidatePayload {
-  path: string
-  message: string | undefined
-}
-
-/**
- * provides types for built-in Vite events
- */
-type InferCustomEventPayload<T extends string> =
-  T extends keyof CustomEventMap ? CustomEventMap[T] : any
-
-type ModuleNamespace = Record<string, any> & {
-  [Symbol.toStringTag]: 'Module'
-}
-
-interface ViteHotContext {
-  readonly data: any
-
-  accept(): void
-  accept(cb: (mod: ModuleNamespace | undefined) => void): void
-  accept(dep: string, cb: (mod: ModuleNamespace | undefined) => void): void
-  accept(
-    deps: readonly string[],
-    cb: (mods: Array<ModuleNamespace | undefined>) => void,
-  ): void
-
-  acceptExports(
-    exportNames: string | readonly string[],
-    cb?: (mod: ModuleNamespace | undefined) => void,
-  ): void
-
-  dispose(cb: (data: any) => void): void
-  prune(cb: (data: any) => void): void
-  invalidate(message?: string): void
-
-  on<T extends string>(
-    event: T,
-    cb: (payload: InferCustomEventPayload<T>) => void,
-  ): void
-  off<T extends string>(
-    event: T,
-    cb: (payload: InferCustomEventPayload<T>) => void,
-  ): void
-  send<T extends string>(event: T, data?: InferCustomEventPayload<T>): void
-}
-
-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): EncodedSourceMap | null;
-}
-type ModuleExecutionInfo = Map<string, {
-    startOffset: 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;
-    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]>;
-    protected getContextPrimitives(): {
-        Object: ObjectConstructor;
-        Reflect: typeof Reflect;
-        Symbol: SymbolConstructor;
-    };
-    protected runModule(context: Record<string, any>, transformed: string): Promise<void>;
-    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>;
-}
-
-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;
-}
-
-export { type Arrayable as A, type CustomEventMap as C, type DebuggerOptions as D, type FetchResult as F, type HMRPayload as H, ModuleCacheMap as M, type Nullable as N, type RawSourceMap as R, type StartOfSourceMap as S, type ViteNodeServerOptions as V, ViteNodeRunner as a, type HotContext as b, type DepsHandlingOptions as c, type ViteNodeResolveId as d, DEFAULT_REQUEST_STUBS as e, type ModuleExecutionInfo as f, type Awaitable as g, type FetchFunction as h, type ResolveIdFunction as i, type CreateHotContextFunction as j, type ModuleCache as k, type ViteNodeRunnerOptions as l, type ViteNodeResolveModule as m };