nitro-nightly 3.0.1-20251217-221413-0e6f159e → 3.0.1-20251217-223946-1ee0b5b8

package/dist/_nitro3.mjs

@@ -1,1158 +0,0 @@
-import { i as __toESM } from "./_rolldown.mjs";
-import { C as isAbsolute, O as relative, T as normalize, h as resolveModulePath, k as resolve$1, w as join } from "./_libs/c12.mjs";
-import { i as unplugin } from "./_libs/unimport.mjs";
-import { t as glob } from "./_libs/tinyglobby.mjs";
-import { i as a, r as T, t as A } from "./_libs/std-env.mjs";
-import { t as src_default } from "./_libs/mime.mjs";
-import { i as genSafeVariableName, t as genImport } from "./_libs/knitwork.mjs";
-import { t as require_etag } from "./_libs/etag.mjs";
-import { t as replace } from "./_libs/@rollup/plugin-replace.mjs";
-import { t as unwasm } from "./_libs/unwasm.mjs";
-import { builtinModules, createRequire } from "node:module";
-import { consola } from "consola";
-import { camelCase } from "scule";
-import { promises } from "node:fs";
-import { joinURL, withTrailingSlash } from "ufo";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { readFile } from "node:fs/promises";
-import { pkgDir, presetsDir, runtimeDir } from "nitro/meta";
-import { hash } from "ohash";
-import { defineEnv } from "unenv";
-import { connectors } from "db0";
-import { RENDER_CONTEXT_KEYS, compileTemplateToString, hasTemplateSyntax } from "rendu";
-import { builtinDrivers, normalizeKey } from "unstorage";
-import { transformSync } from "oxc-transform";
-
-//#region src/utils/regex.ts
-function escapeRegExp(string) {
-	return string.replace(/[-\\^$*+?.()|[\]{}]/g, String.raw`\$&`);
-}
-function pathRegExp(string) {
-	if (A) string = string.replace(/\\/g, "/");
-	let escaped = escapeRegExp(string);
-	if (A) escaped = escaped.replace(/\//g, String.raw`[/\\]`);
-	return escaped;
-}
-function toPathRegExp(input) {
-	if (input instanceof RegExp) return input;
-	if (typeof input === "string") return new RegExp(pathRegExp(input));
-	throw new TypeError("Expected a string or RegExp", { cause: input });
-}
-
-//#endregion
-//#region src/build/config.ts
-function baseBuildConfig(nitro) {
-	const extensions = [
-		".ts",
-		".mjs",
-		".js",
-		".json",
-		".node",
-		".tsx",
-		".jsx"
-	];
-	const isNodeless = nitro.options.node === false;
-	const importMetaInjections = {
-		dev: nitro.options.dev,
-		preset: nitro.options.preset,
-		prerender: nitro.options.preset === "nitro-prerender",
-		nitro: true,
-		server: true,
-		client: false,
-		baseURL: nitro.options.baseURL,
-		_asyncContext: nitro.options.experimental.asyncContext,
-		_tasks: nitro.options.experimental.tasks
-	};
-	const replacements = {
-		...Object.fromEntries(Object.entries(importMetaInjections).map(([key, val]) => [`import.meta.${key}`, JSON.stringify(val)])),
-		...nitro.options.replace
-	};
-	const { env } = defineEnv({
-		nodeCompat: isNodeless,
-		resolve: true,
-		presets: nitro.options.unenv,
-		overrides: { alias: nitro.options.alias }
-	});
-	return {
-		extensions,
-		isNodeless,
-		replacements,
-		env,
-		aliases: resolveAliases({ ...env.alias }),
-		noExternal: getNoExternals(nitro),
-		ignoreWarningCodes: new Set([
-			"EVAL",
-			"CIRCULAR_DEPENDENCY",
-			"THIS_IS_UNDEFINED",
-			"EMPTY_BUNDLE"
-		])
-	};
-}
-function getNoExternals(nitro) {
-	const noExternal = [
-		/\.[mc]?tsx?$/,
-		/^(?:[\0#~.]|virtual:)/,
-		/* @__PURE__ */ new RegExp("^" + pathRegExp(pkgDir) + "(?!.*node_modules)"),
-		...[nitro.options.rootDir, ...nitro.options.scanDirs.filter((dir) => dir.includes("node_modules") || !dir.startsWith(nitro.options.rootDir))].map((dir) => /* @__PURE__ */ new RegExp("^" + pathRegExp(dir) + "(?!.*node_modules)"))
-	];
-	if (nitro.options.wasm !== false) noExternal.push(/\.wasm$/);
-	if (Array.isArray(nitro.options.noExternals)) noExternal.push(...nitro.options.noExternals.filter(Boolean).map((item) => toPathRegExp(item)));
-	return noExternal.sort((a$1, b) => a$1.source.length - b.source.length);
-}
-function resolveAliases(_aliases) {
-	const aliases = Object.fromEntries(Object.entries(_aliases).sort(([a$1], [b]) => b.split("/").length - a$1.split("/").length || b.length - a$1.length));
-	for (const key in aliases) for (const alias in aliases) {
-		if (![
-			"~",
-			"@",
-			"#"
-		].includes(alias[0])) continue;
-		if (alias === "@" && !aliases[key].startsWith("@/")) continue;
-		if (aliases[key].startsWith(alias)) aliases[key] = aliases[alias] + aliases[key].slice(alias.length);
-	}
-	return aliases;
-}
-
-//#endregion
-//#region src/build/chunks.ts
-const virtualRe = /^\0|^virtual:/;
-const NODE_MODULES_RE$1 = /node_modules[/\\][^.]/;
-function libChunkName(id) {
-	return `_libs/${id.match(/.*(?:[/\\])node_modules(?:[/\\])(?<package>@[^/\\]+[/\\][^/\\]+|[^/\\.][^/\\]*)/)?.groups?.package || "common"}`;
-}
-function getChunkName(chunk, nitro) {
-	if (chunk.name.startsWith("_libs/")) return `${chunk.name}.mjs`;
-	if (chunk.name === "rolldown-runtime") return "_runtime/rolldown.mjs";
-	if (chunk.moduleIds.length === 0) return `_chunks/${chunk.name}.mjs`;
-	const ids = chunk.moduleIds.filter((id) => !virtualRe.test(id));
-	if (ids.length === 0) {
-		if (chunk.moduleIds.every((id) => id.includes("virtual:raw"))) return `_raw/[name].mjs`;
-		return `_virtual/[name].mjs`;
-	}
-	if (ids.every((id) => id.endsWith(".wasm"))) return `_wasm/[name].mjs`;
-	if (ids.every((id) => id.includes("vite/services"))) return `_ssr/[name].mjs`;
-	if (ids.every((id) => id.startsWith(nitro.options.buildDir))) return `_build/[name].mjs`;
-	if (ids.every((id) => id.startsWith(runtimeDir) || id.startsWith(presetsDir))) return `_runtime/[name].mjs`;
-	const mainId = ids.at(-1);
-	if (mainId) {
-		const routeHandler = nitro.routing.routes.routes.flatMap((h) => h.data).find((h) => h.handler === mainId);
-		if (routeHandler?.route) return `_routes/${routeToFsPath(routeHandler.route)}.mjs`;
-		if (Object.entries(nitro.options.tasks).find(([_, task]) => task.handler === mainId)) return `_tasks/[name].mjs`;
-	}
-	return `_chunks/[name].mjs`;
-}
-function routeToFsPath(route) {
-	return route.split("/").slice(1).map((s) => `${s.replace(/[:*]+/g, "$").replace(/[^$a-zA-Z0-9_.[\]/]/g, "_")}`).join("/") || "index";
-}
-
-//#endregion
-//#region src/build/virtual/database.ts
-function database(nitro) {
-	return {
-		id: "#nitro/virtual/database",
-		template: () => {
-			if (!nitro.options.experimental.database) return `export const connectionConfigs = {};`;
-			const dbConfigs = nitro.options.dev && nitro.options.devDatabase || nitro.options.database;
-			const connectorsNames = [...new Set(Object.values(dbConfigs || {}).map((config) => config?.connector))].filter(Boolean);
-			for (const name of connectorsNames) if (!connectors[name]) throw new Error(`Database connector "${name}" is invalid.`);
-			return `
-${connectorsNames.map((name) => `import ${camelCase(name)}Connector from "${connectors[name]}";`).join("\n")}
-
-export const connectionConfigs = {
-  ${Object.entries(dbConfigs || {}).filter(([, config]) => !!config?.connector).map(([name, { connector, options }]) => `${name}: {
-          connector: ${camelCase(connector)}Connector,
-          options: ${JSON.stringify(options)}
-        }`).join(",\n")}
-};
-        `;
-		}
-	};
-}
-
-//#endregion
-//#region src/build/virtual/error-handler.ts
-function errorHandler(nitro) {
-	return {
-		id: "#nitro/virtual/error-handler",
-		template: () => {
-			const errorHandlers = Array.isArray(nitro.options.errorHandler) ? nitro.options.errorHandler : [nitro.options.errorHandler];
-			const builtinHandler = join(runtimeDir, `internal/error/${nitro.options.dev ? "dev" : "prod"}`);
-			return `
-${errorHandlers.map((h, i) => `import errorHandler$${i} from "${h}";`).join("\n")}
-
-const errorHandlers = [${errorHandlers.map((_, i) => `errorHandler$${i}`).join(", ")}];
-
-import { defaultHandler } from "${builtinHandler}";
-
-export default async function(error, event) {
-  for (const handler of errorHandlers) {
-    try {
-      const response = await handler(error, event, { defaultHandler });
-      if (response) {
-        return response;
-      }
-    } catch(error) {
-      // Handler itself thrown, log and continue
-      console.error(error);
-    }
-  }
-  // H3 will handle fallback
-}
-`;
-		}
-	};
-}
-
-//#endregion
-//#region src/build/virtual/feature-flags.ts
-function featureFlags(nitro) {
-	return {
-		id: "#nitro/virtual/feature-flags",
-		template: () => {
-			const featureFlags$1 = {
-				hasRoutes: nitro.routing.routes.hasRoutes(),
-				hasRouteRules: nitro.routing.routeRules.hasRoutes(),
-				hasRoutedMiddleware: nitro.routing.routedMiddleware.hasRoutes(),
-				hasGlobalMiddleware: nitro.routing.globalMiddleware.length > 0,
-				hasPlugins: nitro.options.plugins.length > 0,
-				hasHooks: nitro.options.features?.runtimeHooks ?? nitro.options.plugins.length > 0,
-				hasWebSocket: nitro.options.features?.websocket ?? nitro.options.experimental.websocket ?? false
-			};
-			return Object.entries(featureFlags$1).map(([key, value]) => `export const ${key} = ${Boolean(value)};`).join("\n");
-		}
-	};
-}
-
-//#endregion
-//#region src/build/virtual/plugins.ts
-function plugins(nitro) {
-	return {
-		id: "#nitro/virtual/plugins",
-		template: () => {
-			const nitroPlugins = [...new Set(nitro.options.plugins)];
-			return `
-  ${nitroPlugins.map((plugin) => `import _${hash(plugin).replace(/-/g, "")} from "${plugin}";`).join("\n")}
-
-  export const plugins = [
-    ${nitroPlugins.map((plugin) => `_${hash(plugin).replace(/-/g, "")}`).join(",\n")}
-  ]
-      `;
-		}
-	};
-}
-
-//#endregion
-//#region src/build/virtual/polyfills.ts
-function polyfills(_nitro, polyfills$1) {
-	return {
-		id: "#nitro/virtual/polyfills",
-		moduleSideEffects: true,
-		template: () => {
-			return polyfills$1.map((p) => `import '${p}';`).join("\n") || `/* No polyfills */`;
-		}
-	};
-}
-
-//#endregion
-//#region src/build/virtual/public-assets.ts
-var import_etag$1 = /* @__PURE__ */ __toESM(require_etag(), 1);
-const readAssetHandler = {
-	true: "node",
-	node: "node",
-	false: "null",
-	deno: "deno",
-	inline: "inline"
-};
-function publicAssets(nitro) {
-	return [
-		{
-			id: "#nitro/virtual/public-assets-data",
-			template: async () => {
-				const assets = {};
-				const files = await glob("**", {
-					cwd: nitro.options.output.publicDir,
-					absolute: false,
-					dot: true
-				});
-				for (const id of files) {
-					let mimeType = src_default.getType(id.replace(/\.(gz|br)$/, "")) || "text/plain";
-					if (mimeType.startsWith("text")) mimeType += "; charset=utf-8";
-					const fullPath = resolve$1(nitro.options.output.publicDir, id);
-					const assetData = await promises.readFile(fullPath);
-					const etag = (0, import_etag$1.default)(assetData);
-					const stat$2 = await promises.stat(fullPath);
-					const assetId = joinURL(nitro.options.baseURL, decodeURIComponent(id));
-					let encoding;
-					if (id.endsWith(".gz")) encoding = "gzip";
-					else if (id.endsWith(".br")) encoding = "br";
-					assets[assetId] = {
-						type: nitro._prerenderMeta?.[assetId]?.contentType || mimeType,
-						encoding,
-						etag,
-						mtime: stat$2.mtime.toJSON(),
-						size: stat$2.size,
-						path: relative(nitro.options.output.serverDir, fullPath),
-						data: nitro.options.serveStatic === "inline" ? assetData.toString("base64") : void 0
-					};
-				}
-				return `export default ${JSON.stringify(assets, null, 2)};`;
-			}
-		},
-		{
-			id: "#nitro/virtual/public-assets",
-			template: () => {
-				const publicAssetBases = Object.fromEntries(nitro.options.publicAssets.filter((dir) => !dir.fallthrough && dir.baseURL !== "/").map((dir) => [withTrailingSlash(joinURL(nitro.options.baseURL, dir.baseURL || "/")), { maxAge: dir.maxAge }]));
-				return `
-import assets from '#nitro/virtual/public-assets-data'
-export { readAsset } from "${`#nitro/virtual/public-assets-${readAssetHandler[nitro.options.serveStatic] || "null"}`}"
-export const publicAssetBases = ${JSON.stringify(publicAssetBases)}
-
-export function isPublicAssetURL(id = '') {
-  if (assets[id]) {
-    return true
-  }
-  for (const base in publicAssetBases) {
-    if (id.startsWith(base)) { return true }
-  }
-  return false
-}
-
-export function getPublicAssetMeta(id = '') {
-  for (const base in publicAssetBases) {
-    if (id.startsWith(base)) { return publicAssetBases[base] }
-  }
-  return {}
-}
-
-export function getAsset (id) {
-  return assets[id]
-}
-`;
-			}
-		},
-		{
-			id: "#nitro/virtual/public-assets-node",
-			template: () => {
-				return `
-import { promises as fsp } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { resolve, dirname } from 'node:path'
-import assets from '#nitro/virtual/public-assets-data'
-export function readAsset (id) {
-  const serverDir = dirname(fileURLToPath(globalThis.__nitro_main__))
-  return fsp.readFile(resolve(serverDir, assets[id].path))
-}`;
-			}
-		},
-		{
-			id: "#nitro/virtual/public-assets-deno",
-			template: () => {
-				return `
-import assets from '#nitro/virtual/public-assets-data'
-export function readAsset (id) {
-  // https://deno.com/deploy/docs/serve-static-assets
-  const path = '.' + decodeURIComponent(new URL(\`../public\${id}\`, 'file://').pathname)
-  return Deno.readFile(path);
-}`;
-			}
-		},
-		{
-			id: "#nitro/virtual/public-assets-null",
-			template: () => {
-				return `
-    export function readAsset (id) {
-        return Promise.resolve(null);
-    }`;
-			}
-		},
-		{
-			id: "#nitro/virtual/public-assets-inline",
-			template: () => {
-				return `
-  import assets from '#nitro/virtual/public-assets-data'
-  export function readAsset (id) {
-    if (!assets[id]) { return undefined }
-    if (assets[id]._data) { return assets[id]._data }
-    if (!assets[id].data) { return assets[id].data }
-    assets[id]._data = Uint8Array.from(atob(assets[id].data), (c) => c.charCodeAt(0))
-    return assets[id]._data
-}`;
-			}
-		}
-	];
-}
-
-//#endregion
-//#region src/build/virtual/renderer-template.ts
-function rendererTemplate(nitro) {
-	return {
-		id: "#nitro/virtual/renderer-template",
-		template: async () => {
-			const template = nitro.options.renderer?.template;
-			if (typeof template !== "string") return `
-            export const rendererTemplate = () => '<!-- renderer.template is not set -->';
-            export const rendererTemplateFile = undefined;
-            export const isStaticTemplate = true;`;
-			if (nitro.options.dev) return `
-            import { readFile } from 'node:fs/promises';
-            export const rendererTemplate = () => readFile(${JSON.stringify(template)}, "utf8");
-            export const rendererTemplateFile = ${JSON.stringify(template)};
-            export const isStaticTemplate = ${JSON.stringify(nitro.options.renderer?.static)};
-            `;
-			else {
-				const html = await readFile(template, "utf8");
-				if (nitro.options.renderer?.static ?? !hasTemplateSyntax(html)) return `
-              import { HTTPResponse } from "h3";
-              export const rendererTemplate = () => new HTTPResponse(${JSON.stringify(html)}, { headers: { "content-type": "text/html; charset=utf-8" } });
-            `;
-				else return `
-            import { renderToResponse } from 'rendu'
-            import { serverFetch } from 'nitro/app'
-            const template = ${compileTemplateToString(html, { contextKeys: [...RENDER_CONTEXT_KEYS] })};
-            export const rendererTemplate = (request) => renderToResponse(template, { request, context: { serverFetch } })
-            `;
-			}
-		}
-	};
-}
-
-//#endregion
-//#region src/build/virtual/routing-meta.ts
-function routingMeta(nitro) {
-	return {
-		id: "#nitro/virtual/routing-meta",
-		template: () => {
-			const routeHandlers = uniqueBy$1(Object.values(nitro.routing.routes.routes).flatMap((h) => h.data), "_importHash");
-			return `
-  ${routeHandlers.map((h) => `import ${h._importHash}Meta from "${h.handler}?meta";`).join("\n")}
-export const handlersMeta = [
-  ${routeHandlers.map((h) => `{ route: ${JSON.stringify(h.route)}, method: ${JSON.stringify(h.method?.toLowerCase())}, meta: ${h._importHash}Meta }`).join(",\n")}
-  ];
-        `.trim();
-		}
-	};
-}
-function uniqueBy$1(arr, key) {
-	return [...new Map(arr.map((item) => [item[key], item])).values()];
-}
-
-//#endregion
-//#region src/build/virtual/routing.ts
-const RuntimeRouteRules = [
-	"headers",
-	"redirect",
-	"proxy",
-	"cache"
-];
-function routing(nitro) {
-	return {
-		id: "#nitro/virtual/routing",
-		template: () => {
-			const allHandlers = uniqueBy([
-				...Object.values(nitro.routing.routes.routes).flatMap((h) => h.data),
-				...Object.values(nitro.routing.routedMiddleware.routes).map((h) => h.data),
-				...nitro.routing.globalMiddleware
-			], "_importHash");
-			return `
-import * as __routeRules__ from "#nitro/runtime/route-rules";
-import * as srvxNode from "srvx/node"
-import * as h3 from "h3";
-
-export const findRouteRules = ${nitro.routing.routeRules.compileToString({
-				serialize: serializeRouteRule,
-				matchAll: true
-			})}
-
-const multiHandler = (...handlers) => {
-  const final = handlers.pop()
-  const middleware = handlers.filter(Boolean).map(h => h3.toMiddleware(h));
-  return (ev) => h3.callMiddleware(ev, middleware, final);
-}
-
-${allHandlers.filter((h) => !h.lazy).map((h) => `import ${h._importHash} from "${h.handler}";`).join("\n")}
-
-${allHandlers.filter((h) => h.lazy).map((h) => `const ${h._importHash} = h3.defineLazyEventHandler(() => import("${h.handler}")${h.format === "node" ? ".then(m => srvxNode.toFetchHandler(m.default))" : ""});`).join("\n")}
-
-export const findRoute = ${nitro.routing.routes.compileToString({ serialize: serializeHandler })}
-
-export const findRoutedMiddleware = ${nitro.routing.routedMiddleware.compileToString({
-				serialize: serializeHandler,
-				matchAll: true
-			})};
-
-export const globalMiddleware = [
-  ${nitro.routing.globalMiddleware.map((h) => h.lazy ? h._importHash : `h3.toEventHandler(${h._importHash})`).join(",")}
-].filter(Boolean);
-  `;
-		}
-	};
-}
-function uniqueBy(arr, key) {
-	return [...new Map(arr.map((item) => [item[key], item])).values()];
-}
-function serializeHandler(h) {
-	const meta = Array.isArray(h) ? h[0] : h;
-	return `{${[
-		`route:${JSON.stringify(meta.route)}`,
-		meta.method && `method:${JSON.stringify(meta.method)}`,
-		meta.meta && `meta:${JSON.stringify(meta.meta)}`,
-		`handler:${Array.isArray(h) ? `multiHandler(${h.map((handler) => serializeHandlerFn(handler)).join(",")})` : serializeHandlerFn(h)}`
-	].filter(Boolean).join(",")}}`;
-}
-function serializeHandlerFn(h) {
-	let code = h._importHash;
-	if (!h.lazy) {
-		if (h.format === "node") code = `srvxNode.toFetchHandler(${code})`;
-		code = `h3.toEventHandler(${code})`;
-	}
-	return code;
-}
-function serializeRouteRule(h) {
-	return `[${Object.entries(h).filter(([name, options]) => options !== void 0 && name[0] !== "_").map(([name, options]) => {
-		return `{${[
-			`name:${JSON.stringify(name)}`,
-			`route:${JSON.stringify(h._route)}`,
-			h._method && `method:${JSON.stringify(h._method)}`,
-			RuntimeRouteRules.includes(name) && `handler:__routeRules__.${name}`,
-			`options:${JSON.stringify(options)}`
-		].filter(Boolean).join(",")}}`;
-	}).join(",")}]`;
-}
-
-//#endregion
-//#region src/build/virtual/runtime-config.ts
-function runtimeConfig(nitro) {
-	return {
-		id: "#nitro/virtual/runtime-config",
-		template: () => {
-			return `export const runtimeConfig = ${JSON.stringify(nitro.options.runtimeConfig || {})};`;
-		}
-	};
-}
-
-//#endregion
-//#region src/build/virtual/server-assets.ts
-var import_etag = /* @__PURE__ */ __toESM(require_etag(), 1);
-function serverAssets(nitro) {
-	return {
-		id: "#nitro/virtual/server-assets",
-		template: async () => {
-			if (nitro.options.dev || nitro.options.preset === "nitro-prerender") return `
-          import { createStorage } from 'unstorage'
-          import fsDriver from 'unstorage/drivers/fs'
-          const serverAssets = ${JSON.stringify(nitro.options.serverAssets)}
-          export const assets = createStorage()
-          for (const asset of serverAssets) {
-            assets.mount(asset.baseName, fsDriver({ base: asset.dir, ignore: (asset?.ignore || []) }))
-          }`;
-			const assets = {};
-			for (const asset of nitro.options.serverAssets) {
-				const files = await glob(asset.pattern || "**/*", {
-					cwd: asset.dir,
-					absolute: false,
-					ignore: asset.ignore
-				});
-				for (const _id of files) {
-					const fsPath = resolve$1(asset.dir, _id);
-					const id = asset.baseName + "/" + _id;
-					assets[id] = {
-						fsPath,
-						meta: {}
-					};
-					let type = src_default.getType(id) || "text/plain";
-					if (type.startsWith("text")) type += "; charset=utf-8";
-					const etag = (0, import_etag.default)(await promises.readFile(fsPath));
-					const mtime = await promises.stat(fsPath).then((s) => s.mtime.toJSON());
-					assets[id].meta = {
-						type,
-						etag,
-						mtime
-					};
-				}
-			}
-			return `
-const _assets = {\n${Object.entries(assets).map(([id, asset]) => `  [${JSON.stringify(normalizeKey(id))}]: {\n    import: () => import(${JSON.stringify("raw:" + asset.fsPath)}).then(r => r.default || r),\n    meta: ${JSON.stringify(asset.meta)}\n  }`).join(",\n")}\n}
-
-const normalizeKey = ${normalizeKey.toString()}
-
-export const assets = {
-  getKeys() {
-    return Promise.resolve(Object.keys(_assets))
-  },
-  hasItem (id) {
-    id = normalizeKey(id)
-    return Promise.resolve(id in _assets)
-  },
-  getItem (id) {
-    id = normalizeKey(id)
-    return Promise.resolve(_assets[id] ? _assets[id].import() : null)
-  },
-  getMeta (id) {
-    id = normalizeKey(id)
-    return Promise.resolve(_assets[id] ? _assets[id].meta : {})
-  }
-}
-`;
-		}
-	};
-}
-
-//#endregion
-//#region src/build/virtual/storage.ts
-function storage(nitro) {
-	return {
-		id: "#nitro/virtual/storage",
-		template: () => {
-			const mounts = [];
-			const storageMounts = nitro.options.dev || nitro.options.preset === "nitro-prerender" ? {
-				...nitro.options.storage,
-				...nitro.options.devStorage
-			} : nitro.options.storage;
-			for (const path in storageMounts) {
-				const { driver: driverName, ...driverOpts } = storageMounts[path];
-				mounts.push({
-					path,
-					driver: builtinDrivers[driverName] || driverName,
-					opts: driverOpts
-				});
-			}
-			return `
-import { createStorage } from 'unstorage'
-import { assets } from '#nitro/virtual/server-assets'
-
-${[...new Set(mounts.map((m) => m.driver))].map((i) => genImport(i, genSafeVariableName(i))).join("\n")}
-
-export function initStorage() {
-  const storage = createStorage({})
-  storage.mount('/assets', assets)
-  ${mounts.map((m) => `storage.mount('${m.path}', ${genSafeVariableName(m.driver)}(${JSON.stringify(m.opts)}))`).join("\n")}
-  return storage
-}
-`;
-		}
-	};
-}
-
-//#endregion
-//#region src/build/virtual/tasks.ts
-function tasks(nitro) {
-	return {
-		id: "#nitro/virtual/tasks",
-		template: () => {
-			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")}
-};`;
-		}
-	};
-}
-
-//#endregion
-//#region src/build/virtual/_all.ts
-function virtualTemplates(nitro, _polyfills) {
-	const nitroTemplates = [
-		database,
-		errorHandler,
-		featureFlags,
-		plugins,
-		polyfills,
-		publicAssets,
-		rendererTemplate,
-		routingMeta,
-		routing,
-		runtimeConfig,
-		serverAssets,
-		storage,
-		tasks
-	].flatMap((t) => t(nitro, _polyfills));
-	const customTemplates = Object.entries(nitro.options.virtual).map(([id, template]) => ({
-		id,
-		template
-	}));
-	return [...nitroTemplates, ...customTemplates];
-}
-
-//#endregion
-//#region src/build/plugins/route-meta.ts
-const PREFIX$1 = "\0nitro:route-meta:";
-function routeMeta(nitro) {
-	return {
-		name: "nitro:route-meta",
-		resolveId: {
-			filter: { id: /^(?!\u0000)(.+)\?meta$/ },
-			async handler(id, importer, resolveOpts) {
-				if (id.endsWith("?meta")) {
-					const resolved = await this.resolve(id.replace("?meta", ""), importer, resolveOpts);
-					if (!resolved) return;
-					return PREFIX$1 + resolved.id;
-				}
-			}
-		},
-		load: {
-			filter: { id: /* @__PURE__ */ new RegExp(`^${escapeRegExp(PREFIX$1)}`) },
-			handler(id) {
-				if (id.startsWith(PREFIX$1)) {
-					const fullPath = id.slice(18);
-					if (isAbsolute(fullPath)) return readFile(fullPath, { encoding: "utf8" });
-					else return "export default undefined;";
-				}
-			}
-		},
-		transform: {
-			filter: { id: /* @__PURE__ */ new RegExp(`^${escapeRegExp(PREFIX$1)}`) },
-			async handler(code, id) {
-				let meta = null;
-				try {
-					const transformRes = transformSync(id, code);
-					if (transformRes.errors?.length > 0) {
-						for (const error of transformRes.errors) this.warn(error);
-						return {
-							code: `export default {};`,
-							map: null
-						};
-					}
-					const ast = this.parse(transformRes.code);
-					for (const node of ast.body) if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" && node.expression.callee.name === "defineRouteMeta" && node.expression.arguments.length === 1) {
-						meta = astToObject(node.expression.arguments[0]);
-						break;
-					}
-				} catch (error) {
-					nitro.logger.warn(`[handlers-meta] Cannot extra route meta for: ${id}: ${error}`);
-				}
-				return {
-					code: `export default ${JSON.stringify(meta)};`,
-					map: null
-				};
-			}
-		}
-	};
-}
-function astToObject(node) {
-	switch (node.type) {
-		case "ObjectExpression": {
-			const obj = {};
-			for (const prop of node.properties) if (prop.type === "Property") {
-				const key = prop.key.name ?? prop.key.value;
-				obj[key] = astToObject(prop.value);
-			}
-			return obj;
-		}
-		case "ArrayExpression": return node.elements.map((el) => astToObject(el)).filter(Boolean);
-		case "Literal": return node.value;
-	}
-}
-
-//#endregion
-//#region src/build/plugins/server-main.ts
-function serverMain(nitro) {
-	return {
-		name: "nitro:server-main",
-		renderChunk(code, chunk) {
-			if (chunk.isEntry) return {
-				code: `globalThis.__nitro_main__ = import.meta.url; ${code}`,
-				map: null
-			};
-		}
-	};
-}
-
-//#endregion
-//#region package.json
-var version$2 = "3.0.1-alpha.1";
-
-//#endregion
-//#region src/runtime/meta.ts
-const version$1 = version$2;
-const resolve = (path) => fileURLToPath(new URL(path, import.meta.url));
-const runtimeDir$1 = /* @__PURE__ */ resolve("./");
-const runtimeDependencies$1 = [
-	"crossws",
-	"croner",
-	"db0",
-	"defu",
-	"destr",
-	"h3",
-	"rou3",
-	"hookable",
-	"ofetch",
-	"ohash",
-	"rendu",
-	"scule",
-	"srvx",
-	"ufo",
-	"unctx",
-	"unenv",
-	"unstorage"
-];
-
-//#endregion
-//#region src/build/plugins/virtual.ts
-function virtual(input) {
-	const modules = /* @__PURE__ */ new Map();
-	for (const mod of input) {
-		const render = () => typeof mod.template === "function" ? mod.template() : mod.template;
-		modules.set(mod.id, {
-			module: mod,
-			render
-		});
-	}
-	const include = [/^#nitro\/virtual/];
-	const extraIds = [...modules.keys()].filter((key) => !key.startsWith("#nitro/virtual"));
-	if (extraIds.length > 0) include.push(/* @__PURE__ */ new RegExp(`^(${extraIds.map((id) => pathRegExp(id)).join("|")})$`));
-	return {
-		name: "nitro:virtual",
-		api: { modules },
-		resolveId: {
-			order: "pre",
-			filter: { id: include },
-			handler: (id) => {
-				const mod = modules.get(id);
-				if (mod) return {
-					id,
-					moduleSideEffects: mod.module.moduleSideEffects ?? false
-				};
-			}
-		},
-		load: {
-			order: "pre",
-			filter: { id: include },
-			handler: async (id) => {
-				const mod = modules.get(id);
-				if (!mod) throw new Error(`Virtual module ${id} not found.`);
-				return {
-					code: await mod.render(),
-					map: null
-				};
-			}
-		}
-	};
-}
-function virtualDeps() {
-	const cache = /* @__PURE__ */ new Map();
-	return {
-		name: "nitro:virtual-deps",
-		resolveId: {
-			order: "pre",
-			filter: { id: /* @__PURE__ */ new RegExp(`^(#nitro|${runtimeDependencies$1.map((dep) => pathRegExp(dep)).join("|")})`) },
-			handler(id, importer) {
-				if (!importer || !importer.startsWith("#nitro/virtual")) return;
-				let resolved = cache.get(id);
-				if (!resolved) resolved = this.resolve(id, runtimeDir$1).then((_resolved) => {
-					cache.set(id, _resolved);
-					return _resolved;
-				}).catch((error) => {
-					cache.delete(id);
-					throw error;
-				});
-				return resolved;
-			}
-		}
-	};
-}
-
-//#endregion
-//#region src/build/plugins/sourcemap-min.ts
-function sourcemapMinify() {
-	return {
-		name: "nitro:sourcemap-minify",
-		generateBundle(_options, bundle) {
-			for (const [key, asset] of Object.entries(bundle)) {
-				if (!key.endsWith(".map") || !("source" in asset) || typeof asset.source !== "string") continue;
-				const sourcemap = JSON.parse(asset.source);
-				delete sourcemap.sourcesContent;
-				delete sourcemap.x_google_ignoreList;
-				if ((sourcemap.sources || []).some((s) => s.includes("node_modules"))) sourcemap.mappings = "";
-				asset.source = JSON.stringify(sourcemap);
-			}
-		}
-	};
-}
-
-//#endregion
-//#region src/build/plugins/raw.ts
-const HELPER_ID = "\0nitro-raw-helpers";
-const RESOLVED_PREFIX = "\0nitro:raw:";
-const PREFIX = "raw:";
-function raw() {
-	return {
-		name: "nitro:raw",
-		resolveId: {
-			order: "pre",
-			filter: { id: [/* @__PURE__ */ new RegExp(`^${HELPER_ID}$`), /* @__PURE__ */ new RegExp(`^${PREFIX}`)] },
-			async handler(id, importer, resolveOpts) {
-				if (id === HELPER_ID) return id;
-				if (id.startsWith(PREFIX)) {
-					const resolvedId = (await this.resolve(id.slice(4), importer, resolveOpts))?.id;
-					if (!resolvedId) return null;
-					return { id: RESOLVED_PREFIX + resolvedId };
-				}
-			}
-		},
-		load: {
-			order: "pre",
-			filter: { id: [/* @__PURE__ */ new RegExp(`^${HELPER_ID}$`), /* @__PURE__ */ new RegExp(`^${RESOLVED_PREFIX}`)] },
-			handler(id) {
-				if (id === HELPER_ID) return getHelpers();
-				if (id.startsWith(RESOLVED_PREFIX)) return promises.readFile(id.slice(11), isBinary(id) ? "binary" : "utf8");
-			}
-		},
-		transform: {
-			order: "pre",
-			filter: { id: /* @__PURE__ */ new RegExp(`^${RESOLVED_PREFIX}`) },
-			handler(code, id) {
-				const path = id.slice(11);
-				if (isBinary(id)) return {
-					code: `import {base64ToUint8Array } from "${HELPER_ID}" \n export default base64ToUint8Array("${Buffer.from(code, "binary").toString("base64")}")`,
-					map: rawAssetMap(path)
-				};
-				return {
-					code: `export default ${JSON.stringify(code)}`,
-					map: rawAssetMap(path),
-					moduleType: "js"
-				};
-			}
-		}
-	};
-}
-function isBinary(id) {
-	const idMime = src_default.getType(id) || "";
-	if (idMime.startsWith("text/")) return false;
-	if (/application\/(json|sql|xml|yaml)/.test(idMime)) return false;
-	return true;
-}
-function getHelpers() {
-	return `
-export function base64ToUint8Array(str) {
-  const data = atob(str);
-  const size = data.length;
-  const bytes = new Uint8Array(size);
-  for (let i = 0; i < size; i++) {
-    bytes[i] = data.charCodeAt(i);
-  }
-  return bytes;
-}
-  `;
-}
-function rawAssetMap(id) {
-	return {
-		version: 3,
-		file: id,
-		sources: [id],
-		sourcesContent: [],
-		names: [],
-		mappings: ""
-	};
-}
-
-//#endregion
-//#region src/utils/dep.ts
-async function importDep(opts, _retry) {
-	const resolved = resolveModulePath(opts.id, {
-		from: [opts.dir, import.meta.url],
-		cache: _retry ? false : true,
-		try: true
-	});
-	if (resolved) return await import(resolved);
-	let shouldInstall;
-	if (_retry || a) shouldInstall = false;
-	else if (T) {
-		consola.info(`\`${opts.id}\` is required for ${opts.reason}. Installing automatically in CI environment...`);
-		shouldInstall = true;
-	} else shouldInstall = await consola.prompt(`\`${opts.id}\` is required for ${opts.reason}, but it is not installed. Would you like to install it?`, {
-		type: "confirm",
-		default: true,
-		cancel: "undefined"
-	});
-	if (!shouldInstall) throw new Error(`\`${opts.id}\` is not installed. Please add it to your dependencies for ${opts.reason}.`);
-	const start = Date.now();
-	consola.start(`Installing \`${opts.id}\` in \`${opts.dir}\`...`);
-	const { addDevDependency } = await import("./cli/_chunks/dist4.mjs");
-	await addDevDependency(opts.id, { cwd: opts.dir });
-	consola.success(`Installed \`${opts.id}\` in ${opts.dir} (${Date.now() - start}ms).`);
-	return importDep(opts, true);
-}
-
-//#endregion
-//#region src/build/plugins/externals.ts
-const PLUGIN_NAME = "nitro:externals";
-function externals(opts) {
-	const include = opts?.include ? opts.include.map((p) => toPathRegExp(p)) : void 0;
-	const exclude = [/^(?:[\0#~.]|[a-z0-9]{2,}:)|\?/, ...(opts?.exclude || []).map((p) => toPathRegExp(p))];
-	const filter = (id) => {
-		if (include && !include.some((r) => r.test(id))) return false;
-		if (exclude.some((r) => r.test(id))) return false;
-		return true;
-	};
-	const tryResolve = (id, from) => resolveModulePath(id, {
-		try: true,
-		from: from && isAbsolute(from) ? from : opts.rootDir,
-		conditions: opts.conditions
-	});
-	const tracedPaths = /* @__PURE__ */ new Set();
-	if (include && include.length === 0) return { name: PLUGIN_NAME };
-	return {
-		name: PLUGIN_NAME,
-		resolveId: {
-			order: "pre",
-			filter: { id: {
-				exclude,
-				include
-			} },
-			async handler(id, importer, rOpts) {
-				if (builtinModules.includes(id)) return {
-					resolvedBy: PLUGIN_NAME,
-					external: true,
-					id: id.includes(":") ? id : `node:${id}`
-				};
-				if (rOpts.custom?.["node-resolve"]) return null;
-				let resolved = await this.resolve(id, importer, rOpts);
-				const cjsResolved = resolved?.meta?.commonjs?.resolved;
-				if (cjsResolved) {
-					if (!filter(cjsResolved.id)) return resolved;
-					resolved = cjsResolved;
-				}
-				if (!resolved?.id || !filter(resolved.id)) return resolved;
-				let resolvedPath = resolved.id;
-				if (!isAbsolute(resolvedPath)) resolvedPath = tryResolve(resolvedPath, importer) || resolvedPath;
-				if (opts.trace) {
-					let importId = toImport(id) || toImport(resolvedPath);
-					if (!importId) return resolved;
-					if (!tryResolve(importId, importer)) {
-						const guessed = await guessSubpath(resolvedPath, opts.conditions);
-						if (!guessed) return resolved;
-						importId = guessed;
-					}
-					tracedPaths.add(resolvedPath);
-					return {
-						...resolved,
-						resolvedBy: PLUGIN_NAME,
-						external: true,
-						id: importId
-					};
-				}
-				return {
-					...resolved,
-					resolvedBy: PLUGIN_NAME,
-					external: true,
-					id: isAbsolute(resolvedPath) ? pathToFileURL(resolvedPath).href : resolvedPath
-				};
-			}
-		},
-		buildEnd: {
-			order: "post",
-			async handler() {
-				if (!opts.trace || tracedPaths.size === 0) return;
-				const { traceNodeModules } = await importDep({
-					id: "nf3",
-					dir: opts.rootDir,
-					reason: "tracing external dependencies"
-				});
-				await traceNodeModules([...tracedPaths], {
-					...opts.trace,
-					conditions: opts.conditions,
-					rootDir: opts.rootDir,
-					writePackageJson: true
-				});
-			}
-		}
-	};
-}
-const NODE_MODULES_RE = /^(?<dir>.+[\\/]node_modules[\\/])(?<name>[^@\\/]+|@[^\\/]+[\\/][^\\/]+)(?:[\\/](?<subpath>.+))?$/;
-const IMPORT_RE = /^(?!\.)(?<name>[^@/\\]+|@[^/\\]+[/\\][^/\\]+)(?:[/\\](?<subpath>.+))?$/;
-function toImport(id) {
-	if (isAbsolute(id)) {
-		const { name, subpath } = NODE_MODULES_RE.exec(id)?.groups || {};
-		if (name && subpath) return join(name, subpath);
-	} else if (IMPORT_RE.test(id)) return id;
-}
-function guessSubpath(path, conditions) {
-	const { dir, name, subpath } = NODE_MODULES_RE.exec(path)?.groups || {};
-	if (!dir || !name || !subpath) return;
-	const exports = getPkgJSON(join(dir, name) + "/")?.exports;
-	if (!exports || typeof exports !== "object") return;
-	for (const e of flattenExports(exports)) {
-		if (!conditions.includes(e.condition || "default")) continue;
-		if (e.fsPath === subpath) return join(name, e.subpath);
-		if (e.fsPath.includes("*")) {
-			const fsPathRe = /* @__PURE__ */ new RegExp("^" + escapeRegExp(e.fsPath).replace(String.raw`\*`, "(.+?)") + "$");
-			if (fsPathRe.test(subpath)) {
-				const matched = fsPathRe.exec(subpath)?.[1];
-				if (matched) return join(name, e.subpath.replace("*", matched));
-			}
-		}
-	}
-}
-function getPkgJSON(dir) {
-	const cache = getPkgJSON._cache ||= /* @__PURE__ */ new Map();
-	if (cache.has(dir)) return cache.get(dir);
-	try {
-		const pkg = createRequire(dir)("./package.json");
-		cache.set(dir, pkg);
-		return pkg;
-	} catch {}
-}
-function flattenExports(exports = {}, parentSubpath = "./") {
-	return Object.entries(exports).flatMap(([key, value]) => {
-		const [subpath, condition] = key.startsWith(".") ? [key.slice(1)] : [void 0, key];
-		const _subPath = join(parentSubpath, subpath || "");
-		if (typeof value === "string") return [{
-			subpath: _subPath,
-			fsPath: value.replace(/^\.\//, ""),
-			condition
-		}];
-		return typeof value === "object" ? flattenExports(value, _subPath) : [];
-	});
-}
-
-//#endregion
-//#region src/build/plugins.ts
-function baseBuildPlugins(nitro, base) {
-	const plugins$1 = [];
-	const virtualPlugin = virtual(virtualTemplates(nitro, [...base.env.polyfill]));
-	nitro.vfs = virtualPlugin.api.modules;
-	plugins$1.push(virtualPlugin, virtualDeps());
-	if (nitro.options.imports) plugins$1.push(unplugin.rollup(nitro.options.imports));
-	if (nitro.options.wasm !== false) plugins$1.push(unwasm(nitro.options.wasm || {}));
-	plugins$1.push(serverMain(nitro));
-	plugins$1.push(raw());
-	if (nitro.options.experimental.openAPI) plugins$1.push(routeMeta(nitro));
-	plugins$1.push(replace({
-		preventAssignment: true,
-		values: base.replacements
-	}));
-	if (nitro.options.node && nitro.options.noExternals !== true) {
-		const isDevOrPrerender = nitro.options.dev || nitro.options.preset === "nitro-prerender";
-		plugins$1.push(externals({
-			rootDir: nitro.options.rootDir,
-			conditions: nitro.options.exportConditions || ["default"],
-			exclude: [...base.noExternal],
-			include: isDevOrPrerender ? void 0 : nitro.options.traceDeps,
-			trace: isDevOrPrerender ? false : { outDir: nitro.options.output.serverDir }
-		}));
-	}
-	if (nitro.options.sourcemap && !nitro.options.dev && nitro.options.experimental.sourcemapMinify !== false) plugins$1.push(sourcemapMinify());
-	return plugins$1;
-}
-
-//#endregion
-export { baseBuildConfig as a, libChunkName as i, NODE_MODULES_RE$1 as n, getChunkName as r, baseBuildPlugins as t };