vite-node 5.0.0 → 5.2.0

package/dist/{chunk-hmr.js → hmr-qEG3qSgW.mjs}

@@ -1,9 +1,10 @@
-import { EventEmitter } from 'node:events';
-import process from 'node:process';
-import createDebug from 'debug';
-import { C } from './chunk-index.js';
-import { normalizeRequestId } from './utils.js';
+import { t as C } from "./dist-B2ebky9O.mjs";
+import { f as normalizeRequestId } from "./utils-ExLpYVUV.mjs";
+import process from "node:process";
+import { createDebug } from "obug";
+import { EventEmitter } from "node:events";
 
+//#region src/hmr/emitter.ts
 function createHmrEmitter() {
 	return new EventEmitter();
 }
@@ -12,7 +13,6 @@ function viteNodeHmrPlugin() {
 	return {
 		name: "vite-node:hmr",
 		config() {
-			// chokidar fsevents is unstable on macos when emitting "ready" event
 			if (process.platform === "darwin" && process.env.VITE_TEST_WATCHER_DEBUG) return { server: { watch: {
 				useFsEvents: false,
 				usePolling: false
@@ -25,8 +25,6 @@ function viteNodeHmrPlugin() {
 				_send(payload);
 				emitter.emit("message", payload);
 			};
-			// eslint-disable-next-line ts/ban-ts-comment
-			// @ts-ignore Vite 6 compat
 			const environments = server.environments;
 			if (environments) environments.ssr.hot.send = function(payload) {
 				_send(payload);
@@ -36,6 +34,8 @@ function viteNodeHmrPlugin() {
 	};
 }
 
+//#endregion
+//#region src/hmr/hmr.ts
 const debugHmr = createDebug("vite-node:hmr");
 const cache = /* @__PURE__ */ new WeakMap();
 function getCache(runner) {
@@ -59,7 +59,6 @@ function sendMessageBuffer(runner, emitter) {
 	maps.messageBuffer.length = 0;
 }
 async function reload(runner, files) {
-	// invalidate module cache but not node_modules
 	Array.from(runner.moduleCache.keys()).forEach((fsPath) => {
 		if (!fsPath.includes("node_modules")) runner.moduleCache.delete(fsPath);
 	});
@@ -86,14 +85,9 @@ async function fetchUpdate(runner, { path, acceptedPath }) {
 	acceptedPath = normalizeRequestId(acceptedPath);
 	const maps = getCache(runner);
 	const mod = maps.hotModulesMap.get(path);
-	if (!mod)
- // In a code-splitting project,
-	// it is common that the hot-updating module is not loaded yet.
-	// https://github.com/vitejs/vite/issues/721
-	return;
+	if (!mod) return;
 	const isSelfUpdate = path === acceptedPath;
 	let fetchedModule;
-	// determine the qualified callbacks before we re-import the modules
 	const qualifiedCallbacks = mod.callbacks.filter(({ deps }) => deps.includes(acceptedPath));
 	if (isSelfUpdate || qualifiedCallbacks.length > 0) {
 		const disposer = maps.disposeMap.get(acceptedPath);
@@ -124,7 +118,6 @@ async function handleMessage(runner, emitter, files, payload) {
 			await notifyListeners(runner, "vite:beforeUpdate", payload);
 			await Promise.all(payload.updates.map((update) => {
 				if (update.type === "js-update") return queueUpdate(runner, fetchUpdate(runner, update));
-				// css-update
 				console.error(`${C.cyan("[vite-node]")} no support css hmr.}`);
 				return null;
 			}));
@@ -157,37 +150,31 @@ function createHotContext(runner, emitter, files, ownerPath) {
 	debugHmr("createHotContext", ownerPath);
 	const maps = getCache(runner);
 	if (!maps.dataMap.has(ownerPath)) maps.dataMap.set(ownerPath, {});
-	// when a file is hot updated, a new context is created
-	// clear its stale callbacks
 	const mod = maps.hotModulesMap.get(ownerPath);
 	if (mod) mod.callbacks = [];
 	const newListeners = /* @__PURE__ */ new Map();
 	maps.ctxToListenersMap.set(ownerPath, newListeners);
 	function acceptDeps(deps, callback = () => {}) {
-		const mod = maps.hotModulesMap.get(ownerPath) || {
+		const mod$1 = maps.hotModulesMap.get(ownerPath) || {
 			id: ownerPath,
 			callbacks: []
 		};
-		mod.callbacks.push({
+		mod$1.callbacks.push({
 			deps,
 			fn: callback
 		});
-		maps.hotModulesMap.set(ownerPath, mod);
+		maps.hotModulesMap.set(ownerPath, mod$1);
 	}
 	return {
 		get data() {
 			return maps.dataMap.get(ownerPath);
 		},
 		acceptExports(_, callback) {
-			acceptDeps([ownerPath], callback && (([mod]) => callback(mod)));
+			acceptDeps([ownerPath], callback && (([mod$1]) => callback(mod$1)));
 		},
 		accept(deps, callback) {
-			if (typeof deps === "function" || !deps)
- // self-accept: hot.accept(() => {})
-			acceptDeps([ownerPath], ([mod]) => deps && deps(mod));
-			else if (typeof deps === "string")
- // explicit deps
-			acceptDeps([deps], ([mod]) => callback && callback(mod));
+			if (typeof deps === "function" || !deps) acceptDeps([ownerPath], ([mod$1]) => deps && deps(mod$1));
+			else if (typeof deps === "string") acceptDeps([deps], ([mod$1]) => callback && callback(mod$1));
 			else if (Array.isArray(deps)) acceptDeps(deps, callback);
 			else throw new TypeError("invalid hot.accept() usage.");
 		},
@@ -239,4 +226,5 @@ function createHotContext(runner, emitter, files, ownerPath) {
 	};
 }
 
-export { createHotContext as a, createHmrEmitter as c, getCache as g, handleMessage as h, reload as r, sendMessageBuffer as s, viteNodeHmrPlugin as v };
+//#endregion
+export { sendMessageBuffer as a, reload as i, getCache as n, createHmrEmitter as o, handleMessage as r, viteNodeHmrPlugin as s, createHotContext as t };

package/dist/hmr.d.mts

@@ -0,0 +1,57 @@
+import { T as ViteNodeRunner, u as HotContext } from "./types-Dtew7m7O.mjs";
+import { HMRPayload, Plugin } from "vite";
+import { EventEmitter } from "node:events";
+import { CustomEventMap } from "vite/types/customEvent.js";
+import { HMRPayload as HMRPayload$1 } from "vite/types/hmrPayload.js";
+
+//#region src/hmr/emitter.d.ts
+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);
+}
+type HMREmitter = Emitter<{
+  message: HMRPayload;
+}> & EventEmitter;
+declare module "vite" {
+  interface ViteDevServer {
+    emitter: HMREmitter;
+  }
+}
+declare function createHmrEmitter(): HMREmitter;
+declare function viteNodeHmrPlugin(): Plugin;
+//#endregion
+//#region src/hmr/hmr.d.ts
+type ModuleNamespace = Record<string, any> & {
+  [Symbol.toStringTag]: "Module";
+};
+type InferCustomEventPayload<T extends string> = T extends keyof CustomEventMap ? CustomEventMap[T] : any;
+interface HotModule {
+  id: string;
+  callbacks: HotCallback[];
+}
+interface HotCallback {
+  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>[];
+}
+declare function getCache(runner: ViteNodeRunner): CacheData;
+declare function sendMessageBuffer(runner: ViteNodeRunner, emitter: HMREmitter): void;
+declare function reload(runner: ViteNodeRunner, files: string[]): Promise<any[]>;
+declare function handleMessage(runner: ViteNodeRunner, emitter: HMREmitter, files: string[], payload: HMRPayload$1): Promise<void>;
+declare function createHotContext(runner: ViteNodeRunner, emitter: HMREmitter, files: string[], ownerPath: string): HotContext;
+//#endregion
+export { Emitter, EventType, HMREmitter, Handler, HotCallback, HotModule, InferCustomEventPayload, ModuleNamespace, createHmrEmitter, createHotContext, getCache, handleMessage, reload, sendMessageBuffer, viteNodeHmrPlugin };

package/dist/hmr.mjs

@@ -0,0 +1,5 @@
+import "./dist-B2ebky9O.mjs";
+import "./utils-ExLpYVUV.mjs";
+import { a as sendMessageBuffer, i as reload, n as getCache, o as createHmrEmitter, r as handleMessage, s as viteNodeHmrPlugin, t as createHotContext } from "./hmr-qEG3qSgW.mjs";
+
+export { createHmrEmitter, createHotContext, getCache, handleMessage, reload, sendMessageBuffer, viteNodeHmrPlugin };

package/dist/index.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-Dtew7m7O.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/index.mjs

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

package/dist/{server.js → server-BWywEVuB.mjs}

@@ -1,28 +1,25 @@
-import assert from 'node:assert';
-import { existsSync, promises } from 'node:fs';
-import { performance } from 'node:perf_hooks';
-import process from 'node:process';
-import { pathToFileURL } from 'node:url';
-import createDebug from 'debug';
-import { resolve, join, extname, dirname, relative, normalize } from 'pathe';
-import { version } from 'vite';
-import { C } from './chunk-index.js';
-import * as esModuleLexer from 'es-module-lexer';
-import { KNOWN_ASSET_RE } from './constants.js';
-import { isNodeBuiltin, slash, findNearestPackageData, toArray, withTrailingSlash, normalizeModuleId, toFilePath } from './utils.js';
-import { withInlineSourcemap } from './source-map.js';
-import 'node:module';
-import 'node:buffer';
-import 'node:path';
+import { t as C } from "./dist-B2ebky9O.mjs";
+import { n as KNOWN_ASSET_RE } from "./constants-DRkacFwN.mjs";
+import { _ as withTrailingSlash, c as isNodeBuiltin, d as normalizeModuleId, g as toFilePath, h as toArray, i as findNearestPackageData, m as slash } from "./utils-ExLpYVUV.mjs";
+import { r as withInlineSourcemap } from "./source-map-DQLD3K8K.mjs";
+import assert from "node:assert";
+import { existsSync, promises } from "node:fs";
+import { performance } from "node:perf_hooks";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { createDebug } from "obug";
+import { dirname, extname, join, normalize, relative, resolve } from "pathe";
+import { version } from "vite";
+import * as esModuleLexer from "es-module-lexer";
 
-/* eslint-disable no-console */
+//#region src/debug.ts
 function hashCode(s) {
 	return s.split("").reduce((a, b) => {
 		a = (a << 5) - a + b.charCodeAt(0);
 		return a & a;
 	}, 0);
 }
-class Debugger {
+var Debugger = class {
 	dumpDir;
 	initPromise;
 	externalizeMap = /* @__PURE__ */ new Map();
@@ -74,8 +71,10 @@ class Debugger {
 		}, null, 2);
 		return promises.writeFile(join(this.dumpDir, "info.json"), info, "utf-8");
 	}
-}
+};
 
+//#endregion
+//#region src/externalize.ts
 const BUILTIN_EXTENSIONS = new Set([
 	".mjs",
 	".cjs",
@@ -109,7 +108,6 @@ function guessCJSversion(id) {
 		]) if (existsSync(i)) return i;
 	}
 }
-// The code from https://github.com/unjs/mlly/blob/c5bcca0cda175921344fd6de1bc0c499e73e5dac/src/syntax.ts#L51-L98
 async function isValidNodeImport(id) {
 	const extension = extname(id);
 	if (BUILTIN_EXTENSIONS.has(extension)) return true;
@@ -133,20 +131,15 @@ async function shouldExternalize(id, options, cache = _defaultExternalizeCache)
 }
 async function _shouldExternalize(id, options) {
 	if (isNodeBuiltin(id)) return id;
-	// data: should be processed by native import,
-	// since it is a feature of ESM.
-	// also externalize network imports since nodejs allows it when --experimental-network-imports
 	if (id.startsWith("data:") || /^(?:https?:)?\/\//.test(id)) return id;
 	id = patchWindowsImportPath(id);
-	const moduleDirectories = (options === null || options === void 0 ? void 0 : options.moduleDirectories) || ["/node_modules/"];
-	if (matchExternalizePattern(id, moduleDirectories, options === null || options === void 0 ? void 0 : options.inline)) return false;
-	if ((options === null || options === void 0 ? void 0 : options.inlineFiles) && (options === null || options === void 0 ? void 0 : options.inlineFiles.includes(id))) return false;
-	if (matchExternalizePattern(id, moduleDirectories, options === null || options === void 0 ? void 0 : options.external)) return id;
-	// Unless the user explicitly opted to inline them, externalize Vite deps.
-	// They are too big to inline by default.
-	if ((options === null || options === void 0 ? void 0 : options.cacheDir) && id.includes(options.cacheDir)) return id;
+	const moduleDirectories = options?.moduleDirectories || ["/node_modules/"];
+	if (matchExternalizePattern(id, moduleDirectories, options?.inline)) return false;
+	if (options?.inlineFiles && options?.inlineFiles.includes(id)) return false;
+	if (matchExternalizePattern(id, moduleDirectories, options?.external)) return id;
+	if (options?.cacheDir && id.includes(options.cacheDir)) return id;
 	const isLibraryModule = moduleDirectories.some((dir) => id.includes(dir));
-	id = isLibraryModule && (options === null || options === void 0 ? void 0 : options.fallbackCJS) ? guessCJSversion(id) || id : id;
+	id = isLibraryModule && options?.fallbackCJS ? guessCJSversion(id) || id : id;
 	if (matchExternalizePattern(id, moduleDirectories, defaultInline)) return false;
 	if (matchExternalizePattern(id, moduleDirectories, depsExternal)) return id;
 	if (isLibraryModule && await isValidNodeImport(id)) return id;
@@ -166,8 +159,10 @@ function patchWindowsImportPath(path) {
 	else return path;
 }
 
+//#endregion
+//#region src/server.ts
 const debugRequest = createDebug("vite-node:server:request");
-class ViteNodeServer {
+var ViteNodeServer = class {
 	fetchPromiseMap = {
 		ssr: /* @__PURE__ */ new Map(),
 		web: /* @__PURE__ */ new Map()
@@ -189,24 +184,15 @@ class ViteNodeServer {
 	externalizeCache = /* @__PURE__ */ new Map();
 	debugger;
 	constructor(server, options = {}) {
-		var _options$deps3;
 		this.server = server;
 		this.options = options;
 		const ssrOptions = server.config.ssr;
-		options.deps ?? (options.deps = {});
+		options.deps ??= {};
 		options.deps.cacheDir = relative(server.config.root, options.deps.cacheDir || server.config.cacheDir);
 		if (ssrOptions) {
-			// we don't externalize ssr, because it has different semantics in Vite
-			// if (ssrOptions.external) {
-			//   options.deps.external ??= []
-			//   options.deps.external.push(...ssrOptions.external)
-			// }
-			if (ssrOptions.noExternal === true) {
-				var _options$deps;
-				(_options$deps = options.deps).inline ?? (_options$deps.inline = true);
-			} else if (options.deps.inline !== true) {
-				var _options$deps2;
-				(_options$deps2 = options.deps).inline ?? (_options$deps2.inline = []);
+			if (ssrOptions.noExternal === true) options.deps.inline ??= true;
+			else if (options.deps.inline !== true) {
+				options.deps.inline ??= [];
 				const inline = options.deps.inline;
 				options.deps.inline.push(...toArray(ssrOptions.noExternal).filter((dep) => !inline.includes(dep)));
 			}
@@ -221,16 +207,14 @@ class ViteNodeServer {
 			const resolvedId = resolve(file);
 			return [resolvedId, pathToFileURL(resolvedId).href];
 		});
-		(_options$deps3 = options.deps).moduleDirectories ?? (_options$deps3.moduleDirectories = []);
-		const envValue = process.env.VITE_NODE_DEPS_MODULE_DIRECTORIES || process.env.npm_config_VITE_NODE_DEPS_MODULE_DIRECTORIES;
-		const customModuleDirectories = envValue === null || envValue === void 0 ? void 0 : envValue.split(",");
+		options.deps.moduleDirectories ??= [];
+		const customModuleDirectories = (process.env.VITE_NODE_DEPS_MODULE_DIRECTORIES || process.env.npm_config_VITE_NODE_DEPS_MODULE_DIRECTORIES)?.split(",");
 		if (customModuleDirectories) options.deps.moduleDirectories.push(...customModuleDirectories);
 		options.deps.moduleDirectories = options.deps.moduleDirectories.map((dir) => {
 			if (!dir.startsWith("/")) dir = `/${dir}`;
 			if (!dir.endsWith("/")) dir += "/";
 			return normalize(dir);
 		});
-		// always add node_modules as a module directory
 		if (!options.deps.moduleDirectories.includes("/node_modules/")) options.deps.moduleDirectories.push("/node_modules/");
 	}
 	shouldExternalize(id) {
@@ -247,10 +231,10 @@ class ViteNodeServer {
 			this.existingOptimizedDeps.add(id);
 			return true;
 		}
-		return new Promise((resolve) => {
+		return new Promise((resolve$1) => {
 			setTimeout(() => {
 				this.ensureExists(id).then(() => {
-					resolve(true);
+					resolve$1(true);
 				});
 			});
 		});
@@ -261,12 +245,10 @@ class ViteNodeServer {
 		return this.server.pluginContainer.resolveId(id, importer, { ssr: mode === "ssr" });
 	}
 	getSourceMap(source) {
-		var _this$fetchCache$get, _this$server$moduleGr;
 		source = normalizeModuleId(source);
-		const fetchResult = (_this$fetchCache$get = this.fetchCache.get(source)) === null || _this$fetchCache$get === void 0 ? void 0 : _this$fetchCache$get.result;
-		if (fetchResult === null || fetchResult === void 0 ? void 0 : fetchResult.map) return fetchResult.map;
-		const ssrTransformResult = (_this$server$moduleGr = this.server.moduleGraph.getModuleById(source)) === null || _this$server$moduleGr === void 0 ? void 0 : _this$server$moduleGr.ssrTransformResult;
-		return (ssrTransformResult === null || ssrTransformResult === void 0 ? void 0 : ssrTransformResult.map) || null;
+		const fetchResult = this.fetchCache.get(source)?.result;
+		if (fetchResult?.map) return fetchResult.map;
+		return (this.server.moduleGraph.getModuleById(source)?.ssrTransformResult)?.map || null;
 	}
 	assertMode(mode) {
 		assert(mode === "web" || mode === "ssr", `"transformMode" can only be "web" or "ssr", received "${mode}".`);
@@ -284,7 +266,6 @@ class ViteNodeServer {
 		const moduleId = normalizeModuleId(id);
 		this.assertMode(mode);
 		const promiseMap = this.fetchPromiseMap[mode];
-		// reuse transform for concurrent requests
 		if (!promiseMap.has(moduleId)) promiseMap.set(moduleId, this._fetchModule(moduleId, mode).finally(() => {
 			promiseMap.delete(moduleId);
 		}));
@@ -294,7 +275,6 @@ class ViteNodeServer {
 		const mode = transformMode || this.getTransformMode(id);
 		this.assertMode(mode);
 		const promiseMap = this.transformPromiseMap[mode];
-		// reuse transform for concurrent requests
 		if (!promiseMap.has(id)) promiseMap.set(id, this._transformRequest(id, filepath, mode).finally(() => {
 			promiseMap.delete(id);
 		}));
@@ -303,15 +283,12 @@ class ViteNodeServer {
 	async transformModule(id, transformMode) {
 		if (transformMode !== "web") throw new Error("`transformModule` only supports `transformMode: \"web\"`.");
 		const normalizedId = normalizeModuleId(id);
-		const mod = this.server.moduleGraph.getModuleById(normalizedId);
-		const result = (mod === null || mod === void 0 ? void 0 : mod.transformResult) || await this.server.transformRequest(normalizedId);
-		return { code: result === null || result === void 0 ? void 0 : result.code };
+		return { code: (this.server.moduleGraph.getModuleById(normalizedId)?.transformResult || await this.server.transformRequest(normalizedId))?.code };
 	}
 	getTransformMode(id) {
-		var _this$options$transfo, _this$options$transfo2;
 		const withoutQuery = id.split("?")[0];
-		if ((_this$options$transfo = this.options.transformMode) === null || _this$options$transfo === void 0 || (_this$options$transfo = _this$options$transfo.web) === null || _this$options$transfo === void 0 ? void 0 : _this$options$transfo.some((r) => withoutQuery.match(r))) return "web";
-		if ((_this$options$transfo2 = this.options.transformMode) === null || _this$options$transfo2 === void 0 || (_this$options$transfo2 = _this$options$transfo2.ssr) === null || _this$options$transfo2 === void 0 ? void 0 : _this$options$transfo2.some((r) => withoutQuery.match(r))) return "ssr";
+		if (this.options.transformMode?.web?.some((r) => withoutQuery.match(r))) return "web";
+		if (this.options.transformMode?.ssr?.some((r) => withoutQuery.match(r))) return "ssr";
 		if (withoutQuery.match(/\.([cm]?[jt]sx?|json)$/)) return "ssr";
 		return "web";
 	}
@@ -332,9 +309,8 @@ class ViteNodeServer {
 		return mod;
 	}
 	async _fetchModule(id, transformMode) {
-		var _this$options$deps;
 		let result;
-		const cacheDir = (_this$options$deps = this.options.deps) === null || _this$options$deps === void 0 ? void 0 : _this$options$deps.cacheDir;
+		const cacheDir = this.options.deps?.cacheDir;
 		if (cacheDir && id.includes(cacheDir)) {
 			if (!id.startsWith(withTrailingSlash(this.server.config.root))) id = join(this.server.config.root, id);
 			const timeout = setTimeout(() => {
@@ -346,25 +322,21 @@ class ViteNodeServer {
 		const { path: filePath } = toFilePath(id, this.server.config.root);
 		const moduleNode = this.getChangedModule(id, filePath);
 		const cache = this.fetchCaches[transformMode].get(filePath);
-		// lastUpdateTimestamp is the timestamp that marks the last time the module was changed
-		// if lastUpdateTimestamp is 0, then the module was not changed since the server started
-		// we test "timestamp === 0" for expressiveness, but it's not necessary
 		const timestamp = moduleNode ? Math.max(moduleNode.lastHMRTimestamp, moduleNode.lastInvalidationTimestamp) : 0;
 		if (cache && (timestamp === 0 || cache.timestamp >= timestamp)) return cache.result;
 		const time = Date.now();
 		const externalize = await this.shouldExternalize(filePath);
 		let duration;
 		if (externalize) {
-			var _this$debugger;
 			result = { externalize };
-			(_this$debugger = this.debugger) === null || _this$debugger === void 0 || _this$debugger.recordExternalize(id, externalize);
+			this.debugger?.recordExternalize(id, externalize);
 		} else {
 			const start = performance.now();
 			const r = await this._transformRequest(id, filePath, transformMode);
 			duration = performance.now() - start;
 			result = {
-				code: r === null || r === void 0 ? void 0 : r.code,
-				map: r === null || r === void 0 ? void 0 : r.map
+				code: r?.code,
+				map: r?.map
 			};
 		}
 		const cacheEntry = {
@@ -379,35 +351,28 @@ class ViteNodeServer {
 		return result;
 	}
 	async processTransformResult(filepath, result) {
-		const mod = this.server.moduleGraph.getModuleById(filepath);
 		return withInlineSourcemap(result, {
-			filepath: (mod === null || mod === void 0 ? void 0 : mod.file) || filepath,
+			filepath: this.server.moduleGraph.getModuleById(filepath)?.file || filepath,
 			root: this.server.config.root,
 			noFirstLineMapping: Number(version.split(".")[0]) >= 6
 		});
 	}
 	async _transformRequest(id, filepath, transformMode) {
-		var _this$options$debug, _this$options$debug2;
 		debugRequest(id);
 		let result = null;
-		if ((_this$options$debug = this.options.debug) === null || _this$options$debug === void 0 ? void 0 : _this$options$debug.loadDumppedModules) {
-			var _this$debugger2;
-			result = await ((_this$debugger2 = this.debugger) === null || _this$debugger2 === void 0 ? void 0 : _this$debugger2.loadDump(id)) ?? null;
+		if (this.options.debug?.loadDumppedModules) {
+			result = await this.debugger?.loadDump(id) ?? null;
 			if (result) return result;
 		}
 		if (transformMode === "web") {
-			// for components like Vue, we want to use the client side
-			// plugins but then convert the code to be consumed by the server
 			result = await this.server.transformRequest(id);
 			if (result) result = await this.server.ssrTransform(result.code, result.map, id);
 		} else result = await this.server.transformRequest(id, { ssr: true });
 		if ((this.options.sourcemap ?? "inline") === "inline" && result) result = await this.processTransformResult(filepath, result);
-		if ((_this$options$debug2 = this.options.debug) === null || _this$options$debug2 === void 0 ? void 0 : _this$options$debug2.dumpModules) {
-			var _this$debugger3;
-			await ((_this$debugger3 = this.debugger) === null || _this$debugger3 === void 0 ? void 0 : _this$debugger3.dumpFile(id, result));
-		}
+		if (this.options.debug?.dumpModules) await this.debugger?.dumpFile(id, result);
 		return result;
 	}
-}
+};
 
-export { ViteNodeServer, guessCJSversion, shouldExternalize };
+//#endregion
+export { guessCJSversion as n, shouldExternalize as r, ViteNodeServer as t };

package/dist/server.d.mts

@@ -0,0 +1,60 @@
+import { _ as ViteNodeResolveId, b as ViteNodeServerOptions, i as DebuggerOptions, l as FetchResult, o as DepsHandlingOptions, s as EncodedSourceMap } from "./types-Dtew7m7O.mjs";
+import { TransformResult, ViteDevServer } from "vite";
+
+//#region src/debug.d.ts
+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>;
+}
+//#endregion
+//#region src/externalize.d.ts
+declare function guessCJSversion(id: string): string | undefined;
+declare function shouldExternalize(id: string, options?: DepsHandlingOptions, cache?: Map<string, Promise<string | false>>): Promise<string | false>;
+//#endregion
+//#region src/server.d.ts
+interface FetchCache {
+  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;
+}
+//#endregion
+export { ViteNodeServer, guessCJSversion, shouldExternalize };

package/dist/server.mjs

@@ -0,0 +1,7 @@
+import "./dist-B2ebky9O.mjs";
+import { n as guessCJSversion, r as shouldExternalize, t as ViteNodeServer } from "./server-BWywEVuB.mjs";
+import "./constants-DRkacFwN.mjs";
+import "./utils-ExLpYVUV.mjs";
+import "./source-map-DQLD3K8K.mjs";
+
+export { ViteNodeServer, guessCJSversion, shouldExternalize };