initial commit

node_modules/nitropack/dist/runtime/entries/aws-lambda.d.ts

@@ -0,0 +1,8 @@
+import type { APIGatewayProxyEvent, APIGatewayProxyEventV2, APIGatewayProxyResult, APIGatewayProxyResultV2, Context } from 'aws-lambda';
+import '#internal/nitro/virtual/polyfill';
+type Event = Omit<APIGatewayProxyEvent, 'pathParameters' | 'stageVariables' | 'requestContext' | 'resource'> | Omit<APIGatewayProxyEventV2, 'pathParameters' | 'stageVariables' | 'requestContext' | 'resource'>;
+type Result = Exclude<APIGatewayProxyResult | APIGatewayProxyResultV2, string> & {
+    statusCode: number;
+};
+export declare const handler: (event: Event, context: Context) => Promise<Result>;
+export {};

node_modules/nitropack/dist/runtime/entries/aws-lambda.mjs

@@ -0,0 +1,34 @@
+import "#internal/nitro/virtual/polyfill";
+import { withQuery } from "ufo";
+import { nitroApp } from "../app.mjs";
+export const handler = async function handler2(event, context) {
+  const query = { ...event.queryStringParameters, ...event.multiValueQueryStringParameters };
+  const url = withQuery(event.path || event.rawPath, query);
+  const method = event.httpMethod || event.requestContext?.http?.method || "get";
+  if ("cookies" in event && event.cookies) {
+    event.headers.cookie = event.cookies.join(";");
+  }
+  const r = await nitroApp.localCall({
+    event,
+    url,
+    context,
+    headers: normalizeIncomingHeaders(event.headers),
+    method,
+    query,
+    body: event.body
+  });
+  const outgoingCookies = r.headers["set-cookie"];
+  const cookies = Array.isArray(outgoingCookies) ? outgoingCookies : outgoingCookies?.split(",") || [];
+  return {
+    cookies,
+    statusCode: r.status,
+    headers: normalizeOutgoingHeaders(r.headers),
+    body: r.body.toString()
+  };
+};
+function normalizeIncomingHeaders(headers) {
+  return Object.fromEntries(Object.entries(headers || {}).map(([key, value]) => [key.toLowerCase(), value]));
+}
+function normalizeOutgoingHeaders(headers) {
+  return Object.fromEntries(Object.entries(headers).filter(([key]) => !["set-cookie"].includes(key)).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : v]));
+}

node_modules/nitropack/dist/runtime/entries/azure-functions.d.ts

@@ -0,0 +1,2 @@
+import '#internal/nitro/virtual/polyfill';
+export declare function handle(context: any, req: any): Promise<void>;

node_modules/nitropack/dist/runtime/entries/azure-functions.mjs

@@ -0,0 +1,16 @@
+import "#internal/nitro/virtual/polyfill";
+import { nitroApp } from "../app.mjs";
+export async function handle(context, req) {
+  const url = "/" + (req.params.url || "");
+  const { body, status, statusText, headers } = await nitroApp.localCall({
+    url,
+    headers: req.headers,
+    method: req.method,
+    body: req.rawBody
+  });
+  context.res = {
+    status,
+    headers,
+    body: body ? body.toString() : statusText
+  };
+}

node_modules/nitropack/dist/runtime/entries/azure.d.ts

@@ -0,0 +1,2 @@
+import '#internal/nitro/virtual/polyfill';
+export declare function handle(context: any, req: any): Promise<void>;

node_modules/nitropack/dist/runtime/entries/azure.mjs

@@ -0,0 +1,23 @@
+import "#internal/nitro/virtual/polyfill";
+import { parseURL } from "ufo";
+import { nitroApp } from "../app.mjs";
+export async function handle(context, req) {
+  let url;
+  if (req.headers["x-ms-original-url"]) {
+    const parsedURL = parseURL(req.headers["x-ms-original-url"]);
+    url = parsedURL.pathname + parsedURL.search;
+  } else {
+    url = "/api/" + (req.params.url || "");
+  }
+  const { body, status, statusText, headers } = await nitroApp.localCall({
+    url,
+    headers: req.headers,
+    method: req.method,
+    body: req.rawBody
+  });
+  context.res = {
+    status,
+    headers,
+    body: body ? body.toString() : statusText
+  };
+}

node_modules/nitropack/dist/runtime/entries/cli.d.ts

@@ -0,0 +1 @@
+import '#internal/nitro/virtual/polyfill';

