nitro-nightly 4.0.0-20251030-091344-d4418b98 → 4.0.0-20251030-121649-98b56dfe

package/dist/_chunks/B3asVbT4.mjs

@@ -0,0 +1,151 @@
+import { T as resolve, _ as dirname, b as join, v as extname, w as relative } from "../_libs/c12.mjs";
+import { t as glob } from "../_libs/tinyglobby.mjs";
+import { n as a } from "../_libs/std-env.mjs";
+import { i as snapshotStorage, t as runParallel } from "./B5ooyfLk.mjs";
+import { t as src_default } from "../_libs/mime.mjs";
+import { t as gzipSize } from "../_libs/gzip-size.mjs";
+import { t as prettyBytes } from "../_libs/pretty-bytes.mjs";
+import { upperFirst } from "scule";
+import { promises } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { colors } from "consola/utils";
+
+//#region src/build/plugins/raw.ts
+const HELPER_ID = "\0raw-helpers";
+function raw(opts = {}) {
+	const extensions = new Set([
+		".md",
+		".mdx",
+		".txt",
+		".css",
+		".htm",
+		".html",
+		".sql",
+		...opts.extensions || []
+	]);
+	return {
+		name: "raw",
+		async resolveId(id, importer, resolveOpts) {
+			if (id === HELPER_ID) return id;
+			if (id[0] === "\0") return;
+			const withRawSpecifier = id.startsWith("raw:");
+			if (withRawSpecifier) id = id.slice(4);
+			if (!withRawSpecifier && !extensions.has(extname(id))) return;
+			const resolvedId = (await this.resolve(id, importer, resolveOpts))?.id;
+			if (!resolvedId || resolvedId.startsWith("\0")) return resolvedId;
+			if (!withRawSpecifier && !extensions.has(extname(resolvedId))) return;
+			return { id: "\0raw:" + resolvedId };
+		},
+		load(id) {
+			if (id === HELPER_ID) return getHelpers();
+			if (id.startsWith("\0raw:")) return promises.readFile(id.slice(5), isBinary(id) ? "binary" : "utf8");
+		},
+		transform(code, id) {
+			if (!id.startsWith("\0raw:")) return;
+			if (isBinary(id)) return {
+				code: `// ROLLUP_NO_REPLACE \n import {base64ToUint8Array } from "${HELPER_ID}" \n export default base64ToUint8Array("${Buffer.from(code, "binary").toString("base64")}")`,
+				map: null
+			};
+			return {
+				code: `// ROLLUP_NO_REPLACE \n export default ${JSON.stringify(code)}`,
+				map: null,
+				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 String.raw`
+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;
+}
+  `;
+}
+
+//#endregion
+//#region src/utils/nitro.ts
+function nitroServerName(nitro) {
+	return nitro.options.framework.name === "nitro" ? "Nitro Server" : `${upperFirst(nitro.options.framework.name)} Nitro server`;
+}
+
+//#endregion
+//#region src/utils/fs-tree.ts
+async function generateFSTree(dir, options = {}) {
+	if (a) return;
+	const files = await glob("**/*.*", {
+		cwd: dir,
+		ignore: ["*.map"]
+	});
+	const items = [];
+	await runParallel(new Set(files), async (file) => {
+		const path = resolve(dir, file);
+		const src = await promises.readFile(path);
+		const size = src.byteLength;
+		const gzip = options.compressedSizes ? await gzipSize(src) : 0;
+		items.push({
+			file,
+			path,
+			size,
+			gzip
+		});
+	}, { concurrency: 10 });
+	items.sort((a$1, b) => a$1.path.localeCompare(b.path));
+	let totalSize = 0;
+	let totalGzip = 0;
+	let totalNodeModulesSize = 0;
+	let totalNodeModulesGzip = 0;
+	let treeText = "";
+	for (const [index, item] of items.entries()) {
+		let dir$1 = dirname(item.file);
+		if (dir$1 === ".") dir$1 = "";
+		const rpath = relative(process.cwd(), item.path);
+		const treeChar = index === items.length - 1 ? "└─" : "├─";
+		if (item.file.includes("node_modules")) {
+			totalNodeModulesSize += item.size;
+			totalNodeModulesGzip += item.gzip;
+			continue;
+		}
+		treeText += colors.gray(`  ${treeChar} ${rpath} (${prettyBytes(item.size)})`);
+		if (options.compressedSizes) treeText += colors.gray(` (${prettyBytes(item.gzip)} gzip)`);
+		treeText += "\n";
+		totalSize += item.size;
+		totalGzip += item.gzip;
+	}
+	treeText += `${colors.cyan("Σ Total size:")} ${prettyBytes(totalSize + totalNodeModulesSize)}`;
+	if (options.compressedSizes) treeText += ` (${prettyBytes(totalGzip + totalNodeModulesGzip)} gzip)`;
+	treeText += "\n";
+	return treeText;
+}
+
+//#endregion
+//#region src/build/snapshot.ts
+async function snapshot(nitro) {
+	if (nitro.options.bundledStorage.length === 0 || nitro.options.preset === "nitro-prerender") return;
+	const storageDir = resolve(nitro.options.buildDir, "snapshot");
+	nitro.options.serverAssets.push({
+		baseName: "nitro:bundled",
+		dir: storageDir
+	});
+	const data = await snapshotStorage(nitro);
+	await Promise.all(Object.entries(data).map(async ([path, contents]) => {
+		if (typeof contents !== "string") contents = JSON.stringify(contents);
+		const fsPath = join(storageDir, path.replace(/:/g, "/"));
+		await mkdir(dirname(fsPath), { recursive: true });
+		await writeFile(fsPath, contents, "utf8");
+	}));
+}
+
+//#endregion
+export { raw as i, generateFSTree as n, nitroServerName as r, snapshot as t };

package/dist/_chunks/B5ooyfLk.mjs

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

package/dist/_chunks/DXMHy5ca.mjs

@@ -0,0 +1,43 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (all) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toDynamicImportESM = (isNodeMode) => (mod) => __toESM(mod.default, isNodeMode);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __toCommonJS as a, __require as i, __esm as n, __toDynamicImportESM as o, __export as r, __toESM as s, __commonJS as t };

package/dist/_dev.d.mts

@@ -0,0 +1,12 @@
+import { HTTPHandler } from "h3";
+import { Nitro } from "nitro/types";
+
+//#region src/dev/app.d.ts
+declare class NitroDevApp {
+  #private;
+  nitro: Nitro;
+  fetch: (req: Request) => Response | Promise<Response>;
+  constructor(nitro: Nitro, catchAllHandler?: HTTPHandler);
+}
+//#endregion
+export { NitroDevApp as t };