@depup/nitro 3.0.260311-beta-depup.0

package/dist/runtime/internal/error/dev.mjs

@@ -0,0 +1,121 @@
+import { HTTPError } from "h3";
+import { getRequestURL } from "h3";
+import { readFile } from "node:fs/promises";
+import { resolve, dirname } from "node:path";
+import consola from "consola";
+import { defineNitroErrorHandler } from "./utils.mjs";
+import { FastResponse } from "srvx";
+const errorHandler = defineNitroErrorHandler(async function defaultNitroErrorHandler(error, event) {
+	const res = await defaultHandler(error, event);
+	return new FastResponse(typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2), res);
+});
+export default errorHandler;
+export async function defaultHandler(error, event, opts) {
+	const unhandled = error.unhandled ?? !HTTPError.isError(error);
+	const { status = 500, statusText = "" } = unhandled ? {} : error;
+	const url = getRequestURL(event, {
+		xForwardedHost: true,
+		xForwardedProto: true
+	});
+	// Redirects with base URL
+	if (status === 404) {
+		const baseURL = import.meta.baseURL || "/";
+		if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
+			return {
+				status: 302,
+				statusText: "Found",
+				headers: new Headers({ location: `${baseURL}${url.pathname.slice(1)}${url.search}` }),
+				body: `Redirecting...`
+			};
+		}
+	}
+	// Load stack trace with source maps
+	await loadStackTrace(error).catch(consola.error);
+	const { Youch } = await import("youch");
+	// https://github.com/poppinss/youch
+	const youch = new Youch();
+	// Console output
+	if (unhandled && !opts?.silent) {
+		const ansiError = (await youch.toANSI(error)).replaceAll(process.cwd(), ".");
+		consola.error(`[request error] [${event.req.method}] ${url}\n\n`, ansiError);
+	}
+	// Use HTML response only when user-agent expects it (browsers)
+	const useJSON = opts?.json ?? !event.req.headers.get("accept")?.includes("text/html");
+	const headers = new Headers(unhandled ? {} : error.headers);
+	if (useJSON) {
+		headers.set("Content-Type", "application/json; charset=utf-8");
+		const jsonBody = typeof error.toJSON === "function" ? error.toJSON() : {
+			status,
+			statusText,
+			message: error.message
+		};
+		return {
+			status,
+			statusText,
+			headers,
+			body: {
+				error: true,
+				stack: error.stack?.split("\n").map((line) => line.trim()),
+				...jsonBody
+			}
+		};
+	}
+	// HTML response
+	headers.set("Content-Type", "text/html; charset=utf-8");
+	return {
+		status,
+		statusText: unhandled ? "" : error.statusText,
+		headers,
+		body: await youch.toHTML(error, { request: {
+			url: url.href,
+			method: event.req.method,
+			headers: Object.fromEntries(event.req.headers.entries())
+		} })
+	};
+}
+// ---- Source Map support ----
+export async function loadStackTrace(error) {
+	if (!(error instanceof Error)) {
+		return;
+	}
+	const { ErrorParser } = await import("youch-core");
+	const parsed = await new ErrorParser().defineSourceLoader(sourceLoader).parse(error);
+	const stack = error.message + "\n" + parsed.frames.map((frame) => fmtFrame(frame)).join("\n");
+	Object.defineProperty(error, "stack", { value: stack });
+	if (error.cause) {
+		await loadStackTrace(error.cause).catch(consola.error);
+	}
+}
+async function sourceLoader(frame) {
+	if (!frame.fileName || frame.fileType !== "fs" || frame.type === "native") {
+		return;
+	}
+	if (frame.type === "app") {
+		// prettier-ignore
+		const rawSourceMap = await readFile(`${frame.fileName}.map`, "utf8").catch(() => {});
+		if (rawSourceMap) {
+			const { SourceMapConsumer } = await import("source-map");
+			const consumer = await new SourceMapConsumer(rawSourceMap);
+			// prettier-ignore
+			const originalPosition = consumer.originalPositionFor({
+				line: frame.lineNumber,
+				column: frame.columnNumber
+			});
+			if (originalPosition.source && originalPosition.line) {
+				// prettier-ignore
+				frame.fileName = resolve(dirname(frame.fileName), originalPosition.source);
+				frame.lineNumber = originalPosition.line;
+				frame.columnNumber = originalPosition.column || 0;
+			}
+		}
+	}
+	const contents = await readFile(frame.fileName, "utf8").catch(() => {});
+	return contents ? { contents } : undefined;
+}
+function fmtFrame(frame) {
+	if (frame.type === "native") {
+		return frame.raw;
+	}
+	const src = `${frame.fileName || ""}:${frame.lineNumber}:${frame.columnNumber})`;
+	return frame.functionName ? `at ${frame.functionName} (${src}` : `at ${src}`;
+}

