initial commit

node_modules/nitropack/dist/runtime/app.d.ts

@@ -0,0 +1,12 @@
+import { App as H3App, Router } from 'h3';
+import { createCall, createFetch as createLocalFetch } from 'unenv/runtime/fetch/index';
+import { Hookable } from 'hookable';
+export interface NitroApp {
+    h3App: H3App;
+    router: Router;
+    hooks: Hookable;
+    localCall: ReturnType<typeof createCall>;
+    localFetch: ReturnType<typeof createLocalFetch>;
+}
+export declare const nitroApp: NitroApp;
+export declare const useNitroApp: () => NitroApp;

node_modules/nitropack/dist/runtime/app.mjs

@@ -0,0 +1,57 @@
+import { createApp, createRouter, lazyEventHandler, toNodeListener } from "h3";
+import { createFetch, Headers } from "ofetch";
+import destr from "destr";
+import { createCall, createFetch as createLocalFetch } from "unenv/runtime/fetch/index";
+import { createHooks } from "hookable";
+import { useRuntimeConfig } from "./config.mjs";
+import { timingMiddleware } from "./timing.mjs";
+import { cachedEventHandler } from "./cache.mjs";
+import { createRouteRulesHandler, getRouteRulesForPath } from "./route-rules.mjs";
+import { plugins } from "#internal/nitro/virtual/plugins";
+import errorHandler from "#internal/nitro/virtual/error-handler";
+import { handlers } from "#internal/nitro/virtual/server-handlers";
+function createNitroApp() {
+  const config = useRuntimeConfig();
+  const hooks = createHooks();
+  const h3App = createApp({
+    debug: destr(process.env.DEBUG),
+    onError: errorHandler
+  });
+  h3App.use(config.app.baseURL, timingMiddleware);
+  const router = createRouter();
+  h3App.use(createRouteRulesHandler());
+  for (const h of handlers) {
+    let handler = h.lazy ? lazyEventHandler(h.handler) : h.handler;
+    if (h.middleware || !h.route) {
+      const middlewareBase = (config.app.baseURL + (h.route || "/")).replace(/\/+/g, "/");
+      h3App.use(middlewareBase, handler);
+    } else {
+      const routeRules = getRouteRulesForPath(h.route.replace(/:\w+|\*\*/g, "_"));
+      if (routeRules.cache) {
+        handler = cachedEventHandler(handler, {
+          group: "nitro/routes",
+          ...routeRules.cache
+        });
+      }
+      router.use(h.route, handler, h.method);
+    }
+  }
+  h3App.use(config.app.baseURL, router);
+  const localCall = createCall(toNodeListener(h3App));
+  const localFetch = createLocalFetch(localCall, globalThis.fetch);
+  const $fetch = createFetch({ fetch: localFetch, Headers, defaults: { baseURL: config.app.baseURL } });
+  globalThis.$fetch = $fetch;
+  const app = {
+    hooks,
+    h3App,
+    router,
+    localCall,
+    localFetch
+  };
+  for (const plugin of plugins) {
+    plugin(app);
+  }
+  return app;
+}
+export const nitroApp = createNitroApp();
+export const useNitroApp = () => nitroApp;

node_modules/nitropack/dist/runtime/cache.d.ts

