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

package/dist/_chunks/nitro3.mjs

@@ -1,2696 +0,0 @@
-import { a as join$1, l as relative$1, u as resolve$1 } from "../_libs/pathe.mjs";
-import { a as watchConfig, n as loadConfig } from "../_libs/c12+dotenv+rc9.mjs";
-import { l as resolveModulePath, r as findWorkspaceDir, u as resolveModuleURL } from "../_libs/confbox+exsolve+pkg-types.mjs";
-import { n as resolveCompatibilityDates, r as resolveCompatibilityDatesFromEnv } from "../_libs/compatx.mjs";
-import { a as d, i as a } from "../_libs/std-env.mjs";
-import { i as writeFile$1, n as prettyPath, r as resolveNitroPath, t as isDirectory } from "./nitro4.mjs";
-import { t as glob } from "../_libs/fdir+picomatch+tinyglobby.mjs";
-import { c as scanHandlers, s as scanAndSyncOptions, t as runParallel } from "./nitro5.mjs";
-import { i as src_default } from "./nitro6.mjs";
-import { createRequire } from "node:module";
-import consola$1, { consola } from "consola";
-import { Hookable, createDebugger } from "hookable";
-import fs, { existsSync, promises } from "node:fs";
-import fsp, { readFile } from "node:fs/promises";
-import { pathToFileURL } from "node:url";
-import path from "node:path";
-import { defu } from "defu";
-import { joinURL, parseURL, withBase, withLeadingSlash, withQuery, withTrailingSlash, withoutBase, withoutTrailingSlash } from "ufo";
-import { runtimeDir } from "nitro/meta";
-import { createRequire as createRequire$1 } from "module";
-import { colors } from "consola/utils";
-import { hash } from "ohash";
-import zlib from "node:zlib";
-import http from "node:http";
-import { toRequest } from "h3";
-
-//#region node_modules/.pnpm/klona@2.0.6/node_modules/klona/full/index.mjs
-function set(obj, key, val) {
-	if (typeof val.value === "object") val.value = klona(val.value);
-	if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === "__proto__") Object.defineProperty(obj, key, val);
-	else obj[key] = val.value;
-}
-function klona(x$1) {
-	if (typeof x$1 !== "object") return x$1;
-	var i = 0, k, list, tmp, str = Object.prototype.toString.call(x$1);
-	if (str === "[object Object]") tmp = Object.create(x$1.__proto__ || null);
-	else if (str === "[object Array]") tmp = Array(x$1.length);
-	else if (str === "[object Set]") {
-		tmp = /* @__PURE__ */ new Set();
-		x$1.forEach(function(val) {
-			tmp.add(klona(val));
-		});
-	} else if (str === "[object Map]") {
-		tmp = /* @__PURE__ */ new Map();
-		x$1.forEach(function(val, key) {
-			tmp.set(klona(key), klona(val));
-		});
-	} else if (str === "[object Date]") tmp = /* @__PURE__ */ new Date(+x$1);
-	else if (str === "[object RegExp]") tmp = new RegExp(x$1.source, x$1.flags);
-	else if (str === "[object DataView]") tmp = new x$1.constructor(klona(x$1.buffer));
-	else if (str === "[object ArrayBuffer]") tmp = x$1.slice(0);
-	else if (str.slice(-6) === "Array]") tmp = new x$1.constructor(x$1);
-	if (tmp) {
-		for (list = Object.getOwnPropertySymbols(x$1); i < list.length; i++) set(tmp, list[i], Object.getOwnPropertyDescriptor(x$1, list[i]));
-		for (i = 0, list = Object.getOwnPropertyNames(x$1); i < list.length; i++) {
-			if (Object.hasOwnProperty.call(tmp, k = list[i]) && tmp[k] === x$1[k]) continue;
-			set(tmp, k, Object.getOwnPropertyDescriptor(x$1, k));
-		}
-	}
-	return tmp || x$1;
-}
-
-//#endregion
-//#region src/config/defaults.ts
-const NitroDefaults = {
-	compatibilityDate: "latest",
-	debug: d,
-	logLevel: a ? 1 : 3,
-	runtimeConfig: {
-		app: {},
-		nitro: {}
-	},
-	serverDir: false,
-	scanDirs: [],
-	buildDir: `node_modules/.nitro`,
-	output: {
-		dir: "{{ rootDir }}/.output",
-		serverDir: "{{ output.dir }}/server",
-		publicDir: "{{ output.dir }}/public"
-	},
-	features: {},
-	experimental: {},
-	future: {},
-	storage: {},
-	devStorage: {},
-	publicAssets: [],
-	serverAssets: [],
-	plugins: [],
-	tasks: {},
-	scheduledTasks: {},
-	imports: false,
-	virtual: {},
-	compressPublicAssets: false,
-	ignore: [],
-	wasm: {},
-	dev: false,
-	devServer: { watch: [] },
-	watchOptions: { ignoreInitial: true },
-	devProxy: {},
-	logging: {
-		compressedSizes: true,
-		buildSuccess: true
-	},
-	baseURL: process.env.NITRO_APP_BASE_URL || "/",
-	handlers: [],
-	devHandlers: [],
-	errorHandler: void 0,
-	routes: {},
-	routeRules: {},
-	prerender: {
-		autoSubfolderIndex: true,
-		concurrency: 1,
-		interval: 0,
-		retry: 3,
-		retryDelay: 500,
-		failOnError: false,
-		crawlLinks: false,
-		ignore: [],
-		routes: []
-	},
-	builder: void 0,
-	moduleSideEffects: ["unenv/polyfill/"],
-	replace: {},
-	node: true,
-	sourcemap: false,
-	traceDeps: [],
-	typescript: {
-		strict: true,
-		generateRuntimeConfigTypes: false,
-		generateTsConfig: false,
-		tsconfigPath: "tsconfig.json",
-		tsConfig: void 0
-	},
-	hooks: {},
-	commands: {},
-	framework: {
-		name: "nitro",
-		version: ""
-	}
-};
-
-//#endregion
-//#region src/config/resolvers/assets.ts
-async function resolveAssetsOptions(options) {
-	for (const publicAsset of options.publicAssets) {
-		publicAsset.dir = resolve$1(options.rootDir, publicAsset.dir);
-		publicAsset.baseURL = withLeadingSlash(withoutTrailingSlash(publicAsset.baseURL || "/"));
-	}
-	for (const dir of [options.rootDir, ...options.scanDirs]) {
-		const publicDir = resolve$1(dir, "public");
-		if (!existsSync(publicDir)) continue;
-		if (options.publicAssets.some((asset) => asset.dir === publicDir)) continue;
-		options.publicAssets.push({ dir: publicDir });
-	}
-	for (const serverAsset of options.serverAssets) serverAsset.dir = resolve$1(options.rootDir, serverAsset.dir);
-	options.serverAssets.push({
-		baseName: "server",
-		dir: resolve$1(options.rootDir, "assets")
-	});
-	for (const asset of options.publicAssets) {
-		asset.baseURL = asset.baseURL || "/";
-		const isTopLevel = asset.baseURL === "/";
-		asset.fallthrough = asset.fallthrough ?? isTopLevel;
-		const routeRule = options.routeRules[asset.baseURL + "/**"];
-		asset.maxAge = (routeRule?.cache)?.maxAge ?? asset.maxAge ?? 0;
-		if (asset.maxAge && !asset.fallthrough) options.routeRules[asset.baseURL + "/**"] = defu(routeRule, { headers: { "cache-control": `public, max-age=${asset.maxAge}, immutable` } });
-	}
-}
-
-//#endregion
-//#region src/config/resolvers/compatibility.ts
-async function resolveCompatibilityOptions(options) {
-	options.compatibilityDate = resolveCompatibilityDatesFromEnv(options.compatibilityDate);
-}
-
-//#endregion
-//#region src/config/resolvers/database.ts
-async function resolveDatabaseOptions(options) {
-	if (options.experimental.database && options.imports) {
-		options.imports.presets ??= [];
-		options.imports.presets.push({
-			from: "nitro/database",
-			imports: ["useDatabase"]
-		});
-		if (options.dev && !options.database && !options.devDatabase) options.devDatabase = { default: {
-			connector: "sqlite",
-			options: { cwd: options.rootDir }
-		} };
-		else if (options.node && !options.database) options.database = { default: {
-			connector: "sqlite",
-			options: {}
-		} };
-	}
-}
-
-//#endregion
-//#region src/config/resolvers/export-conditions.ts
-async function resolveExportConditionsOptions(options) {
-	options.exportConditions = _resolveExportConditions(options.exportConditions || [], {
-		dev: options.dev,
-		node: options.node,
-		wasm: options.wasm !== false
-	});
-}
-function _resolveExportConditions(conditions, opts) {
-	const resolvedConditions = [];
-	resolvedConditions.push(opts.dev ? "development" : "production");
-	resolvedConditions.push(...conditions);
-	if (opts.node) resolvedConditions.push("node");
-	else resolvedConditions.push("wintercg", "worker", "web", "browser", "workerd", "edge-light", "netlify", "edge-routine", "deno");
-	if (opts.wasm) resolvedConditions.push("wasm", "unwasm");
-	resolvedConditions.push("import", "default", "module");
-	if ("Bun" in globalThis) resolvedConditions.push("bun");
-	else if ("Deno" in globalThis) resolvedConditions.push("deno");
-	return resolvedConditions.filter((c, i) => resolvedConditions.indexOf(c) === i);
-}
-
-//#endregion
-//#region node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js
-function escapeStringRegexp(string) {
-	if (typeof string !== "string") throw new TypeError("Expected a string");
-	return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
-}
-
-//#endregion
-//#region src/config/resolvers/imports.ts
-async function resolveImportsOptions(options) {
-	if (options.imports === false) return;
-	options.imports.presets ??= [];
-	options.imports.dirs ??= [];
-	options.imports.dirs.push(...options.scanDirs.map((dir) => join$1(dir, "utils/**/*")));
-	if (Array.isArray(options.imports.exclude) && options.imports.exclude.length === 0) {
-		options.imports.exclude.push(/[/\\]\.git[/\\]/);
-		options.imports.exclude.push(options.buildDir);
-		const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
-		options.imports.exclude.push(scanDirsInNodeModules.length > 0 ? /* @__PURE__ */ new RegExp(`node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeStringRegexp(dir)).join("|")})`) : /[/\\]node_modules[/\\]/);
-	}
-}
-
-//#endregion
-//#region src/config/resolvers/open-api.ts
-async function resolveOpenAPIOptions(options) {
-	if (!options.experimental.openAPI) return;
-	if (!options.dev && !options.openAPI?.production) return;
-	const shouldPrerender = !options.dev && options.openAPI?.production === "prerender";
-	const handlersEnv = shouldPrerender ? "prerender" : "";
-	const prerenderRoutes = [];
-	const jsonRoute = options.openAPI?.route || "/_openapi.json";
-	prerenderRoutes.push(jsonRoute);
-	options.handlers.push({
-		route: jsonRoute,
-		env: handlersEnv,
-		handler: join$1(runtimeDir, "internal/routes/openapi")
-	});
-	if (options.openAPI?.ui?.scalar !== false) {
-		const scalarRoute = options.openAPI?.ui?.scalar?.route || "/_scalar";
-		prerenderRoutes.push(scalarRoute);
-		options.handlers.push({
-			route: options.openAPI?.ui?.scalar?.route || "/_scalar",
-			env: handlersEnv,
-			handler: join$1(runtimeDir, "internal/routes/scalar")
-		});
-	}
-	if (options.openAPI?.ui?.swagger !== false) {
-		const swaggerRoute = options.openAPI?.ui?.swagger?.route || "/_swagger";
-		prerenderRoutes.push(swaggerRoute);
-		options.handlers.push({
-			route: swaggerRoute,
-			env: handlersEnv,
-			handler: join$1(runtimeDir, "internal/routes/swagger")
-		});
-	}
-	if (shouldPrerender) {
-		options.prerender ??= {};
-		options.prerender.routes ??= [];
-		options.prerender.routes.push(...prerenderRoutes);
-	}
-}
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/util.js
-const POSIX_SEP_RE = new RegExp("\\" + path.posix.sep, "g");
-const NATIVE_SEP_RE = new RegExp("\\" + path.sep, "g");
-/** @type {Map<string,RegExp>}*/
-const PATTERN_REGEX_CACHE = /* @__PURE__ */ new Map();
-const GLOB_ALL_PATTERN = `**/*`;
-const TS_EXTENSIONS = [
-	".ts",
-	".tsx",
-	".mts",
-	".cts"
-];
-const TSJS_EXTENSIONS = TS_EXTENSIONS.concat([
-	".js",
-	".jsx",
-	".mjs",
-	".cjs"
-]);
-const TS_EXTENSIONS_RE_GROUP = `\\.(?:${TS_EXTENSIONS.map((ext) => ext.substring(1)).join("|")})`;
-const TSJS_EXTENSIONS_RE_GROUP = `\\.(?:${TSJS_EXTENSIONS.map((ext) => ext.substring(1)).join("|")})`;
-const IS_POSIX = path.posix.sep === path.sep;
-/**
-* @template T
-* @returns {{resolve:(result:T)=>void, reject:(error:any)=>void, promise: Promise<T>}}
-*/
-function makePromise() {
-	let resolve$2, reject;
-	return {
-		promise: new Promise((res, rej) => {
-			resolve$2 = res;
-			reject = rej;
-		}),
-		resolve: resolve$2,
-		reject
-	};
-}
-/**
-* @param {string} filename
-* @param {import('./cache.js').TSConfckCache} [cache]
-* @returns {Promise<string|void>}
-*/
-async function resolveTSConfigJson(filename, cache) {
-	if (path.extname(filename) !== ".json") return;
-	const tsconfig = path.resolve(filename);
-	if (cache && (cache.hasParseResult(tsconfig) || cache.hasParseResult(filename))) return tsconfig;
-	return promises.stat(tsconfig).then((stat$2) => {
-		if (stat$2.isFile() || stat$2.isFIFO()) return tsconfig;
-		else throw new Error(`${filename} exists but is not a regular file.`);
-	});
-}
-/**
-*
-* @param {string} dir an absolute directory path
-* @returns {boolean}  if dir path includes a node_modules segment
-*/
-const isInNodeModules = IS_POSIX ? (dir) => dir.includes("/node_modules/") : (dir) => dir.match(/[/\\]node_modules[/\\]/);
-/**
-* convert posix separator to native separator
-*
-* eg.
-* windows: C:/foo/bar -> c:\foo\bar
-* linux: /foo/bar -> /foo/bar
-*
-* @param {string} filename with posix separators
-* @returns {string} filename with native separators
-*/
-const posix2native = IS_POSIX ? (filename) => filename : (filename) => filename.replace(POSIX_SEP_RE, path.sep);
-/**
-* convert native separator to posix separator
-*
-* eg.
-* windows: C:\foo\bar -> c:/foo/bar
-* linux: /foo/bar -> /foo/bar
-*
-* @param {string} filename - filename with native separators
-* @returns {string} filename with posix separators
-*/
-const native2posix = IS_POSIX ? (filename) => filename : (filename) => filename.replace(NATIVE_SEP_RE, path.posix.sep);
-/**
-* converts params to native separator, resolves path and converts native back to posix
-*
-* needed on windows to handle posix paths in tsconfig
-*
-* @param dir {string|null} directory to resolve from
-* @param filename {string} filename or pattern to resolve
-* @returns string
-*/
-const resolve2posix = IS_POSIX ? (dir, filename) => dir ? path.resolve(dir, filename) : path.resolve(filename) : (dir, filename) => native2posix(dir ? path.resolve(posix2native(dir), posix2native(filename)) : path.resolve(posix2native(filename)));
-/**
-*
-* @param {import('./public.d.ts').TSConfckParseResult} result
-* @param {import('./public.d.ts').TSConfckParseOptions} [options]
-* @returns {string[]}
-*/
-function resolveReferencedTSConfigFiles(result, options) {
-	const dir = path.dirname(result.tsconfigFile);
-	return result.tsconfig.references.map((ref) => {
-		return resolve2posix(dir, ref.path.endsWith(".json") ? ref.path : path.join(ref.path, options?.configName ?? "tsconfig.json"));
-	});
-}
-/**
-* @param {string} filename
-* @param {import('./public.d.ts').TSConfckParseResult} result
-* @returns {import('./public.d.ts').TSConfckParseResult}
-*/
-function resolveSolutionTSConfig(filename, result) {
-	const extensions = result.tsconfig.compilerOptions?.allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
-	if (result.referenced && extensions.some((ext) => filename.endsWith(ext)) && !isIncluded(filename, result)) {
-		const solutionTSConfig = result.referenced.find((referenced) => isIncluded(filename, referenced));
-		if (solutionTSConfig) return solutionTSConfig;
-	}
-	return result;
-}
-/**
-*
-* @param {string} filename
-* @param {import('./public.d.ts').TSConfckParseResult} result
-* @returns {boolean}
-*/
-function isIncluded(filename, result) {
-	const dir = native2posix(path.dirname(result.tsconfigFile));
-	const files = (result.tsconfig.files || []).map((file) => resolve2posix(dir, file));
-	const absoluteFilename = resolve2posix(null, filename);
-	if (files.includes(filename)) return true;
-	const allowJs = result.tsconfig.compilerOptions?.allowJs;
-	if (isGlobMatch(absoluteFilename, dir, result.tsconfig.include || (result.tsconfig.files ? [] : [GLOB_ALL_PATTERN]), allowJs)) return !isGlobMatch(absoluteFilename, dir, result.tsconfig.exclude || [], allowJs);
-	return false;
-}
-/**
-* test filenames agains glob patterns in tsconfig
-*
-* @param filename {string} posix style abolute path to filename to test
-* @param dir {string} posix style absolute path to directory of tsconfig containing patterns
-* @param patterns {string[]} glob patterns to match against
-* @param allowJs {boolean} allowJs setting in tsconfig to include js extensions in checks
-* @returns {boolean} true when at least one pattern matches filename
-*/
-function isGlobMatch(filename, dir, patterns, allowJs) {
-	const extensions = allowJs ? TSJS_EXTENSIONS : TS_EXTENSIONS;
-	return patterns.some((pattern) => {
-		let lastWildcardIndex = pattern.length;
-		let hasWildcard = false;
-		let hasExtension = false;
-		let hasSlash = false;
-		let lastSlashIndex = -1;
-		for (let i = pattern.length - 1; i > -1; i--) {
-			const c = pattern[i];
-			if (!hasWildcard) {
-				if (c === "*" || c === "?") {
-					lastWildcardIndex = i;
-					hasWildcard = true;
-				}
-			}
-			if (!hasSlash) {
-				if (c === ".") hasExtension = true;
-				else if (c === "/") {
-					lastSlashIndex = i;
-					hasSlash = true;
-				}
-			}
-			if (hasWildcard && hasSlash) break;
-		}
-		if (!hasExtension && (!hasWildcard || lastWildcardIndex < lastSlashIndex)) {
-			pattern += `${pattern.endsWith("/") ? "" : "/"}${GLOB_ALL_PATTERN}`;
-			lastWildcardIndex = pattern.length - 1;
-			hasWildcard = true;
-		}
-		if (lastWildcardIndex < pattern.length - 1 && !filename.endsWith(pattern.slice(lastWildcardIndex + 1))) return false;
-		if (pattern.endsWith("*") && !extensions.some((ext) => filename.endsWith(ext))) return false;
-		if (pattern === GLOB_ALL_PATTERN) return filename.startsWith(`${dir}/`);
-		const resolvedPattern = resolve2posix(dir, pattern);
-		let firstWildcardIndex = -1;
-		for (let i = 0; i < resolvedPattern.length; i++) if (resolvedPattern[i] === "*" || resolvedPattern[i] === "?") {
-			firstWildcardIndex = i;
-			hasWildcard = true;
-			break;
-		}
-		if (firstWildcardIndex > 1 && !filename.startsWith(resolvedPattern.slice(0, firstWildcardIndex - 1))) return false;
-		if (!hasWildcard) return filename === resolvedPattern;
-		else if (firstWildcardIndex + GLOB_ALL_PATTERN.length === resolvedPattern.length - (pattern.length - 1 - lastWildcardIndex) && resolvedPattern.slice(firstWildcardIndex, firstWildcardIndex + GLOB_ALL_PATTERN.length) === GLOB_ALL_PATTERN) return true;
-		if (PATTERN_REGEX_CACHE.has(resolvedPattern)) return PATTERN_REGEX_CACHE.get(resolvedPattern).test(filename);
-		const regex = pattern2regex(resolvedPattern, allowJs);
-		PATTERN_REGEX_CACHE.set(resolvedPattern, regex);
-		return regex.test(filename);
-	});
-}
-/**
-* @param {string} resolvedPattern
-* @param {boolean} allowJs
-* @returns {RegExp}
-*/
-function pattern2regex(resolvedPattern, allowJs) {
-	let regexStr = "^";
-	for (let i = 0; i < resolvedPattern.length; i++) {
-		const char = resolvedPattern[i];
-		if (char === "?") {
-			regexStr += "[^\\/]";
-			continue;
-		}
-		if (char === "*") {
-			if (resolvedPattern[i + 1] === "*" && resolvedPattern[i + 2] === "/") {
-				i += 2;
-				regexStr += "(?:[^\\/]*\\/)*";
-				continue;
-			}
-			regexStr += "[^\\/]*";
-			continue;
-		}
-		if ("/.+^${}()|[]\\".includes(char)) regexStr += `\\`;
-		regexStr += char;
-	}
-	if (resolvedPattern.endsWith("*")) regexStr += allowJs ? TSJS_EXTENSIONS_RE_GROUP : TS_EXTENSIONS_RE_GROUP;
-	regexStr += "$";
-	return new RegExp(regexStr);
-}
-/**
-* replace tokens like ${configDir}
-* @param {import('./public.d.ts').TSConfckParseResult} result
-*/
-function replaceTokens(result) {
-	if (result.tsconfig) result.tsconfig = JSON.parse(JSON.stringify(result.tsconfig).replaceAll(/"\${configDir}/g, `"${native2posix(path.dirname(result.tsconfigFile))}`));
-}
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/find.js
-/**
-* find the closest tsconfig.json file
-*
-* @param {string} filename - path to file to find tsconfig for (absolute or relative to cwd)
-* @param {import('./public.d.ts').TSConfckFindOptions} [options] - options
-* @returns {Promise<string|null>} absolute path to closest tsconfig.json or null if not found
-*/
-async function find(filename, options) {
-	let dir = path.dirname(path.resolve(filename));
-	if (options?.ignoreNodeModules && isInNodeModules(dir)) return null;
-	const cache = options?.cache;
-	const configName = options?.configName ?? "tsconfig.json";
-	if (cache?.hasConfigPath(dir, configName)) return cache.getConfigPath(dir, configName);
-	const { promise, resolve: resolve$2, reject } = makePromise();
-	if (options?.root && !path.isAbsolute(options.root)) options.root = path.resolve(options.root);
-	findUp(dir, {
-		promise,
-		resolve: resolve$2,
-		reject
-	}, options);
-	return promise;
-}
-/**
-*
-* @param {string} dir
-* @param {{promise:Promise<string|null>,resolve:(result:string|null)=>void,reject:(err:any)=>void}} madePromise
-* @param {import('./public.d.ts').TSConfckFindOptions} [options] - options
-*/
-function findUp(dir, { resolve: resolve$2, reject, promise }, options) {
-	const { cache, root, configName } = options ?? {};
-	if (cache) if (cache.hasConfigPath(dir, configName)) {
-		let cached;
-		try {
-			cached = cache.getConfigPath(dir, configName);
-		} catch (e) {
-			reject(e);
-			return;
-		}
-		if (cached?.then) cached.then(resolve$2).catch(reject);
-		else resolve$2(cached);
-	} else cache.setConfigPath(dir, promise, configName);
-	const tsconfig = path.join(dir, options?.configName ?? "tsconfig.json");
-	fs.stat(tsconfig, (err, stats) => {
-		if (stats && (stats.isFile() || stats.isFIFO())) resolve$2(tsconfig);
-		else if (err?.code !== "ENOENT") reject(err);
-		else {
-			let parent;
-			if (root === dir || (parent = path.dirname(dir)) === dir) resolve$2(null);
-			else findUp(parent, {
-				promise,
-				resolve: resolve$2,
-				reject
-			}, options);
-		}
-	});
-}
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/find-all.js
-/**
-* @typedef WalkState
-* @interface
-* @property {string[]} files - files
-* @property {number} calls - number of ongoing calls
-* @property {(dir: string)=>boolean} skip - function to skip dirs
-* @property {boolean} err - error flag
-* @property {string[]} configNames - config file names
-*/
-const sep$1 = path.sep;
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/to-json.js
-/**
-* convert content of tsconfig.json to regular json
-*
-* @param {string} tsconfigJson - content of tsconfig.json
-* @returns {string} content as regular json, comments and dangling commas have been replaced with whitespace
-*/
-function toJson(tsconfigJson) {
-	const stripped = stripDanglingComma(stripJsonComments(stripBom(tsconfigJson)));
-	if (stripped.trim() === "") return "{}";
-	else return stripped;
-}
-/**
-* replace dangling commas from pseudo-json string with single space
-* implementation heavily inspired by strip-json-comments
-*
-* @param {string} pseudoJson
-* @returns {string}
-*/
-function stripDanglingComma(pseudoJson) {
-	let insideString = false;
-	let offset = 0;
-	let result = "";
-	let danglingCommaPos = null;
-	for (let i = 0; i < pseudoJson.length; i++) {
-		const currentCharacter = pseudoJson[i];
-		if (currentCharacter === "\"") {
-			if (!isEscaped(pseudoJson, i)) insideString = !insideString;
-		}
-		if (insideString) {
-			danglingCommaPos = null;
-			continue;
-		}
-		if (currentCharacter === ",") {
-			danglingCommaPos = i;
-			continue;
-		}
-		if (danglingCommaPos) {
-			if (currentCharacter === "}" || currentCharacter === "]") {
-				result += pseudoJson.slice(offset, danglingCommaPos) + " ";
-				offset = danglingCommaPos + 1;
-				danglingCommaPos = null;
-			} else if (!currentCharacter.match(/\s/)) danglingCommaPos = null;
-		}
-	}
-	return result + pseudoJson.substring(offset);
-}
-/**
-*
-* @param {string} jsonString
-* @param {number} quotePosition
-* @returns {boolean}
-*/
-function isEscaped(jsonString, quotePosition) {
-	let index = quotePosition - 1;
-	let backslashCount = 0;
-	while (jsonString[index] === "\\") {
-		index -= 1;
-		backslashCount += 1;
-	}
-	return Boolean(backslashCount % 2);
-}
-/**
-*
-* @param {string} string
-* @param {number?} start
-* @param {number?} end
-*/
-function strip(string, start, end) {
-	return string.slice(start, end).replace(/\S/g, " ");
-}
-const singleComment = Symbol("singleComment");
-const multiComment = Symbol("multiComment");
-/**
-* @param {string} jsonString
-* @returns {string}
-*/
-function stripJsonComments(jsonString) {
-	let isInsideString = false;
-	/** @type {false | symbol} */
-	let isInsideComment = false;
-	let offset = 0;
-	let result = "";
-	for (let index = 0; index < jsonString.length; index++) {
-		const currentCharacter = jsonString[index];
-		const nextCharacter = jsonString[index + 1];
-		if (!isInsideComment && currentCharacter === "\"") {
-			if (!isEscaped(jsonString, index)) isInsideString = !isInsideString;
-		}
-		if (isInsideString) continue;
-		if (!isInsideComment && currentCharacter + nextCharacter === "//") {
-			result += jsonString.slice(offset, index);
-			offset = index;
-			isInsideComment = singleComment;
-			index++;
-		} else if (isInsideComment === singleComment && currentCharacter + nextCharacter === "\r\n") {
-			index++;
-			isInsideComment = false;
-			result += strip(jsonString, offset, index);
-			offset = index;
-		} else if (isInsideComment === singleComment && currentCharacter === "\n") {
-			isInsideComment = false;
-			result += strip(jsonString, offset, index);
-			offset = index;
-		} else if (!isInsideComment && currentCharacter + nextCharacter === "/*") {
-			result += jsonString.slice(offset, index);
-			offset = index;
-			isInsideComment = multiComment;
-			index++;
-		} else if (isInsideComment === multiComment && currentCharacter + nextCharacter === "*/") {
-			index++;
-			isInsideComment = false;
-			result += strip(jsonString, offset, index + 1);
-			offset = index + 1;
-		}
-	}
-	return result + (isInsideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
-}
-/**
-* @param {string} string
-* @returns {string}
-*/
-function stripBom(string) {
-	if (string.charCodeAt(0) === 65279) return string.slice(1);
-	return string;
-}
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/parse.js
-const not_found_result = {
-	tsconfigFile: null,
-	tsconfig: {}
-};
-/**
-* parse the closest tsconfig.json file
-*
-* @param {string} filename - path to a tsconfig .json or a source file or directory (absolute or relative to cwd)
-* @param {import('./public.d.ts').TSConfckParseOptions} [options] - options
-* @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
-* @throws {TSConfckParseError}
-*/
-async function parse(filename, options) {
-	/** @type {import('./cache.js').TSConfckCache} */
-	const cache = options?.cache;
-	if (cache?.hasParseResult(filename)) return getParsedDeep(filename, cache, options);
-	const { resolve: resolve$2, reject, promise } = makePromise();
-	cache?.setParseResult(filename, promise, true);
-	try {
-		let tsconfigFile = await resolveTSConfigJson(filename, cache) || await find(filename, options);
-		if (!tsconfigFile) {
-			resolve$2(not_found_result);
-			return promise;
-		}
-		let result;
-		if (filename !== tsconfigFile && cache?.hasParseResult(tsconfigFile)) result = await getParsedDeep(tsconfigFile, cache, options);
-		else {
-			result = await parseFile(tsconfigFile, cache, filename === tsconfigFile);
-			await Promise.all([parseExtends(result, cache), parseReferences(result, options)]);
-		}
-		replaceTokens(result);
-		resolve$2(resolveSolutionTSConfig(filename, result));
-	} catch (e) {
-		reject(e);
-	}
-	return promise;
-}
-/**
-* ensure extends and references are parsed
-*
-* @param {string} filename - cached file
-* @param {import('./cache.js').TSConfckCache} cache - cache
-* @param {import('./public.d.ts').TSConfckParseOptions} options - options
-*/
-async function getParsedDeep(filename, cache, options) {
-	const result = await cache.getParseResult(filename);
-	if (result.tsconfig.extends && !result.extended || result.tsconfig.references && !result.referenced) {
-		const promise = Promise.all([parseExtends(result, cache), parseReferences(result, options)]).then(() => result);
-		cache.setParseResult(filename, promise, true);
-		return promise;
-	}
-	return result;
-}
-/**
-*
-* @param {string} tsconfigFile - path to tsconfig file
-* @param {import('./cache.js').TSConfckCache} [cache] - cache
-* @param {boolean} [skipCache] - skip cache
-* @returns {Promise<import('./public.d.ts').TSConfckParseResult>}
-*/
-async function parseFile(tsconfigFile, cache, skipCache) {
-	if (!skipCache && cache?.hasParseResult(tsconfigFile) && !cache.getParseResult(tsconfigFile)._isRootFile_) return cache.getParseResult(tsconfigFile);
-	const promise = promises.readFile(tsconfigFile, "utf-8").then(toJson).then((json) => {
-		const parsed = JSON.parse(json);
-		applyDefaults(parsed, tsconfigFile);
-		return {
-			tsconfigFile,
-			tsconfig: normalizeTSConfig(parsed, path.dirname(tsconfigFile))
-		};
-	}).catch((e) => {
-		throw new TSConfckParseError(`parsing ${tsconfigFile} failed: ${e}`, "PARSE_FILE", tsconfigFile, e);
-	});
-	if (!skipCache && (!cache?.hasParseResult(tsconfigFile) || !cache.getParseResult(tsconfigFile)._isRootFile_)) cache?.setParseResult(tsconfigFile, promise);
-	return promise;
-}
-/**
-* normalize to match the output of ts.parseJsonConfigFileContent
-*
-* @param {any} tsconfig - typescript tsconfig output
-* @param {string} dir - directory
-*/
-function normalizeTSConfig(tsconfig, dir) {
-	const baseUrl = tsconfig.compilerOptions?.baseUrl;
-	if (baseUrl && !baseUrl.startsWith("${") && !path.isAbsolute(baseUrl)) tsconfig.compilerOptions.baseUrl = resolve2posix(dir, baseUrl);
-	return tsconfig;
-}
-/**
-*
-* @param {import('./public.d.ts').TSConfckParseResult} result
-* @param {import('./public.d.ts').TSConfckParseOptions} [options]
-* @returns {Promise<void>}
-*/
-async function parseReferences(result, options) {
-	if (!result.tsconfig.references) return;
-	const referencedFiles = resolveReferencedTSConfigFiles(result, options);
-	const referenced = await Promise.all(referencedFiles.map((file) => parseFile(file, options?.cache)));
-	await Promise.all(referenced.map((ref) => parseExtends(ref, options?.cache)));
-	referenced.forEach((ref) => {
-		ref.solution = result;
-		replaceTokens(ref);
-	});
-	result.referenced = referenced;
-}
-/**
-* @param {import('./public.d.ts').TSConfckParseResult} result
-* @param {import('./cache.js').TSConfckCache}[cache]
-* @returns {Promise<void>}
-*/
-async function parseExtends(result, cache) {
-	if (!result.tsconfig.extends) return;
-	/** @type {import('./public.d.ts').TSConfckParseResult[]} */
-	const extended = [{
-		tsconfigFile: result.tsconfigFile,
-		tsconfig: JSON.parse(JSON.stringify(result.tsconfig))
-	}];
-	let pos = 0;
-	/** @type {string[]} */
-	const extendsPath = [];
-	let currentBranchDepth = 0;
-	while (pos < extended.length) {
-		const extending = extended[pos];
-		extendsPath.push(extending.tsconfigFile);
-		if (extending.tsconfig.extends) {
-			currentBranchDepth += 1;
-			/** @type {string[]} */
-			let resolvedExtends;
-			if (!Array.isArray(extending.tsconfig.extends)) resolvedExtends = [resolveExtends(extending.tsconfig.extends, extending.tsconfigFile)];
-			else resolvedExtends = extending.tsconfig.extends.reverse().map((ex) => resolveExtends(ex, extending.tsconfigFile));
-			const circularExtends = resolvedExtends.find((tsconfigFile) => extendsPath.includes(tsconfigFile));
-			if (circularExtends) throw new TSConfckParseError(`Circular dependency in "extends": ${extendsPath.concat([circularExtends]).join(" -> ")}`, "EXTENDS_CIRCULAR", result.tsconfigFile);
-			extended.splice(pos + 1, 0, ...await Promise.all(resolvedExtends.map((file) => parseFile(file, cache))));
-		} else {
-			extendsPath.splice(-currentBranchDepth);
-			currentBranchDepth = 0;
-		}
-		pos = pos + 1;
-	}
-	result.extended = extended;
-	for (const ext of result.extended.slice(1)) extendTSConfig(result, ext);
-}
-/**
-*
-* @param {string} extended
-* @param {string} from
-* @returns {string}
-*/
-function resolveExtends(extended, from) {
-	if ([".", ".."].includes(extended)) extended = extended + "/tsconfig.json";
-	const req = createRequire$1(from);
-	let error;
-	try {
-		return req.resolve(extended);
-	} catch (e) {
-		error = e;
-	}
-	if (extended[0] !== "." && !path.isAbsolute(extended)) try {
-		return req.resolve(`${extended}/tsconfig.json`);
-	} catch (e) {
-		error = e;
-	}
-	throw new TSConfckParseError(`failed to resolve "extends":"${extended}" in ${from}`, "EXTENDS_RESOLVE", from, error);
-}
-const EXTENDABLE_KEYS = [
-	"compilerOptions",
-	"files",
-	"include",
-	"exclude",
-	"watchOptions",
-	"compileOnSave",
-	"typeAcquisition",
-	"buildOptions"
-];
-/**
-*
-* @param {import('./public.d.ts').TSConfckParseResult} extending
-* @param {import('./public.d.ts').TSConfckParseResult} extended
-* @returns void
-*/
-function extendTSConfig(extending, extended) {
-	const extendingConfig = extending.tsconfig;
-	const extendedConfig = extended.tsconfig;
-	const relativePath = native2posix(path.relative(path.dirname(extending.tsconfigFile), path.dirname(extended.tsconfigFile)));
-	for (const key of Object.keys(extendedConfig).filter((key$1) => EXTENDABLE_KEYS.includes(key$1))) if (key === "compilerOptions") {
-		if (!extendingConfig.compilerOptions) extendingConfig.compilerOptions = {};
-		for (const option of Object.keys(extendedConfig.compilerOptions)) {
-			if (Object.prototype.hasOwnProperty.call(extendingConfig.compilerOptions, option)) continue;
-			extendingConfig.compilerOptions[option] = rebaseRelative(option, extendedConfig.compilerOptions[option], relativePath);
-		}
-	} else if (extendingConfig[key] === void 0) if (key === "watchOptions") {
-		extendingConfig.watchOptions = {};
-		for (const option of Object.keys(extendedConfig.watchOptions)) extendingConfig.watchOptions[option] = rebaseRelative(option, extendedConfig.watchOptions[option], relativePath);
-	} else extendingConfig[key] = rebaseRelative(key, extendedConfig[key], relativePath);
-}
-const REBASE_KEYS = [
-	"files",
-	"include",
-	"exclude",
-	"baseUrl",
-	"rootDir",
-	"rootDirs",
-	"typeRoots",
-	"outDir",
-	"outFile",
-	"declarationDir",
-	"excludeDirectories",
-	"excludeFiles"
-];
-/** @typedef {string | string[]} PathValue */
-/**
-*
-* @param {string} key
-* @param {PathValue} value
-* @param {string} prependPath
-* @returns {PathValue}
-*/
-function rebaseRelative(key, value, prependPath) {
-	if (!REBASE_KEYS.includes(key)) return value;
-	if (Array.isArray(value)) return value.map((x$1) => rebasePath(x$1, prependPath));
-	else return rebasePath(value, prependPath);
-}
-/**
-*
-* @param {string} value
-* @param {string} prependPath
-* @returns {string}
-*/
-function rebasePath(value, prependPath) {
-	if (path.isAbsolute(value) || value.startsWith("${configDir}")) return value;
-	else return path.posix.normalize(path.posix.join(prependPath, value));
-}
-var TSConfckParseError = class TSConfckParseError extends Error {
-	/**
-	* error code
-	* @type {string}
-	*/
-	code;
-	/**
-	* error cause
-	* @type { Error | undefined}
-	*/
-	cause;
-	/**
-	* absolute path of tsconfig file where the error happened
-	* @type {string}
-	*/
-	tsconfigFile;
-	/**
-	*
-	* @param {string} message - error message
-	* @param {string} code - error code
-	* @param {string} tsconfigFile - path to tsconfig file
-	* @param {Error?} cause - cause of this error
-	*/
-	constructor(message, code, tsconfigFile, cause) {
-		super(message);
-		Object.setPrototypeOf(this, TSConfckParseError.prototype);
-		this.name = TSConfckParseError.name;
-		this.code = code;
-		this.cause = cause;
-		this.tsconfigFile = tsconfigFile;
-	}
-};
-/**
-*
-* @param {any} tsconfig
-* @param {string} tsconfigFile
-*/
-function applyDefaults(tsconfig, tsconfigFile) {
-	if (isJSConfig(tsconfigFile)) tsconfig.compilerOptions = {
-		...DEFAULT_JSCONFIG_COMPILER_OPTIONS,
-		...tsconfig.compilerOptions
-	};
-}
-const DEFAULT_JSCONFIG_COMPILER_OPTIONS = {
-	allowJs: true,
-	maxNodeModuleJsDepth: 2,
-	allowSyntheticDefaultImports: true,
-	skipLibCheck: true,
-	noEmit: true
-};
-/**
-* @param {string} configFileName
-*/
-function isJSConfig(configFileName) {
-	return path.basename(configFileName) === "jsconfig.json";
-}
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/parse-native.js
-/** @typedef TSDiagnosticError {
-code: number;
-category: number;
-messageText: string;
-start?: number;
-} TSDiagnosticError */
-
-//#endregion
-//#region node_modules/.pnpm/tsconfck@3.1.6_typescript@5.9.3/node_modules/tsconfck/src/cache.js
-/** @template T */
-var TSConfckCache = class {
-	/**
-	* clear cache, use this if you have a long running process and tsconfig files have been added,changed or deleted
-	*/
-	clear() {
-		this.#configPaths.clear();
-		this.#parsed.clear();
-	}
-	/**
-	* has cached closest config for files in dir
-	* @param {string} dir
-	* @param {string} [configName=tsconfig.json]
-	* @returns {boolean}
-	*/
-	hasConfigPath(dir, configName = "tsconfig.json") {
-		return this.#configPaths.has(`${dir}/${configName}`);
-	}
-	/**
-	* get cached closest tsconfig for files in dir
-	* @param {string} dir
-	* @param {string} [configName=tsconfig.json]
-	* @returns {Promise<string|null>|string|null}
-	* @throws {unknown} if cached value is an error
-	*/
-	getConfigPath(dir, configName = "tsconfig.json") {
-		const key = `${dir}/${configName}`;
-		const value = this.#configPaths.get(key);
-		if (value == null || value.length || value.then) return value;
-		else throw value;
-	}
-	/**
-	* has parsed tsconfig for file
-	* @param {string} file
-	* @returns {boolean}
-	*/
-	hasParseResult(file) {
-		return this.#parsed.has(file);
-	}
-	/**
-	* get parsed tsconfig for file
-	* @param {string} file
-	* @returns {Promise<T>|T}
-	* @throws {unknown} if cached value is an error
-	*/
-	getParseResult(file) {
-		const value = this.#parsed.get(file);
-		if (value.then || value.tsconfig) return value;
-		else throw value;
-	}
-	/**
-	* @internal
-	* @private
-	* @param file
-	* @param {boolean} isRootFile a flag to check if current file which involking the parse() api, used to distinguish the normal cache which only parsed by parseFile()
-	* @param {Promise<T>} result
-	*/
-	setParseResult(file, result, isRootFile = false) {
-		Object.defineProperty(result, "_isRootFile_", {
-			value: isRootFile,
-			writable: false,
-			enumerable: false,
-			configurable: false
-		});
-		this.#parsed.set(file, result);
-		result.then((parsed) => {
-			if (this.#parsed.get(file) === result) this.#parsed.set(file, parsed);
-		}).catch((e) => {
-			if (this.#parsed.get(file) === result) this.#parsed.set(file, e);
-		});
-	}
-	/**
-	* @internal
-	* @private
-	* @param {string} dir
-	* @param {Promise<string|null>} configPath
-	* @param {string} [configName=tsconfig.json]
-	*/
-	setConfigPath(dir, configPath, configName = "tsconfig.json") {
-		const key = `${dir}/${configName}`;
-		this.#configPaths.set(key, configPath);
-		configPath.then((path$1) => {
-			if (this.#configPaths.get(key) === configPath) this.#configPaths.set(key, path$1);
-		}).catch((e) => {
-			if (this.#configPaths.get(key) === configPath) this.#configPaths.set(key, e);
-		});
-	}
-	/**
-	* map directories to their closest tsconfig.json
-	* @internal
-	* @private
-	* @type{Map<string,(Promise<string|null>|string|null)>}
-	*/
-	#configPaths = /* @__PURE__ */ new Map();
-	/**
-	* map files to their parsed tsconfig result
-	* @internal
-	* @private
-	* @type {Map<string,(Promise<T>|T)> }
-	*/
-	#parsed = /* @__PURE__ */ new Map();
-};
-
-//#endregion
-//#region src/config/resolvers/tsconfig.ts
-async function resolveTsconfig(options) {
-	const root = resolve$1(options.rootDir || ".") + "/";
-	if (!options.typescript.tsConfig) options.typescript.tsConfig = await loadTsconfig(root);
-	if (options.experimental.tsconfigPaths && options.typescript.tsConfig.compilerOptions?.paths) options.alias = {
-		...tsConfigToAliasObj(options.typescript.tsConfig, root),
-		...options.alias
-	};
-}
-async function loadTsconfig(root) {
-	const opts = {
-		root,
-		cache: loadTsconfig["__cache"] ??= new TSConfckCache(),
-		ignoreNodeModules: true
-	};
-	const tsConfigPath = join$1(root, "tsconfig.json");
-	const parsed = await parse(tsConfigPath, opts).catch(() => void 0);
-	if (!parsed) return {};
-	const { tsconfig, tsconfigFile } = parsed;
-	tsconfig.compilerOptions ??= {};
-	if (!tsconfig.compilerOptions.baseUrl) tsconfig.compilerOptions.baseUrl = resolve$1(tsconfigFile, "..");
-	return tsconfig;
-}
-function tsConfigToAliasObj(tsconfig, root) {
-	const compilerOptions = tsconfig?.compilerOptions;
-	if (!compilerOptions?.paths) return {};
-	const paths = compilerOptions.paths;
-	const alias = {};
-	for (const [key, targets] of Object.entries(paths)) {
-		let source = key;
-		let target = targets?.[0];
-		if (!target) continue;
-		if (source.includes("*") || target.includes("*")) {
-			source = source.replace(/\/\*$/, "");
-			target = target.replace(/\/\*$/, "");
-			if (source.includes("*") || target.includes("*")) continue;
-		}
-		if (target.startsWith(".")) {
-			if (!compilerOptions.baseUrl) continue;
-			target = resolve$1(root, compilerOptions.baseUrl, target) + (key.endsWith("*") ? "/" : "");
-		}
-		alias[source] = target;
-	}
-	return alias;
-}
-
-//#endregion
-//#region src/config/resolvers/paths.ts
-const RESOLVE_EXTENSIONS = [
-	".ts",
-	".js",
-	".mts",
-	".mjs",
-	".tsx",
-	".jsx"
-];
-async function resolvePathOptions(options) {
-	options.rootDir = resolve$1(options.rootDir || ".") + "/";
-	options.buildDir = resolve$1(options.rootDir, options.buildDir || ".") + "/";
-	options.workspaceDir ||= await findWorkspaceDir(options.rootDir).catch(() => options.rootDir) + "/";
-	if (options.srcDir) {
-		if (options.serverDir === void 0) options.serverDir = options.srcDir;
-		consola$1.warn(`"srcDir" option is deprecated. Please use "serverDir" instead.`);
-	}
-	if (options.serverDir !== false) {
-		if (options.serverDir === true) options.serverDir = "server";
-		options.serverDir = resolve$1(options.rootDir, options.serverDir || ".") + "/";
-	}
-	options.alias ??= {};
-	if (!options.static && !options.entry) throw new Error(`Nitro entry is missing! Is "${options.preset}" preset correct?`);
-	if (options.entry) options.entry = resolveNitroPath(options.entry, options);
-	options.output.dir = resolveNitroPath(options.output.dir || NitroDefaults.output.dir, options, options.rootDir) + "/";
-	options.output.publicDir = resolveNitroPath(options.output.publicDir || NitroDefaults.output.publicDir, options, options.rootDir) + "/";
-	options.output.serverDir = resolveNitroPath(options.output.serverDir || NitroDefaults.output.serverDir, options, options.rootDir) + "/";
-	options.plugins = options.plugins.map((p$1) => resolveNitroPath(p$1, options));
-	if (options.serverDir) options.scanDirs.unshift(options.serverDir);
-	options.scanDirs = options.scanDirs.map((dir) => resolve$1(options.rootDir, dir));
-	options.scanDirs = [...new Set(options.scanDirs.map((dir) => dir + "/"))];
-	options.handlers = options.handlers.map((h) => {
-		return {
-			...h,
-			handler: resolveNitroPath(h.handler, options)
-		};
-	});
-	options.routes = Object.fromEntries(Object.entries(options.routes).map(([route, h]) => {
-		if (typeof h === "string") h = { handler: h };
-		h.handler = resolveNitroPath(h.handler, options);
-		return [route, h];
-	}));
-	if (options.serverEntry !== false) {
-		if (typeof options?.serverEntry === "string") options.serverEntry = { handler: options.serverEntry };
-		if (options.serverEntry?.handler) options.serverEntry.handler = resolveNitroPath(options.serverEntry.handler, options);
-		else {
-			const detected = resolveModulePath("./server", {
-				try: true,
-				from: options.rootDir,
-				extensions: RESOLVE_EXTENSIONS.flatMap((ext) => [ext, `.node${ext}`])
-			});
-			if (detected) {
-				options.serverEntry ??= { handler: "" };
-				options.serverEntry.handler = detected;
-				consola$1.info(`Detected \`${prettyPath(detected)}\` as server entry.`);
-			}
-		}
-		if (options.serverEntry?.handler && !options.serverEntry?.format) {
-			const isNode = /\.(node)\.\w+$/.test(options.serverEntry.handler);
-			options.serverEntry.format = isNode ? "node" : "web";
-		}
-	}
-	if (options.renderer === false) options.renderer = void 0;
-	else {
-		if (options.renderer?.handler) options.renderer.handler = resolveModulePath(resolveNitroPath(options.renderer?.handler, options), {
-			from: [options.rootDir, ...options.scanDirs],
-			extensions: RESOLVE_EXTENSIONS
-		});
-		if (options.renderer?.template) options.renderer.template = resolveModulePath(resolveNitroPath(options.renderer?.template, options), {
-			from: [options.rootDir, ...options.scanDirs],
-			extensions: [".html"]
-		});
-		else if (!options.renderer?.handler) {
-			const defaultIndex = resolveModulePath("./index.html", {
-				from: [options.rootDir, ...options.scanDirs],
-				extensions: [".html"],
-				try: true
-			});
-			if (defaultIndex) {
-				options.renderer ??= {};
-				options.renderer.template = defaultIndex;
-				consola$1.info(`Using \`${prettyPath(defaultIndex)}\` as renderer template.`);
-			}
-		}
-		if (options.renderer?.template && !options.renderer?.handler) {
-			options.renderer ??= {};
-			options.renderer.handler = join$1(runtimeDir, "internal/routes/renderer-template" + (options.dev ? ".dev" : ""));
-		}
-	}
-}
-
-//#endregion
-//#region src/config/resolvers/route-rules.ts
-async function resolveRouteRulesOptions(options) {
-	options.routeRules = normalizeRouteRules(options);
-}
-function normalizeRouteRules(config) {
-	const normalizedRules = {};
-	for (let path$1 in config.routeRules) {
-		const routeConfig = config.routeRules[path$1];
-		path$1 = withLeadingSlash(path$1);
-		const routeRules = {
-			...routeConfig,
-			redirect: void 0,
-			proxy: void 0
-		};
-		if (routeConfig.redirect) {
-			routeRules.redirect = {
-				to: "/",
-				status: 307,
-				...typeof routeConfig.redirect === "string" ? { to: routeConfig.redirect } : routeConfig.redirect
-			};
-			if (path$1.endsWith("/**")) routeRules.redirect._redirectStripBase = path$1.slice(0, -3);
-		}
-		if (routeConfig.proxy) {
-			routeRules.proxy = typeof routeConfig.proxy === "string" ? { to: routeConfig.proxy } : routeConfig.proxy;
-			if (path$1.endsWith("/**")) routeRules.proxy._proxyStripBase = path$1.slice(0, -3);
-		}
-		if (routeConfig.cors) routeRules.headers = {
-			"access-control-allow-origin": "*",
-			"access-control-allow-methods": "*",
-			"access-control-allow-headers": "*",
-			"access-control-max-age": "0",
-			...routeRules.headers
-		};
-		if (routeConfig.swr) {
-			routeRules.cache = routeRules.cache || {};
-			routeRules.cache.swr = true;
-			if (typeof routeConfig.swr === "number") routeRules.cache.maxAge = routeConfig.swr;
-		}
-		if (routeConfig.cache === false) routeRules.cache = false;
-		normalizedRules[path$1] = routeRules;
-	}
-	return normalizedRules;
-}
-
-//#endregion
-//#region src/config/resolvers/runtime-config.ts
-async function resolveRuntimeConfigOptions(options) {
-	options.runtimeConfig = normalizeRuntimeConfig(options);
-}
-function normalizeRuntimeConfig(config) {
-	provideFallbackValues(config.runtimeConfig || {});
-	const runtimeConfig = defu(config.runtimeConfig, {
-		app: { baseURL: config.baseURL },
-		nitro: {
-			envExpansion: config.experimental?.envExpansion,
-			openAPI: config.openAPI
-		}
-	});
-	runtimeConfig.nitro ??= {};
-	runtimeConfig.nitro.routeRules = config.routeRules;
-	checkSerializableRuntimeConfig(runtimeConfig);
-	return runtimeConfig;
-}
-function provideFallbackValues(obj) {
-	for (const key in obj) if (obj[key] === void 0 || obj[key] === null) obj[key] = "";
-	else if (typeof obj[key] === "object") provideFallbackValues(obj[key]);
-}
-function checkSerializableRuntimeConfig(obj, path$1 = []) {
-	if (isPrimitiveValue(obj)) return;
-	for (const key in obj) {
-		const value = obj[key];
-		if (value === null || value === void 0 || isPrimitiveValue(value)) continue;
-		if (Array.isArray(value)) for (const [index, item] of value.entries()) checkSerializableRuntimeConfig(item, [...path$1, `${key}[${index}]`]);
-		else if (typeof value === "object" && value.constructor === Object && (!value.constructor?.name || value.constructor.name === "Object")) checkSerializableRuntimeConfig(value, [...path$1, key]);
-		else console.warn(`Runtime config option \`${[...path$1, key].join(".")}\` may not be able to be serialized.`);
-	}
-}
-function isPrimitiveValue(value) {
-	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-
-//#endregion
-//#region src/config/resolvers/storage.ts
-async function resolveStorageOptions(options) {}
-
-//#endregion
-//#region src/config/resolvers/url.ts
-async function resolveURLOptions(options) {
-	options.baseURL = withLeadingSlash(withTrailingSlash(options.baseURL));
-}
-
-//#endregion
-//#region src/config/resolvers/error.ts
-async function resolveErrorOptions(options) {
-	if (!options.errorHandler) options.errorHandler = [];
-	else if (!Array.isArray(options.errorHandler)) options.errorHandler = [options.errorHandler];
-	options.errorHandler = options.errorHandler.map((h) => resolveNitroPath(h, options));
-	options.errorHandler.push(join$1(runtimeDir, `internal/error/${options.dev ? "dev" : "prod"}`));
-}
-
-//#endregion
-//#region src/config/resolvers/unenv.ts
-const common = {
-	meta: {
-		name: "nitro-common",
-		url: import.meta.url
-	},
-	alias: {
-		"buffer/": "node:buffer",
-		"buffer/index": "node:buffer",
-		"buffer/index.js": "node:buffer",
-		"string_decoder/": "node:string_decoder",
-		"process/": "node:process"
-	}
-};
-const nodeless = {
-	meta: {
-		name: "nitro-nodeless",
-		url: import.meta.url
-	},
-	inject: {
-		global: "unenv/polyfill/globalthis",
-		process: "node:process",
-		Buffer: ["node:buffer", "Buffer"],
-		clearImmediate: ["node:timers", "clearImmediate"],
-		setImmediate: ["node:timers", "setImmediate"],
-		performance: "unenv/polyfill/performance",
-		PerformanceObserver: ["node:perf_hooks", "PerformanceObserver"],
-		BroadcastChannel: ["node:worker_threads", "BroadcastChannel"]
-	},
-	polyfill: [
-		"unenv/polyfill/globalthis-global",
-		"unenv/polyfill/process",
-		"unenv/polyfill/buffer",
-		"unenv/polyfill/timers"
-	]
-};
-async function resolveUnenv(options) {
-	options.unenv ??= [];
-	if (!Array.isArray(options.unenv)) options.unenv = [options.unenv];
-	options.unenv = options.unenv.filter(Boolean);
-	if (!options.node) options.unenv.unshift(nodeless);
-	options.unenv.unshift(common);
-}
-
-//#endregion
-//#region src/config/resolvers/builder.ts
-const VALID_BUILDERS = [
-	"rolldown",
-	"rollup",
-	"vite"
-];
-async function resolveBuilder(options) {
-	options.builder ??= process.env.NITRO_BUILDER;
-	if (options.builder) {
-		if (!VALID_BUILDERS.includes(options.builder)) throw new Error(`Invalid nitro builder "${options.builder}". Valid builders are: ${VALID_BUILDERS.join(", ")}.`);
-		const pkg = options.builder;
-		if (!isPkgInstalled(pkg, options.rootDir)) {
-			if (!await consola$1.prompt(`Nitro builder package \`${pkg}\` is not installed. Would you like to install it?`, {
-				type: "confirm",
-				default: true,
-				cancel: "null"
-			})) throw new Error(`Nitro builder package "${options.builder}" is not installed. Please install it in your project dependencies.`);
-			await installPkg(pkg, options.rootDir);
-		}
-		return;
-	}
-	for (const pkg of [
-		"rolldown",
-		"rollup",
-		"vite"
-	]) if (isPkgInstalled(pkg, options.rootDir)) {
-		options.builder = pkg;
-		return;
-	}
-	const pkgToInstall = await consola$1.prompt(`No nitro builder specified. Which builder would you like to install?`, {
-		type: "select",
-		cancel: "null",
-		options: VALID_BUILDERS.map((b$1) => ({
-			label: b$1,
-			value: b$1
-		}))
-	});
-	if (!pkgToInstall) throw new Error(`No nitro builder specified. Please install one of the following packages: ${VALID_BUILDERS.join(", ")} and set it as the builder in your nitro config or via the NITRO_BUILDER environment variable.`);
-	await installPkg(pkgToInstall, options.rootDir);
-	options.builder = pkgToInstall;
-}
-const require = createRequire(process.cwd() + "/_index.js");
-function isPkgInstalled(pkg, root) {
-	try {
-		require.resolve(pkg, { paths: [root] });
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function installPkg(pkg, root) {
-	const { addDevDependency } = await import("../_libs/nypm+tinyexec.mjs");
-	return addDevDependency(pkg, { cwd: root });
-}
-
-//#endregion
-//#region src/config/loader.ts
-const configResolvers = [
-	resolveCompatibilityOptions,
-	resolveTsconfig,
-	resolvePathOptions,
-	resolveImportsOptions,
-	resolveRouteRulesOptions,
-	resolveDatabaseOptions,
-	resolveExportConditionsOptions,
-	resolveRuntimeConfigOptions,
-	resolveOpenAPIOptions,
-	resolveURLOptions,
-	resolveAssetsOptions,
-	resolveStorageOptions,
-	resolveErrorOptions,
-	resolveUnenv,
-	resolveBuilder
-];
-async function loadOptions(configOverrides = {}, opts = {}) {
-	const options = await _loadUserConfig(configOverrides, opts);
-	for (const resolver of configResolvers) await resolver(options);
-	return options;
-}
-async function _loadUserConfig(configOverrides = {}, opts = {}) {
-	configOverrides = klona(configOverrides);
-	globalThis.defineNitroConfig = globalThis.defineNitroConfig || ((c) => c);
-	let compatibilityDate = configOverrides.compatibilityDate || opts.compatibilityDate || process.env.NITRO_COMPATIBILITY_DATE || process.env.SERVER_COMPATIBILITY_DATE || process.env.COMPATIBILITY_DATE;
-	const { resolvePreset } = await import("../_presets.mjs");
-	let preset = configOverrides.preset || process.env.NITRO_PRESET || process.env.SERVER_PRESET;
-	const _dotenv = opts.dotenv ?? (configOverrides.dev && { fileName: [".env", ".env.local"] });
-	const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
-		name: "nitro",
-		cwd: configOverrides.rootDir,
-		dotenv: _dotenv,
-		extend: { extendKey: ["extends", "preset"] },
-		defaults: NitroDefaults,
-		jitiOptions: { alias: {
-			nitropack: "nitro/config",
-			"nitro/config": "nitro/config"
-		} },
-		async overrides({ rawConfigs }) {
-			const getConf = (key) => configOverrides[key] ?? rawConfigs.main?.[key] ?? rawConfigs.rc?.[key] ?? rawConfigs.packageJson?.[key];
-			if (!compatibilityDate) compatibilityDate = getConf("compatibilityDate");
-			const framework = getConf("framework");
-			const isCustomFramework = framework?.name && framework.name !== "nitro";
-			if (!preset) preset = getConf("preset");
-			if (configOverrides.dev) preset = preset && preset !== "nitro-dev" ? await resolvePreset(preset, {
-				static: getConf("static"),
-				dev: true,
-				compatibilityDate: compatibilityDate || "latest"
-			}).then((p$1) => p$1?._meta?.name || "nitro-dev").catch(() => "nitro-dev") : "nitro-dev";
-			else if (!preset) preset = await resolvePreset("", {
-				static: getConf("static"),
-				dev: false,
-				compatibilityDate: compatibilityDate || "latest"
-			}).then((p$1) => p$1?._meta?.name);
-			return {
-				...configOverrides,
-				preset,
-				typescript: {
-					generateRuntimeConfigTypes: !isCustomFramework,
-					...getConf("typescript"),
-					...configOverrides.typescript
-				}
-			};
-		},
-		async resolve(id) {
-			const preset$1 = await resolvePreset(id, {
-				static: configOverrides.static,
-				compatibilityDate: compatibilityDate || "latest",
-				dev: configOverrides.dev
-			});
-			if (preset$1) return { config: klona(preset$1) };
-		},
-		...opts.c12
-	});
-	const options = klona(loadedConfig.config);
-	options._config = configOverrides;
-	options._c12 = loadedConfig;
-	options.preset = (loadedConfig.layers || []).find((l) => l.config?._meta?.name)?.config?._meta?.name || preset;
-	options.compatibilityDate = resolveCompatibilityDates(compatibilityDate, options.compatibilityDate);
-	if (options.dev && options.preset !== "nitro-dev") consola$1.info(`Using \`${options.preset}\` emulation in development mode.`);
-	return options;
-}
-
-//#endregion
-//#region src/config/update.ts
-async function updateNitroConfig(nitro, config) {
-	nitro.options.routeRules = normalizeRouteRules(config.routeRules ? config : nitro.options);
-	nitro.options.runtimeConfig = normalizeRuntimeConfig(config.runtimeConfig ? config : nitro.options);
-	await nitro.hooks.callHook("rollup:reload");
-	consola$1.success("Nitro config hot reloaded!");
-}
-
-//#endregion
-//#region src/module.ts
-async function installModules(nitro) {
-	const _modules = [...nitro.options.modules || []];
-	const modules = await Promise.all(_modules.map((mod) => _resolveNitroModule(mod, nitro.options)));
-	const _installedURLs = /* @__PURE__ */ new Set();
-	for (const mod of modules) {
-		if (mod._url) {
-			if (_installedURLs.has(mod._url)) continue;
-			_installedURLs.add(mod._url);
-		}
-		await mod.setup(nitro);
-	}
-}
-async function _resolveNitroModule(mod, nitroOptions) {
-	let _url;
-	if (typeof mod === "string") mod = await import(resolveModuleURL(mod, {
-		from: [nitroOptions.rootDir],
-		extensions: [
-			".mjs",
-			".cjs",
-			".js",
-			".mts",
-			".cts",
-			".ts"
-		]
-	})).then((m) => m.default || m);
-	if (typeof mod === "function") mod = { setup: mod };
-	if ("nitro" in mod) mod = mod.nitro;
-	if (!mod.setup) throw new Error("Invalid Nitro module: missing setup() function.");
-	return {
-		_url,
-		...mod
-	};
-}
-
-//#endregion
-//#region node_modules/.pnpm/rou3@0.7.12/node_modules/rou3/dist/index.mjs
-const NullProtoObj = /* @__PURE__ */ (() => {
-	const e = function() {};
-	return e.prototype = Object.create(null), Object.freeze(e.prototype), e;
-})();
-/**
-* Create a new router context.
-*/
-function createRouter() {
-	return {
-		root: { key: "" },
-		static: new NullProtoObj()
-	};
-}
-function splitPath(path$1) {
-	const [_, ...s] = path$1.split("/");
-	return s[s.length - 1] === "" ? s.slice(0, -1) : s;
-}
-function getMatchParams(segments, paramsMap) {
-	const params = new NullProtoObj();
-	for (const [index, name] of paramsMap) {
-		const segment = index < 0 ? segments.slice(-(index + 1)).join("/") : segments[index];
-		if (typeof name === "string") params[name] = segment;
-		else {
-			const match = segment.match(name);
-			if (match) for (const key in match.groups) params[key] = match.groups[key];
-		}
-	}
-	return params;
-}
-/**
-* Add a route to the router context.
-*/
-function addRoute(ctx, method = "", path$1, data) {
-	method = method.toUpperCase();
-	if (path$1.charCodeAt(0) !== 47) path$1 = `/${path$1}`;
-	path$1 = path$1.replace(/\\:/g, "%3A");
-	const segments = splitPath(path$1);
-	let node = ctx.root;
-	let _unnamedParamIndex = 0;
-	const paramsMap = [];
-	const paramsRegexp = [];
-	for (let i = 0; i < segments.length; i++) {
-		let segment = segments[i];
-		if (segment.startsWith("**")) {
-			if (!node.wildcard) node.wildcard = { key: "**" };
-			node = node.wildcard;
-			paramsMap.push([
-				-(i + 1),
-				segment.split(":")[1] || "_",
-				segment.length === 2
-			]);
-			break;
-		}
-		if (segment === "*" || segment.includes(":")) {
-			if (!node.param) node.param = { key: "*" };
-			node = node.param;
-			if (segment === "*") paramsMap.push([
-				i,
-				`_${_unnamedParamIndex++}`,
-				true
-			]);
-			else if (segment.includes(":", 1)) {
-				const regexp = getParamRegexp(segment);
-				paramsRegexp[i] = regexp;
-				node.hasRegexParam = true;
-				paramsMap.push([
-					i,
-					regexp,
-					false
-				]);
-			} else paramsMap.push([
-				i,
-				segment.slice(1),
-				false
-			]);
-			continue;
-		}
-		if (segment === "\\*") segment = segments[i] = "*";
-		else if (segment === "\\*\\*") segment = segments[i] = "**";
-		const child = node.static?.[segment];
-		if (child) node = child;
-		else {
-			const staticNode = { key: segment };
-			if (!node.static) node.static = new NullProtoObj();
-			node.static[segment] = staticNode;
-			node = staticNode;
-		}
-	}
-	const hasParams = paramsMap.length > 0;
-	if (!node.methods) node.methods = new NullProtoObj();
-	node.methods[method] ??= [];
-	node.methods[method].push({
-		data: data || null,
-		paramsRegexp,
-		paramsMap: hasParams ? paramsMap : void 0
-	});
-	if (!hasParams) ctx.static["/" + segments.join("/")] = node;
-}
-function getParamRegexp(segment) {
-	const regex = segment.replace(/:(\w+)/g, (_, id) => `(?<${id}>[^/]+)`).replace(/\./g, "\\.");
-	return /* @__PURE__ */ new RegExp(`^${regex}$`);
-}
-/**
-* Find a route by path.
-*/
-function findRoute(ctx, method = "", path$1, opts) {
-	if (path$1.charCodeAt(path$1.length - 1) === 47) path$1 = path$1.slice(0, -1);
-	const staticNode = ctx.static[path$1];
-	if (staticNode && staticNode.methods) {
-		const staticMatch = staticNode.methods[method] || staticNode.methods[""];
-		if (staticMatch !== void 0) return staticMatch[0];
-	}
-	const segments = splitPath(path$1);
-	const match = _lookupTree(ctx, ctx.root, method, segments, 0)?.[0];
-	if (match === void 0) return;
-	if (opts?.params === false) return match;
-	return {
-		data: match.data,
-		params: match.paramsMap ? getMatchParams(segments, match.paramsMap) : void 0
-	};
-}
-function _lookupTree(ctx, node, method, segments, index) {
-	if (index === segments.length) {
-		if (node.methods) {
-			const match = node.methods[method] || node.methods[""];
-			if (match) return match;
-		}
-		if (node.param && node.param.methods) {
-			const match = node.param.methods[method] || node.param.methods[""];
-			if (match) {
-				const pMap = match[0].paramsMap;
-				if (pMap?.[pMap?.length - 1]?.[2]) return match;
-			}
-		}
-		if (node.wildcard && node.wildcard.methods) {
-			const match = node.wildcard.methods[method] || node.wildcard.methods[""];
-			if (match) {
-				const pMap = match[0].paramsMap;
-				if (pMap?.[pMap?.length - 1]?.[2]) return match;
-			}
-		}
-		return;
-	}
-	const segment = segments[index];
-	if (node.static) {
-		const staticChild = node.static[segment];
-		if (staticChild) {
-			const match = _lookupTree(ctx, staticChild, method, segments, index + 1);
-			if (match) return match;
-		}
-	}
-	if (node.param) {
-		const match = _lookupTree(ctx, node.param, method, segments, index + 1);
-		if (match) {
-			if (node.param.hasRegexParam) {
-				const exactMatch = match.find((m) => m.paramsRegexp[index]?.test(segment)) || match.find((m) => !m.paramsRegexp[index]);
-				return exactMatch ? [exactMatch] : void 0;
-			}
-			return match;
-		}
-	}
-	if (node.wildcard && node.wildcard.methods) return node.wildcard.methods[method] || node.wildcard.methods[""];
-}
-/**
-* Find all route patterns that match the given path.
-*/
-function findAllRoutes(ctx, method = "", path$1, opts) {
-	if (path$1.charCodeAt(path$1.length - 1) === 47) path$1 = path$1.slice(0, -1);
-	const segments = splitPath(path$1);
-	const matches = _findAll(ctx, ctx.root, method, segments, 0);
-	if (opts?.params === false) return matches;
-	return matches.map((m) => {
-		return {
-			data: m.data,
-			params: m.paramsMap ? getMatchParams(segments, m.paramsMap) : void 0
-		};
-	});
-}
-function _findAll(ctx, node, method, segments, index, matches = []) {
-	const segment = segments[index];
-	if (node.wildcard && node.wildcard.methods) {
-		const match = node.wildcard.methods[method] || node.wildcard.methods[""];
-		if (match) matches.push(...match);
-	}
-	if (node.param) {
-		_findAll(ctx, node.param, method, segments, index + 1, matches);
-		if (index === segments.length && node.param.methods) {
-			const match = node.param.methods[method] || node.param.methods[""];
-			if (match) {
-				const pMap = match[0].paramsMap;
-				if (pMap?.[pMap?.length - 1]?.[2]) matches.push(...match);
-			}
-		}
-	}
-	const staticChild = node.static?.[segment];
-	if (staticChild) _findAll(ctx, staticChild, method, segments, index + 1, matches);
-	if (index === segments.length && node.methods) {
-		const match = node.methods[method] || node.methods[""];
-		if (match) matches.push(...match);
-	}
-	return matches;
-}
-
-//#endregion
-//#region node_modules/.pnpm/rou3@0.7.12/node_modules/rou3/dist/compiler.mjs
-/**
-* Compile the router instance into a compact runnable code.
-*
-* **IMPORTANT:** Route data must be serializable to JSON (i.e., no functions or classes) or implement the `toJSON()` method to render custom code or you can pass custom `serialize` function in options.
-*
-* @example
-* import { createRouter, addRoute } from "rou3";
-* import { compileRouterToString } from "rou3/compiler";
-* const router = createRouter();
-* // [add some routes with serializable data]
-* const compilerCode = compileRouterToString(router, "findRoute");
-* // "const findRoute=(m, p) => {}"
-*/
-function compileRouterToString(router, functionName, opts) {
-	const ctx = {
-		opts: opts || {},
-		router,
-		data: [],
-		compileToString: true
-	};
-	let compiled = `(m,p)=>{${compileRouteMatch(ctx)}}`;
-	if (ctx.data.length > 0) compiled = `/* @__PURE__ */ (() => { ${`const ${ctx.data.map((v, i) => `$${i}=${v}`).join(",")};`}; return ${compiled}})()`;
-	return functionName ? `const ${functionName}=${compiled};` : compiled;
-}
-function compileRouteMatch(ctx) {
-	let code = "";
-	const staticNodes = /* @__PURE__ */ new Set();
-	for (const key in ctx.router.static) {
-		const node = ctx.router.static[key];
-		if (node?.methods) {
-			staticNodes.add(node);
-			code += `if(p===${JSON.stringify(key.replace(/\/$/, "") || "/")}){${compileMethodMatch(ctx, node.methods, [], -1)}}`;
-		}
-	}
-	const match = compileNode(ctx, ctx.router.root, [], 0, staticNodes);
-	if (match) code += `let s=p.split("/"),l=s.length-1;${match}`;
-	if (!code) return ctx.opts?.matchAll ? `return [];` : "";
-	return `${ctx.opts?.matchAll ? `let r=[];` : ""}if(p.charCodeAt(p.length-1)===47)p=p.slice(0,-1)||"/";${code}${ctx.opts?.matchAll ? "return r;" : ""}`;
-}
-function compileMethodMatch(ctx, methods, params, currentIdx) {
-	let code = "";
-	for (const key in methods) {
-		const matchers = methods[key];
-		if (matchers && matchers?.length > 0) {
-			if (key !== "") code += `if(m==="${key}")${matchers.length > 1 ? "{" : ""}`;
-			const _matchers = matchers.map((m) => compileFinalMatch(ctx, m, currentIdx, params)).sort((a$1, b$1) => b$1.weight - a$1.weight);
-			for (const matcher of _matchers) code += matcher.code;
-			if (key !== "") code += matchers.length > 1 ? "}" : "";
-		}
-	}
-	return code;
-}
-function compileFinalMatch(ctx, data, currentIdx, params) {
-	let ret = `{data:${serializeData(ctx, data.data)}`;
-	const conditions = [];
-	const { paramsMap, paramsRegexp } = data;
-	if (paramsMap && paramsMap.length > 0) {
-		if (!paramsMap[paramsMap.length - 1][2] && currentIdx !== -1) conditions.push(`l>=${currentIdx}`);
-		for (let i = 0; i < paramsRegexp.length; i++) {
-			const regexp = paramsRegexp[i];
-			if (!regexp) continue;
-			conditions.push(`${regexp.toString()}.test(s[${i + 1}])`);
-		}
-		ret += ",params:{";
-		for (let i = 0; i < paramsMap.length; i++) {
-			const map = paramsMap[i];
-			ret += typeof map[1] === "string" ? `${JSON.stringify(map[1])}:${params[i]},` : `...(${map[1].toString()}.exec(${params[i]}))?.groups,`;
-		}
-		ret += "}";
-	}
-	return {
-		code: (conditions.length > 0 ? `if(${conditions.join("&&")})` : "") + (ctx.opts?.matchAll ? `r.unshift(${ret}});` : `return ${ret}};`),
-		weight: conditions.length
-	};
-}
-function compileNode(ctx, node, params, startIdx, staticNodes) {
-	let code = "";
-	if (node.methods && !staticNodes.has(node)) {
-		const match = compileMethodMatch(ctx, node.methods, params, node.key === "*" ? startIdx : -1);
-		if (match) {
-			const hasLastOptionalParam = node.key === "*";
-			code += `if(l===${startIdx}${hasLastOptionalParam ? `||l===${startIdx - 1}` : ""}){${match}}`;
-		}
-	}
-	if (node.static) for (const key in node.static) {
-		const match = compileNode(ctx, node.static[key], params, startIdx + 1, staticNodes);
-		if (match) code += `if(s[${startIdx + 1}]===${JSON.stringify(key)}){${match}}`;
-	}
-	if (node.param) {
-		const match = compileNode(ctx, node.param, [...params, `s[${startIdx + 1}]`], startIdx + 1, staticNodes);
-		if (match) code += match;
-	}
-	if (node.wildcard) {
-		const { wildcard } = node;
-		if (wildcard.static || wildcard.param || wildcard.wildcard) throw new Error("Compiler mode does not support patterns after wildcard");
-		if (wildcard.methods) {
-			const match = compileMethodMatch(ctx, wildcard.methods, [...params, `s.slice(${startIdx + 1}).join('/')`], startIdx);
-			if (match) code += match;
-		}
-	}
-	return code;
-}
-function serializeData(ctx, value) {
-	if (ctx.compileToString) if (ctx.opts?.serialize) value = ctx.opts.serialize(value);
-	else if (typeof value?.toJSON === "function") value = value.toJSON();
-	else value = JSON.stringify(value);
-	let index = ctx.data.indexOf(value);
-	if (index === -1) {
-		ctx.data.push(value);
-		index = ctx.data.length - 1;
-	}
-	return `$${index}`;
-}
-
-//#endregion
-//#region src/routing.ts
-const isGlobalMiddleware = (h) => !h.method && (!h.route || h.route === "/**");
-function initNitroRouting(nitro) {
-	const envConditions = new Set([
-		nitro.options.dev ? "dev" : "prod",
-		nitro.options.preset,
-		nitro.options.preset === "nitro-prerender" ? "prerender" : void 0
-	].filter(Boolean));
-	const matchesEnv = (h) => {
-		const envs = (Array.isArray(h.env) ? h.env : [h.env]).filter(Boolean);
-		return envs.length === 0 || envs.some((env) => envConditions.has(env));
-	};
-	const routes = new Router(nitro.options.baseURL);
-	const routeRules = new Router(nitro.options.baseURL);
-	const globalMiddleware = [];
-	const routedMiddleware = new Router(nitro.options.baseURL);
-	const sync = () => {
-		routeRules._update(Object.entries(nitro.options.routeRules).map(([route, data]) => ({
-			route,
-			method: "",
-			data: {
-				...data,
-				_route: route
-			}
-		})));
-		const _routes = [
-			...Object.entries(nitro.options.routes).flatMap(([route, handler]) => {
-				if (typeof handler === "string") handler = { handler };
-				return {
-					...handler,
-					route,
-					middleware: false
-				};
-			}),
-			...nitro.options.handlers,
-			...nitro.scannedHandlers
-		].filter((h) => h && !h.middleware && matchesEnv(h));
-		if (nitro.options.serverEntry && nitro.options.serverEntry.handler) _routes.push({
-			route: "/**",
-			lazy: false,
-			format: nitro.options.serverEntry.format,
-			handler: nitro.options.serverEntry.handler
-		});
-		if (nitro.options.renderer?.handler) _routes.push({
-			route: "/**",
-			lazy: true,
-			handler: nitro.options.renderer?.handler
-		});
-		routes._update(_routes.map((h) => ({
-			...h,
-			method: h.method || "",
-			data: handlerWithImportHash(h)
-		})), { merge: true });
-		const _middleware = [...nitro.scannedHandlers, ...nitro.options.handlers].filter((h) => h && h.middleware && matchesEnv(h));
-		if (nitro.options.serveStatic) _middleware.unshift({
-			route: "/**",
-			middleware: true,
-			handler: join$1(runtimeDir, "internal/static")
-		});
-		globalMiddleware.splice(0, globalMiddleware.length, ..._middleware.filter((h) => isGlobalMiddleware(h)).map((m) => handlerWithImportHash(m)));
-		routedMiddleware._update(_middleware.filter((h) => !isGlobalMiddleware(h)).map((h) => ({
-			...h,
-			method: h.method || "",
-			data: handlerWithImportHash(h)
-		})));
-	};
-	nitro.routing = Object.freeze({
-		sync,
-		routes,
-		routeRules,
-		globalMiddleware,
-		routedMiddleware
-	});
-}
-function handlerWithImportHash(h) {
-	const id = (h.lazy ? "_lazy_" : "_") + hash(h.handler).replace(/-/g, "").slice(0, 6);
-	return {
-		...h,
-		_importHash: id
-	};
-}
-var Router = class {
-	_routes;
-	_router;
-	_compiled;
-	_baseURL;
-	constructor(baseURL) {
-		this._update([]);
-		this._baseURL = baseURL || "";
-		if (this._baseURL.endsWith("/")) this._baseURL = this._baseURL.slice(0, -1);
-	}
-	get routes() {
-		return this._routes;
-	}
-	_update(routes, opts) {
-		this._routes = routes;
-		this._router = createRouter();
-		this._compiled = void 0;
-		for (const route of routes) addRoute(this._router, route.method, this._baseURL + route.route, route.data);
-		if (opts?.merge) mergeCatchAll(this._router);
-	}
-	hasRoutes() {
-		return this._routes.length > 0;
-	}
-	compileToString(opts) {
-		const key = opts ? hash(opts) : "";
-		this._compiled ||= {};
-		if (this._compiled[key]) return this._compiled[key];
-		this._compiled[key] = compileRouterToString(this._router, void 0, opts);
-		if (this.routes.length === 1 && this.routes[0].route === "/**" && this.routes[0].method === "") {
-			const data = (opts?.serialize || JSON.stringify)(this.routes[0].data);
-			let retCode = `{data,params:{"_":p.slice(1)}}`;
-			if (opts?.matchAll) retCode = `[${retCode}]`;
-			this._compiled[key] = `/* @__PURE__ */ (() => {const data=${data};return ((_m, p)=>{return ${retCode};})})()`;
-		}
-		return this._compiled[key];
-	}
-	match(method, path$1) {
-		return findRoute(this._router, method, path$1)?.data;
-	}
-	matchAll(method, path$1) {
-		return findAllRoutes(this._router, method, path$1).map((route) => route.data);
-	}
-};
-function mergeCatchAll(router) {
-	const handlers = router.root?.wildcard?.methods?.[""];
-	if (!handlers || handlers.length < 2) return;
-	handlers.splice(0, handlers.length, {
-		...handlers[0],
-		data: handlers.map((h) => h.data)
-	});
-}
-
-//#endregion
-//#region src/global.ts
-const nitroInstances = globalThis.__nitro_instances__ ||= [];
-const globalKey = "__nitro_builder__";
-function registerNitroInstance(nitro) {
-	if (nitroInstances.includes(nitro)) return;
-	globalInit();
-	nitroInstances.unshift(nitro);
-	nitro.hooks.hookOnce("close", () => {
-		nitroInstances.splice(nitroInstances.indexOf(nitro), 1);
-		if (nitroInstances.length === 0) delete globalThis[globalKey];
-	});
-}
-function globalInit() {
-	if (globalThis[globalKey]) return;
-	globalThis[globalKey] = { async fetch(req) {
-		for (let r = 0; r < 10 && nitroInstances.length === 0; r++) await new Promise((resolve$2) => setTimeout(resolve$2, 300));
-		const nitro = nitroInstances[0];
-		if (!nitro) throw new Error("No Nitro instance is running.");
-		return nitro.fetch(req);
-	} };
-}
-
-//#endregion
-//#region src/nitro.ts
-async function createNitro(config = {}, opts = {}) {
-	const nitro = {
-		options: await loadOptions(config, opts),
-		hooks: new Hookable(),
-		vfs: /* @__PURE__ */ new Map(),
-		routing: {},
-		logger: consola.withTag("nitro"),
-		scannedHandlers: [],
-		fetch: () => {
-			throw new Error("no dev server attached!");
-		},
-		close: () => Promise.resolve(nitro.hooks.callHook("close")),
-		async updateConfig(config$1) {
-			updateNitroConfig(nitro, config$1);
-		}
-	};
-	registerNitroInstance(nitro);
-	initNitroRouting(nitro);
-	await scanAndSyncOptions(nitro);
-	if (nitro.options.debug) createDebugger(nitro.hooks, { tag: "nitro" });
-	if (nitro.options.logLevel !== void 0) nitro.logger.level = nitro.options.logLevel;
-	nitro.hooks.addHooks(nitro.options.hooks);
-	await installModules(nitro);
-	if (nitro.options.imports) {
-		const { createUnimport } = await import("../_libs/_4.mjs");
-		nitro.unimport = createUnimport(nitro.options.imports);
-		await nitro.unimport.init();
-		nitro.options.virtual["#imports"] = () => nitro.unimport?.toExports() || "";
-		nitro.options.virtual["#nitro"] = "export * from \"#imports\"";
-	}
-	await scanHandlers(nitro);
-	nitro.routing.sync();
-	return nitro;
-}
-
-//#endregion
-//#region src/build/build.ts
-async function build(nitro) {
-	switch (nitro.options.builder) {
-		case "rollup": {
-			const { rollupBuild } = await import("./nitro8.mjs");
-			return rollupBuild(nitro);
-		}
-		case "rolldown": {
-			const { rolldownBuild } = await import("../_build/rolldown.mjs");
-			return rolldownBuild(nitro);
-		}
-		case "vite": {
-			const { viteBuild } = await import("../_build/vite.build.mjs");
-			return viteBuild(nitro);
-		}
-		default: throw new Error(`Unknown builder: ${nitro.options.builder}`);
-	}
-}
-
-//#endregion
-//#region src/utils/compress.ts
-async function compressPublicAssets(nitro) {
-	const publicFiles = await glob("**", {
-		cwd: nitro.options.output.publicDir,
-		absolute: false,
-		dot: true,
-		ignore: ["**/*.gz", "**/*.br"]
-	});
-	await Promise.all(publicFiles.map(async (fileName) => {
-		const filePath = resolve$1(nitro.options.output.publicDir, fileName);
-		if (existsSync(filePath + ".gz") || existsSync(filePath + ".br")) return;
-		const mimeType = src_default.getType(fileName) || "text/plain";
-		const fileContents = await fsp.readFile(filePath);
-		if (fileContents.length < 1024 || fileName.endsWith(".map") || !isCompressibleMime(mimeType)) return;
-		const { gzip, brotli } = nitro.options.compressPublicAssets || {};
-		const encodings = [gzip !== false && "gzip", brotli !== false && "br"].filter(Boolean);
-		await Promise.all(encodings.map(async (encoding) => {
-			const compressedPath = filePath + ("." + (encoding === "gzip" ? "gz" : "br"));
-			if (existsSync(compressedPath)) return;
-			const gzipOptions = { level: zlib.constants.Z_BEST_COMPRESSION };
-			const brotliOptions = {
-				[zlib.constants.BROTLI_PARAM_MODE]: isTextMime(mimeType) ? zlib.constants.BROTLI_MODE_TEXT : zlib.constants.BROTLI_MODE_GENERIC,
-				[zlib.constants.BROTLI_PARAM_QUALITY]: zlib.constants.BROTLI_MAX_QUALITY,
-				[zlib.constants.BROTLI_PARAM_SIZE_HINT]: fileContents.length
-			};
-			const compressedBuff = await new Promise((resolve$2, reject) => {
-				const cb = (error, result) => error ? reject(error) : resolve$2(result);
-				if (encoding === "gzip") zlib.gzip(fileContents, gzipOptions, cb);
-				else zlib.brotliCompress(fileContents, brotliOptions, cb);
-			});
-			await fsp.writeFile(compressedPath, compressedBuff);
-		}));
-	}));
-}
-function isTextMime(mimeType) {
-	return /text|javascript|json|xml/.test(mimeType);
-}
-const COMPRESSIBLE_MIMES_RE = new Set([
-	"application/dash+xml",
-	"application/eot",
-	"application/font",
-	"application/font-sfnt",
-	"application/javascript",
-	"application/json",
-	"application/opentype",
-	"application/otf",
-	"application/pdf",
-	"application/pkcs7-mime",
-	"application/protobuf",
-	"application/rss+xml",
-	"application/truetype",
-	"application/ttf",
-	"application/vnd.apple.mpegurl",
-	"application/vnd.mapbox-vector-tile",
-	"application/vnd.ms-fontobject",
-	"application/wasm",
-	"application/xhtml+xml",
-	"application/xml",
-	"application/x-font-opentype",
-	"application/x-font-truetype",
-	"application/x-font-ttf",
-	"application/x-httpd-cgi",
-	"application/x-javascript",
-	"application/x-mpegurl",
-	"application/x-opentype",
-	"application/x-otf",
-	"application/x-perl",
-	"application/x-ttf",
-	"font/eot",
-	"font/opentype",
-	"font/otf",
-	"font/ttf",
-	"image/svg+xml",
-	"text/css",
-	"text/csv",
-	"text/html",
-	"text/javascript",
-	"text/js",
-	"text/plain",
-	"text/richtext",
-	"text/tab-separated-values",
-	"text/xml",
-	"text/x-component",
-	"text/x-java-source",
-	"text/x-script",
-	"vnd.apple.mpegurl"
-]);
-function isCompressibleMime(mimeType) {
-	return COMPRESSIBLE_MIMES_RE.has(mimeType);
-}
-
-//#endregion
-//#region src/build/assets.ts
-const NEGATION_RE = /^(!?)(.*)$/;
-const PARENT_DIR_GLOB_RE = /!?\.\.\//;
-async function scanUnprefixedPublicAssets(nitro) {
-	const scannedPaths = [];
-	for (const asset of nitro.options.publicAssets) {
-		if (asset.baseURL && asset.baseURL !== "/" && !asset.fallthrough) continue;
-		if (!await isDirectory(asset.dir)) continue;
-		const publicAssets = await glob(getIncludePatterns(nitro, asset.dir, asset.ignore), {
-			cwd: asset.dir,
-			absolute: false,
-			dot: true
-		});
-		scannedPaths.push(...publicAssets.map((file) => join$1(asset.baseURL || "/", file)));
-	}
-	return scannedPaths;
-}
-async function copyPublicAssets(nitro) {
-	if (nitro.options.noPublicDir) return;
-	for (const asset of nitro.options.publicAssets) {
-		const assetDir = asset.dir;
-		const dstDir = join$1(nitro.options.output.publicDir, asset.baseURL);
-		if (await isDirectory(assetDir)) {
-			const publicAssets = await glob(getIncludePatterns(nitro, assetDir, asset.ignore), {
-				cwd: assetDir,
-				absolute: false,
-				dot: true
-			});
-			await Promise.all(publicAssets.map(async (file) => {
-				const src = join$1(assetDir, file);
-				const dst = join$1(dstDir, file);
-				if (!existsSync(dst)) await promises.cp(src, dst);
-			}));
-		}
-	}
-	if (nitro.options.compressPublicAssets) await compressPublicAssets(nitro);
-	nitro.logger.success("Generated public " + prettyPath(nitro.options.output.publicDir));
-}
-function getIncludePatterns(nitro, assetDir, ignorePatterns = nitro.options.ignore) {
-	return ["**", ...(ignorePatterns || []).map((p$1) => {
-		const [_, negation, pattern] = p$1.match(NEGATION_RE) || [];
-		return (negation ? "" : "!") + (pattern.startsWith("*") ? pattern : relative$1(assetDir, resolve$1(nitro.options.rootDir, pattern)));
-	})].filter((p$1) => !PARENT_DIR_GLOB_RE.test(p$1));
-}
-
-//#endregion
-//#region src/build/prepare.ts
-async function prepare(nitro) {
-	await prepareDir(nitro.options.output.dir);
-	if (!nitro.options.noPublicDir) await prepareDir(nitro.options.output.publicDir);
-	if (!nitro.options.static) await prepareDir(nitro.options.output.serverDir);
-}
-async function prepareDir(dir) {
-	await fsp.rm(dir, {
-		recursive: true,
-		force: true
-	});
-	await fsp.mkdir(dir, { recursive: true });
-}
-
-//#endregion
-//#region node_modules/.pnpm/ultrahtml@1.6.0/node_modules/ultrahtml/dist/index.js
-var S = Symbol("Fragment"), D = new Set([
-	"area",
-	"base",
-	"br",
-	"col",
-	"embed",
-	"hr",
-	"img",
-	"input",
-	"keygen",
-	"link",
-	"meta",
-	"param",
-	"source",
-	"track",
-	"wbr"
-]), x = new Set(["script", "style"]), o = /(?:<(\/?)([a-zA-Z][a-zA-Z0-9\:-]*)(?:\s([^>]*?))?((?:\s*\/)?)>|(<\!\-\-)([\s\S]*?)(\-\->)|(<\!)([\s\S]*?)(>))/gm, b = /[\@\.a-z0-9_\:\-]/i;
-function I(e) {
-	let t = {};
-	if (e) {
-		let i = "none", r, n = "", a$1, l;
-		for (let c = 0; c < e.length; c++) {
-			let d$1 = e[c];
-			i === "none" ? b.test(d$1) ? (r && (t[r] = n, r = void 0, n = ""), a$1 = c, i = "key") : d$1 === "=" && r && (i = "value") : i === "key" ? b.test(d$1) || (r = e.substring(a$1, c), d$1 === "=" ? i = "value" : i = "none") : d$1 === l && c > 0 && e[c - 1] !== "\\" ? l && (n = e.substring(a$1, c), l = void 0, i = "none") : (d$1 === "\"" || d$1 === "'") && !l && (a$1 = c + 1, l = d$1);
-		}
-		i === "key" && a$1 != null && a$1 < e.length && (r = e.substring(a$1, e.length)), r && (t[r] = n);
-	}
-	return t;
-}
-function P(e) {
-	let t = typeof e == "string" ? e : e.value, i, r, n, a$1, l, c, d$1, m, s, u = [];
-	o.lastIndex = 0, r = i = {
-		type: 0,
-		children: []
-	};
-	let g = 0;
-	function h() {
-		a$1 = t.substring(g, o.lastIndex - n[0].length), a$1 && r.children.push({
-			type: 2,
-			value: a$1,
-			parent: r
-		});
-	}
-	for (; n = o.exec(t);) {
-		if (c = n[5] || n[8], d$1 = n[6] || n[9], m = n[7] || n[10], x.has(r.name) && n[2] !== r.name) {
-			l = o.lastIndex - n[0].length, r.children.length > 0 && (r.children[0].value += n[0]);
-			continue;
-		} else if (c === "<!--") {
-			if (l = o.lastIndex - n[0].length, x.has(r.name)) continue;
-			s = {
-				type: 3,
-				value: d$1,
-				parent: r,
-				loc: [{
-					start: l,
-					end: l + c.length
-				}, {
-					start: o.lastIndex - m.length,
-					end: o.lastIndex
-				}]
-			}, u.push(s), s.parent.children.push(s);
-		} else if (c === "<!") l = o.lastIndex - n[0].length, s = {
-			type: 4,
-			value: d$1,
-			parent: r,
-			loc: [{
-				start: l,
-				end: l + c.length
-			}, {
-				start: o.lastIndex - m.length,
-				end: o.lastIndex
-			}]
-		}, u.push(s), s.parent.children.push(s);
-		else if (n[1] !== "/") if (h(), x.has(r.name)) {
-			g = o.lastIndex, h();
-			continue;
-		} else s = {
-			type: 1,
-			name: n[2] + "",
-			attributes: I(n[3]),
-			parent: r,
-			children: [],
-			loc: [{
-				start: o.lastIndex - n[0].length,
-				end: o.lastIndex
-			}]
-		}, u.push(s), s.parent.children.push(s), n[4] && n[4].indexOf("/") > -1 || D.has(s.name) ? (s.loc[1] = s.loc[0], s.isSelfClosingTag = !0) : r = s;
-		else h(), n[2] + "" === r.name ? (s = r, r = s.parent, s.loc.push({
-			start: o.lastIndex - n[0].length,
-			end: o.lastIndex
-		}), a$1 = t.substring(s.loc[0].end, s.loc[1].start), s.children.length === 0 && s.children.push({
-			type: 2,
-			value: a$1,
-			parent: r
-		})) : n[2] + "" === u[u.length - 1].name && u[u.length - 1].isSelfClosingTag === !0 && (s = u[u.length - 1], s.loc.push({
-			start: o.lastIndex - n[0].length,
-			end: o.lastIndex
-		}));
-		g = o.lastIndex;
-	}
-	return a$1 = t.slice(g), r.children.push({
-		type: 2,
-		value: a$1,
-		parent: r
-	}), i;
-}
-var T = class {
-	constructor(t) {
-		this.callback = t;
-	}
-	async visit(t, i, r) {
-		if (await this.callback(t, i, r), Array.isArray(t.children)) {
-			let n = [];
-			for (let a$1 = 0; a$1 < t.children.length; a$1++) {
-				let l = t.children[a$1];
-				n.push(this.visit(l, t, a$1));
-			}
-			await Promise.all(n);
-		}
-	}
-}, O = class {
-	constructor(t) {
-		this.callback = t;
-	}
-	visit(t, i, r) {
-		if (this.callback(t, i, r), Array.isArray(t.children)) for (let n = 0; n < t.children.length; n++) {
-			let a$1 = t.children[n];
-			this.visit(a$1, t, n);
-		}
-	}
-}, p = Symbol("HTMLString"), M = Symbol("AttrString"), f = Symbol("RenderFn");
-function z(e, t) {
-	return new T(t).visit(e);
-}
-
-//#endregion
-//#region src/prerender/utils.ts
-const allowedExtensions = new Set(["", ".json"]);
-const linkParents = /* @__PURE__ */ new Map();
-const HTML_ENTITIES = {
-	"&lt;": "<",
-	"&gt;": ">",
-	"&amp;": "&",
-	"&apos;": "'",
-	"&quot;": "\""
-};
-function escapeHtml(text) {
-	return text.replace(/&(lt|gt|amp|apos|quot);/g, (ch) => HTML_ENTITIES[ch] || ch);
-}
-async function extractLinks(html, from, res, crawlLinks) {
-	const links = [];
-	const _links = [];
-	if (crawlLinks) await z(P(html), (node) => {
-		if (!node.attributes?.href) return;
-		const link = escapeHtml(node.attributes.href);
-		if (!decodeURIComponent(link).startsWith("#") && allowedExtensions.has(getExtension(link))) _links.push(link);
-	});
-	const header = res.headers.get("x-nitro-prerender") || "";
-	_links.push(...header.split(",").map((i) => decodeURIComponent(i.trim())));
-	for (const link of _links.filter(Boolean)) {
-		const _link = parseURL(link);
-		if (_link.protocol || _link.host) continue;
-		if (!_link.pathname.startsWith("/")) {
-			const fromURL = new URL(from, "http://localhost");
-			_link.pathname = new URL(_link.pathname, fromURL).pathname;
-		}
-		links.push(_link.pathname + _link.search);
-	}
-	for (const link of links) {
-		const _parents = linkParents.get(link);
-		if (_parents) _parents.add(from);
-		else linkParents.set(link, new Set([from]));
-	}
-	return links;
-}
-const EXT_REGEX = /\.[\da-z]+$/;
-function getExtension(link) {
-	return (parseURL(link).pathname.match(EXT_REGEX) || [])[0] || "";
-}
-function formatPrerenderRoute(route) {
-	let str = `  ├─ ${route.route} (${route.generateTimeMS}ms)`;
-	if (route.error) {
-		const parents = linkParents.get(route.route);
-		const errorColor = colors[route.error.status === 404 ? "yellow" : "red"];
-		const errorLead = parents?.size ? "├──" : "└──";
-		str += `\n  │ ${errorLead} ${errorColor(route.error.message)}`;
-		if (parents?.size) str += `\n${[...parents.values()].map((link) => `  │ └── Linked from ${link}`).join("\n")}`;
-	}
-	if (route.skip) str += colors.gray(" (skipped)");
-	return colors.gray(str);
-}
-function matchesIgnorePattern(path$1, pattern) {
-	if (typeof pattern === "string") return path$1.startsWith(pattern);
-	if (typeof pattern === "function") return pattern(path$1) === true;
-	if (pattern instanceof RegExp) return pattern.test(path$1);
-	return false;
-}
-
-//#endregion
-//#region src/prerender/prerender.ts
-const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
-async function prerender(nitro) {
-	if (nitro.options.noPublicDir) {
-		nitro.logger.warn("Skipping prerender since `noPublicDir` option is enabled.");
-		return;
-	}
-	if (nitro.options.builder === "vite") {
-		nitro.logger.warn("Skipping prerender since not supported with vite builder yet...");
-		return;
-	}
-	const routes = new Set(nitro.options.prerender.routes);
-	const prerenderRulePaths = Object.entries(nitro.options.routeRules).filter(([path$2, options]) => options.prerender && !path$2.includes("*")).map((e) => e[0]);
-	for (const route of prerenderRulePaths) routes.add(route);
-	await nitro.hooks.callHook("prerender:routes", routes);
-	if (routes.size === 0) if (nitro.options.prerender.crawlLinks) routes.add("/");
-	else return;
-	nitro.logger.info("Initializing prerenderer");
-	nitro._prerenderedRoutes = [];
-	nitro._prerenderMeta = nitro._prerenderMeta || {};
-	const prerendererConfig = {
-		...nitro.options._config,
-		static: false,
-		rootDir: nitro.options.rootDir,
-		logLevel: 0,
-		preset: "nitro-prerender"
-	};
-	await nitro.hooks.callHook("prerender:config", prerendererConfig);
-	const nitroRenderer = await createNitro(prerendererConfig);
-	const prerenderStartTime = Date.now();
-	await nitro.hooks.callHook("prerender:init", nitroRenderer);
-	let path$1 = relative$1(nitro.options.output.dir, nitro.options.output.publicDir);
-	if (!path$1.startsWith(".")) path$1 = `./${path$1}`;
-	nitroRenderer.options.commands.preview = `npx serve ${path$1}`;
-	nitroRenderer.options.output.dir = nitro.options.output.dir;
-	await build(nitroRenderer);
-	const serverFilename = typeof nitroRenderer.options.rollupConfig?.output?.entryFileNames === "string" ? nitroRenderer.options.rollupConfig.output.entryFileNames : "index.mjs";
-	const prerenderer = await import(pathToFileURL(resolve$1(nitroRenderer.options.output.serverDir, serverFilename)).href).then((m) => m.default);
-	const routeRules = createRouter();
-	for (const [route, rules] of Object.entries(nitro.options.routeRules)) addRoute(routeRules, void 0, route, rules);
-	const _getRouteRules = (path$2) => defu({}, ...findAllRoutes(routeRules, void 0, path$2).map((r) => r.data).reverse());
-	const generatedRoutes = /* @__PURE__ */ new Set();
-	const failedRoutes = /* @__PURE__ */ new Set();
-	const skippedRoutes = /* @__PURE__ */ new Set();
-	const displayedLengthWarns = /* @__PURE__ */ new Set();
-	const publicAssetBases = nitro.options.publicAssets.filter((a$1) => !!a$1.baseURL && a$1.baseURL !== "/" && !a$1.fallthrough).map((a$1) => withTrailingSlash(a$1.baseURL));
-	const scannedPublicAssets = nitro.options.prerender.ignoreUnprefixedPublicAssets ? new Set(await scanUnprefixedPublicAssets(nitro)) : /* @__PURE__ */ new Set();
-	const canPrerender = (route = "/") => {
-		if (generatedRoutes.has(route) || skippedRoutes.has(route)) return false;
-		if (nitro.options.prerender.ignore) {
-			for (const pattern of nitro.options.prerender.ignore) if (matchesIgnorePattern(route, pattern)) return false;
-		}
-		if (publicAssetBases.some((base) => route.startsWith(base))) return false;
-		if (scannedPublicAssets.has(route)) return false;
-		if (_getRouteRules(route).prerender === false) return false;
-		return true;
-	};
-	const canWriteToDisk = (route) => {
-		if (route.route.includes("?")) return false;
-		const FS_MAX_SEGMENT = 255;
-		const FS_MAX_PATH_PUBLIC_HTML = 1024 - (nitro.options.output.publicDir.length + 10);
-		if ((route.route.length >= FS_MAX_PATH_PUBLIC_HTML || route.route.split("/").some((s) => s.length > FS_MAX_SEGMENT)) && !displayedLengthWarns.has(route)) {
-			displayedLengthWarns.add(route);
-			const _route = route.route.slice(0, 60) + "...";
-			if (route.route.length >= FS_MAX_PATH_PUBLIC_HTML) nitro.logger.warn(`Prerendering long route "${_route}" (${route.route.length}) can cause filesystem issues since it exceeds ${FS_MAX_PATH_PUBLIC_HTML}-character limit when writing to \`${nitro.options.output.publicDir}\`.`);
-			else {
-				nitro.logger.warn(`Skipping prerender of the route "${_route}" since it exceeds the ${FS_MAX_SEGMENT}-character limit in one of the path segments and can cause filesystem issues.`);
-				return false;
-			}
-		}
-		return true;
-	};
-	const generateRoute = async (route) => {
-		const start = Date.now();
-		route = decodeURI(route);
-		if (!canPrerender(route)) {
-			skippedRoutes.add(route);
-			return;
-		}
-		generatedRoutes.add(route);
-		const _route = { route };
-		const encodedRoute = encodeURI(route);
-		const req = toRequest(withBase(encodedRoute, nitro.options.baseURL), { headers: [["x-nitro-prerender", encodedRoute]] });
-		const res = await prerenderer.fetch(req);
-		let dataBuff = Buffer.from(await res.arrayBuffer());
-		Object.defineProperty(_route, "contents", {
-			get: () => {
-				return dataBuff ? dataBuff.toString("utf8") : void 0;
-			},
-			set(value) {
-				if (dataBuff) dataBuff = Buffer.from(value);
-			}
-		});
-		Object.defineProperty(_route, "data", {
-			get: () => {
-				return dataBuff ? dataBuff.buffer : void 0;
-			},
-			set(value) {
-				if (dataBuff) dataBuff = Buffer.from(value);
-			}
-		});
-		if (![200, ...[
-			301,
-			302,
-			303,
-			304,
-			307,
-			308
-		]].includes(res.status)) {
-			_route.error = /* @__PURE__ */ new Error(`[${res.status}] ${res.statusText}`);
-			_route.error.status = res.status;
-			_route.error.statusText = res.statusText;
-		}
-		_route.generateTimeMS = Date.now() - start;
-		const contentType = res.headers.get("content-type") || "";
-		const isImplicitHTML = !route.endsWith(".html") && contentType.includes("html") && !JsonSigRx.test(dataBuff.subarray(0, 32).toString("utf8"));
-		const routeWithIndex = route.endsWith("/") ? route + "index" : route;
-		const htmlPath = route.endsWith("/") || nitro.options.prerender.autoSubfolderIndex ? joinURL(route, "index.html") : route + ".html";
-		_route.fileName = withoutBase(isImplicitHTML ? htmlPath : routeWithIndex, nitro.options.baseURL);
-		const inferredContentType = src_default.getType(_route.fileName) || "text/plain";
-		_route.contentType = contentType || inferredContentType;
-		await nitro.hooks.callHook("prerender:generate", _route, nitro);
-		if (_route.contentType !== inferredContentType) {
-			nitro._prerenderMeta[_route.fileName] ||= {};
-			nitro._prerenderMeta[_route.fileName].contentType = _route.contentType;
-		}
-		if (_route.error) failedRoutes.add(_route);
-		if (_route.skip || _route.error) {
-			await nitro.hooks.callHook("prerender:route", _route);
-			nitro.logger.log(formatPrerenderRoute(_route));
-			dataBuff = void 0;
-			return _route;
-		}
-		if (canWriteToDisk(_route)) {
-			await writeFile$1(join$1(nitro.options.output.publicDir, _route.fileName), dataBuff);
-			nitro._prerenderedRoutes.push(_route);
-		} else _route.skip = true;
-		if (!_route.error && (isImplicitHTML || route.endsWith(".html"))) {
-			const extractedLinks = await extractLinks(dataBuff.toString("utf8"), route, res, nitro.options.prerender.crawlLinks ?? false);
-			for (const _link of extractedLinks) if (canPrerender(_link)) routes.add(_link);
-		}
-		await nitro.hooks.callHook("prerender:route", _route);
-		nitro.logger.log(formatPrerenderRoute(_route));
-		dataBuff = void 0;
-		return _route;
-	};
-	nitro.logger.info(nitro.options.prerender.crawlLinks ? `Prerendering ${routes.size} initial routes with crawler` : `Prerendering ${routes.size} routes`);
-	await runParallel(routes, generateRoute, {
-		concurrency: nitro.options.prerender.concurrency || 1,
-		interval: nitro.options.prerender.interval
-	});
-	await prerenderer.close();
-	await nitro.hooks.callHook("prerender:done", {
-		prerenderedRoutes: nitro._prerenderedRoutes,
-		failedRoutes: [...failedRoutes]
-	});
-	if (nitro.options.prerender.failOnError && failedRoutes.size > 0) {
-		nitro.logger.log("\nErrors prerendering:");
-		for (const route of failedRoutes) nitro.logger.log(formatPrerenderRoute(route));
-		nitro.logger.log("");
-		throw new Error("Exiting due to prerender errors.");
-	}
-	const prerenderTimeInMs = Date.now() - prerenderStartTime;
-	nitro.logger.info(`Prerendered ${nitro._prerenderedRoutes.length} routes in ${prerenderTimeInMs / 1e3} seconds`);
-	if (nitro.options.compressPublicAssets) await compressPublicAssets(nitro);
-}
-
-//#endregion
-//#region src/task.ts
-/** @experimental */
-async function runTask(taskEvent, opts) {
-	return await (await _getTasksContext(opts)).devFetch(`/_nitro/tasks/${taskEvent.name}`, {
-		method: "POST",
-		body: taskEvent
-	});
-}
-/** @experimental */
-async function listTasks(opts) {
-	return (await (await _getTasksContext(opts)).devFetch("/_nitro/tasks")).tasks;
-}
-const _devHint = `(is dev server running?)`;
-async function _getTasksContext(opts) {
-	const buildInfoPath = resolve$1(resolve$1(resolve$1(process.cwd(), opts?.cwd || "."), opts?.buildDir || "node_modules/.nitro"), "nitro.dev.json");
-	if (!existsSync(buildInfoPath)) throw new Error(`Missing info file: \`${buildInfoPath}\` ${_devHint}`);
-	const buildInfo = JSON.parse(await readFile(buildInfoPath, "utf8"));
-	if (!buildInfo.dev?.pid || !buildInfo.dev?.workerAddress) throw new Error(`Missing dev server info in: \`${buildInfoPath}\` ${_devHint}`);
-	if (!_pidIsRunning(buildInfo.dev.pid)) throw new Error(`Dev server is not running (pid: ${buildInfo.dev.pid})`);
-	const baseURL = `http://${buildInfo.dev.workerAddress.host || "localhost"}:${buildInfo.dev.workerAddress.port || "3000"}`;
-	const socketPath = buildInfo.dev.workerAddress.socketPath;
-	const devFetch = (path$1, options) => {
-		return new Promise((resolve$2, reject) => {
-			let url = withBase(path$1, baseURL);
-			if (options?.query) url = withQuery(url, options.query);
-			const request = http.request(url, {
-				socketPath,
-				method: options?.method,
-				headers: {
-					Accept: "application/json",
-					"Content-Type": "application/json"
-				}
-			}, (response) => {
-				if (!response.statusCode || response.statusCode >= 400 && response.statusCode < 600) {
-					reject(new Error(response.statusMessage));
-					return;
-				}
-				let data = "";
-				response.on("data", (chunk) => data += chunk).on("end", () => resolve$2(JSON.parse(data))).on("error", (e) => reject(e));
-			});
-			request.on("error", (e) => reject(e));
-			if (options?.body) request.write(JSON.stringify(options.body));
-			request.end();
-		});
-	};
-	return {
-		buildInfo,
-		devFetch
-	};
-}
-function _pidIsRunning(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-//#endregion
-export { copyPublicAssets as a, loadOptions as c, prepare as i, runTask as n, build as o, prerender as r, createNitro as s, listTasks as t };