node_modules/nitropack/dist/runtime/entries/cli.mjs

@@ -0,0 +1,20 @@
+import "#internal/nitro/virtual/polyfill";
+import { nitroApp } from "../app.mjs";
+async function cli() {
+  const url = process.argv[2] || "/";
+  const debug = (label, ...args) => console.debug(`> ${label}:`, ...args);
+  const r = await nitroApp.localCall({ url });
+  debug("URL", url);
+  debug("StatusCode", r.status);
+  debug("StatusMessage", r.statusText);
+  for (const header of r.headers.entries()) {
+    debug(header[0], header[1]);
+  }
+  console.log("\n", r.body.toString());
+}
+if (require.main === module) {
+  cli().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}

node_modules/nitropack/dist/runtime/entries/cloudflare-pages.d.ts

@@ -0,0 +1,18 @@
+import '#internal/nitro/virtual/polyfill';
+/** @see https://developers.cloudflare.com/pages/platform/functions/#writing-your-first-function */
+interface CFRequestContext {
+    /** same as existing Worker API */
+    request: any;
+    /** same as existing Worker API */
+    env: any;
+    /** if filename includes [id] or [[path]] **/
+    params: any;
+    /** Same as ctx.waitUntil in existing Worker API */
+    waitUntil: any;
+    /** Used for middleware or to fetch assets */
+    next: any;
+    /** Arbitrary space for passing data between middlewares */
+    data: any;
+}
+export declare function onRequest(ctx: CFRequestContext): Promise<any>;
+export {};

node_modules/nitropack/dist/runtime/entries/cloudflare-pages.mjs

@@ -0,0 +1,33 @@
+import "#internal/nitro/virtual/polyfill";
+import { requestHasBody } from "../utils.mjs";
+import { nitroApp } from "../app.mjs";
+export async function onRequest(ctx) {
+  try {
+    const asset = await ctx.next();
+    if (asset.status !== 404) {
+      return asset;
+    }
+  } catch (_err) {
+  }
+  const url = new URL(ctx.request.url);
+  let body;
+  if (requestHasBody(ctx.request)) {
+    body = Buffer.from(await ctx.request.arrayBuffer());
+  }
+  const r = await nitroApp.localCall({
+    url: url.pathname + url.search,
+    method: ctx.request.method,
+    headers: ctx.request.headers,
+    host: url.hostname,
+    protocol: url.protocol,
+    body
+  });
+  return new Response(r.body, {
+    headers: normalizeOutgoingHeaders(r.headers),
+    status: r.status,
+    statusText: r.statusText
+  });
+}
+function normalizeOutgoingHeaders(headers) {
+  return Object.entries(headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : v]);
+}

node_modules/nitropack/dist/runtime/entries/cloudflare.d.ts

@@ -0,0 +1 @@
+import '#internal/nitro/virtual/polyfill';

node_modules/nitropack/dist/runtime/entries/cloudflare.mjs

@@ -0,0 +1,45 @@
+import "#internal/nitro/virtual/polyfill";
+import { getAssetFromKV, mapRequestToAsset } from "@cloudflare/kv-asset-handler";
+import { withoutBase } from "ufo";
+import { requestHasBody } from "../utils.mjs";
+import { nitroApp } from "../app.mjs";
+import { useRuntimeConfig } from "#internal/nitro";
+addEventListener("fetch", (event) => {
+  event.respondWith(handleEvent(event));
+});
+async function handleEvent(event) {
+  try {
+    return await getAssetFromKV(event, { cacheControl: assetsCacheControl, mapRequestToAsset: baseURLModifier });
+  } catch (_err) {
+  }
+  const url = new URL(event.request.url);
+  let body;
+  if (requestHasBody(event.request)) {
+    body = Buffer.from(await event.request.arrayBuffer());
+  }
+  const r = await nitroApp.localCall({
+    event,
+    url: url.pathname + url.search,
+    host: url.hostname,
+    protocol: url.protocol,
+    headers: Object.fromEntries(event.request.headers.entries()),
+    method: event.request.method,
+    redirect: event.request.redirect,
+    body
+  });
+  return new Response(r.body, {
+    headers: normalizeOutgoingHeaders(r.headers),
+    status: r.status,
+    statusText: r.statusText
+  });
+}
+function assetsCacheControl(_request) {
+  return {};
+}
+const baseURLModifier = (request) => {
+  const url = withoutBase(request.url, useRuntimeConfig().app.baseURL);
+  return mapRequestToAsset(new Request(url, request));
+};
+function normalizeOutgoingHeaders(headers) {
+  return Object.entries(headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : v]);
+}