@@ -0,0 +1,32 @@
+import { EventHandler } from 'h3';
+export interface CacheEntry<T = any> {
+    value?: T;
+    expires?: number;
+    mtime?: number;
+    integrity?: string;
+}
+export interface CacheOptions<T = any> {
+    name?: string;
+    getKey?: (...args: any[]) => string;
+    transform?: (entry: CacheEntry<T>, ...args: any[]) => any;
+    validate?: (entry: CacheEntry<T>) => boolean;
+    group?: string;
+    integrity?: any;
+    maxAge?: number;
+    static?: boolean;
+    swr?: boolean;
+    staleMaxAge?: number;
+    base?: string;
+}
+export declare function defineCachedFunction<T = any>(fn: ((...args: any[]) => T | Promise<T>), opts: CacheOptions<T>): (...args: any[]) => Promise<T | undefined>;
+export declare const cachedFunction: typeof defineCachedFunction;
+export interface ResponseCacheEntry<T = any> {
+    body: T;
+    code: number;
+    headers: Record<string, string | number | string[]>;
+}
+export interface CachedEventHandlerOptions<T = any> extends Omit<CacheOptions<ResponseCacheEntry<T>>, 'getKey' | 'transform' | 'validate'> {
+    headersOnly?: boolean;
+}
+export declare function defineCachedEventHandler<T = any>(handler: EventHandler<T>, opts?: CachedEventHandlerOptions<T>): EventHandler<T>;
+export declare const cachedEventHandler: typeof defineCachedEventHandler;

node_modules/nitropack/dist/runtime/cache.mjs

