vite-node 5.1.0 → 5.3.0

package/dist/cli.js

@@ -1,162 +0,0 @@
-import { resolve } from 'node:path';
-import process from 'node:process';
-import cac from 'cac';
-import { C } from './chunk-index.js';
-import { createServer, version as version$1, loadEnv } from 'vite';
-import { ViteNodeRunner } from './client.js';
-import { ViteNodeServer } from './server.js';
-import { installSourcemapsSupport } from './source-map.js';
-import { toArray } from './utils.js';
-import { v as viteNodeHmrPlugin, a as createHotContext, h as handleMessage } from './chunk-hmr.js';
-import 'node:module';
-import 'node:url';
-import 'node:vm';
-import 'debug';
-import 'node:buffer';
-import 'pathe';
-import 'node:fs';
-import 'node:assert';
-import 'node:perf_hooks';
-import 'es-module-lexer';
-import './constants.js';
-import 'node:events';
-
-var version = "5.1.0";
-
-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 = {}) {
-	var _server$emitter;
-	if (options.inspect || options.inspectAddr) {
-		var _options$inspectAddr;
-		const { open } = await import('node:inspector');
-		const [host, port] = ((_options$inspectAddr = options.inspectAddr) === null || _options$inspectAddr === void 0 ? void 0 : _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);
-		cli.outputVersion();
-		process.exit(0);
-	}
-	if (options.help) {
-		cli.version(version).outputHelp();
-		process.exit(0);
-	}
-	if (!files.length) {
-		console.error(C.red("No files specified."));
-		cli.version(version).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$1.split(".")[0]) < 6) await server.pluginContainer.buildStart({});
-	else
- // directly access client plugin container until https://github.com/vitejs/vite/issues/19607
-	await server.environments.client.pluginContainer.buildStart({});
-	const env = loadEnv(server.config.mode, server.config.envDir, "");
-	for (const key in env) {
-		var _process$env;
-		(_process$env = process.env)[key] ?? (_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, url) {
-			return createHotContext(runner, server.emitter, files, url);
-		}
-	});
-	// provide the vite define variable in this context
-	await runner.executeId("/@vite/env");
-	for (const file of files) await runner.executeFile(file);
-	if (!options.watch) await server.close();
-	(_server$emitter = server.emitter) === null || _server$emitter === void 0 || _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) {
-			// manually check `watcher.getWatched()` to make sure entry files are ready
-			// since watcher.on('ready', ...) event is not reliable since 5.1.
-			// https://github.com/vitejs/vite/blob/63a39c244b08cf1f2299bc2c3cfddcb82070d05b/playground/hmr-ssr/__tests__/hmr.spec.ts#L1065
-			const nodePath = await import('node:path');
-			async function waitForWatched(files) {
-				while (!files.every((file) => isWatched(file))) await new Promise((resolve) => setTimeout(resolve, 20));
-			}
-			function isWatched(file) {
-				var _watched$dir;
-				const watched = server.watcher.getWatched();
-				const resolved = nodePath.resolve(file);
-				const dir = nodePath.dirname(resolved);
-				const base = nodePath.basename(resolved);
-				return (_watched$dir = watched[dir]) === null || _watched$dir === void 0 ? void 0 : _watched$dir.includes(base);
-			}
-			await waitForWatched(files);
-			console.log("[debug] watcher is ready");
-		}
-	}
-}
-function parseServerOptions(serverOptions) {
-	var _serverOptions$deps, _serverOptions$deps2, _serverOptions$deps3, _serverOptions$deps4, _serverOptions$deps5, _serverOptions$deps6, _serverOptions$transf, _serverOptions$transf2;
-	const inlineOptions = ((_serverOptions$deps = serverOptions.deps) === null || _serverOptions$deps === void 0 ? void 0 : _serverOptions$deps.inline) === true ? true : toArray((_serverOptions$deps2 = serverOptions.deps) === null || _serverOptions$deps2 === void 0 ? void 0 : _serverOptions$deps2.inline);
-	return {
-		...serverOptions,
-		deps: {
-			...serverOptions.deps,
-			inlineFiles: toArray((_serverOptions$deps3 = serverOptions.deps) === null || _serverOptions$deps3 === void 0 ? void 0 : _serverOptions$deps3.inlineFiles),
-			inline: inlineOptions !== true ? inlineOptions.map((dep) => {
-				return dep.startsWith("/") && dep.endsWith("/") ? new RegExp(dep) : dep;
-			}) : true,
-			external: toArray((_serverOptions$deps4 = serverOptions.deps) === null || _serverOptions$deps4 === void 0 ? void 0 : _serverOptions$deps4.external).map((dep) => {
-				return dep.startsWith("/") && dep.endsWith("/") ? new RegExp(dep) : dep;
-			}),
-			moduleDirectories: ((_serverOptions$deps5 = serverOptions.deps) === null || _serverOptions$deps5 === void 0 ? void 0 : _serverOptions$deps5.moduleDirectories) ? toArray((_serverOptions$deps6 = serverOptions.deps) === null || _serverOptions$deps6 === void 0 ? void 0 : _serverOptions$deps6.moduleDirectories) : void 0
-		},
-		transformMode: {
-			...serverOptions.transformMode,
-			ssr: toArray((_serverOptions$transf = serverOptions.transformMode) === null || _serverOptions$transf === void 0 ? void 0 : _serverOptions$transf.ssr).map((dep) => new RegExp(dep)),
-			web: toArray((_serverOptions$transf2 = serverOptions.transformMode) === null || _serverOptions$transf2 === void 0 ? void 0 : _serverOptions$transf2.web).map((dep) => new RegExp(dep))
-		}
-	};
-}