node_modules/nitropack/dist/runtime/entries/deno.d.ts

@@ -0,0 +1 @@
+import '#internal/nitro/virtual/polyfill';

node_modules/nitropack/dist/runtime/entries/deno.mjs

@@ -0,0 +1,31 @@
+import "#internal/nitro/virtual/polyfill";
+import { serve } from "https://deno.land/std/http/server.ts";
+import { requestHasBody, useRequestBody } from "../utils.mjs";
+import { nitroApp } from "../app.mjs";
+serve((request) => {
+  return handleRequest(request);
+});
+async function handleRequest(request) {
+  const url = new URL(request.url);
+  let body;
+  if (requestHasBody(request)) {
+    body = await useRequestBody(request);
+  }
+  const r = await nitroApp.localCall({
+    url: url.pathname + url.search,
+    host: url.hostname,
+    protocol: url.protocol,
+    headers: Object.fromEntries(request.headers.entries()),
+    method: request.method,
+    redirect: request.redirect,
+    body
+  });
+  return new Response(r.body || void 0, {
+    headers: normalizeOutgoingHeaders(r.headers),
+    status: r.status,
+    statusText: r.statusText
+  });
+}
+function normalizeOutgoingHeaders(headers) {
+  return Object.entries(headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : v]);
+}

node_modules/nitropack/dist/runtime/entries/firebase.d.ts

@@ -0,0 +1,2 @@
+import '#internal/nitro/virtual/polyfill';
+export declare const server: any;

node_modules/nitropack/dist/runtime/entries/firebase.mjs

@@ -0,0 +1,5 @@
+import "#internal/nitro/virtual/polyfill";
+import functions from "firebase-functions";
+import { toNodeListener } from "h3";
+import { nitroApp } from "../app.mjs";
+export const server = functions.https.onRequest(toNodeListener(nitroApp.h3App));

node_modules/nitropack/dist/runtime/entries/netlify-builder.d.ts

@@ -0,0 +1 @@
+export declare const handler: import("@netlify/functions").Handler;

node_modules/nitropack/dist/runtime/entries/netlify-builder.mjs

@@ -0,0 +1,3 @@
+import { builder } from "@netlify/functions";
+import { handler as _handler } from "#internal/nitro/entries/aws-lambda";
+export const handler = builder(_handler);

node_modules/nitropack/dist/runtime/entries/netlify-edge.d.ts

@@ -0,0 +1,2 @@
+import '#internal/nitro/virtual/polyfill';
+export default function (request: Request, _context: any): Promise<Response>;

node_modules/nitropack/dist/runtime/entries/netlify-edge.mjs

@@ -0,0 +1,24 @@
+import "#internal/nitro/virtual/polyfill";
+import { nitroApp } from "../app.mjs";
+import { requestHasBody, useRequestBody } from "../utils.mjs";
+export default async function(request, _context) {
+  const url = new URL(request.url);
+  let body;
+  if (requestHasBody(request)) {
+    body = await useRequestBody(request);
+  }
+  const r = await nitroApp.localCall({
+    url: url.pathname + url.search,
+    host: url.hostname,
+    protocol: url.protocol,
+    headers: request.headers,
+    method: request.method,
+    redirect: request.redirect,
+    body
+  });
+  return new Response(r.body, {
+    headers: r.headers,
+    status: r.status,
+    statusText: r.statusText
+  });
+}

node_modules/nitropack/dist/runtime/entries/netlify.d.ts

@@ -0,0 +1,3 @@
+import '#internal/nitro/virtual/polyfill';
+import type { Handler } from '@netlify/functions/dist/main';
+export declare const handler: Handler;

node_modules/nitropack/dist/runtime/entries/netlify.mjs