@@ -0,0 +1,217 @@
+import { hash } from "ohash";
+import { handleCacheHeaders, defineEventHandler, createEvent } from "h3";
+import { parseURL } from "ufo";
+import { useStorage } from "#internal/nitro";
+const defaultCacheOptions = {
+  name: "_",
+  base: "/cache",
+  swr: true,
+  maxAge: 1
+};
+export function defineCachedFunction(fn, opts) {
+  opts = { ...defaultCacheOptions, ...opts };
+  const pending = {};
+  const group = opts.group || "nitro";
+  const name = opts.name || fn.name || "_";
+  const integrity = hash([opts.integrity, fn, opts]);
+  const validate = opts.validate || (() => true);
+  async function get(key, resolver) {
+    const cacheKey = [opts.base, group, name, key + ".json"].filter(Boolean).join(":").replace(/:\/$/, ":index");
+    const entry = await useStorage().getItem(cacheKey) || {};
+    const ttl = (opts.maxAge ?? opts.maxAge ?? 0) * 1e3;
+    if (ttl) {
+      entry.expires = Date.now() + ttl;
+    }
+    const expired = entry.integrity !== integrity || ttl && Date.now() - (entry.mtime || 0) > ttl || !validate(entry);
+    const _resolve = async () => {
+      if (!pending[key]) {
+        entry.value = void 0;
+        entry.integrity = void 0;
+        entry.mtime = void 0;
+        entry.expires = void 0;
+        pending[key] = Promise.resolve(resolver());
+      }
+      entry.value = await pending[key];
+      entry.mtime = Date.now();
+      entry.integrity = integrity;
+      delete pending[key];
+      if (validate(entry)) {
+        useStorage().setItem(cacheKey, entry).catch((error) => console.error("[nitro] [cache]", error));
+      }
+    };
+    const _resolvePromise = expired ? _resolve() : Promise.resolve();
+    if (opts.swr && entry.value) {
+      _resolvePromise.catch(console.error);
+      return Promise.resolve(entry);
+    }
+    return _resolvePromise.then(() => entry);
+  }
+  return async (...args) => {
+    const key = (opts.getKey || getKey)(...args);
+    const entry = await get(key, () => fn(...args));
+    let value = entry.value;
+    if (opts.transform) {
+      value = await opts.transform(entry, ...args) || value;
+    }
+    return value;
+  };
+}
+export const cachedFunction = defineCachedFunction;
+function getKey(...args) {
+  return args.length ? hash(args, {}) : "";
+}
+export function defineCachedEventHandler(handler, opts = defaultCacheOptions) {
+  const _opts = {
+    ...opts,
+    getKey: (event) => {
+      const url = event.req.originalUrl || event.req.url;
+      const friendlyName = decodeURI(parseURL(url).pathname).replace(/[^a-zA-Z0-9]/g, "").substring(0, 16);
+      const urlHash = hash(url);
+      return `${friendlyName}.${urlHash}`;
+    },
+    validate: (entry) => {
+      if (entry.value.code >= 400) {
+        return false;
+      }
+      if (entry.value.body === void 0) {
+        return false;
+      }
+      return true;
+    },
+    group: opts.group || "nitro/handlers",
+    integrity: [
+      opts.integrity,
+      handler
+    ]
+  };
+  const _cachedHandler = cachedFunction(async (incomingEvent) => {
+    const reqProxy = cloneWithProxy(incomingEvent.req, { headers: {} });
+    const resHeaders = {};
+    let _resSendBody;
+    const resProxy = cloneWithProxy(incomingEvent.res, {
+      statusCode: 200,
+      getHeader(name) {
+        return resHeaders[name];
+      },
+      setHeader(name, value) {
+        resHeaders[name] = value;
+        return this;
+      },
+      getHeaderNames() {
+        return Object.keys(resHeaders);
+      },
+      hasHeader(name) {
+        return name in resHeaders;
+      },
+      removeHeader(name) {
+        delete resHeaders[name];
+      },
+      getHeaders() {
+        return resHeaders;
+      },
+      end(chunk, arg2, arg3) {
+        if (typeof chunk === "string") {
+          _resSendBody = chunk;
+        }
+        if (typeof arg2 === "function") {
+          arg2();
+        }
+        if (typeof arg3 === "function") {
+          arg3();
+        }
+        return this;
+      },
+      write(chunk, arg2, arg3) {
+        if (typeof chunk === "string") {
+          _resSendBody = chunk;
+        }
+        if (typeof arg2 === "function") {
+          arg2();
+        }
+        if (typeof arg3 === "function") {
+          arg3();
+        }
+        return this;
+      },
+      writeHead(statusCode, headers2) {
+        this.statusCode = statusCode;
+        if (headers2) {
+          for (const header in headers2) {
+            this.setHeader(header, headers2[header]);
+          }
+        }
+        return this;
+      }
+    });
+    const event = createEvent(reqProxy, resProxy);
+    event.context = incomingEvent.context;
+    const body = await handler(event) || _resSendBody;
+    const headers = event.res.getHeaders();
+    headers.etag = headers.Etag || headers.etag || `W/"${hash(body)}"`;
+    headers["last-modified"] = headers["Last-Modified"] || headers["last-modified"] || new Date().toUTCString();
+    const cacheControl = [];
+    if (opts.swr) {
+      if (opts.maxAge) {
+        cacheControl.push(`s-maxage=${opts.maxAge}`);
+      }
+      if (opts.staleMaxAge) {
+        cacheControl.push(`stale-while-revalidate=${opts.staleMaxAge}`);
+      } else {
+        cacheControl.push("stale-while-revalidate");
+      }
+    } else if (opts.maxAge) {
+      cacheControl.push(`max-age=${opts.maxAge}`);
+    }
+    if (cacheControl.length) {
+      headers["cache-control"] = cacheControl.join(", ");
+    }
+    const cacheEntry = {
+      code: event.res.statusCode,
+      headers,
+      body
+    };
+    return cacheEntry;
+  }, _opts);
+  return defineEventHandler(async (event) => {
+    if (opts.headersOnly) {
+      if (handleCacheHeaders(event, { maxAge: opts.maxAge })) {
+        return;
+      }
+      return handler(event);
+    }
+    const response = await _cachedHandler(event);
+    if (event.res.headersSent || event.res.writableEnded) {
+      return response.body;
+    }
+    if (handleCacheHeaders(event, {
+      modifiedTime: new Date(response.headers["last-modified"]),
+      etag: response.headers.etag,
+      maxAge: opts.maxAge
+    })) {
+      return;
+    }
+    event.res.statusCode = response.code;
+    for (const name in response.headers) {
+      event.res.setHeader(name, response.headers[name]);
+    }
+    return response.body;
+  });
+}
+function cloneWithProxy(obj, overrides) {
+  return new Proxy(obj, {
+    get(target, property, receiver) {
+      if (property in overrides) {
+        return overrides[property];
+      }
+      return Reflect.get(target, property, receiver);
+    },
+    set(target, property, value, receiver) {
+      if (property in overrides) {
+        overrides[property] = value;
+        return true;
+      }
+      return Reflect.set(target, property, value, receiver);
+    }
+  });
+}
+export const cachedEventHandler = defineCachedEventHandler;

