nitro-nightly 3.0.1-20260106-182834-5019d347 → 3.0.1-20260106-205209-b085a480

package/dist/_libs/webpack-virtual-modules.mjs

@@ -1,272 +0,0 @@
-import { r as __require, t as __commonJSMin } from "../_rolldown.mjs";
-
-//#region node_modules/.pnpm/webpack-virtual-modules@0.6.2/node_modules/webpack-virtual-modules/lib/virtual-stats.js
-var require_virtual_stats = /* @__PURE__ */ __commonJSMin(((exports) => {
-	var __importDefault = exports && exports.__importDefault || function(mod) {
-		return mod && mod.__esModule ? mod : { "default": mod };
-	};
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.VirtualStats = void 0;
-	const constants_1 = __importDefault(__require("constants"));
-	var VirtualStats = class {
-		constructor(config) {
-			for (const key in config) {
-				if (!Object.prototype.hasOwnProperty.call(config, key)) continue;
-				this[key] = config[key];
-			}
-		}
-		_checkModeProperty(property) {
-			return (this.mode & constants_1.default.S_IFMT) === property;
-		}
-		isDirectory() {
-			return this._checkModeProperty(constants_1.default.S_IFDIR);
-		}
-		isFile() {
-			return this._checkModeProperty(constants_1.default.S_IFREG);
-		}
-		isBlockDevice() {
-			return this._checkModeProperty(constants_1.default.S_IFBLK);
-		}
-		isCharacterDevice() {
-			return this._checkModeProperty(constants_1.default.S_IFCHR);
-		}
-		isSymbolicLink() {
-			return this._checkModeProperty(constants_1.default.S_IFLNK);
-		}
-		isFIFO() {
-			return this._checkModeProperty(constants_1.default.S_IFIFO);
-		}
-		isSocket() {
-			return this._checkModeProperty(constants_1.default.S_IFSOCK);
-		}
-	};
-	exports.VirtualStats = VirtualStats;
-}));
-
-//#endregion
-//#region node_modules/.pnpm/webpack-virtual-modules@0.6.2/node_modules/webpack-virtual-modules/lib/index.js
-var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	const path_1 = (exports && exports.__importDefault || function(mod) {
-		return mod && mod.__esModule ? mod : { "default": mod };
-	})(__require("path"));
-	const virtual_stats_1 = require_virtual_stats();
-	let inode = 45e6;
-	const ALL = "all";
-	const STATIC = "static";
-	const DYNAMIC = "dynamic";
-	function checkActivation(instance) {
-		if (!instance._compiler) throw new Error("You must use this plugin only after creating webpack instance!");
-	}
-	function getModulePath(filePath, compiler) {
-		return path_1.default.isAbsolute(filePath) ? filePath : path_1.default.join(compiler.context, filePath);
-	}
-	function createWebpackData(result) {
-		return (backendOrStorage) => {
-			if (backendOrStorage._data) {
-				const curLevelIdx = backendOrStorage._currentLevel;
-				return {
-					result,
-					level: backendOrStorage._levels[curLevelIdx]
-				};
-			}
-			return [null, result];
-		};
-	}
-	function getData(storage, key) {
-		if (storage._data instanceof Map) return storage._data.get(key);
-		else if (storage._data) return storage.data[key];
-		else if (storage.data instanceof Map) return storage.data.get(key);
-		else return storage.data[key];
-	}
-	function setData(backendOrStorage, key, valueFactory) {
-		const value = valueFactory(backendOrStorage);
-		if (backendOrStorage._data instanceof Map) backendOrStorage._data.set(key, value);
-		else if (backendOrStorage._data) backendOrStorage.data[key] = value;
-		else if (backendOrStorage.data instanceof Map) backendOrStorage.data.set(key, value);
-		else backendOrStorage.data[key] = value;
-	}
-	function getStatStorage(fileSystem) {
-		if (fileSystem._statStorage) return fileSystem._statStorage;
-		else if (fileSystem._statBackend) return fileSystem._statBackend;
-		else throw new Error("Couldn't find a stat storage");
-	}
-	function getFileStorage(fileSystem) {
-		if (fileSystem._readFileStorage) return fileSystem._readFileStorage;
-		else if (fileSystem._readFileBackend) return fileSystem._readFileBackend;
-		else throw new Error("Couldn't find a readFileStorage");
-	}
-	function getReadDirBackend(fileSystem) {
-		if (fileSystem._readdirBackend) return fileSystem._readdirBackend;
-		else if (fileSystem._readdirStorage) return fileSystem._readdirStorage;
-		else throw new Error("Couldn't find a readDirStorage from Webpack Internals");
-	}
-	function getRealpathBackend(fileSystem) {
-		if (fileSystem._realpathBackend) return fileSystem._realpathBackend;
-	}
-	var VirtualModulesPlugin = class {
-		constructor(modules) {
-			this._compiler = null;
-			this._watcher = null;
-			this._staticModules = modules || null;
-		}
-		getModuleList(filter = ALL) {
-			var _a, _b;
-			let modules = {};
-			const shouldGetStaticModules = filter === ALL || filter === STATIC;
-			const shouldGetDynamicModules = filter === ALL || filter === DYNAMIC;
-			if (shouldGetStaticModules) modules = Object.assign(Object.assign({}, modules), this._staticModules);
-			if (shouldGetDynamicModules) {
-				const finalInputFileSystem = (_a = this._compiler) === null || _a === void 0 ? void 0 : _a.inputFileSystem;
-				const virtualFiles = (_b = finalInputFileSystem === null || finalInputFileSystem === void 0 ? void 0 : finalInputFileSystem._virtualFiles) !== null && _b !== void 0 ? _b : {};
-				const dynamicModules = {};
-				Object.keys(virtualFiles).forEach((key) => {
-					dynamicModules[key] = virtualFiles[key].contents;
-				});
-				modules = Object.assign(Object.assign({}, modules), dynamicModules);
-			}
-			return modules;
-		}
-		writeModule(filePath, contents) {
-			if (!this._compiler) throw new Error(`Plugin has not been initialized`);
-			checkActivation(this);
-			const len = contents ? contents.length : 0;
-			const time = Date.now();
-			const date = new Date(time);
-			const stats = new virtual_stats_1.VirtualStats({
-				dev: 8675309,
-				nlink: 0,
-				uid: 1e3,
-				gid: 1e3,
-				rdev: 0,
-				blksize: 4096,
-				ino: inode++,
-				mode: 33188,
-				size: len,
-				blocks: Math.floor(len / 4096),
-				atime: date,
-				mtime: date,
-				ctime: date,
-				birthtime: date
-			});
-			const modulePath = getModulePath(filePath, this._compiler);
-			if (process.env.WVM_DEBUG) console.log(this._compiler.name, "Write virtual module:", modulePath, contents);
-			let finalWatchFileSystem = this._watcher && this._watcher.watchFileSystem;
-			while (finalWatchFileSystem && finalWatchFileSystem.wfs) finalWatchFileSystem = finalWatchFileSystem.wfs;
-			let finalInputFileSystem = this._compiler.inputFileSystem;
-			while (finalInputFileSystem && finalInputFileSystem._inputFileSystem) finalInputFileSystem = finalInputFileSystem._inputFileSystem;
-			finalInputFileSystem._writeVirtualFile(modulePath, stats, contents);
-			if (finalWatchFileSystem && finalWatchFileSystem.watcher && (finalWatchFileSystem.watcher.fileWatchers.size || finalWatchFileSystem.watcher.fileWatchers.length)) {
-				const fileWatchers = finalWatchFileSystem.watcher.fileWatchers instanceof Map ? Array.from(finalWatchFileSystem.watcher.fileWatchers.values()) : finalWatchFileSystem.watcher.fileWatchers;
-				for (let fileWatcher of fileWatchers) {
-					if ("watcher" in fileWatcher) fileWatcher = fileWatcher.watcher;
-					if (fileWatcher.path === modulePath) {
-						if (process.env.DEBUG) console.log(this._compiler.name, "Emit file change:", modulePath, time);
-						delete fileWatcher.directoryWatcher._cachedTimeInfoEntries;
-						fileWatcher.emit("change", time, null);
-					}
-				}
-			}
-		}
-		apply(compiler) {
-			this._compiler = compiler;
-			const afterEnvironmentHook = () => {
-				let finalInputFileSystem = compiler.inputFileSystem;
-				while (finalInputFileSystem && finalInputFileSystem._inputFileSystem) finalInputFileSystem = finalInputFileSystem._inputFileSystem;
-				if (!finalInputFileSystem._writeVirtualFile) {
-					const originalPurge = finalInputFileSystem.purge;
-					finalInputFileSystem.purge = () => {
-						originalPurge.apply(finalInputFileSystem, []);
-						if (finalInputFileSystem._virtualFiles) Object.keys(finalInputFileSystem._virtualFiles).forEach((file) => {
-							const data = finalInputFileSystem._virtualFiles[file];
-							finalInputFileSystem._writeVirtualFile(file, data.stats, data.contents);
-						});
-					};
-					finalInputFileSystem._writeVirtualFile = (file, stats, contents) => {
-						const statStorage = getStatStorage(finalInputFileSystem);
-						const fileStorage = getFileStorage(finalInputFileSystem);
-						const readDirStorage = getReadDirBackend(finalInputFileSystem);
-						const realPathStorage = getRealpathBackend(finalInputFileSystem);
-						finalInputFileSystem._virtualFiles = finalInputFileSystem._virtualFiles || {};
-						finalInputFileSystem._virtualFiles[file] = {
-							stats,
-							contents
-						};
-						setData(statStorage, file, createWebpackData(stats));
-						setData(fileStorage, file, createWebpackData(contents));
-						const segments = file.split(/[\\/]/);
-						let count = segments.length - 1;
-						const minCount = segments[0] ? 1 : 0;
-						while (count > minCount) {
-							const dir = segments.slice(0, count).join(path_1.default.sep) || path_1.default.sep;
-							try {
-								finalInputFileSystem.readdirSync(dir);
-							} catch (e) {
-								const time = Date.now();
-								const dirStats = new virtual_stats_1.VirtualStats({
-									dev: 8675309,
-									nlink: 0,
-									uid: 1e3,
-									gid: 1e3,
-									rdev: 0,
-									blksize: 4096,
-									ino: inode++,
-									mode: 16877,
-									size: stats.size,
-									blocks: Math.floor(stats.size / 4096),
-									atime: time,
-									mtime: time,
-									ctime: time,
-									birthtime: time
-								});
-								setData(readDirStorage, dir, createWebpackData([]));
-								if (realPathStorage) setData(realPathStorage, dir, createWebpackData(dir));
-								setData(statStorage, dir, createWebpackData(dirStats));
-							}
-							let dirData = getData(getReadDirBackend(finalInputFileSystem), dir);
-							dirData = dirData[1] || dirData.result;
-							const filename = segments[count];
-							if (dirData.indexOf(filename) < 0) {
-								const files = dirData.concat([filename]).sort();
-								setData(getReadDirBackend(finalInputFileSystem), dir, createWebpackData(files));
-							} else break;
-							count--;
-						}
-					};
-				}
-			};
-			const afterResolversHook = () => {
-				if (this._staticModules) {
-					for (const [filePath, contents] of Object.entries(this._staticModules)) this.writeModule(filePath, contents);
-					this._staticModules = null;
-				}
-			};
-			const version = typeof compiler.webpack === "undefined" ? 4 : 5;
-			const watchRunHook = (watcher, callback) => {
-				this._watcher = watcher.compiler || watcher;
-				const virtualFiles = compiler.inputFileSystem._virtualFiles;
-				const fts = compiler.fileTimestamps;
-				if (virtualFiles && fts && typeof fts.set === "function") Object.keys(virtualFiles).forEach((file) => {
-					const mtime = +virtualFiles[file].stats.mtime;
-					fts.set(file, version === 4 ? mtime : {
-						safeTime: mtime,
-						timestamp: mtime
-					});
-				});
-				callback();
-			};
-			if (compiler.hooks) {
-				compiler.hooks.afterEnvironment.tap("VirtualModulesPlugin", afterEnvironmentHook);
-				compiler.hooks.afterResolvers.tap("VirtualModulesPlugin", afterResolversHook);
-				compiler.hooks.watchRun.tapAsync("VirtualModulesPlugin", watchRunHook);
-			} else {
-				compiler.plugin("after-environment", afterEnvironmentHook);
-				compiler.plugin("after-resolvers", afterResolversHook);
-				compiler.plugin("watch-run", watchRunHook);
-			}
-		}
-	};
-	module.exports = VirtualModulesPlugin;
-}));
-
-//#endregion
-export { require_lib as t };