@@ -0,0 +1,41 @@
+import "#internal/nitro/virtual/polyfill";
+import { withQuery } from "ufo";
+import { nitroApp } from "../app.mjs";
+import { getRouteRulesForPath } from "../route-rules.mjs";
+export const handler = async function handler2(event, context) {
+  const query = { ...event.queryStringParameters, ...event.multiValueQueryStringParameters };
+  const url = withQuery(event.path, query);
+  const routeRules = getRouteRulesForPath(url);
+  if (routeRules.cache && (routeRules.cache.swr || routeRules.cache.static)) {
+    const builder = await import("@netlify/functions").then((r) => r.builder || r.default.builder);
+    const ttl = typeof routeRules.cache.swr === "number" ? routeRules.cache.swr : 60;
+    const swrHandler = routeRules.cache.swr ? (event2, context2) => lambda(event2, context2).then((r) => ({ ...r, ttl })) : lambda;
+    return builder(swrHandler)(event, context);
+  }
+  return lambda(event, context);
+};
+async function lambda(event, context) {
+  const query = { ...event.queryStringParameters, ...event.multiValueQueryStringParameters };
+  const url = withQuery(event.path, query);
+  const method = event.httpMethod || "get";
+  const r = await nitroApp.localCall({
+    event,
+    url,
+    context,
+    headers: normalizeIncomingHeaders(event.headers),
+    method,
+    query,
+    body: event.body
+  });
+  return {
+    statusCode: r.status,
+    headers: normalizeOutgoingHeaders(r.headers),
+    body: r.body.toString()
+  };
+}
+function normalizeIncomingHeaders(headers) {
+  return Object.fromEntries(Object.entries(headers || {}).map(([key, value]) => [key.toLowerCase(), value]));
+}
+function normalizeOutgoingHeaders(headers) {
+  return Object.fromEntries(Object.entries(headers).filter(([key]) => !["set-cookie"].includes(key)).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : v]));
+}

node_modules/nitropack/dist/runtime/entries/nitro-dev.d.ts

@@ -0,0 +1 @@
+import '#internal/nitro/virtual/polyfill';

node_modules/nitropack/dist/runtime/entries/nitro-dev.mjs

@@ -0,0 +1,38 @@
+import "#internal/nitro/virtual/polyfill";
+import { Server } from "http";
+import { tmpdir } from "os";
+import { join } from "path";
+import { mkdirSync } from "fs";
+import { threadId, parentPort } from "worker_threads";
+import { isWindows, provider } from "std-env";
+import { toNodeListener } from "h3";
+import { nitroApp } from "../app.mjs";
+const server = new Server(toNodeListener(nitroApp.h3App));
+function getAddress() {
+  if (provider === "stackblitz" || process.env.NITRO_NO_UNIX_SOCKET) {
+    return "0";
+  }
+  const socketName = `worker-${process.pid}-${threadId}.sock`;
+  if (isWindows) {
+    return join("\\\\.\\pipe\\nitro", socketName);
+  } else {
+    const socketDir = join(tmpdir(), "nitro");
+    mkdirSync(socketDir, { recursive: true });
+    return join(socketDir, socketName);
+  }
+}
+const listenAddress = getAddress();
+server.listen(listenAddress, () => {
+  const _address = server.address();
+  parentPort.postMessage({
+    event: "listen",
+    address: typeof _address === "string" ? { socketPath: _address } : { host: "localhost", port: _address.port }
+  });
+});
+if (process.env.DEBUG) {
+  process.on("unhandledRejection", (err) => console.error("[nitro] [dev] [unhandledRejection]", err));
+  process.on("uncaughtException", (err) => console.error("[nitro] [dev] [uncaughtException]", err));
+} else {
+  process.on("unhandledRejection", (err) => console.error("[nitro] [dev] [unhandledRejection] " + err));
+  process.on("uncaughtException", (err) => console.error("[nitro] [dev] [uncaughtException] " + err));
+}

node_modules/nitropack/dist/runtime/entries/nitro-prerenderer.d.ts

@@ -0,0 +1,2 @@
+import '#internal/nitro/virtual/polyfill';
+export declare const localFetch: (input: string | Request, init: import("unenv/runtime/fetch").FetchOptions) => Promise<Response>;

node_modules/nitropack/dist/runtime/entries/nitro-prerenderer.mjs

@@ -0,0 +1,10 @@
+import "#internal/nitro/virtual/polyfill";
+import { nitroApp } from "../app.mjs";
+export const localFetch = nitroApp.localFetch;
+if (process.env.DEBUG) {
+  process.on("unhandledRejection", (err) => console.error("[nitro] [dev] [unhandledRejection]", err));
+  process.on("uncaughtException", (err) => console.error("[nitro] [dev] [uncaughtException]", err));
+} else {
+  process.on("unhandledRejection", (err) => console.error("[nitro] [dev] [unhandledRejection] " + err));
+  process.on("uncaughtException", (err) => console.error("[nitro] [dev] [uncaughtException] " + err));
+}