node_modules/nitropack/dist/runtime/client.d.ts

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

node_modules/nitropack/dist/runtime/client.mjs

@@ -0,0 +1,4 @@
+import { $fetch } from "ofetch";
+if (!globalThis.$fetch) {
+  globalThis.$fetch = $fetch;
+}

node_modules/nitropack/dist/runtime/config.d.ts

@@ -0,0 +1,3 @@
+declare const config: Readonly<Record<string, any>>;
+export declare const useRuntimeConfig: () => Readonly<Record<string, any>>;
+export default config;

node_modules/nitropack/dist/runtime/config.mjs

@@ -0,0 +1,40 @@
+import destr from "destr";
+import { snakeCase } from "scule";
+const _runtimeConfig = process.env.RUNTIME_CONFIG;
+const ENV_PREFIX = "NITRO_";
+const ENV_PREFIX_ALT = _runtimeConfig.nitro.envPrefix ?? process.env.NITRO_ENV_PREFIX ?? "_";
+const getEnv = (key) => {
+  const envKey = snakeCase(key).toUpperCase();
+  return destr(process.env[ENV_PREFIX + envKey] ?? process.env[ENV_PREFIX_ALT + envKey]);
+};
+function isObject(input) {
+  return typeof input === "object" && !Array.isArray(input);
+}
+function overrideConfig(obj, parentKey = "") {
+  for (const key in obj) {
+    const subKey = parentKey ? `${parentKey}_${key}` : key;
+    const envValue = getEnv(subKey);
+    if (isObject(obj[key])) {
+      if (isObject(envValue)) {
+        obj[key] = { ...obj[key], ...envValue };
+      }
+      overrideConfig(obj[key], subKey);
+    } else {
+      obj[key] = envValue ?? obj[key];
+    }
+  }
+}
+overrideConfig(_runtimeConfig);
+const config = deepFreeze(_runtimeConfig);
+export const useRuntimeConfig = () => config;
+export default config;
+function deepFreeze(object) {
+  const propNames = Object.getOwnPropertyNames(object);
+  for (const name of propNames) {
+    const value = object[name];
+    if (value && typeof value === "object") {
+      deepFreeze(value);
+    }
+  }
+  return Object.freeze(object);
+}

node_modules/nitropack/dist/runtime/debug.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./plugin").NitroAppPlugin;
+export default _default;

node_modules/nitropack/dist/runtime/debug.mjs

@@ -0,0 +1,5 @@
+import { createDebugger } from "hookable";
+import { defineNitroPlugin } from "./plugin.mjs";
+export default defineNitroPlugin((nitro) => {
+  createDebugger(nitro.hooks, { tag: "nitro-runtime" });
+});

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);
+});

node_modules/nitropack/dist/runtime/error.d.ts

@@ -0,0 +1,3 @@
+import type { NitroErrorHandler } from '../types';
+declare const _default: NitroErrorHandler;
+export default _default;

node_modules/nitropack/dist/runtime/error.mjs