package/dist/_nitro2.mjs

@@ -1,303 +0,0 @@
-import { a as isAbsolute, l as relative, o as join, r as dirname, t as resolveAlias, u as resolve } from "./_libs/pathe.mjs";
-import { t as resolveModulePath } from "./_libs/exsolve.mjs";
-import { i as writeFile, r as resolveNitroPath, t as isDirectory } from "./_build/shared2.mjs";
-import { t as glob } from "./_libs/tinyglobby.mjs";
-import { a as lookupNodeModuleSubpath, o as parseNodeModulePath } from "./_libs/mlly.mjs";
-import { n as resolveSchema, t as generateTypes } from "./_libs/untyped.mjs";
-import { M as toExports } from "./_libs/unimport.mjs";
-import { existsSync, promises } from "node:fs";
-import { defu } from "defu";
-import { withBase, withLeadingSlash, withoutTrailingSlash } from "ufo";
-import { runtimeDir } from "nitro/meta";
-
-//#region src/scan.ts
-const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
-const suffixRegex = /(\.(?<method>connect|delete|get|head|options|patch|post|put|trace))?(\.(?<env>dev|prod|prerender))?$/;
-async function scanAndSyncOptions(nitro) {
-	const scannedPlugins = await scanPlugins(nitro);
-	for (const plugin of scannedPlugins) if (!nitro.options.plugins.includes(plugin)) nitro.options.plugins.push(plugin);
-	if (nitro.options.experimental.tasks) {
-		const scannedTasks = await scanTasks(nitro);
-		for (const scannedTask of scannedTasks) if (scannedTask.name in nitro.options.tasks) {
-			if (!nitro.options.tasks[scannedTask.name].handler) nitro.options.tasks[scannedTask.name].handler = scannedTask.handler;
-		} else nitro.options.tasks[scannedTask.name] = {
-			handler: scannedTask.handler,
-			description: ""
-		};
-	}
-	const scannedModules = await scanModules(nitro);
-	nitro.options.modules = nitro.options.modules || [];
-	for (const modPath of scannedModules) if (!nitro.options.modules.includes(modPath)) nitro.options.modules.push(modPath);
-}
-async function scanHandlers(nitro) {
-	const middleware = await scanMiddleware(nitro);
-	const handlers = await Promise.all([scanServerRoutes(nitro, nitro.options.apiDir || "api", nitro.options.apiBaseURL || "/api"), scanServerRoutes(nitro, nitro.options.routesDir || "routes")]).then((r) => r.flat());
-	nitro.scannedHandlers = [...middleware, ...handlers.filter((h, index, array) => {
-		return array.findIndex((h2) => h.route === h2.route && h.method === h2.method && h.env === h2.env) === index;
-	})];
-	return handlers;
-}
-async function scanMiddleware(nitro) {
-	return (await scanFiles(nitro, "middleware")).map((file) => {
-		return {
-			route: "/**",
-			middleware: true,
-			handler: file.fullPath
-		};
-	});
-}
-async function scanServerRoutes(nitro, dir, prefix = "/") {
-	return (await scanFiles(nitro, dir)).map((file) => {
-		let route = file.path.replace(/\.[A-Za-z]+$/, "").replace(/\(([^(/\\]+)\)[/\\]/g, "").replace(/\[\.{3}]/g, "**").replace(/\[\.{3}(\w+)]/g, "**:$1").replace(/\[([^/\]]+)]/g, ":$1");
-		route = withLeadingSlash(withoutTrailingSlash(withBase(route, prefix)));
-		const suffixMatch = route.match(suffixRegex);
-		let method;
-		let env;
-		if (suffixMatch?.index && suffixMatch?.index >= 0) {
-			route = route.slice(0, suffixMatch.index);
-			method = suffixMatch.groups?.method;
-			env = suffixMatch.groups?.env;
-		}
-		route = route.replace(/\/index$/, "") || "/";
-		return {
-			handler: file.fullPath,
-			lazy: true,
-			middleware: false,
-			route,
-			method,
-			env
-		};
-	});
-}
-async function scanPlugins(nitro) {
-	return (await scanFiles(nitro, "plugins")).map((f) => f.fullPath);
-}
-async function scanTasks(nitro) {
-	return (await scanFiles(nitro, "tasks")).map((f) => {
-		return {
-			name: f.path.replace(/\/index$/, "").replace(/\.[A-Za-z]+$/, "").replace(/\//g, ":"),
-			handler: f.fullPath
-		};
-	});
-}
-async function scanModules(nitro) {
-	return (await scanFiles(nitro, "modules")).map((f) => f.fullPath);
-}
-async function scanFiles(nitro, name) {
-	return await Promise.all(nitro.options.scanDirs.map((dir) => scanDir(nitro, dir, name))).then((r) => r.flat());
-}
-async function scanDir(nitro, dir, name) {
-	return (await glob(join(name, GLOB_SCAN_PATTERN), {
-		cwd: dir,
-		dot: true,
-		ignore: nitro.options.ignore,
-		absolute: true
-	}).catch((error) => {
-		if (error?.code === "ENOTDIR") {
-			nitro.logger.warn(`Ignoring \`${join(dir, name)}\`. It must be a directory.`);
-			return [];
-		}
-		throw error;
-	})).map((fullPath) => {
-		return {
-			fullPath,
-			path: relative(join(dir, name), fullPath)
-		};
-	}).sort((a, b) => a.path.localeCompare(b.path));
-}
-
-//#endregion
-//#region src/build/types.ts
-async function writeTypes(nitro) {
-	const types = { routes: {} };
-	const generatedTypesDir = resolve(nitro.options.rootDir, nitro.options.typescript.generatedTypesDir || "node_modules/.nitro/types");
-	const middleware = [...nitro.scannedHandlers, ...nitro.options.handlers];
-	for (const mw of middleware) {
-		if (typeof mw.handler !== "string" || !mw.route) continue;
-		const relativePath = relative(generatedTypesDir, resolveNitroPath(mw.handler, nitro.options)).replace(/\.(js|mjs|cjs|ts|mts|cts|tsx|jsx)$/, "");
-		const method = mw.method || "default";
-		types.routes[mw.route] ??= {};
-		types.routes[mw.route][method] ??= [];
-		types.routes[mw.route][method].push(`Simplify<Serialize<Awaited<ReturnType<typeof import('${relativePath}').default>>>>`);
-	}
-	let autoImportedTypes = [];
-	let autoImportExports = "";
-	if (nitro.unimport) {
-		await nitro.unimport.init();
-		const allImports = await nitro.unimport.getImports();
-		autoImportExports = toExports(allImports).replace(/#internal\/nitro/g, relative(generatedTypesDir, runtimeDir));
-		const resolvedImportPathMap = /* @__PURE__ */ new Map();
-		for (const i of allImports) {
-			const from = i.typeFrom || i.from;
-			if (resolvedImportPathMap.has(from)) continue;
-			let path = resolveAlias(from, nitro.options.alias);
-			if (!isAbsolute(path)) {
-				const resolvedPath = resolveModulePath(from, {
-					try: true,
-					from: nitro.options.rootDir,
-					conditions: [
-						"type",
-						"node",
-						"import"
-					],
-					suffixes: ["", "/index"],
-					extensions: [
-						".mjs",
-						".cjs",
-						".js",
-						".mts",
-						".cts",
-						".ts"
-					]
-				});
-				if (resolvedPath) {
-					const { dir, name } = parseNodeModulePath(resolvedPath);
-					if (!dir || !name) path = resolvedPath;
-					else path = join(dir, name, await lookupNodeModuleSubpath(resolvedPath) || "");
-				}
-			}
-			if (existsSync(path) && !await isDirectory(path)) path = path.replace(/\.[a-z]+$/, "");
-			if (isAbsolute(path)) path = relative(generatedTypesDir, path);
-			resolvedImportPathMap.set(from, path);
-		}
-		autoImportedTypes = [nitro.options.imports && nitro.options.imports.autoImport !== false ? (await nitro.unimport.generateTypeDeclarations({
-			exportHelper: false,
-			resolvePath: (i) => {
-				const from = i.typeFrom || i.from;
-				return resolvedImportPathMap.get(from) ?? from;
-			}
-		})).trim() : ""];
-	}
-	const generateRoutes = () => [
-		"// Generated by nitro",
-		"import type { Serialize, Simplify } from \"nitro/types\";",
-		"declare module \"nitro/types\" {",
-		"  type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T",
-		"  interface InternalApi {",
-		...Object.entries(types.routes).map(([path, methods]) => [
-			`    '${path}': {`,
-			...Object.entries(methods).map(([method, types$1]) => `      '${method}': ${types$1.join(" | ")}`),
-			"    }"
-		].join("\n")),
-		"  }",
-		"}",
-		"export {}"
-	];
-	const config = [
-		"// Generated by nitro",
-		`declare module "nitro/types" {`,
-		nitro.options.typescript.generateRuntimeConfigTypes ? generateTypes(await resolveSchema(Object.fromEntries(Object.entries(nitro.options.runtimeConfig).filter(([key]) => !["app", "nitro"].includes(key)))), {
-			interfaceName: "NitroRuntimeConfig",
-			addExport: false,
-			addDefaults: false,
-			allowExtraKeys: false,
-			indentation: 2
-		}) : "",
-		`}`,
-		"export {}"
-	];
-	const declarations = [
-		"/// <reference path=\"./nitro-routes.d.ts\" />",
-		"/// <reference path=\"./nitro-config.d.ts\" />",
-		"/// <reference path=\"./nitro-imports.d.ts\" />"
-	];
-	const buildFiles = [];
-	buildFiles.push({
-		path: join(generatedTypesDir, "nitro-routes.d.ts"),
-		contents: () => generateRoutes().join("\n")
-	});
-	buildFiles.push({
-		path: join(generatedTypesDir, "nitro-config.d.ts"),
-		contents: config.join("\n")
-	});
-	buildFiles.push({
-		path: join(generatedTypesDir, "nitro-imports.d.ts"),
-		contents: [...autoImportedTypes, autoImportExports || "export {}"].join("\n")
-	});
-	buildFiles.push({
-		path: join(generatedTypesDir, "nitro.d.ts"),
-		contents: declarations.join("\n")
-	});
-	if (nitro.options.typescript.generateTsConfig) {
-		const tsConfigPath = resolve(generatedTypesDir, nitro.options.typescript.tsconfigPath || "tsconfig.json");
-		const tsconfigDir = dirname(tsConfigPath);
-		const tsConfig = defu(nitro.options.typescript.tsConfig, {
-			compilerOptions: {
-				esModuleInterop: true,
-				allowSyntheticDefaultImports: true,
-				skipLibCheck: true,
-				target: "ESNext",
-				allowJs: true,
-				resolveJsonModule: true,
-				moduleDetection: "force",
-				isolatedModules: true,
-				verbatimModuleSyntax: true,
-				allowImportingTsExtensions: true,
-				strict: nitro.options.typescript.strict,
-				noUncheckedIndexedAccess: true,
-				noImplicitOverride: true,
-				forceConsistentCasingInFileNames: true,
-				module: "Preserve",
-				jsx: "preserve",
-				jsxFactory: "h",
-				jsxFragmentFactory: "Fragment",
-				paths: { "#imports": [relativeWithDot(tsconfigDir, join(generatedTypesDir, "nitro-imports"))] }
-			},
-			include: [
-				relativeWithDot(tsconfigDir, join(generatedTypesDir, "nitro.d.ts")).replace(/^(?=[^.])/, "./"),
-				join(relativeWithDot(tsconfigDir, nitro.options.rootDir), "**/*"),
-				...!nitro.options.serverDir || nitro.options.serverDir === nitro.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, nitro.options.serverDir), "**/*")]
-			]
-		});
-		for (const alias in tsConfig.compilerOptions.paths) {
-			const paths = await Promise.all(tsConfig.compilerOptions.paths[alias].map(async (path) => {
-				if (!isAbsolute(path)) return path;
-				return relativeWithDot(tsconfigDir, (await promises.stat(path).catch(() => null))?.isFile() ? path.replace(/(?<=\w)\.\w+$/g, "") : path);
-			}));
-			tsConfig.compilerOptions.paths[alias] = [...new Set(paths)];
-		}
-		tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
-		if (tsConfig.exclude) tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(tsconfigDir, p) : p))];
-		types.tsConfig = tsConfig;
-		buildFiles.push({
-			path: tsConfigPath,
-			contents: () => JSON.stringify(tsConfig, null, 2)
-		});
-	}
-	await nitro.hooks.callHook("types:extend", types);
-	await Promise.all(buildFiles.map(async (file) => {
-		await writeFile(resolve(generatedTypesDir, file.path), typeof file.contents === "string" ? file.contents : file.contents());
-	}));
-}
-const RELATIVE_RE = /^\.{1,2}\//;
-function relativeWithDot(from, to) {
-	const rel = relative(from, to);
-	return RELATIVE_RE.test(rel) ? rel : "./" + rel;
-}
-
-//#endregion
-//#region src/utils/parallel.ts
-async function runParallel(inputs, cb, opts) {
-	const tasks = /* @__PURE__ */ new Set();
-	function queueNext() {
-		const route = inputs.values().next().value;
-		if (!route) return;
-		inputs.delete(route);
-		const task = (opts.interval ? new Promise((resolve$1) => setTimeout(resolve$1, opts.interval)) : Promise.resolve()).then(() => cb(route)).catch((error) => {
-			console.error(error);
-		});
-		tasks.add(task);
-		return task.then(() => {
-			tasks.delete(task);
-			if (inputs.size > 0) return refillQueue();
-		});
-	}
-	function refillQueue() {
-		const workers = Math.min(opts.concurrency - tasks.size, inputs.size);
-		return Promise.all(Array.from({ length: workers }, () => queueNext()));
-	}
-	await refillQueue();
-}
-
-//#endregion
-export { scanHandlers as i, writeTypes as n, scanAndSyncOptions as r, runParallel as t };