node_modules/nitropack/dist/runtime/entries/node-cluster.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/nitropack/dist/runtime/entries/node-cluster.mjs

@@ -0,0 +1,16 @@
+import os from "node:os";
+import cluster from "node:cluster";
+if (cluster.isPrimary) {
+  const numberOfWorkers = parseInt(process.env.NITRO_CLUSTER_WORKERS) || os.cpus().length;
+  for (let i = 0; i < numberOfWorkers; i++) {
+    cluster.fork();
+  }
+  cluster.on("exit", () => {
+    cluster.fork();
+  });
+} else {
+  import("./node-server").catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}

node_modules/nitropack/dist/runtime/entries/node-server.d.ts

@@ -0,0 +1,3 @@
+import '#internal/nitro/virtual/polyfill';
+declare const _default: {};
+export default _default;

node_modules/nitropack/dist/runtime/entries/node-server.mjs

@@ -0,0 +1,31 @@
+import "#internal/nitro/virtual/polyfill";
+import { Server as HttpServer } from "http";
+import { Server as HttpsServer } from "https";
+import destr from "destr";
+import { toNodeListener } from "h3";
+import { nitroApp } from "../app.mjs";
+import { useRuntimeConfig } from "#internal/nitro";
+const cert = process.env.NITRO_SSL_CERT;
+const key = process.env.NITRO_SSL_KEY;
+const server = cert && key ? new HttpsServer({ key, cert }, toNodeListener(nitroApp.h3App)) : new HttpServer(toNodeListener(nitroApp.h3App));
+const port = destr(process.env.NITRO_PORT || process.env.PORT) || 3e3;
+const host = process.env.NITRO_HOST || process.env.HOST;
+const s = server.listen(port, host, (err) => {
+  if (err) {
+    console.error(err);
+    process.exit(1);
+  }
+  const protocol = cert && key ? "https" : "http";
+  const i = s.address();
+  const baseURL = (useRuntimeConfig().app.baseURL || "").replace(/\/$/, "");
+  const url = `${protocol}://${i.family === "IPv6" ? `[${i.address}]` : i.address}:${i.port}${baseURL}`;
+  console.log(`Listening ${url}`);
+});
+if (process.env.DEBUG) {
+  process.on("unhandledRejection", (err) => console.error("[nitro] [dev] [unhandledRejection]", err));
+  process.on("uncaughtException", (err) => console.error("[nitro] [dev] [uncaughtException]", err));
+} else {
+  process.on("unhandledRejection", (err) => console.error("[nitro] [dev] [unhandledRejection] " + err));
+  process.on("uncaughtException", (err) => console.error("[nitro] [dev] [uncaughtException] " + err));
+}
+export default {};

node_modules/nitropack/dist/runtime/entries/node.d.ts

@@ -0,0 +1,4 @@
+import '#internal/nitro/virtual/polyfill';
+export declare const listener: import("h3").NodeListener;
+/** @deprecated use new `listener` export instead */
+export declare const handler: import("h3").NodeListener;

node_modules/nitropack/dist/runtime/entries/node.mjs

@@ -0,0 +1,12 @@
+import "#internal/nitro/virtual/polyfill";
+import { toNodeListener } from "h3";
+import { nitroApp } from "../app.mjs";
+export const listener = toNodeListener(nitroApp.h3App);
+export const handler = listener;
+if (process.env.DEBUG) {
+  process.on("unhandledRejection", (err) => console.error("[nitro] [dev] [unhandledRejection]", err));
+  process.on("uncaughtException", (err) => console.error("[nitro] [dev] [uncaughtException]", err));
+} else {
+  process.on("unhandledRejection", (err) => console.error("[nitro] [dev] [unhandledRejection] " + err));
+  process.on("uncaughtException", (err) => console.error("[nitro] [dev] [uncaughtException] " + err));
+}

node_modules/nitropack/dist/runtime/entries/service-worker.d.ts

@@ -0,0 +1 @@
+import '#internal/nitro/virtual/polyfill';

node_modules/nitropack/dist/runtime/entries/service-worker.mjs