@@ -0,0 +1,65 @@
+import { normalizeError, isJsonRequest } from "./utils.mjs";
+const isDev = process.env.NODE_ENV === "development";
+export default (function(error, event) {
+  const { stack, statusCode, statusMessage, message } = normalizeError(error);
+  const showDetails = isDev && statusCode !== 404;
+  const errorObject = {
+    url: event.req.url || "",
+    statusCode,
+    statusMessage,
+    message,
+    stack: showDetails ? stack.map((i) => i.text) : void 0
+  };
+  if (error.unhandled || error.fatal) {
+    const tags = [
+      "[nitro]",
+      "[request error]",
+      error.unhandled && "[unhandled]",
+      error.fatal && "[fatal]"
+    ].filter(Boolean).join(" ");
+    console.error(tags, error.message + "\n" + stack.map((l) => "  " + l.text).join("  \n"));
+  }
+  event.res.statusCode = statusCode;
+  if (statusMessage) {
+    event.res.statusMessage = statusMessage;
+  }
+  if (isJsonRequest(event)) {
+    event.res.setHeader("Content-Type", "application/json");
+    event.res.end(JSON.stringify(errorObject));
+  } else {
+    event.res.setHeader("Content-Type", "text/html");
+    event.res.end(renderHTMLError(errorObject));
+  }
+});
+function renderHTMLError(error) {
+  const statusCode = error.statusCode || 500;
+  const statusMessage = error.statusMessage || "Request Error";
+  return `<!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>${statusCode} ${statusMessage}</title>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@picocss/pico/css/pico.min.css">
+  </head>
+  <body>
+    <main class="container">
+      <dialog open>
+        <article>
+          <header>
+            <h2>${statusCode} ${statusMessage}</h2>
+          </header>
+          <code>
+            ${error.message}<br><br>
+            ${"\n" + (error.stack || []).map((i) => `&nbsp;&nbsp;${i}`).join("<br>")}
+          </code>
+          <footer>
+            <a href="/" onclick="event.preventDefault();history.back();">Go Back</a>
+          </footer>
+        </article>
+      </dialog>
+    </main>
+  </body>
+</html>
+`;
+}

node_modules/nitropack/dist/runtime/index.d.ts

@@ -0,0 +1,7 @@
+export { useStorage } from '#internal/nitro/virtual/storage';
+export { useRuntimeConfig } from './config';
+export * from './cache';
+export { useNitroApp } from './app';
+export * from './plugin';
+export * from './renderer';
+export { getRouteRules } from './route-rules';

node_modules/nitropack/dist/runtime/index.mjs

@@ -0,0 +1,7 @@
+export { useStorage } from "#internal/nitro/virtual/storage";
+export { useRuntimeConfig } from "./config.mjs";
+export * from "./cache.mjs";
+export { useNitroApp } from "./app.mjs";
+export * from "./plugin.mjs";
+export * from "./renderer.mjs";
+export { getRouteRules } from "./route-rules.mjs";

node_modules/nitropack/dist/runtime/plugin.d.ts

@@ -0,0 +1,6 @@
+import type { NitroApp } from './app';
+export interface NitroAppPlugin {
+    (nitro: NitroApp): void;
+}
+export declare function defineNitroPlugin(def: NitroAppPlugin): NitroAppPlugin;
+export declare const nitroPlugin: typeof defineNitroPlugin;

node_modules/nitropack/dist/runtime/plugin.mjs

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

node_modules/nitropack/dist/runtime/renderer.d.ts

@@ -0,0 +1,9 @@
+import { H3Event } from 'h3';
+export interface RenderResponse {
+    body: string;
+    statusCode: number;
+    statusMessage: string;
+    headers: Record<string, string>;
+}
+export type RenderHandler = (event: H3Event) => Partial<RenderResponse> | Promise<Partial<RenderResponse>>;
+export declare function defineRenderHandler(handler: RenderHandler): import("h3").EventHandler<string | undefined>;

node_modules/nitropack/dist/runtime/renderer.mjs

