nitro-nightly 3.0.1-20260120-020848-6786d069 → 3.0.1-20260120-133849-ca1a9dee

package/dist/_chunks/nitro5.mjs

@@ -1,733 +0,0 @@
-import { a as join, i as isAbsolute, l as relative, n as dirname, s as normalizeWindowsPath, u as resolve } from "../_libs/pathe.mjs";
-import { l as resolveModulePath } from "../_libs/confbox+exsolve+pkg-types.mjs";
-import { i as writeFile, r as resolveNitroPath, t as isDirectory } from "./nitro4.mjs";
-import { t as glob } from "../_libs/fdir+picomatch+tinyglobby.mjs";
-import { A as parseNodeModulePath, h as toExports, k as lookupNodeModuleSubpath } from "../_libs/acorn+confbox+js-tokens+magic-string+mlly+pkg-types+sourcemap-codec+strip-literal+unimport.mjs";
-import { existsSync, promises } from "node:fs";
-import { defu } from "defu";
-import { withBase, withLeadingSlash, withoutTrailingSlash } from "ufo";
-import { runtimeDir } from "nitro/meta";
-import "scule";
-
-//#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 node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/utils.mjs
-const pathSeparators = /* @__PURE__ */ new Set([
-	"/",
-	"\\",
-	void 0
-]);
-const normalizedAliasSymbol = Symbol.for("pathe:normalizedAlias");
-function normalizeAliases(_aliases) {
-	if (_aliases[normalizedAliasSymbol]) return _aliases;
-	const aliases = Object.fromEntries(Object.entries(_aliases).sort(([a], [b]) => _compareAliases(a, b)));
-	for (const key in aliases) for (const alias in aliases) {
-		if (alias === key || key.startsWith(alias)) continue;
-		if (aliases[key]?.startsWith(alias) && pathSeparators.has(aliases[key][alias.length])) aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
-	}
-	Object.defineProperty(aliases, normalizedAliasSymbol, {
-		value: true,
-		enumerable: false
-	});
-	return aliases;
-}
-function resolveAlias(path, aliases) {
-	const _path = normalizeWindowsPath(path);
-	aliases = normalizeAliases(aliases);
-	for (const [alias, to] of Object.entries(aliases)) {
-		if (!_path.startsWith(alias)) continue;
-		if (hasTrailingSlash(_path[(hasTrailingSlash(alias) ? alias.slice(0, -1) : alias).length])) return join(to, _path.slice(alias.length));
-	}
-	return _path;
-}
-function _compareAliases(a, b) {
-	return b.split("/").length - a.split("/").length;
-}
-function hasTrailingSlash(path = "/") {
-	const lastChar = path[path.length - 1];
-	return lastChar === "/" || lastChar === "\\";
-}
-
-//#endregion
-//#region node_modules/.pnpm/untyped@2.0.0/node_modules/untyped/dist/shared/untyped.Br_uXjZG.mjs
-function getType(val) {
-	const type = typeof val;
-	if (type === "undefined" || val === null) return;
-	if (Array.isArray(val)) return "array";
-	return type;
-}
-function isObject(val) {
-	return val !== null && !Array.isArray(val) && typeof val === "object";
-}
-function nonEmpty(arr) {
-	return arr.filter(Boolean);
-}
-function unique(arr) {
-	return [...new Set(arr)];
-}
-function joinPath(a, b = "", sep = ".") {
-	return a ? a + sep + b : b;
-}
-function setValue(obj, path, val) {
-	const keys = path.split(".");
-	const _key = keys.pop();
-	for (const key of keys) {
-		if (!obj || typeof obj !== "object") return;
-		if (!(key in obj)) obj[key] = {};
-		obj = obj[key];
-	}
-	if (_key) {
-		if (!obj || typeof obj !== "object") return;
-		obj[_key] = val;
-	}
-}
-function getValue(obj, path) {
-	for (const key of path.split(".")) {
-		if (!obj || typeof obj !== "object" || !(key in obj)) return;
-		obj = obj[key];
-	}
-	return obj;
-}
-function normalizeTypes(val) {
-	const arr = unique(val.filter(Boolean));
-	if (arr.length === 0 || arr.includes("any")) return;
-	return arr.length > 1 ? arr : arr[0];
-}
-
-//#endregion
-//#region node_modules/.pnpm/untyped@2.0.0/node_modules/untyped/dist/shared/untyped.BTwOq8Jl.mjs
-async function resolveSchema(obj, defaults, options = {}) {
-	return await _resolveSchema(obj, "", {
-		root: obj,
-		defaults,
-		resolveCache: {},
-		ignoreDefaults: !!options.ignoreDefaults
-	});
-}
-async function _resolveSchema(input, id, ctx) {
-	if (id in ctx.resolveCache) return ctx.resolveCache[id];
-	const schemaId = "#" + id.replace(/\./g, "/");
-	if (!isObject(input)) {
-		const safeInput = Array.isArray(input) ? [...input] : input;
-		const schema2 = {
-			type: getType(input),
-			id: schemaId,
-			default: ctx.ignoreDefaults ? void 0 : safeInput
-		};
-		normalizeSchema(schema2, { ignoreDefaults: ctx.ignoreDefaults });
-		ctx.resolveCache[id] = schema2;
-		if (ctx.defaults && getValue(ctx.defaults, id) === void 0) setValue(ctx.defaults, id, schema2.default);
-		return schema2;
-	}
-	const node = { ...input };
-	const schema = ctx.resolveCache[id] = {
-		...node.$schema,
-		id: schemaId
-	};
-	for (const key in node) {
-		if (key === "$resolve" || key === "$schema" || key === "$default") continue;
-		schema.properties = schema.properties || {};
-		if (!schema.properties[key]) {
-			const child = schema.properties[key] = await _resolveSchema(node[key], joinPath(id, key), ctx);
-			if (Array.isArray(child.tags) && child.tags.includes("@required")) {
-				schema.required = schema.required || [];
-				if (!schema.required.includes(key)) schema.required.push(key);
-			}
-		}
-	}
-	if (!ctx.ignoreDefaults) {
-		if (ctx.defaults) schema.default = getValue(ctx.defaults, id);
-		if (schema.default === void 0 && "$default" in node) schema.default = node.$default;
-		if (typeof node.$resolve === "function") schema.default = await node.$resolve(schema.default, async (key) => {
-			return (await _resolveSchema(getValue(ctx.root, key), key, ctx)).default;
-		});
-	}
-	if (ctx.defaults) setValue(ctx.defaults, id, schema.default);
-	if (!schema.type) schema.type = getType(schema.default) || (schema.properties ? "object" : "any");
-	normalizeSchema(schema, { ignoreDefaults: ctx.ignoreDefaults });
-	if (ctx.defaults && getValue(ctx.defaults, id) === void 0) setValue(ctx.defaults, id, schema.default);
-	return schema;
-}
-function normalizeSchema(schema, options) {
-	if (schema.type === "array" && !("items" in schema)) {
-		schema.items = { type: nonEmpty(unique(schema.default.map((i) => getType(i)))) };
-		if (schema.items.type) {
-			if (schema.items.type.length === 0) schema.items.type = "any";
-			else if (schema.items.type.length === 1) schema.items.type = schema.items.type[0];
-		}
-	}
-	if (!options.ignoreDefaults && schema.default === void 0 && ("properties" in schema || schema.type === "object" || schema.type === "any")) {
-		const propsWithDefaults = Object.entries(schema.properties || {}).filter(([, prop]) => "default" in prop).map(([key, value]) => [key, value.default]);
-		schema.default = Object.fromEntries(propsWithDefaults);
-	}
-}
-
-//#endregion
-//#region node_modules/.pnpm/knitwork@1.3.0/node_modules/knitwork/dist/index.mjs
-function genString(input, options = {}) {
-	const str = JSON.stringify(input);
-	if (!options.singleQuotes) return str;
-	return `'${escapeString(str).slice(1, -1)}'`;
-}
-const NEEDS_ESCAPE_RE = /[\n\r'\\\u2028\u2029]/;
-const QUOTE_NEWLINE_RE = /([\n\r'\u2028\u2029])/g;
-const BACKSLASH_RE = /\\/g;
-function escapeString(id) {
-	if (!NEEDS_ESCAPE_RE.test(id)) return id;
-	return id.replace(BACKSLASH_RE, "\\\\").replace(QUOTE_NEWLINE_RE, "\\$1");
-}
-function genSafeVariableName(name) {
-	if (reservedNames.has(name)) return `_${name}`;
-	return name.replace(/^\d/, (r) => `_${r}`).replace(/\W/g, (r) => "_" + r.charCodeAt(0));
-}
-const reservedNames = /* @__PURE__ */ new Set([
-	"Infinity",
-	"NaN",
-	"arguments",
-	"await",
-	"break",
-	"case",
-	"catch",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"finally",
-	"for",
-	"function",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"interface",
-	"let",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"static",
-	"super",
-	"switch",
-	"this",
-	"throw",
-	"true",
-	"try",
-	"typeof",
-	"undefined",
-	"var",
-	"void",
-	"while",
-	"with",
-	"yield"
-]);
-const VALID_IDENTIFIER_RE = /^[$_]?([A-Z_a-z]\w*|\d)$/;
-function _genStatement(type, specifier, names, options = {}) {
-	const specifierString = genString(specifier, options);
-	if (!names) return `${type} ${specifierString};`;
-	const nameArray = Array.isArray(names);
-	const namesString = (nameArray ? names : [names]).map((index) => {
-		if (typeof index === "string") return { name: index };
-		if (index.name === index.as) index = { name: index.name };
-		return index;
-	}).map((index) => index.as ? `${index.name} as ${index.as}` : index.name).join(", ");
-	if (nameArray) return `${type} { ${namesString} } from ${genString(specifier, options)}${_genImportAttributes(type, options)};`;
-	return `${type} ${namesString} from ${genString(specifier, options)}${_genImportAttributes(type, options)};`;
-}
-function _genImportAttributes(type, options) {
-	if (type === "import type" || type === "export type") return "";
-	if (typeof options.attributes?.type === "string") return ` with { type: ${genString(options.attributes.type)} }`;
-	if (typeof options.assert?.type === "string") return ` assert { type: ${genString(options.assert.type)} }`;
-	return "";
-}
-function genImport(specifier, imports, options = {}) {
-	return _genStatement("import", specifier, imports, options);
-}
-function wrapInDelimiters(lines, indent = "", delimiters = "{}", withComma = true) {
-	if (lines.length === 0) return delimiters;
-	const [start, end] = delimiters;
-	return `${start}
-` + lines.join(withComma ? ",\n" : "\n") + `
-${indent}${end}`;
-}
-function genObjectKey(key) {
-	return VALID_IDENTIFIER_RE.test(key) ? key : genString(key);
-}
-function genObjectFromRaw(object, indent = "", options = {}) {
-	return genObjectFromRawEntries(Object.entries(object), indent, options);
-}
-function genArrayFromRaw(array, indent = "", options = {}) {
-	const newIdent = indent + "  ";
-	return wrapInDelimiters(array.map((index) => `${newIdent}${genRawValue(index, newIdent, options)}`), indent, "[]");
-}
-function genObjectFromRawEntries(array, indent = "", options = {}) {
-	const newIdent = indent + "  ";
-	return wrapInDelimiters(array.map(([key, value]) => `${newIdent}${genObjectKey(key)}: ${genRawValue(value, newIdent, options)}`), indent, "{}");
-}
-function genRawValue(value, indent = "", options = {}) {
-	if (value === void 0) return "undefined";
-	if (value === null) return "null";
-	if (Array.isArray(value)) return genArrayFromRaw(value, indent, options);
-	if (value && typeof value === "object") return genObjectFromRaw(value, indent, options);
-	if (options.preserveTypes && typeof value !== "function") return JSON.stringify(value);
-	return value.toString();
-}
-
-//#endregion
-//#region node_modules/.pnpm/untyped@2.0.0/node_modules/untyped/dist/index.mjs
-const GenerateTypesDefaults = {
-	interfaceName: "Untyped",
-	addExport: true,
-	addDefaults: true,
-	allowExtraKeys: void 0,
-	partial: false,
-	indentation: 0
-};
-const TYPE_MAP = {
-	array: "any[]",
-	bigint: "bigint",
-	boolean: "boolean",
-	number: "number",
-	object: "",
-	any: "any",
-	string: "string",
-	symbol: "Symbol",
-	function: "Function"
-};
-const SCHEMA_KEYS = /* @__PURE__ */ new Set([
-	"items",
-	"default",
-	"resolve",
-	"properties",
-	"title",
-	"description",
-	"$schema",
-	"type",
-	"tsType",
-	"markdownType",
-	"tags",
-	"args",
-	"id",
-	"returns"
-]);
-const DECLARATION_RE = /typeof import\(["'](?<source>[^)]+)["']\)(\.(?<type>\w+)|\[["'](?<type1>\w+)["']])/g;
-function extractTypeImports(declarations) {
-	const typeImports = {};
-	const aliases = /* @__PURE__ */ new Set();
-	const imports = [];
-	for (const match of declarations.matchAll(DECLARATION_RE)) {
-		const { source, type1, type = type1 } = match.groups || {};
-		typeImports[source] = typeImports[source] || /* @__PURE__ */ new Set();
-		typeImports[source].add(type);
-	}
-	for (const source in typeImports) {
-		const sourceImports = [];
-		for (const type of typeImports[source]) {
-			let count = 0;
-			let alias = type;
-			while (aliases.has(alias)) alias = `${type}${count++}`;
-			aliases.add(alias);
-			sourceImports.push(alias === type ? type : `${type} as ${alias}`);
-			declarations = declarations.replace(new RegExp(`typeof import\\(['"]${source}['"]\\)(\\.${type}|\\[['"]${type}['"]\\])`, "g"), alias);
-		}
-		imports.push(`import type { ${sourceImports.join(", ")} } from '${source}'`);
-	}
-	return [...imports, declarations].join("\n");
-}
-function generateTypes(schema, opts = {}) {
-	opts = {
-		...GenerateTypesDefaults,
-		...opts
-	};
-	const baseIden = " ".repeat(opts.indentation || 0);
-	const interfaceCode = `interface ${opts.interfaceName} {
-` + _genTypes(schema, baseIden + " ", opts).map((l) => l.trim().length > 0 ? l : "").join("\n") + `
-${baseIden}}`;
-	if (!opts.addExport) return baseIden + interfaceCode;
-	return extractTypeImports(baseIden + `export ${interfaceCode}`);
-}
-function _genTypes(schema, spaces, opts) {
-	const buff = [];
-	if (!schema) return buff;
-	for (const key in schema.properties) {
-		const val = schema.properties[key];
-		buff.push(...generateJSDoc(val, opts));
-		if (val.tsType) buff.push(`${genObjectKey(key)}${isRequired(schema, key, opts) ? "" : "?"}: ${val.tsType},
-`);
-		else if (val.type === "object") buff.push(`${genObjectKey(key)}${isRequired(schema, key, opts) ? "" : "?"}: {`, ..._genTypes(val, spaces, opts), "},\n");
-		else {
-			let type;
-			if (val.type === "array") type = `Array<${getTsType(val.items || [], opts)}>`;
-			else if (val.type === "function") type = genFunctionType(val, opts);
-			else type = getTsType(val, opts);
-			buff.push(`${genObjectKey(key)}${isRequired(schema, key, opts) ? "" : "?"}: ${type},
-`);
-		}
-	}
-	if (buff.length > 0) {
-		const last = buff.pop() || "";
-		buff.push(last.slice(0, Math.max(0, last.length - 1)));
-	}
-	if (opts.allowExtraKeys === true || buff.length === 0 && opts.allowExtraKeys !== false) buff.push("[key: string]: any");
-	return buff.flatMap((l) => l.split("\n")).map((l) => spaces + l);
-}
-function getTsType(type, opts) {
-	if (Array.isArray(type)) return [normalizeTypes(type.map((t) => getTsType(t, opts)))].flat().join("|") || "any";
-	if (!type) return "any";
-	if (type.tsType) return type.tsType;
-	if (!type.type) return "any";
-	if (Array.isArray(type.type)) return type.type.map((t) => {
-		if (t === "object" && type.type.length > 1) return `{
-` + _genTypes(type, " ", opts).join("\n") + `
-}`;
-		return TYPE_MAP[t];
-	}).join("|");
-	if (type.type === "array") return `Array<${getTsType(type.items || [], opts)}>`;
-	if (type.type === "object") return `{
-` + _genTypes(type, " ", opts).join("\n") + `
-}`;
-	return TYPE_MAP[type.type] || type.type;
-}
-function genFunctionType(schema, opts) {
-	return `(${genFunctionArgs(schema.args, opts)}) => ${getTsType(schema.returns || [], opts)}`;
-}
-function genFunctionArgs(args, opts) {
-	return args?.map((arg) => {
-		let argStr = arg.name;
-		if (arg.optional || arg.default) argStr += "?";
-		if (arg.type || arg.tsType) argStr += `: ${getTsType(arg, opts)}`;
-		return argStr;
-	}).join(", ") || "";
-}
-function generateJSDoc(schema, opts) {
-	opts.defaultDescription = opts.defaultDescription || opts.defaultDescrption;
-	let buff = [];
-	if (schema.title) buff.push(schema.title, "");
-	if (schema.description) buff.push(schema.description, "");
-	else if (opts.defaultDescription && schema.type !== "object") buff.push(opts.defaultDescription, "");
-	if (opts.addDefaults && schema.type !== "object" && schema.type !== "any" && !(Array.isArray(schema.default) && schema.default.length === 0)) {
-		const stringified = JSON.stringify(schema.default);
-		if (stringified) buff.push(`@default ${stringified.replace(/\*\//g, String.raw`*\/`)}`);
-	}
-	for (const key in schema) if (!SCHEMA_KEYS.has(key)) buff.push("", `@${key} ${schema[key]}`);
-	if (Array.isArray(schema.tags)) {
-		for (const tag of schema.tags) if (tag !== "@untyped") buff.push("", tag);
-	}
-	buff = buff.flatMap((i) => i.split("\n"));
-	if (buff.length > 0) return buff.length === 1 ? ["/** " + buff[0] + " */"] : [
-		"/**",
-		...buff.map((i) => ` * ${i}`),
-		"*/"
-	];
-	return [];
-}
-function isRequired(schema, key, opts) {
-	if (Array.isArray(schema.required) && schema.required.includes(key)) return true;
-	return !opts.partial;
-}
-
-//#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 errors = [];
-	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);
-			errors.push(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();
-	return { errors };
-}
-
-//#endregion
-export { genSafeVariableName as a, scanHandlers as c, genObjectFromRaw as i, writeTypes as n, genString as o, genImport as r, scanAndSyncOptions as s, runParallel as t };