nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-121649-98b56dfe

package/dist/_chunks/B-7HiF0V.mjs

@@ -0,0 +1,1303 @@
+import { s as __toESM } from "./DXMHy5ca.mjs";
+import { T as resolve, b as join, f as resolveModulePath, o as findWorkspaceDir, r as loadConfig, t as watchConfig, w as relative, x as normalize } from "../_libs/c12.mjs";
+import { d as resolveModuleExportNames } from "../_libs/local-pkg.mjs";
+import { s as createUnimport } from "../_libs/unimport.mjs";
+import { t as glob } from "../_libs/tinyglobby.mjs";
+import { n as resolveCompatibilityDates, r as resolveCompatibilityDatesFromEnv } from "../_libs/compatx.mjs";
+import { n as klona } from "../_libs/klona.mjs";
+import { n as a, r as d } from "../_libs/std-env.mjs";
+import { t as escapeStringRegexp } from "../_libs/escape-string-regexp.mjs";
+import { a as scanAndSyncOptions, c as prettyPath, l as resolveNitroPath, o as scanHandlers, r as createStorage, s as isDirectory, t as runParallel, u as writeFile$1 } from "./B5ooyfLk.mjs";
+import { a as findRoute, i as findAllRoutes, n as addRoute, r as createRouter, t as compileRouterToString } from "../_libs/rou3.mjs";
+import { t as src_default } from "../_libs/mime.mjs";
+import { n as z, t as P } from "../_libs/ultrahtml.mjs";
+import consola$1, { consola } from "consola";
+import { Hookable, createDebugger } from "hookable";
+import { existsSync, promises } from "node:fs";
+import { joinURL, parseURL, withBase, withLeadingSlash, withTrailingSlash, withoutBase, withoutTrailingSlash } from "ufo";
+import { pathToFileURL } from "node:url";
+import fsp, { readFile } from "node:fs/promises";
+import { createJiti } from "jiti";
+import { defu } from "defu";
+import { pkgDir, runtimeDir } from "nitro/runtime/meta";
+import { colors } from "consola/utils";
+import { ofetch } from "ofetch";
+import { hash } from "ohash";
+import zlib from "node:zlib";
+
+//#region src/config/defaults.ts
+const NitroDefaults = {
+	compatibilityDate: "latest",
+	debug: d,
+	logLevel: a ? 1 : 3,
+	runtimeConfig: {
+		app: {},
+		nitro: {}
+	},
+	scanDirs: [],
+	buildDir: ".nitro",
+	output: {
+		dir: "{{ rootDir }}/.output",
+		serverDir: "{{ output.dir }}/server",
+		publicDir: "{{ output.dir }}/public"
+	},
+	experimental: {},
+	future: {},
+	storage: {},
+	devStorage: {},
+	bundledStorage: [],
+	publicAssets: [],
+	serverAssets: [],
+	plugins: [],
+	tasks: {},
+	scheduledTasks: {},
+	imports: false,
+	virtual: {},
+	compressPublicAssets: false,
+	ignore: [],
+	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,
+	routeRules: {},
+	prerender: {
+		autoSubfolderIndex: true,
+		concurrency: 1,
+		interval: 0,
+		retry: 3,
+		retryDelay: 500,
+		failOnError: false,
+		crawlLinks: false,
+		ignore: [],
+		routes: []
+	},
+	builder: void 0,
+	moduleSideEffects: ["unenv/polyfill/", resolve(runtimeDir, "polyfill/")],
+	replace: {},
+	node: true,
+	sourceMap: true,
+	esbuild: { options: {
+		jsxFactory: "h",
+		jsxFragment: "Fragment"
+	} },
+	typescript: {
+		strict: true,
+		generateRuntimeConfigTypes: false,
+		generateTsConfig: false,
+		tsconfigPath: "types/tsconfig.json",
+		internalPaths: false,
+		tsConfig: {}
+	},
+	nodeModulesDirs: [],
+	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(options.srcDir, publicAsset.dir);
+		publicAsset.baseURL = withLeadingSlash(withoutTrailingSlash(publicAsset.baseURL || "/"));
+	}
+	for (const dir of options.scanDirs) {
+		const publicDir = resolve(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(options.srcDir, serverAsset.dir);
+	options.serverAssets.push({
+		baseName: "server",
+		dir: resolve(options.srcDir, "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.push({
+			from: "nitro/runtime/internal/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.experimental.wasm
+	});
+}
+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");
+	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 src/config/resolvers/imports.ts
+async function resolveImportsOptions(options) {
+	if (options.imports === false) return;
+	options.imports.presets ??= [];
+	options.imports.presets.push(...getNitroImportsPreset());
+	const h3Exports = await resolveModuleExportNames("h3", { url: import.meta.url });
+	options.imports.presets ??= [];
+	options.imports.presets.push({
+		from: "h3",
+		imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
+	});
+	options.imports.dirs ??= [];
+	options.imports.dirs.push(...options.scanDirs.map((dir) => join(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[/\\]/);
+	}
+}
+function getNitroImportsPreset() {
+	return [
+		{
+			from: "nitro/runtime/internal/app",
+			imports: ["useNitroApp"]
+		},
+		{
+			from: "nitro/runtime/internal/runtime-config",
+			imports: ["useRuntimeConfig"]
+		},
+		{
+			from: "nitro/runtime/internal/plugin",
+			imports: ["defineNitroPlugin", "nitroPlugin"]
+		},
+		{
+			from: "nitro/runtime/internal/cache",
+			imports: [
+				"defineCachedFunction",
+				"defineCachedEventHandler",
+				"defineCachedHandler",
+				"cachedFunction",
+				"cachedEventHandler"
+			]
+		},
+		{
+			from: "nitro/runtime/internal/storage",
+			imports: ["useStorage"]
+		},
+		{
+			from: "nitro/runtime/internal/renderer",
+			imports: ["defineRenderHandler"]
+		},
+		{
+			from: "nitro/runtime/internal/meta",
+			imports: ["defineRouteMeta"]
+		},
+		{
+			from: "nitro/runtime/internal/route-rules",
+			imports: ["getRouteRules"]
+		},
+		{
+			from: "nitro/runtime/internal/context",
+			imports: ["useRequest"]
+		},
+		{
+			from: "nitro/runtime/internal/task",
+			imports: ["defineTask", "runTask"]
+		},
+		{
+			from: "nitro/runtime/internal/error/utils",
+			imports: ["defineNitroErrorHandler"]
+		},
+		{
+			from: "nitro/deps/ofetch",
+			imports: ["$fetch"]
+		}
+	];
+}
+
+//#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(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(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(runtimeDir, "internal/routes/swagger")
+		});
+	}
+	if (shouldPrerender) {
+		options.prerender ??= {};
+		options.prerender.routes ??= [];
+		options.prerender.routes.push(...prerenderRoutes);
+	}
+}
+
+//#endregion
+//#region src/config/resolvers/paths.ts
+const RESOLVE_EXTENSIONS = [
+	".ts",
+	".js",
+	".mts",
+	".mjs",
+	".tsx",
+	".jsx"
+];
+async function resolvePathOptions(options) {
+	options.rootDir = resolve(options.rootDir || ".") + "/";
+	options.workspaceDir ||= await findWorkspaceDir(options.rootDir).catch(() => options.rootDir) + "/";
+	for (const key of ["srcDir", "buildDir"]) options[key] = resolve(options.rootDir, options[key] || ".");
+	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.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
+	options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
+	options.nodeModulesDirs.push(resolve(pkgDir, "dist/node_modules"));
+	options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
+	options.nodeModulesDirs.push(resolve(pkgDir, ".."));
+	options.nodeModulesDirs = [...new Set(options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir) + "/"))];
+	options.plugins = options.plugins.map((p) => resolveNitroPath(p, options));
+	options.scanDirs.unshift(options.srcDir);
+	options.scanDirs = options.scanDirs.map((dir) => resolve(options.srcDir, dir));
+	options.scanDirs = [...new Set(options.scanDirs.map((dir) => dir + "/"))];
+	if (options.serverEntry) options.serverEntry = resolveModulePath(resolveNitroPath(options.serverEntry, options), {
+		from: options.scanDirs,
+		extensions: RESOLVE_EXTENSIONS
+	});
+	else {
+		const defaultServerEntry = resolveModulePath("./server", {
+			from: options.scanDirs,
+			extensions: RESOLVE_EXTENSIONS,
+			try: true
+		});
+		if (defaultServerEntry) {
+			options.serverEntry = defaultServerEntry;
+			consola$1.info(`Using \`${prettyPath(defaultServerEntry)}\` as server entry.`);
+		}
+	}
+	if (options.renderer?.entry) options.renderer.entry = resolveModulePath(resolveNitroPath(options.renderer?.entry, options), {
+		from: options.scanDirs,
+		extensions: RESOLVE_EXTENSIONS
+	});
+	if (options.renderer?.template) options.renderer.template = resolveModulePath(resolveNitroPath(options.renderer?.template, options), {
+		from: options.scanDirs,
+		extensions: [".html"]
+	});
+	else if (!options.renderer?.entry) {
+		const defaultIndex = resolveModulePath("./index.html", {
+			from: 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?.entry) {
+		options.renderer ??= {};
+		options.renderer.entry = join(runtimeDir, "internal/routes/renderer-template" + (options.dev ? ".dev" : ""));
+	}
+}
+
+//#endregion
+//#region src/config/resolvers/route-rules.ts
+async function resolveRouteRulesOptions(options) {
+	options.routeRules = defu(options.routeRules, options.routes || {});
+	options.routeRules = normalizeRouteRules(options);
+}
+function normalizeRouteRules(config) {
+	const normalizedRules = {};
+	for (let path in config.routeRules) {
+		const routeConfig = config.routeRules[path];
+		path = withLeadingSlash(path);
+		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.endsWith("/**")) routeRules.redirect._redirectStripBase = path.slice(0, -3);
+		}
+		if (routeConfig.proxy) {
+			routeRules.proxy = typeof routeConfig.proxy === "string" ? { to: routeConfig.proxy } : routeConfig.proxy;
+			if (path.endsWith("/**")) routeRules.proxy._proxyStripBase = path.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] = 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.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 = []) {
+	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, `${key}[${index}]`]);
+		else if (typeof value === "object" && value.constructor === Object && (!value.constructor?.name || value.constructor.name === "Object")) checkSerializableRuntimeConfig(value, [...path, key]);
+		else console.warn(`Runtime config option \`${[...path, 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) {
+	const fsMounts = {
+		root: resolve(options.rootDir),
+		src: resolve(options.srcDir),
+		build: resolve(options.buildDir),
+		cache: resolve(options.buildDir, "cache")
+	};
+	for (const p in fsMounts) options.devStorage[p] = options.devStorage[p] || {
+		driver: "fs",
+		readOnly: p === "root" || p === "src",
+		base: fsMounts[p]
+	};
+	if (options.dev && options.storage.data === void 0 && options.devStorage.data === void 0) options.devStorage.data = {
+		driver: "fs",
+		base: resolve(options.rootDir, ".data/kv")
+	};
+	else if (options.node && options.storage.data === void 0) options.storage.data = {
+		driver: "fsLite",
+		base: "./.data/kv"
+	};
+}
+
+//#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.push(join(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
+async function resolveBuilder(options) {
+	if (!options.builder) options.builder = process.env.NITRO_BUILDER || "rollup";
+	if (options.builder === "rolldown") try {
+		await import("rolldown");
+	} catch {
+		throw new Error(`Builder "rolldown" is not available. Make sure to install "rolldown" package.`);
+	}
+	else if (options.builder === "vite") try {
+		await import("vite");
+	} catch {
+		throw new Error(`Builder "vite" is not available. Make sure to install "vite" package.`);
+	}
+	if (![
+		"rollup",
+		"rolldown",
+		"vite"
+	].includes(options.builder)) throw new Error(`Builder "${options.builder}" is not supported.`);
+}
+
+//#endregion
+//#region src/config/loader.ts
+const configResolvers = [
+	resolveCompatibilityOptions,
+	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) => p?._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) => p?._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") {
+		globalThis.defineNitroModule = globalThis.defineNitroModule || ((mod$1) => mod$1);
+		const jiti = createJiti(nitroOptions.rootDir, { alias: nitroOptions.alias });
+		const _modPath = jiti.esmResolve(mod);
+		_url = _modPath;
+		mod = await jiti.import(_modPath, { default: true });
+	}
+	if (typeof mod === "function") mod = { setup: mod };
+	if (!mod.setup) mod.setup = () => {};
+	return {
+		_url,
+		...mod
+	};
+}
+
+//#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;
+}
+function addNitroTasksVirtualFile(nitro) {
+	nitro.options.virtual["#nitro-internal-virtual/tasks"] = () => {
+		const _scheduledTasks = Object.entries(nitro.options.scheduledTasks || {}).map(([cron, _tasks]) => {
+			return {
+				cron,
+				tasks: (Array.isArray(_tasks) ? _tasks : [_tasks]).filter((name) => {
+					if (!nitro.options.tasks[name]) {
+						nitro.logger.warn(`Scheduled task \`${name}\` is not defined!`);
+						return false;
+					}
+					return true;
+				})
+			};
+		}).filter((e) => e.tasks.length > 0);
+		const scheduledTasks = _scheduledTasks.length > 0 ? _scheduledTasks : false;
+		return `
+export const scheduledTasks = ${JSON.stringify(scheduledTasks)};
+
+export const tasks = {
+  ${Object.entries(nitro.options.tasks).map(([name, task]) => `"${name}": {
+          meta: {
+            description: ${JSON.stringify(task.description)},
+          },
+          resolve: ${task.handler ? `() => import("${normalize(task.handler)}").then(r => r.default || r)` : "undefined"},
+        }`).join(",\n")}
+};`;
+	};
+}
+const _devHint = `(is dev server running?)`;
+async function _getTasksContext(opts) {
+	const buildInfoPath = resolve(resolve(resolve(process.cwd(), opts?.cwd || "."), opts?.buildDir || ".nitro"), "nitro.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})`);
+	return {
+		buildInfo,
+		devFetch: ofetch.create({
+			baseURL: `http://${buildInfo.dev.workerAddress.host || "localhost"}:${buildInfo.dev.workerAddress.port || "3000"}`,
+			socketPath: buildInfo.dev.workerAddress.socketPath
+		})
+	};
+}
+function _pidIsRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#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();
+	const routeRules = new Router(true);
+	const globalMiddleware = [];
+	const routedMiddleware = new Router(true);
+	const warns = /* @__PURE__ */ new Set();
+	const sync = () => {
+		routeRules._update(Object.entries(nitro.options.routeRules).map(([route, data]) => ({
+			route,
+			method: "",
+			data: {
+				...data,
+				_route: route
+			}
+		})));
+		const _routes = [...nitro.scannedHandlers, ...nitro.options.handlers].filter((h) => h && !h.middleware && matchesEnv(h));
+		if (nitro.options.renderer?.entry) {
+			const existingWildcard = _routes.findIndex((h) => /^\/\*\*(:.+)?$/.test(h.route) && (!h.method || h.method === "GET"));
+			if (existingWildcard !== -1) {
+				const h = _routes[existingWildcard];
+				const warn = `The renderer will override \`${relative(".", h.handler)}\` (route: \`${h.route}\`). Use a more specific route or different HTTP method.`;
+				if (!warns.has(warn)) {
+					warns.add(warn);
+					nitro.logger.warn(warn);
+				}
+				_routes.splice(existingWildcard, 1);
+			}
+			_routes.push({
+				route: "/**",
+				lazy: true,
+				handler: nitro.options.renderer?.entry
+			});
+		}
+		routes._update(_routes.map((h) => ({
+			...h,
+			method: h.method || "",
+			data: handlerWithImportHash(h)
+		})));
+		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(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;
+	constructor(matchAll) {
+		this._update([]);
+	}
+	get routes() {
+		return this.#routes;
+	}
+	_update(routes) {
+		this.#routes = routes;
+		this.#router = createRouter();
+		this.#compiled = void 0;
+		for (const route of routes) addRoute(this.#router, route.method, route.route, route.data);
+	}
+	hasRoutes() {
+		return this.#routes.length > 0;
+	}
+	compileToString(opts) {
+		return this.#compiled || (this.#compiled = compileRouterToString(this.#router, void 0, opts));
+	}
+	match(method, path) {
+		return findRoute(this.#router, method, path)?.data;
+	}
+	matchAll(method, path) {
+		return findAllRoutes(this.#router, method, path).map((route) => route.data);
+	}
+};
+
+//#endregion
+//#region src/nitro.ts
+async function createNitro(config = {}, opts = {}) {
+	const nitro = {
+		options: await loadOptions(config, opts),
+		hooks: new Hookable(),
+		vfs: {},
+		routing: {},
+		logger: consola.withTag("nitro"),
+		scannedHandlers: [],
+		close: () => Promise.resolve(nitro.hooks.callHook("close")),
+		storage: void 0,
+		async updateConfig(config$1) {
+			updateNitroConfig(nitro, config$1);
+		}
+	};
+	initNitroRouting(nitro);
+	await scanAndSyncOptions(nitro);
+	nitro.storage = await createStorage(nitro);
+	nitro.hooks.hook("close", async () => {
+		await nitro.storage.dispose();
+	});
+	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);
+	addNitroTasksVirtualFile(nitro);
+	await installModules(nitro);
+	if (nitro.options.imports) {
+		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("../_build/rollup.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(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$1, reject) => {
+				const cb = (error, result) => error ? reject(error) : resolve$1(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), {
+			cwd: asset.dir,
+			absolute: false,
+			dot: true
+		});
+		scannedPaths.push(...publicAssets.map((file) => join(asset.baseURL || "/", file)));
+	}
+	return scannedPaths;
+}
+async function copyPublicAssets(nitro) {
+	if (nitro.options.noPublicDir) return;
+	for (const asset of nitro.options.publicAssets) {
+		const srcDir = asset.dir;
+		const dstDir = join(nitro.options.output.publicDir, asset.baseURL);
+		if (await isDirectory(srcDir)) {
+			const publicAssets = await glob(getIncludePatterns(nitro, srcDir), {
+				cwd: srcDir,
+				absolute: false,
+				dot: true
+			});
+			await Promise.all(publicAssets.map(async (file) => {
+				const src = join(srcDir, file);
+				const dst = join(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, srcDir) {
+	return ["**", ...nitro.options.ignore.map((p) => {
+		const [_, negation, pattern] = p.match(NEGATION_RE) || [];
+		return (negation ? "" : "!") + (pattern.startsWith("*") ? pattern : relative(srcDir, resolve(nitro.options.srcDir, pattern)));
+	})].filter((p) => !PARENT_DIR_GLOB_RE.test(p));
+}
+
+//#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 src/prerender/utils.ts
+const allowedExtensions = new Set(["", ".json"]);
+const linkParents$1 = /* @__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$1.get(link);
+		if (_parents) _parents.add(from);
+		else linkParents$1.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$1.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, pattern) {
+	if (typeof pattern === "string") return path.startsWith(pattern);
+	if (typeof pattern === "function") return pattern(path) === true;
+	if (pattern instanceof RegExp) return pattern.test(path);
+	return false;
+}
+
+//#endregion
+//#region src/prerender/prerender.ts
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+const linkParents = /* @__PURE__ */ new Map();
+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$1, options]) => options.prerender && !path$1.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 = relative(nitro.options.output.dir, nitro.options.output.publicDir);
+	if (!path.startsWith(".")) path = `./${path}`;
+	nitroRenderer.options.commands.preview = `npx serve ${path}`;
+	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 { closePrerenderer, appFetch } = await import(pathToFileURL(resolve(nitroRenderer.options.output.serverDir, serverFilename)).href);
+	const routeRules = createRouter();
+	for (const [route, rules] of Object.entries(nitro.options.routeRules)) addRoute(routeRules, void 0, route, rules);
+	const _getRouteRules = (path$1) => defu({}, ...findAllRoutes(routeRules, void 0, path$1).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;
+		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 res = await appFetch(withBase(encodedRoute, nitro.options.baseURL), { headers: [["x-nitro-prerender", encodedRoute]] });
+		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(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);
+			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,
+		interval: nitro.options.prerender.interval
+	});
+	await closePrerenderer();
+	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) {
+			const parents = linkParents.get(route.route);
+			parents?.size && `${[...parents.values()].map((link) => colors.gray(`  │ └── Linked from ${link}`)).join("\n")}`;
+			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
+export { createNitro as a, loadOptions as c, build as i, prepare as n, listTasks as o, copyPublicAssets as r, runTask as s, prerender as t };