@@ -0,0 +1,33 @@
+import { eventHandler } from "h3";
+import { useNitroApp } from "./app.mjs";
+export function defineRenderHandler(handler) {
+  return eventHandler(async (event) => {
+    if (event.req.url.endsWith("/favicon.ico")) {
+      event.res.setHeader("Content-Type", "image/x-icon");
+      event.res.end("data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7");
+      return;
+    }
+    const response = await handler(event);
+    if (!response) {
+      if (!event.res.writableEnded) {
+        event.res.statusCode = event.res.statusCode === 200 ? 500 : event.res.statusCode;
+        event.res.end("No response returned from render handler: " + event.req.url);
+      }
+      return;
+    }
+    const nitroApp = useNitroApp();
+    await nitroApp.hooks.callHook("render:response", response, { event });
+    if (!event.res.headersSent && response.headers) {
+      for (const header in response.headers) {
+        event.res.setHeader(header, response.headers[header]);
+      }
+      if (response.statusCode) {
+        event.res.statusCode = response.statusCode;
+      }
+      if (response.statusMessage) {
+        event.res.statusMessage = response.statusMessage;
+      }
+    }
+    return typeof response.body === "string" ? response.body : JSON.stringify(response.body);
+  });
+}

node_modules/nitropack/dist/runtime/route-rules.d.ts

@@ -0,0 +1,5 @@
+import { H3Event } from 'h3';
+import type { NitroRouteRules } from 'nitropack';
+export declare function createRouteRulesHandler(): import("h3").EventHandler<void | undefined>;
+export declare function getRouteRules(event: H3Event): NitroRouteRules;
+export declare function getRouteRulesForPath(path: string): NitroRouteRules;

node_modules/nitropack/dist/runtime/route-rules.mjs

@@ -0,0 +1,28 @@
+import { eventHandler, sendRedirect, setHeaders } from "h3";
+import defu from "defu";
+import { createRouter as createRadixRouter, toRouteMatcher } from "radix3";
+import { useRuntimeConfig } from "./config.mjs";
+const config = useRuntimeConfig();
+const _routeRulesMatcher = toRouteMatcher(createRadixRouter({ routes: config.nitro.routeRules }));
+export function createRouteRulesHandler() {
+  return eventHandler((event) => {
+    const routeRules = getRouteRules(event);
+    if (routeRules.headers) {
+      setHeaders(event, routeRules.headers);
+    }
+    if (routeRules.redirect) {
+      return sendRedirect(event, routeRules.redirect.to, routeRules.redirect.statusCode);
+    }
+  });
+}
+export function getRouteRules(event) {
+  event.context._nitro = event.context._nitro || {};
+  if (!event.context._nitro.routeRules) {
+    const path = new URL(event.req.url, "http://localhost").pathname;
+    event.context._nitro.routeRules = getRouteRulesForPath(path);
+  }
+  return event.context._nitro.routeRules;
+}
+export function getRouteRulesForPath(path) {
+  return defu({}, ..._routeRulesMatcher.matchAll(path).reverse());
+}

node_modules/nitropack/dist/runtime/static.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<any>;
+export default _default;

node_modules/nitropack/dist/runtime/static.mjs