@@ -0,0 +1,38 @@
+import "#internal/nitro/virtual/polyfill";
+import { requestHasBody, useRequestBody } from "../utils.mjs";
+import { nitroApp } from "../app.mjs";
+import { isPublicAssetURL } from "#internal/nitro/virtual/public-assets";
+addEventListener("fetch", (event) => {
+  const url = new URL(event.request.url);
+  if (isPublicAssetURL(url.pathname) || url.pathname.includes("/_server/")) {
+    return;
+  }
+  event.respondWith(handleEvent(url, event));
+});
+async function handleEvent(url, event) {
+  let body;
+  if (requestHasBody(event.request)) {
+    body = await useRequestBody(event.request);
+  }
+  const r = await nitroApp.localCall({
+    event,
+    url: url.pathname + url.search,
+    host: url.hostname,
+    protocol: url.protocol,
+    headers: event.request.headers,
+    method: event.request.method,
+    redirect: event.request.redirect,
+    body
+  });
+  return new Response(r.body, {
+    headers: r.headers,
+    status: r.status,
+    statusText: r.statusText
+  });
+}
+self.addEventListener("install", () => {
+  self.skipWaiting();
+});
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});

node_modules/nitropack/dist/runtime/entries/stormkit.d.ts

@@ -0,0 +1,20 @@
+import type { Handler } from 'aws-lambda';
+import '#internal/nitro/virtual/polyfill';
+interface StormkitEvent {
+    url: string;
+    path: string;
+    method: string;
+    body?: string;
+    query?: Record<string, Array<string>>;
+    headers?: Record<string, string>;
+    rawHeaders?: Array<string>;
+}
+export interface StormkitResult {
+    statusCode: number;
+    headers?: {
+        [header: string]: boolean | number | string;
+    } | undefined;
+    body?: string | undefined;
+}
+export declare const handler: Handler<StormkitEvent, StormkitResult>;
+export {};

node_modules/nitropack/dist/runtime/entries/stormkit.mjs

@@ -0,0 +1,22 @@
+import "#internal/nitro/virtual/polyfill";
+import { nitroApp } from "../app.mjs";
+export const handler = async function(event, context) {
+  const method = event.method || "get";
+  const r = await nitroApp.localCall({
+    event,
+    url: event.url,
+    context,
+    headers: event.headers,
+    method,
+    query: event.query,
+    body: event.body
+  });
+  return {
+    statusCode: r.status,
+    headers: normalizeOutgoingHeaders(r.headers),
+    body: r.body.toString()
+  };
+};
+function normalizeOutgoingHeaders(headers) {
+  return Object.fromEntries(Object.entries(headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : v]));
+}

node_modules/nitropack/dist/runtime/entries/vercel-edge.d.ts

@@ -0,0 +1,2 @@
+import '#internal/nitro/virtual/polyfill';
+export default function handleEvent(request: any, event: any): Promise<Response>;

node_modules/nitropack/dist/runtime/entries/vercel-edge.mjs

@@ -0,0 +1,27 @@
+import "#internal/nitro/virtual/polyfill";
+import { requestHasBody, useRequestBody } from "#internal/nitro/utils";
+import { nitroApp } from "#internal/nitro/app";
+export default async function handleEvent(request, event) {
+  const url = new URL(request.url);
+  let body;
+  if (requestHasBody(request)) {
+    body = await useRequestBody(request);
+  }
+  const r = await nitroApp.localCall({
+    event,
+    url: url.pathname + url.search,
+    host: url.hostname,
+    protocol: url.protocol,
+    headers: Object.fromEntries(request.headers.entries()),
+    method: request.method,
+    body
+  });
+  return new Response(r.body, {
+    headers: normalizeOutgoingHeaders(r.headers),
+    status: r.status,
+    statusText: r.statusText
+  });
+}
+function normalizeOutgoingHeaders(headers) {
+  return Object.entries(headers).map(([k, v]) => [k, Array.isArray(v) ? v.join(",") : v]);
+}

node_modules/nitropack/dist/runtime/entries/vercel.d.ts

@@ -0,0 +1,4 @@
+import '#internal/nitro/virtual/polyfill';
+import { NodeListener } from 'h3';
+declare const _default: NodeListener;
+export default _default;

node_modules/nitropack/dist/runtime/entries/vercel.mjs

@@ -0,0 +1,15 @@
+import "#internal/nitro/virtual/polyfill";
+import { toNodeListener } from "h3";
+import { parseQuery } from "ufo";
+import { nitroApp } from "../app.mjs";
+const handler = toNodeListener(nitroApp.h3App);
+export default (function(req, res) {
+  const query = req.headers["x-now-route-matches"];
+  if (query) {
+    const { url } = parseQuery(query);
+    if (url) {
+      req.url = url;
+    }
+  }
+  return handler(req, res);
+});