vite-node 5.2.0 → 6.0.0

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-<img src="https://github.com/antfu/vite-node/blob/main/assets/vite-node.svg?raw=true" height="120">
+<img src="https://raw.githubusercontent.com/antfu-collective/vite-node/refs/heads/main/assets/vite-node.svg" alt="vite-node logo" height="120">
 </p>
 
 <h1 align="center">
@@ -10,7 +10,7 @@ Vite as Node runtime.<br>The engine that powers <a href="https://github.com/nuxt
 
 <p>
 <p align="center">
-  <a href="https://www.npmjs.com/package/vite-node"><img src="https://img.shields.io/npm/v/vite-node?color=FCC72B&label="></a>
+  <a href="https://npmx.dev/package/vite-node"><img src="https://img.shields.io/npm/v/vite-node?color=FCC72B&label=" alt="vite-node"></a>
 <p>
 
 > [!NOTE]
@@ -188,7 +188,7 @@ Thanks [@brillout](https://github.com/brillout) for kindly sharing this package
 
 <p align="center">
   <a href="https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg">
-    <img src='https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg'/>
+    <img src='https://cdn.jsdelivr.net/gh/antfu/static/sponsors.svg' alt="Sponsors" />
   </a>
 </p>
 

package/dist/cli.d.mts

@@ -1,4 +1,4 @@
-import { b as ViteNodeServerOptions } from "./types-Dtew7m7O.mjs";
+import { _ as ViteNodeServerOptions } from "./types-Bl6mw_Ii.mjs";
 
 //#region src/cli.d.ts
 interface CliOptions {

package/dist/cli.mjs

@@ -1,19 +1,16 @@
 #!/usr/bin/env node
-import { t as C } from "./dist-B2ebky9O.mjs";
-import { t as ViteNodeServer } from "./server-BWywEVuB.mjs";
-import "./constants-DRkacFwN.mjs";
-import { h as toArray } from "./utils-ExLpYVUV.mjs";
-import { n as installSourcemapsSupport } from "./source-map-DQLD3K8K.mjs";
-import { r as ViteNodeRunner } from "./client-CyS7w_FB.mjs";
-import { r as handleMessage, s as viteNodeHmrPlugin, t as createHotContext } from "./hmr-qEG3qSgW.mjs";
+import { t as y } from "./dist-2eHC7DTD.mjs";
+import { t as ViteNodeServer } from "./server-Bdy4M7lM.mjs";
+import { toArray } from "./utils.mjs";
+import { n as installSourcemapsSupport } from "./source-map-BFKsz_pY.mjs";
+import { ViteNodeRunner } from "./client.mjs";
+import { createHotContext, handleMessage, viteNodeHmrPlugin } from "./hmr.mjs";
 import process from "node:process";
 import { createServer, loadEnv, version } from "vite";
 import { resolve } from "node:path";
 import cac from "cac";
-
 //#region package.json
-var version$1 = "5.2.0";
-
+var version$1 = "6.0.0";
 //#endregion
 //#region src/cli.ts
 const cli = cac("vite-node");
@@ -56,7 +53,7 @@ async function run(files, options = {}) {
 		process.exit(0);
 	}
 	if (!files.length) {
-		console.error(C.red("No files specified."));
+		console.error(y.red("No files specified."));
 		cli.version(version$1).outputHelp();
 		process.exit(1);
 	}
@@ -87,8 +84,8 @@ async function run(files, options = {}) {
 		resolveId(id, importer) {
 			return node.resolveId(id, importer);
 		},
-		createHotContext(runner$1, url) {
-			return createHotContext(runner$1, server.emitter, files, url);
+		createHotContext(runner, url) {
+			return createHotContext(runner, server.emitter, files, url);
 		}
 	});
 	await runner.executeId("/@vite/env");
@@ -99,12 +96,12 @@ async function run(files, options = {}) {
 	});
 	if (options.watch) {
 		process.on("uncaughtException", (err) => {
-			console.error(C.red("[vite-node] Failed to execute file: \n"), err);
+			console.error(y.red("[vite-node] Failed to execute file: \n"), err);
 		});
 		if (process.env.VITE_TEST_WATCHER_DEBUG) {
 			const nodePath = await import("node:path");
-			async function waitForWatched(files$1) {
-				while (!files$1.every((file) => isWatched(file))) await new Promise((resolve$1) => setTimeout(resolve$1, 20));
+			async function waitForWatched(files) {
+				while (!files.every((file) => isWatched(file))) await new Promise((resolve) => setTimeout(resolve, 20));
 			}
 			function isWatched(file) {
 				const watched = server.watcher.getWatched();
@@ -140,6 +137,5 @@ function parseServerOptions(serverOptions) {
 		}
 	};
 }
-
 //#endregion
-export {  };
+export {};

package/dist/client.d.mts

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

package/dist/client.mjs

@@ -1,5 +1,503 @@
-import "./utils-ExLpYVUV.mjs";
-import "./source-map-DQLD3K8K.mjs";
-import { n as ModuleCacheMap, r as ViteNodeRunner, t as DEFAULT_REQUEST_STUBS } from "./client-CyS7w_FB.mjs";
+import { cleanUrl, createImportMetaEnvProxy, isBareImport, isInternalRequest, isNodeBuiltin, isPrimitive, normalizeModuleId, normalizeRequestId, slash, toFilePath } from "./utils.mjs";
+import { a as originalPositionFor, i as TraceMap, t as extractSourceMap } from "./source-map-BFKsz_pY.mjs";
+import { createRequire } from "node:module";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createDebug } from "obug";
+import { dirname, resolve } from "node:path";
+import vm from "node:vm";
+//#region src/client.ts
+const { setTimeout, clearTimeout } = globalThis;
+const debugExecute = createDebug("vite-node:client:execute");
+const debugNative = createDebug("vite-node:client:native");
+const clientStub = {
+	injectQuery: (id) => id,
+	createHotContext: () => {
+		return {
+			accept: () => {},
+			prune: () => {},
+			dispose: () => {},
+			decline: () => {},
+			invalidate: () => {},
+			on: () => {},
+			send: () => {}
+		};
+	},
+	updateStyle: () => {},
+	removeStyle: () => {}
+};
+const env = createImportMetaEnvProxy();
+const DEFAULT_REQUEST_STUBS = {
+	"/@vite/client": clientStub,
+	"@vite/client": clientStub
+};
+var ModuleCacheMap = class extends Map {
+	normalizePath(fsPath) {
+		return normalizeModuleId(fsPath);
+	}
+	/**
+	* Assign partial data to the map
+	*/
+	update(fsPath, mod) {
+		fsPath = this.normalizePath(fsPath);
+		if (!super.has(fsPath)) this.setByModuleId(fsPath, mod);
+		else Object.assign(super.get(fsPath), mod);
+		return this;
+	}
+	setByModuleId(modulePath, mod) {
+		return super.set(modulePath, mod);
+	}
+	set(fsPath, mod) {
+		return this.setByModuleId(this.normalizePath(fsPath), mod);
+	}
+	getByModuleId(modulePath) {
+		if (!super.has(modulePath)) this.setByModuleId(modulePath, {});
+		const mod = super.get(modulePath);
+		if (!mod.imports) Object.assign(mod, {
+			imports: /* @__PURE__ */ new Set(),
+			importers: /* @__PURE__ */ new Set()
+		});
+		return mod;
+	}
+	get(fsPath) {
+		return this.getByModuleId(this.normalizePath(fsPath));
+	}
+	deleteByModuleId(modulePath) {
+		return super.delete(modulePath);
+	}
+	delete(fsPath) {
+		return this.deleteByModuleId(this.normalizePath(fsPath));
+	}
+	invalidateModule(mod) {
+		delete mod.evaluated;
+		delete mod.resolving;
+		delete mod.promise;
+		delete mod.exports;
+		mod.importers?.clear();
+		mod.imports?.clear();
+		return true;
+	}
+	/**
+	* Invalidate modules that dependent on the given modules, up to the main entry
+	*/
+	invalidateDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+		for (const _id of ids) {
+			const id = this.normalizePath(_id);
+			if (invalidated.has(id)) continue;
+			invalidated.add(id);
+			const mod = super.get(id);
+			if (mod?.importers) this.invalidateDepTree(mod.importers, invalidated);
+			super.delete(id);
+		}
+		return invalidated;
+	}
+	/**
+	* Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+	*/
+	invalidateSubDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+		for (const _id of ids) {
+			const id = this.normalizePath(_id);
+			if (invalidated.has(id)) continue;
+			invalidated.add(id);
+			const subIds = [...super.entries()].filter(([, mod]) => mod.importers?.has(id)).map(([key]) => key);
+			if (subIds.length) this.invalidateSubDepTree(subIds, invalidated);
+			super.delete(id);
+		}
+		return invalidated;
+	}
+	/**
+	* Return parsed source map based on inlined source map of the module
+	*/
+	getSourceMap(id) {
+		const cache = this.get(id);
+		if (cache.map) return cache.map;
+		const map = cache.code && extractSourceMap(cache.code);
+		if (map) {
+			cache.map = map;
+			return map;
+		}
+		return null;
+	}
+};
+var ViteNodeRunner = class {
+	root;
+	debug;
+	/**
+	* Holds the cache of modules
+	* Keys of the map are filepaths, or plain package names
+	*/
+	moduleCache;
+	/**
+	* 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.
+	*/
+	executionStack = [];
+	performanceNow = performance.now.bind(performance);
+	constructor(options) {
+		this.options = options;
+		this.root = options.root ?? process.cwd();
+		this.moduleCache = options.moduleCache ?? new ModuleCacheMap();
+		this.debug = options.debug ?? (typeof process !== "undefined" ? !!process.env.VITE_NODE_DEBUG_RUNNER : false);
+	}
+	async executeFile(file) {
+		const url = `/@fs/${slash(resolve(file))}`;
+		return await this.cachedRequest(url, url, []);
+	}
+	async executeId(rawId) {
+		const [id, url] = await this.resolveUrl(rawId);
+		return await this.cachedRequest(id, url, []);
+	}
+	/** @internal */
+	async cachedRequest(id, fsPath, callstack) {
+		const importee = callstack.at(-1);
+		const mod = this.moduleCache.get(fsPath);
+		const { imports, importers } = mod;
+		if (importee) importers.add(importee);
+		const getStack = () => `stack:\n${[...callstack, fsPath].reverse().map((p) => `  - ${p}`).join("\n")}`;
+		if (callstack.includes(fsPath) || [...imports.values()].some((i) => importers.has(i))) {
+			if (mod.exports) return mod.exports;
+		}
+		let debugTimer;
+		if (this.debug) debugTimer = setTimeout(() => console.warn(`[vite-node] module ${fsPath} takes over 2s to load.\n${getStack()}`), 2e3);
+		try {
+			if (mod.promise) return await mod.promise;
+			const promise = this.directRequest(id, fsPath, callstack);
+			Object.assign(mod, {
+				promise,
+				evaluated: false
+			});
+			return await promise;
+		} finally {
+			mod.evaluated = true;
+			if (debugTimer) clearTimeout(debugTimer);
+		}
+	}
+	shouldResolveId(id, _importee) {
+		return !isInternalRequest(id) && !isNodeBuiltin(id) && !id.startsWith("data:");
+	}
+	async _resolveUrl(id, importer) {
+		const dep = normalizeRequestId(id, this.options.base);
+		if (!this.shouldResolveId(dep)) return [dep, dep];
+		const { path, exists } = toFilePath(dep, this.root);
+		if (!this.options.resolveId || exists) return [dep, path];
+		const resolved = await this.options.resolveId(dep, importer);
+		if (resolved?.meta?.["vite:alias"]?.noResolved) {
+			const error = /* @__PURE__ */ new Error(`Cannot find module '${id}'${importer ? ` imported from '${importer}'` : ""}.
 
-export { DEFAULT_REQUEST_STUBS, ModuleCacheMap, ViteNodeRunner };
+- If you rely on tsconfig.json's "paths" to resolve modules, please install "vite-tsconfig-paths" plugin to handle module resolution.
+- Make sure you don't have relative aliases in your Vitest config. Use absolute paths instead. Read more: https://vitest.dev/guide/common-errors`);
+			Object.defineProperty(error, "code", {
+				value: "ERR_MODULE_NOT_FOUND",
+				enumerable: true
+			});
+			Object.defineProperty(error, Symbol.for("vitest.error.not_found.data"), {
+				value: {
+					id: dep,
+					importer
+				},
+				enumerable: false
+			});
+			throw error;
+		}
+		const resolvedId = resolved ? normalizeRequestId(resolved.id, this.options.base) : dep;
+		return [resolvedId, resolvedId];
+	}
+	async resolveUrl(id, importee) {
+		const resolveKey = `resolve:${id}`;
+		this.moduleCache.setByModuleId(resolveKey, { resolving: true });
+		try {
+			return await this._resolveUrl(id, importee);
+		} finally {
+			this.moduleCache.deleteByModuleId(resolveKey);
+		}
+	}
+	/** @internal */
+	async dependencyRequest(id, fsPath, callstack) {
+		return await this.cachedRequest(id, fsPath, callstack);
+	}
+	async _fetchModule(id, importer) {
+		try {
+			return await this.options.fetchModule(id);
+		} catch (cause) {
+			if (typeof cause === "object" && cause.code === "ERR_LOAD_URL" || typeof cause?.message === "string" && cause.message.includes("Failed to load url")) {
+				const error = new Error(`Cannot find ${isBareImport(id) ? "package" : "module"} '${id}'${importer ? ` imported from '${importer}'` : ""}`, { cause });
+				error.code = "ERR_MODULE_NOT_FOUND";
+				throw error;
+			}
+			throw cause;
+		}
+	}
+	/** @internal */
+	async directRequest(id, fsPath, _callstack) {
+		const moduleId = normalizeModuleId(fsPath);
+		const callstack = [..._callstack, moduleId];
+		const mod = this.moduleCache.getByModuleId(moduleId);
+		const request = async (dep) => {
+			const [id, depFsPath] = await this.resolveUrl(String(dep), fsPath);
+			this.moduleCache.getByModuleId(depFsPath).importers.add(moduleId);
+			mod.imports.add(depFsPath);
+			return this.dependencyRequest(id, depFsPath, callstack);
+		};
+		const requestStubs = this.options.requestStubs || DEFAULT_REQUEST_STUBS;
+		if (id in requestStubs) return requestStubs[id];
+		let { code: transformed, externalize } = await this._fetchModule(id, callstack[callstack.length - 2]);
+		if (externalize) {
+			debugNative(externalize);
+			const exports = await this.interopedImport(externalize);
+			mod.exports = exports;
+			return exports;
+		}
+		if (transformed == null) throw new Error(`[vite-node] Failed to load "${id}" imported from ${callstack[callstack.length - 2]}`);
+		const { Object, Reflect, Symbol } = this.getContextPrimitives();
+		const modulePath = cleanUrl(moduleId);
+		const href = pathToFileURL(modulePath).href;
+		const __filename = fileURLToPath(href);
+		const __dirname = dirname(__filename);
+		const meta = {
+			url: href,
+			env,
+			filename: __filename,
+			dirname: __dirname
+		};
+		const exports = Object.create(null);
+		Object.defineProperty(exports, Symbol.toStringTag, {
+			value: "Module",
+			enumerable: false,
+			configurable: false
+		});
+		const SYMBOL_NOT_DEFINED = Symbol("not defined");
+		let moduleExports = SYMBOL_NOT_DEFINED;
+		const cjsExports = new Proxy(exports, {
+			get: (target, p, receiver) => {
+				if (Reflect.has(target, p)) return Reflect.get(target, p, receiver);
+				return Reflect.get(Object.prototype, p, receiver);
+			},
+			getPrototypeOf: () => Object.prototype,
+			set: (_, p, value) => {
+				if (p === "default" && this.shouldInterop(modulePath, { default: value }) && cjsExports !== value) {
+					exportAll(cjsExports, value);
+					exports.default = value;
+					return true;
+				}
+				if (!Reflect.has(exports, "default")) exports.default = {};
+				if (moduleExports !== SYMBOL_NOT_DEFINED && isPrimitive(moduleExports)) {
+					defineExport(exports, p, () => void 0);
+					return true;
+				}
+				if (!isPrimitive(exports.default)) exports.default[p] = value;
+				if (p !== "default") defineExport(exports, p, () => value);
+				return true;
+			}
+		});
+		Object.assign(mod, {
+			code: transformed,
+			exports
+		});
+		const moduleProxy = {
+			set exports(value) {
+				exportAll(cjsExports, value);
+				exports.default = value;
+				moduleExports = value;
+			},
+			get exports() {
+				return cjsExports;
+			}
+		};
+		let hotContext;
+		if (this.options.createHotContext) Object.defineProperty(meta, "hot", {
+			enumerable: true,
+			get: () => {
+				hotContext ||= this.options.createHotContext?.(this, moduleId);
+				return hotContext;
+			},
+			set: (value) => {
+				hotContext = value;
+			}
+		});
+		const context = this.prepareContext({
+			__vite_ssr_import__: request,
+			__vite_ssr_dynamic_import__: request,
+			__vite_ssr_exports__: exports,
+			__vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
+			__vite_ssr_exportName__: (name, getter) => Object.defineProperty(exports, name, {
+				enumerable: true,
+				configurable: true,
+				get: getter
+			}),
+			__vite_ssr_import_meta__: meta,
+			require: createRequire(href),
+			exports: cjsExports,
+			module: moduleProxy,
+			__filename,
+			__dirname
+		});
+		debugExecute(__filename);
+		if (transformed[0] === "#") transformed = transformed.replace(/^#!.*/, (s) => " ".repeat(s.length));
+		await this.runModule(context, transformed);
+		return exports;
+	}
+	getContextPrimitives() {
+		return {
+			Object,
+			Reflect,
+			Symbol
+		};
+	}
+	async runModule(context, transformed) {
+		const codeDefinition = `'use strict';async (${Object.keys(context).join(",")})=>{{`;
+		const code = `${codeDefinition}${transformed}\n}}`;
+		const options = {
+			filename: context.__filename,
+			lineOffset: 0,
+			columnOffset: -codeDefinition.length
+		};
+		const finishModuleExecutionInfo = this.startCalculateModuleExecutionInfo(options.filename, codeDefinition.length);
+		try {
+			await vm.runInThisContext(code, options)(...Object.values(context));
+		} finally {
+			this.options.moduleExecutionInfo?.set(options.filename, finishModuleExecutionInfo());
+		}
+	}
+	/**
+	* mutate the given error to have fixed stacktraces based on source maps
+	* Does the same thing as Vite's ssrFixStacktrace
+	*/
+	async ssrFixStacktrace(error) {
+		const stack = (error.stack || "").split("\n");
+		const rewrittenStack = [];
+		for (const line of stack) {
+			const match = line.match(/\((.*):(\d+):(\d+)\)$/);
+			if (match) {
+				const [, file, lineStr, columnStr] = match;
+				const lineNum = Number(lineStr);
+				const columnNum = Number(columnStr);
+				const sourceMap = this.moduleCache.getSourceMap(file);
+				if (sourceMap) {
+					const originalPos = originalPositionFor(new TraceMap(sourceMap), {
+						line: lineNum,
+						column: columnNum
+					});
+					if (originalPos.source) {
+						const rewrittenLine = line.replace(/\(.*:\d+:\d+\)$/, `(${file}:${originalPos.line || lineNum}:${originalPos.column || columnNum})`);
+						rewrittenStack.push(rewrittenLine);
+						continue;
+					}
+				}
+			}
+			rewrittenStack.push(line);
+		}
+		error.stack = rewrittenStack.join("\n") || error.stack;
+		return 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.
+	*/
+	startCalculateModuleExecutionInfo(filename, startOffset) {
+		const startTime = this.performanceNow();
+		this.executionStack.push({
+			filename,
+			startTime,
+			subImportTime: 0
+		});
+		return () => {
+			const duration = this.performanceNow() - startTime;
+			const currentExecution = this.executionStack.pop();
+			if (currentExecution == null) throw new Error("Execution stack is empty, this should never happen");
+			const selfTime = duration - currentExecution.subImportTime;
+			if (this.executionStack.length > 0) this.executionStack.at(-1).subImportTime += duration;
+			return {
+				startOffset,
+				duration,
+				selfTime
+			};
+		};
+	}
+	prepareContext(context) {
+		return context;
+	}
+	/**
+	* Define if a module should be interop-ed
+	* This function mostly for the ability to override by subclass
+	*/
+	shouldInterop(path, mod) {
+		if (this.options.interopDefault === false) return false;
+		return !path.endsWith(".mjs") && "default" in mod;
+	}
+	importExternalModule(path) {
+		return import(
+			/* @vite-ignore */
+			path
+);
+	}
+	/**
+	* Import a module and interop it
+	*/
+	async interopedImport(path) {
+		const importedModule = await this.importExternalModule(path);
+		if (!this.shouldInterop(path, importedModule)) return importedModule;
+		const { mod, defaultExport } = interopModule(importedModule);
+		return new Proxy(mod, {
+			get(mod, prop) {
+				if (prop === "default") return defaultExport;
+				return mod[prop] ?? defaultExport?.[prop];
+			},
+			has(mod, prop) {
+				if (prop === "default") return defaultExport !== void 0;
+				return prop in mod || defaultExport && prop in defaultExport;
+			},
+			getOwnPropertyDescriptor(mod, prop) {
+				const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
+				if (descriptor) return descriptor;
+				if (prop === "default" && defaultExport !== void 0) return {
+					value: defaultExport,
+					enumerable: true,
+					configurable: true
+				};
+			}
+		});
+	}
+};
+function interopModule(mod) {
+	if (isPrimitive(mod)) return {
+		mod: { default: mod },
+		defaultExport: mod
+	};
+	let defaultExport = "default" in mod ? mod.default : mod;
+	if (!isPrimitive(defaultExport) && "__esModule" in defaultExport) {
+		mod = defaultExport;
+		if ("default" in defaultExport) defaultExport = defaultExport.default;
+	}
+	return {
+		mod,
+		defaultExport
+	};
+}
+function defineExport(exports, key, value) {
+	Object.defineProperty(exports, key, {
+		enumerable: true,
+		configurable: true,
+		get: value
+	});
+}
+function exportAll(exports, sourceModule) {
+	if (exports === sourceModule) return;
+	if (isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise) return;
+	for (const key in sourceModule) if (key !== "default" && !(key in exports)) try {
+		defineExport(exports, key, () => sourceModule[key]);
+	} catch {}
+}
+//#endregion
+export { DEFAULT_REQUEST_STUBS, ModuleCacheMap, ViteNodeRunner };

package/dist/constants.mjs

@@ -1,3 +1,33 @@
-import { n as KNOWN_ASSET_RE, r as KNOWN_ASSET_TYPES, t as CSS_LANGS_RE } from "./constants-DRkacFwN.mjs";
-
-export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES };
+//#region src/constants.ts
+const KNOWN_ASSET_TYPES = [
+	"apng",
+	"bmp",
+	"png",
+	"jpe?g",
+	"jfif",
+	"pjpeg",
+	"pjp",
+	"gif",
+	"svg",
+	"ico",
+	"webp",
+	"avif",
+	"mp4",
+	"webm",
+	"ogg",
+	"mp3",
+	"wav",
+	"flac",
+	"aac",
+	"woff2?",
+	"eot",
+	"ttf",
+	"otf",
+	"webmanifest",
+	"pdf",
+	"txt"
+];
+const KNOWN_ASSET_RE = new RegExp(`\\.(${KNOWN_ASSET_TYPES.join("|")})$`);
+const CSS_LANGS_RE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+//#endregion
+export { CSS_LANGS_RE, KNOWN_ASSET_RE, KNOWN_ASSET_TYPES };