@@ -0,0 +1,66 @@
+import { eventHandler, createError } from "h3";
+import { joinURL, withoutTrailingSlash, withLeadingSlash, parseURL } from "ufo";
+import { getAsset, readAsset, isPublicAssetURL } from "#internal/nitro/virtual/public-assets";
+const METHODS = ["HEAD", "GET"];
+const EncodingMap = { gzip: ".gz", br: ".br" };
+export default eventHandler((event) => {
+  if (event.req.method && !METHODS.includes(event.req.method)) {
+    return;
+  }
+  let id = decodeURIComponent(withLeadingSlash(withoutTrailingSlash(parseURL(event.req.url).pathname)));
+  let asset;
+  const encodingHeader = String(event.req.headers["accept-encoding"] || "");
+  const encodings = encodingHeader.split(",").map((e) => EncodingMap[e.trim()]).filter(Boolean).sort().concat([""]);
+  if (encodings.length > 1) {
+    event.res.setHeader("Vary", "Accept-Encoding");
+  }
+  for (const encoding of encodings) {
+    for (const _id of [id + encoding, joinURL(id, "index.html" + encoding)]) {
+      const _asset = getAsset(_id);
+      if (_asset) {
+        asset = _asset;
+        id = _id;
+        break;
+      }
+    }
+  }
+  if (!asset) {
+    if (isPublicAssetURL(id)) {
+      throw createError({
+        statusMessage: "Cannot find static asset " + id,
+        statusCode: 404
+      });
+    }
+    return;
+  }
+  const ifNotMatch = event.req.headers["if-none-match"] === asset.etag;
+  if (ifNotMatch) {
+    event.res.statusCode = 304;
+    event.res.end();
+    return;
+  }
+  const ifModifiedSinceH = event.req.headers["if-modified-since"];
+  if (ifModifiedSinceH && asset.mtime) {
+    if (new Date(ifModifiedSinceH) >= new Date(asset.mtime)) {
+      event.res.statusCode = 304;
+      event.res.end();
+      return;
+    }
+  }
+  if (asset.type && !event.res.getHeader("Content-Type")) {
+    event.res.setHeader("Content-Type", asset.type);
+  }
+  if (asset.etag && !event.res.getHeader("ETag")) {
+    event.res.setHeader("ETag", asset.etag);
+  }
+  if (asset.mtime && !event.res.getHeader("Last-Modified")) {
+    event.res.setHeader("Last-Modified", asset.mtime);
+  }
+  if (asset.encoding && !event.res.getHeader("Content-Encoding")) {
+    event.res.setHeader("Content-Encoding", asset.encoding);
+  }
+  if (asset.size && !event.res.getHeader("Content-Length")) {
+    event.res.setHeader("Content-Length", asset.size);
+  }
+  return readAsset(id);
+});

node_modules/nitropack/dist/runtime/timing.d.ts

@@ -0,0 +1,2 @@
+export declare const globalTiming: any;
+export declare const timingMiddleware: import("h3").EventHandler<void>;

node_modules/nitropack/dist/runtime/timing.mjs

@@ -0,0 +1,19 @@
+import { eventHandler } from "h3";
+export const globalTiming = globalThis.__timing__ || {
+  start: () => 0,
+  end: () => 0,
+  metrics: []
+};
+export const timingMiddleware = eventHandler((event) => {
+  const start = globalTiming.start();
+  const _end = event.res.end;
+  event.res.end = function(chunk, encoding, cb) {
+    const metrics = [["Generate", globalTiming.end(start)], ...globalTiming.metrics];
+    const serverTiming = metrics.map((m) => `-;dur=${m[1]};desc="${encodeURIComponent(m[0])}"`).join(", ");
+    if (!event.res.headersSent) {
+      event.res.setHeader("Server-Timing", serverTiming);
+    }
+    _end.call(event.res, chunk, encoding, cb);
+    return this;
+  }.bind(event.res);
+});

node_modules/nitropack/dist/runtime/types.d.ts

@@ -0,0 +1,4 @@
+export type { NitroApp } from './app';
+export type { CacheEntry, CacheOptions, ResponseCacheEntry, CachedEventHandlerOptions } from './cache';
+export type { NitroAppPlugin } from './plugin';
+export type { RenderResponse, RenderHandler } from './renderer';

node_modules/nitropack/dist/runtime/utils.d.ts

@@ -0,0 +1,14 @@
+import type { H3Event } from 'h3';
+export declare function requestHasBody(request: globalThis.Request): boolean;
+export declare function useRequestBody(request: globalThis.Request): Promise<any>;
+export declare function hasReqHeader(event: H3Event, name: string, includes: string): boolean | "" | undefined;
+export declare function isJsonRequest(event: H3Event): boolean | undefined;
+export declare function normalizeError(error: any): {
+    stack: {
+        text: string;
+        internal: boolean;
+    }[];
+    statusCode: any;
+    statusMessage: any;
+    message: any;
+};

node_modules/nitropack/dist/runtime/utils.mjs