package/dist/runtime/internal/error/hooks.d.mts

@@ -0,0 +1 @@
+export declare function trapUnhandledErrors(): void;

package/dist/runtime/internal/error/hooks.mjs

@@ -0,0 +1,9 @@
+import { useNitroApp } from "../app.mjs";
+function _captureError(error, type) {
+	console.error(`[${type}]`, error);
+	useNitroApp().captureError?.(error, { tags: [type] });
+}
+export function trapUnhandledErrors() {
+	process.on("unhandledRejection", (error) => _captureError(error, "unhandledRejection"));
+	process.on("uncaughtException", (error) => _captureError(error, "uncaughtException"));
+}

package/dist/runtime/internal/error/prod.d.mts

@@ -0,0 +1,6 @@
+import { HTTPError, type HTTPEvent } from "h3";
+import type { InternalHandlerResponse } from "./utils.mjs";
+import type { NitroErrorHandler } from "nitro/types";
+declare const errorHandler: NitroErrorHandler;
+export default errorHandler;
+export declare function defaultHandler(error: HTTPError, event: HTTPEvent): InternalHandlerResponse;

package/dist/runtime/internal/error/prod.mjs

@@ -0,0 +1,40 @@
+import { HTTPError } from "h3";
+import { FastResponse } from "srvx";
+const errorHandler = (error, event) => {
+	const res = defaultHandler(error, event);
+	return new FastResponse(typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2), res);
+};
+export default errorHandler;
+export function defaultHandler(error, event) {
+	const unhandled = error.unhandled ?? !HTTPError.isError(error);
+	const { status = 500, statusText = "" } = unhandled ? {} : error;
+	if (status === 404) {
+		const url = event.url || new URL(event.req.url);
+		const baseURL = import.meta.baseURL || "/";
+		if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) {
+			return {
+				status: 302,
+				headers: new Headers({ location: `${baseURL}${url.pathname.slice(1)}${url.search}` })
+			};
+		}
+	}
+	const headers = new Headers(unhandled ? {} : error.headers);
+	headers.set("content-type", "application/json; charset=utf-8");
+	const jsonBody = unhandled ? {
+		status,
+		unhandled: true
+	} : typeof error.toJSON === "function" ? error.toJSON() : {
+		status,
+		statusText,
+		message: error.message
+	};
+	return {
+		status,
+		statusText,
+		headers,
+		body: {
+			error: true,
+			...jsonBody
+		}
+	};
+}

package/dist/runtime/internal/error/utils.d.mts

@@ -0,0 +1,8 @@
+import type { NitroErrorHandler } from "nitro/types";
+export declare function defineNitroErrorHandler(handler: NitroErrorHandler): NitroErrorHandler;
+export type InternalHandlerResponse = {
+	status?: number;
+	statusText?: string | undefined;
+	headers?: HeadersInit;
+	body?: string | Record<string, any>;
+};

package/dist/runtime/internal/error/utils.mjs

@@ -0,0 +1,3 @@
+export function defineNitroErrorHandler(handler) {
+	return handler;
+}

package/dist/runtime/internal/meta.d.mts

@@ -0,0 +1,2 @@
+import type { NitroRouteMeta } from "nitro/types";
+export declare function defineRouteMeta(meta: NitroRouteMeta): NitroRouteMeta;

package/dist/runtime/internal/meta.mjs

@@ -0,0 +1,3 @@
+export function defineRouteMeta(meta) {
+	return meta;
+}

package/dist/runtime/internal/plugin.d.mts

@@ -0,0 +1,3 @@
+import type { NitroAppPlugin } from "nitro/types";
+export declare function defineNitroPlugin(def: NitroAppPlugin): NitroAppPlugin;
+export declare const nitroPlugin: (def: NitroAppPlugin) => NitroAppPlugin;