package/dist/client.d.ts

@@ -1,2 +0,0 @@
-import './trace-mapping.d-BWFx6tPc.js';
-export { e as DEFAULT_REQUEST_STUBS, M as ModuleCacheMap, f as ModuleExecutionInfo, g as ModuleExecutionInfoEntry, a as ViteNodeRunner } from './index.d-D6Pqey3g.js';

package/dist/hmr.d.ts

@@ -1,55 +0,0 @@
-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.d-D6Pqey3g.js';
-import './trace-mapping.d-BWFx6tPc.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);
-}
-type HMREmitter = Emitter<{
-	message: HMRPayload;
-}> & EventEmitter;
-declare module "vite" {
-	interface ViteDevServer {
-		emitter: HMREmitter;
-	}
-}
-declare function createHmrEmitter(): HMREmitter;
-declare function viteNodeHmrPlugin(): Plugin;
-
-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;
-
-export { createHmrEmitter, createHotContext, getCache, handleMessage, reload, sendMessageBuffer, viteNodeHmrPlugin };
-export type { Emitter, EventType, HMREmitter, Handler, HotCallback, HotModule, InferCustomEventPayload, ModuleNamespace };

package/dist/hmr.js

@@ -1,10 +0,0 @@
-export { c as createHmrEmitter, a as createHotContext, g as getCache, h as handleMessage, r as reload, s as sendMessageBuffer, v as viteNodeHmrPlugin } from './chunk-hmr.js';
-import 'node:events';
-import 'node:process';
-import 'debug';
-import './chunk-index.js';
-import './utils.js';
-import 'node:fs';
-import 'node:module';
-import 'node:url';
-import 'pathe';

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

@@ -1,367 +0,0 @@
-import { E as EncodedSourceMap } from './trace-mapping.d-BWFx6tPc.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 */
-  firstInvalidatedBy?: string
-  /** @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 {
-  // client events
-  '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
-
-  // server events
-  'vite:client:connect': undefined
-  'vite:client:disconnect': undefined
-}
-
-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
-  firstInvalidatedBy: string
-}
-
-/**
- * provides types for payloads of built-in Vite events
- */
-type InferCustomEventPayload<T extends string> =
-  T extends keyof CustomEventMap ? CustomEventMap[T] : any
-
-/**
- * provides types for names of built-in Vite events
- */
-type CustomEventName = keyof CustomEventMap | (string & {})
-
-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 CustomEventName>(
-    event: T,
-    cb: (payload: InferCustomEventPayload<T>) => void,
-  ): void
-  off<T extends CustomEventName>(
-    event: T,
-    cb: (payload: InferCustomEventPayload<T>) => void,
-  ): void
-  send<T extends CustomEventName>(
-    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, 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>;
-	/**
-	* 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>;
-}
-
-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 { ModuleCacheMap as M, ViteNodeRunner as a, DEFAULT_REQUEST_STUBS as e };
-export type { Arrayable as A, CustomEventMap as C, DebuggerOptions as D, FetchResult as F, HMRPayload as H, Nullable as N, RawSourceMap as R, StartOfSourceMap as S, ViteNodeServerOptions as V, HotContext as b, DepsHandlingOptions as c, ViteNodeResolveId as d, ModuleExecutionInfo as f, ModuleExecutionInfoEntry as g, Awaitable as h, FetchFunction as i, ResolveIdFunction as j, CreateHotContextFunction as k, ModuleCache as l, ViteNodeRunnerOptions as m, ViteNodeResolveModule as n };

package/dist/index.d.ts

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

package/dist/index.js

@@ -1 +0,0 @@
-

package/dist/server.d.ts

@@ -1,58 +0,0 @@
-import { TransformResult, ViteDevServer } from 'vite';
-import { D as DebuggerOptions, c as DepsHandlingOptions, V as ViteNodeServerOptions, F as FetchResult, d as ViteNodeResolveId } from './index.d-D6Pqey3g.js';
-import { E as EncodedSourceMap } from './trace-mapping.d-BWFx6tPc.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>;
-}
-
-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;
-}
-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;
-}
-
-export { ViteNodeServer, guessCJSversion, shouldExternalize };