@@ -0,0 +1,51 @@
+import { getRequestHeader } from "h3";
+const METHOD_WITH_BODY_RE = /post|put|patch/i;
+const TEXT_MIME_RE = /application\/text|text\/html/;
+const JSON_MIME_RE = /application\/json/;
+export function requestHasBody(request) {
+  return METHOD_WITH_BODY_RE.test(request.method);
+}
+export async function useRequestBody(request) {
+  const contentType = request.headers.get("content-type") || "";
+  if (contentType.includes("form")) {
+    const formData = await request.formData();
+    const body = /* @__PURE__ */ Object.create(null);
+    for (const entry of formData.entries()) {
+      body[entry[0]] = entry[1];
+    }
+    return body;
+  } else if (JSON_MIME_RE.test(contentType)) {
+    return request.json();
+  } else if (TEXT_MIME_RE.test(contentType)) {
+    return request.text();
+  } else {
+    const blob = await request.blob();
+    return URL.createObjectURL(blob);
+  }
+}
+export function hasReqHeader(event, name, includes) {
+  const value = getRequestHeader(event, name);
+  return value && typeof value === "string" && value.toLowerCase().includes(includes);
+}
+export function isJsonRequest(event) {
+  return hasReqHeader(event, "accept", "application/json") || hasReqHeader(event, "user-agent", "curl/") || hasReqHeader(event, "user-agent", "httpie/") || event.req.url?.endsWith(".json") || event.req.url?.includes("/api/");
+}
+export function normalizeError(error) {
+  const cwd = process.cwd();
+  const stack = (error.stack || "").split("\n").splice(1).filter((line) => line.includes("at ")).map((line) => {
+    const text = line.replace(cwd + "/", "./").replace("webpack:/", "").replace("file://", "").trim();
+    return {
+      text,
+      internal: line.includes("node_modules") && !line.includes(".cache") || line.includes("internal") || line.includes("new Promise")
+    };
+  });
+  const statusCode = error.statusCode || 500;
+  const statusMessage = error.statusMessage ?? (statusCode === 404 ? "Not Found" : "");
+  const message = error.message || error.toString();
+  return {
+    stack,
+    statusCode,
+    statusMessage,
+    message
+  };
+}

node_modules/nitropack/dist/runtime/virtual/error-handler.d.ts

@@ -0,0 +1,5 @@
+import type { NitroErrorHandler } from '../../types'
+
+const errorHandler: NitroErrorHandler
+
+export default errorHandler

node_modules/nitropack/dist/runtime/virtual/plugins.d.ts

@@ -0,0 +1,3 @@
+import type { NitroAppPlugin } from '../plugin'
+
+export const plugins: NitroAppPlugin[] = []

node_modules/nitropack/dist/runtime/virtual/polyfills.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

node_modules/nitropack/dist/runtime/virtual/polyfills.mjs

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

node_modules/nitropack/dist/runtime/virtual/public-assets.d.ts

@@ -0,0 +1,4 @@
+export const publicAssetBases: string[]
+export const isPublicAssetURL: (id: string) => boolean
+export const readAsset: (id: string) => Promise<Buffer>
+export const getAsset: (id: string) => any

node_modules/nitropack/dist/runtime/virtual/server-assets.d.ts

@@ -0,0 +1,4 @@
+export interface AssetMeta { type?: string, etag?: string, mtime?: string }
+export function readAsset<T = any> (id: string): Promise<T>
+export function statAsset (id: string): Promise<AssetMeta>
+export function getKeys() : Promise<string[]>

node_modules/nitropack/dist/runtime/virtual/server-handlers.d.ts

@@ -0,0 +1,14 @@
+import type { H3EventHandler, LazyEventHandler, RouterMethod } from 'h3'
+
+type HandlerDefinition = {
+  route: string
+  lazy?: boolean
+  middleware?: boolean
+  handler: H3EventHandler
+  method?: RouterMethod
+} & {
+  lazy: true
+  handler: LazyEventHandler
+}
+
+export const handlers: HandlerDefinition[]

node_modules/nitropack/dist/runtime/virtual/storage.d.ts

@@ -0,0 +1,3 @@
+import type { Storage } from 'unstorage'
+
+export declare const useStorage: () => Storage