package/dist/runtime/internal/plugin.mjs

@@ -0,0 +1,4 @@
+export function defineNitroPlugin(def) {
+	return def;
+}
+export const nitroPlugin = defineNitroPlugin;

package/dist/runtime/internal/route-rules.d.mts

@@ -0,0 +1,9 @@
+import type { Middleware } from "h3";
+import type { MatchedRouteRule, NitroRouteRules } from "nitro/types";
+type RouteRuleCtor<T extends keyof NitroRouteRules> = (m: MatchedRouteRule<T>) => Middleware;
+export declare const headers: RouteRuleCtor<"headers">;
+export declare const redirect: RouteRuleCtor<"redirect">;
+export declare const proxy: RouteRuleCtor<"proxy">;
+export declare const cache: RouteRuleCtor<"cache">;
+export declare const basicAuth: RouteRuleCtor<"auth">;
+export {};

package/dist/runtime/internal/route-rules.mjs

@@ -0,0 +1,72 @@
+import { proxyRequest, redirect as sendRedirect, requireBasicAuth } from "h3";
+import { joinURL, withQuery, withoutBase } from "ufo";
+import { defineCachedHandler } from "./cache.mjs";
+// Headers route rule
+export const headers = ((m) => function headersRouteRule(event) {
+	for (const [key, value] of Object.entries(m.options || {})) {
+		event.res.headers.set(key, value);
+	}
+});
+// Redirect route rule
+export const redirect = ((m) => function redirectRouteRule(event) {
+	let target = m.options?.to;
+	if (!target) {
+		return;
+	}
+	if (target.endsWith("/**")) {
+		let targetPath = event.url.pathname + event.url.search;
+		const strpBase = m.options._redirectStripBase;
+		if (strpBase) {
+			targetPath = withoutBase(targetPath, strpBase);
+		}
+		target = joinURL(target.slice(0, -3), targetPath);
+	} else if (event.url.search) {
+		target = withQuery(target, Object.fromEntries(event.url.searchParams));
+	}
+	return sendRedirect(target, m.options?.status);
+});
+// Proxy route rule
+export const proxy = ((m) => function proxyRouteRule(event) {
+	let target = m.options?.to;
+	if (!target) {
+		return;
+	}
+	if (target.endsWith("/**")) {
+		let targetPath = event.url.pathname + event.url.search;
+		const strpBase = m.options._proxyStripBase;
+		if (strpBase) {
+			targetPath = withoutBase(targetPath, strpBase);
+		}
+		target = joinURL(target.slice(0, -3), targetPath);
+	} else if (event.url.search) {
+		target = withQuery(target, Object.fromEntries(event.url.searchParams));
+	}
+	return proxyRequest(event, target, { ...m.options });
+});
+// Cache route rule
+export const cache = ((m) => function cacheRouteRule(event, next) {
+	if (!event.context.matchedRoute) {
+		return next();
+	}
+	const cachedHandlers = globalThis.__nitroCachedHandlers ??= new Map();
+	const { handler, route } = event.context.matchedRoute;
+	const key = `${m.route}:${route}`;
+	let cachedHandler = cachedHandlers.get(key);
+	if (!cachedHandler) {
+		cachedHandler = defineCachedHandler(handler, {
+			group: "nitro/route-rules",
+			name: key,
+			...m.options
+		});
+		cachedHandlers.set(key, cachedHandler);
+	}
+	return cachedHandler(event);
+});
+// basicAuth auth route rule
+export const basicAuth = ((m) => async function authRouteRule(event, next) {
+	if (!m.options) {
+		return;
+	}
+	await requireBasicAuth(event, m.options);
+	return next();
+});

package/dist/runtime/internal/routes/dev-tasks.d.mts

@@ -0,0 +1,3 @@
+import { H3 } from "h3";
+declare const app: H3;
+export default app;

package/dist/runtime/internal/routes/dev-tasks.mjs

@@ -0,0 +1,25 @@
+import { H3 } from "h3";
+import { runTask } from "../task.mjs";
+import { scheduledTasks, tasks } from "#nitro/virtual/tasks";
+const app = new H3().get("/_nitro/tasks", async () => {
+	const _tasks = await Promise.all(Object.entries(tasks).map(async ([name, task]) => {
+		const _task = await task.resolve?.();
+		return [name, { description: _task?.meta?.description }];
+	}));
+	return {
+		tasks: Object.fromEntries(_tasks),
+		scheduledTasks
+	};
+}).get("/_nitro/tasks/:name", async (event) => {
+	const name = event.context.params?.name;
+	const body = await event.req.json().catch(() => ({}));
+	const payload = {
+		...Object.fromEntries(event.url.searchParams.entries()),
+		...body
+	};
+	return await runTask(name, {
+		context: { waitUntil: event.req.waitUntil },
+		payload
+	});
+});
+export default app;

package/dist/runtime/internal/routes/openapi.d.mts

@@ -0,0 +1,3 @@
+import type { EventHandler } from "h3";
+declare const _default: EventHandler;
+export default _default;

package/dist/runtime/internal/routes/openapi.mjs

@@ -0,0 +1,94 @@
+import { defineHandler, getRequestURL } from "h3";
+import { joinURL } from "ufo";
+import { defu } from "defu";
+import { handlersMeta } from "#nitro/virtual/routing-meta";
+import { useRuntimeConfig } from "../runtime-config.mjs";
+// Served as /_openapi.json
+export default defineHandler((event) => {
+	const runtimeConfig = useRuntimeConfig();
+	const base = runtimeConfig.app?.baseURL;
+	const url = joinURL(getRequestURL(event).origin, base);
+	const meta = {
+		title: "Nitro Server Routes",
+		...runtimeConfig.nitro?.openAPI?.meta
+	};
+	const { paths, globals: { components, ...globalsRest } } = getHandlersMeta();
+	const extensible = Object.fromEntries(Object.entries(globalsRest).filter(([key]) => key.startsWith("x-")));
+	return {
+		openapi: "3.1.0",
+		info: {
+			title: meta?.title,
+			version: meta?.version || "1.0.0",
+			description: meta?.description
+		},
+		servers: [{
+			url,
+			description: "Local Development Server",
+			variables: {}
+		}],
+		paths,
+		components,
+		...extensible
+	};
+});
+function getHandlersMeta() {
+	const paths = {};
+	let globals = {};
+	for (const h of handlersMeta) {
+		const { route, parameters } = normalizeRoute(h.route || "");
+		const tags = defaultTags(h.route || "");
+		const method = (h.method || "get").toLowerCase();
+		const { $global, ...openAPI } = h.meta?.openAPI || {};
+		const item = { [method]: {
+			tags,
+			parameters,
+			responses: { 200: { description: "OK" } },
+			...openAPI
+		} };
+		if ($global) {
+			// TODO: Warn on conflicting global definitions?
+			globals = defu($global, globals);
+		}
+		if (paths[route] === undefined) {
+			paths[route] = item;
+		} else {
+			Object.assign(paths[route], item);
+		}
+	}
+	return {
+		paths,
+		globals
+	};
+}
+function normalizeRoute(_route) {
+	const parameters = [];
+	let anonymousCtr = 0;
+	const route = _route.replace(/:(\w+)/g, (_, name) => `{${name}}`).replace(/\/(\*)\//g, () => `/{param${++anonymousCtr}}/`).replace(/\*\*{/, "{").replace(/\/(\*\*)$/g, () => `/{*param${++anonymousCtr}}`);
+	const paramMatches = route.matchAll(/{(\*?\w+)}/g);
+	for (const match of paramMatches) {
+		const name = match[1];
+		if (!parameters.some((p) => p.name === name)) {
+			parameters.push({
+				name,
+				in: "path",
+				required: true,
+				schema: { type: "string" }
+			});
+		}
+	}
+	return {
+		route,
+		parameters
+	};
+}
+function defaultTags(route) {
+	const tags = [];
+	if (route.startsWith("/api/")) {
+		tags.push("API Routes");
+	} else if (route.startsWith("/_")) {
+		tags.push("Internal");
+	} else {
+		tags.push("App Routes");
+	}
+	return tags;
+}

package/dist/runtime/internal/routes/renderer-template.d.mts

@@ -0,0 +1,2 @@
+import type { H3Event } from "h3";
+export default function renderIndexHTML(event: H3Event): any;

package/dist/runtime/internal/routes/renderer-template.dev.d.mts

@@ -0,0 +1,3 @@
+import type { H3Event } from "h3";
+import { HTTPResponse } from "h3";
+export default function renderIndexHTML(event: H3Event): Promise<HTTPResponse | Response>;

package/dist/runtime/internal/routes/renderer-template.dev.mjs

@@ -0,0 +1,19 @@
+import { serverFetch } from "../app.mjs";
+import { rendererTemplate, rendererTemplateFile, isStaticTemplate } from "#nitro/virtual/renderer-template";
+import { HTTPResponse } from "h3";
+import { hasTemplateSyntax, renderToResponse, compileTemplate } from "rendu";
+export default async function renderIndexHTML(event) {
+	let html = await rendererTemplate(event.req);
+	if (globalThis.__transform_html__) {
+		html = await globalThis.__transform_html__(html);
+	}
+	const isStatic = isStaticTemplate ?? !hasTemplateSyntax(html);
+	if (isStatic) {
+		return new HTTPResponse(html, { headers: { "content-type": "text/html; charset=utf-8" } });
+	}
+	const template = compileTemplate(html, { filename: rendererTemplateFile });
+	return renderToResponse(template, {
+		request: event.req,
+		context: { serverFetch }
+	});
+}

package/dist/runtime/internal/routes/renderer-template.mjs

@@ -0,0 +1,4 @@
+import { rendererTemplate } from "#nitro/virtual/renderer-template";
+export default function renderIndexHTML(event) {
+	return rendererTemplate(event.req);
+}

package/dist/runtime/internal/routes/scalar.d.mts

@@ -0,0 +1,3 @@
+import { type EventHandler } from "h3";
+declare const _default: EventHandler;
+export default _default;

package/dist/runtime/internal/routes/scalar.mjs

@@ -0,0 +1,193 @@
+import { defineHandler } from "h3";
+import { useRuntimeConfig } from "../runtime-config.mjs";
+// Served as /_scalar
+export default defineHandler((event) => {
+	const runtimeConfig = useRuntimeConfig();
+	const title = runtimeConfig.nitro?.openAPI?.meta?.title || "API Reference";
+	const description = runtimeConfig.nitro?.openAPI?.meta?.description || "";
+	const openAPIEndpoint = runtimeConfig.nitro?.openAPI?.route || "./_openapi.json";
+	// https://github.com/scalar/scalar
+	const _config = runtimeConfig.nitro?.openAPI?.ui?.scalar;
+	const scalarConfig = {
+		..._config,
+		url: openAPIEndpoint,
+		spec: {
+			url: openAPIEndpoint,
+			..._config?.spec
+		}
+	};
+	// The default page title
+	event.res.headers.set("Content-Type", "text/html");
+	return `<!doctype html>
+    <html lang="en">
+      <head>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <meta name="description" content="${description}" />
+        <title>${title}</title>
+        <style>
+          ${scalarConfig.theme ? null : customTheme}
+        </style>
+      </head>
+      <body>
+        <script
+          id="api-reference"
+          data-configuration="${JSON.stringify(scalarConfig).split("\"").join("&quot;")}"
+        ><\/script>
+        <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
+      </body>
+    </html>`;
+});
+const customTheme = `/* basic theme */
+  .light-mode,
+  .light-mode .dark-mode {
+    --theme-background-1: #fff;
+    --theme-background-2: #fafafa;
+    --theme-background-3: rgb(245 245 245);
+
+    --theme-color-1: #2a2f45;
+    --theme-color-2: #757575;
+    --theme-color-3: #8e8e8e;
+
+    --theme-color-accent: #ef4444;
+    --theme-background-accent: transparent;
+
+    --theme-border-color: rgba(0, 0, 0, 0.1);
+  }
+  .dark-mode {
+    --theme-background-1: #171717;
+    --theme-background-2: #262626;
+    --theme-background-3: #2e2e2e;
+
+    --theme-color-1: rgba(255, 255, 255, 0.9);
+    --theme-color-2: rgba(255, 255, 255, 0.62);
+    --theme-color-3: rgba(255, 255, 255, 0.44);
+
+    --theme-color-accent: #f87171;
+    --theme-background-accent: transparent;
+
+    --theme-border-color: rgba(255, 255, 255, 0.1);
+  }
+
+  /* Document Sidebar */
+  .light-mode .t-doc__sidebar,
+  .dark-mode .t-doc__sidebar {
+    --sidebar-background-1: var(--theme-background-1);
+    --sidebar-color-1: var(--theme-color-1);
+    --sidebar-color-2: var(--theme-color-2);
+    --sidebar-border-color: var(--theme-border-color);
+
+    --sidebar-item-hover-background: transparent;
+    --sidebar-item-hover-color: var(--sidebar-color-1);
+
+    --sidebar-item-active-background: var(--theme-background-accent);
+    --sidebar-color-active: var(--theme-color-accent);
+
+    --sidebar-search-background: transparent;
+    --sidebar-search-color: var(--theme-color-3);
+    --sidebar-search-border-color: var(--theme-border-color);
+  }
+
+  /* advanced */
+  .light-mode .dark-mode,
+  .light-mode {
+    --theme-color-green: #91b859;
+    --theme-color-red: #e53935;
+    --theme-color-yellow: #e2931d;
+    --theme-color-blue: #6182b8;
+    --theme-color-orange: #f76d47;
+    --theme-color-purple: #9c3eda;
+  }
+  .dark-mode {
+    --theme-color-green: #c3e88d;
+    --theme-color-red: #f07178;
+    --theme-color-yellow: #ffcb6b;
+    --theme-color-blue: #82aaff;
+    --theme-color-orange: #f78c6c;
+    --theme-color-purple: #c792ea;
+  }
+  /* custom-theme */
+  .section-container:nth-of-type(2)
+    ~ .section-container
+    .scalar-card
+    .scalar-card-header {
+    --theme-background-2: var(--theme-background-1) !important;
+  }
+  .section-flare {
+    width: 100%;
+    height: 100%;
+    position: absolute;
+    top: 0;
+    left: 0;
+    animation: spin 39s linear infinite;
+    transition: all 0.3s ease-in-out;
+    opacity: 1;
+  }
+  .section-flare-item:nth-of-type(1),
+  .section-flare-item:nth-of-type(2),
+  .section-flare-item:nth-of-type(3) {
+    content: "";
+    width: 1000px;
+    height: 1000px;
+    position: absolute;
+    top: 0;
+    right: 0;
+    border-radius: 50%;
+    background: var(--default-theme-background-1);
+    display: block;
+    opacity: 1;
+    filter: blur(48px);
+    -webkit-backface-visibility: hidden;
+    -webkit-perspective: 1000;
+    -webkit-transform: translate3d(0, 0, 0);
+    -webkit-transform: translateZ(0);
+    perspective: 1000;
+    transform: translate3d(0, 0, 0);
+    transform: translateZ(0);
+  }
+  .section-flare-item:nth-of-type(2) {
+    top: initial;
+    right: initial;
+    background: #ef4444;
+    width: 700px;
+    height: 700px;
+    opacity: 0.3;
+    animation: sectionflare 37s linear infinite;
+  }
+  .section-flare-item:nth-of-type(1) {
+    top: initial;
+    right: initial;
+    bottom: 0;
+    left: -20px;
+    background: #ef4444;
+    width: 500px;
+    height: 500px;
+    opacity: 0.3;
+    animation: sectionflare2 38s linear infinite;
+  }
+  @keyframes sectionflare {
+    0%,
+    100% {
+      transform: translate3d(0, 0, 0);
+    }
+    50% {
+      transform: translate3d(525px, 525px, 0);
+    }
+  }
+  @keyframes sectionflare2 {
+    0%,
+    100% {
+      transform: translate3d(700px, 700px, 0);
+    }
+    50% {
+      transform: translate3d(0, 0, 0);
+    }
+  }
+  @keyframes spin {
+    100% {
+      transform: rotate(360deg);
+    }
+  }
+  .section-container:nth-of-type(2) {
+    overflow: hidden;
+  }`;

package/dist/runtime/internal/routes/swagger.d.mts

@@ -0,0 +1,3 @@
+import type { EventHandler } from "h3";
+declare const _default: EventHandler;
+export default _default;