|
|
@@ -0,0 +1,959 @@
|
|
|
+import process from 'node:process';globalThis._importMeta_=globalThis._importMeta_||{url:"file:///_entry.js",env:process.env};import { getRequestHeader, splitCookiesString, setResponseStatus, setResponseHeader, send, getRequestHeaders, eventHandler, appendResponseHeader, removeResponseHeader, createError, getResponseHeader, defineEventHandler, handleCacheHeaders, createEvent, fetchWithEvent, isEvent, setHeaders, sendRedirect, proxyRequest, createApp, createRouter as createRouter$1, toNodeListener, lazyEventHandler, getResponseStatus, setResponseHeaders } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/h3/dist/index.mjs';
|
|
|
+import destr from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/destr/dist/index.mjs';
|
|
|
+import { createHooks } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/hookable/dist/index.mjs';
|
|
|
+import { createFetch as createFetch$1, Headers as Headers$1 } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/ofetch/dist/node.mjs';
|
|
|
+import { createCall, createFetch } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/unenv/runtime/fetch/index.mjs';
|
|
|
+import { withQuery, joinURL, decodePath, withLeadingSlash, withoutTrailingSlash, parseURL, withoutBase, getQuery } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/ufo/dist/index.mjs';
|
|
|
+import { klona } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/klona/dist/index.mjs';
|
|
|
+import defu, { defuFn } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/defu/dist/defu.mjs';
|
|
|
+import { snakeCase } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/scule/dist/index.mjs';
|
|
|
+import { promises } from 'node:fs';
|
|
|
+import { fileURLToPath } from 'node:url';
|
|
|
+import { dirname, resolve } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/pathe/dist/index.mjs';
|
|
|
+import { hash } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/ohash/dist/index.mjs';
|
|
|
+import { createStorage, prefixStorage } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/unstorage/dist/index.mjs';
|
|
|
+import unstorage_47drivers_47fs from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/unstorage/drivers/fs.mjs';
|
|
|
+import file_58_47_47_47D_58_47dev_47nuxt_47sannongzixunwang_web_47node_modules_47nuxt_47dist_47core_47runtime_47nitro_47cache_45driver_46js from 'file:///D:/dev/nuxt/sannongzixunwang_web/node_modules/nuxt/dist/core/runtime/nitro/cache-driver.js';
|
|
|
+import unstorage_47drivers_47fs_45lite from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/unstorage/drivers/fs-lite.mjs';
|
|
|
+import { toRouteMatcher, createRouter } from 'file://D:/dev/nuxt/sannongzixunwang_web/node_modules/radix3/dist/index.mjs';
|
|
|
+
|
|
|
+function hasReqHeader(event, name, includes) {
|
|
|
+ const value = getRequestHeader(event, name);
|
|
|
+ return value && typeof value === "string" && value.toLowerCase().includes(includes);
|
|
|
+}
|
|
|
+function isJsonRequest(event) {
|
|
|
+ if (hasReqHeader(event, "accept", "text/html")) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ return hasReqHeader(event, "accept", "application/json") || hasReqHeader(event, "user-agent", "curl/") || hasReqHeader(event, "user-agent", "httpie/") || hasReqHeader(event, "sec-fetch-mode", "cors") || event.path.startsWith("/api/") || event.path.endsWith(".json");
|
|
|
+}
|
|
|
+function normalizeError(error, isDev) {
|
|
|
+ const cwd = typeof process.cwd === "function" ? 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.unhandled ? "internal server error" : error.message || error.toString();
|
|
|
+ return {
|
|
|
+ stack,
|
|
|
+ statusCode,
|
|
|
+ statusMessage,
|
|
|
+ message
|
|
|
+ };
|
|
|
+}
|
|
|
+function _captureError(error, type) {
|
|
|
+ console.error(`[nitro] [${type}]`, error);
|
|
|
+ useNitroApp().captureError(error, { tags: [type] });
|
|
|
+}
|
|
|
+function trapUnhandledNodeErrors() {
|
|
|
+ process.on(
|
|
|
+ "unhandledRejection",
|
|
|
+ (error) => _captureError(error, "unhandledRejection")
|
|
|
+ );
|
|
|
+ process.on(
|
|
|
+ "uncaughtException",
|
|
|
+ (error) => _captureError(error, "uncaughtException")
|
|
|
+ );
|
|
|
+}
|
|
|
+function joinHeaders(value) {
|
|
|
+ return Array.isArray(value) ? value.join(", ") : String(value);
|
|
|
+}
|
|
|
+function normalizeFetchResponse(response) {
|
|
|
+ if (!response.headers.has("set-cookie")) {
|
|
|
+ return response;
|
|
|
+ }
|
|
|
+ return new Response(response.body, {
|
|
|
+ status: response.status,
|
|
|
+ statusText: response.statusText,
|
|
|
+ headers: normalizeCookieHeaders(response.headers)
|
|
|
+ });
|
|
|
+}
|
|
|
+function normalizeCookieHeader(header = "") {
|
|
|
+ return splitCookiesString(joinHeaders(header));
|
|
|
+}
|
|
|
+function normalizeCookieHeaders(headers) {
|
|
|
+ const outgoingHeaders = new Headers();
|
|
|
+ for (const [name, header] of headers) {
|
|
|
+ if (name === "set-cookie") {
|
|
|
+ for (const cookie of normalizeCookieHeader(header)) {
|
|
|
+ outgoingHeaders.append("set-cookie", cookie);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ outgoingHeaders.set(name, joinHeaders(header));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return outgoingHeaders;
|
|
|
+}
|
|
|
+
|
|
|
+const errorHandler = (async function errorhandler(error, event) {
|
|
|
+ const { stack, statusCode, statusMessage, message } = normalizeError(error);
|
|
|
+ const errorObject = {
|
|
|
+ url: event.path,
|
|
|
+ statusCode,
|
|
|
+ statusMessage,
|
|
|
+ message,
|
|
|
+ stack: "",
|
|
|
+ // TODO: check and validate error.data for serialisation into query
|
|
|
+ data: error.data
|
|
|
+ };
|
|
|
+ if (error.unhandled || error.fatal) {
|
|
|
+ const tags = [
|
|
|
+ "[nuxt]",
|
|
|
+ "[request error]",
|
|
|
+ error.unhandled && "[unhandled]",
|
|
|
+ error.fatal && "[fatal]",
|
|
|
+ Number(errorObject.statusCode) !== 200 && `[${errorObject.statusCode}]`
|
|
|
+ ].filter(Boolean).join(" ");
|
|
|
+ console.error(tags, (error.message || error.toString() || "internal server error") + "\n" + stack.map((l) => " " + l.text).join(" \n"));
|
|
|
+ }
|
|
|
+ if (event.handled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ setResponseStatus(event, errorObject.statusCode !== 200 && errorObject.statusCode || 500, errorObject.statusMessage);
|
|
|
+ if (isJsonRequest(event)) {
|
|
|
+ setResponseHeader(event, "Content-Type", "application/json");
|
|
|
+ return send(event, JSON.stringify(errorObject));
|
|
|
+ }
|
|
|
+ const reqHeaders = getRequestHeaders(event);
|
|
|
+ const isRenderingError = event.path.startsWith("/__nuxt_error") || !!reqHeaders["x-nuxt-error"];
|
|
|
+ const res = isRenderingError ? null : await useNitroApp().localFetch(
|
|
|
+ withQuery(joinURL(useRuntimeConfig(event).app.baseURL, "/__nuxt_error"), errorObject),
|
|
|
+ {
|
|
|
+ headers: { ...reqHeaders, "x-nuxt-error": "true" },
|
|
|
+ redirect: "manual"
|
|
|
+ }
|
|
|
+ ).catch(() => null);
|
|
|
+ if (!res) {
|
|
|
+ const { template } = await import('./error-500.mjs');
|
|
|
+ if (event.handled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ setResponseHeader(event, "Content-Type", "text/html;charset=UTF-8");
|
|
|
+ return send(event, template(errorObject));
|
|
|
+ }
|
|
|
+ const html = await res.text();
|
|
|
+ if (event.handled) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ for (const [header, value] of res.headers.entries()) {
|
|
|
+ setResponseHeader(event, header, value);
|
|
|
+ }
|
|
|
+ setResponseStatus(event, res.status && res.status !== 200 ? res.status : undefined, res.statusText);
|
|
|
+ return send(event, html);
|
|
|
+});
|
|
|
+
|
|
|
+const plugins = [
|
|
|
+
|
|
|
+];
|
|
|
+
|
|
|
+const assets$1 = {};
|
|
|
+
|
|
|
+function readAsset (id) {
|
|
|
+ const serverDir = dirname(fileURLToPath(globalThis._importMeta_.url));
|
|
|
+ return promises.readFile(resolve(serverDir, assets$1[id].path))
|
|
|
+}
|
|
|
+
|
|
|
+const publicAssetBases = {"/_nuxt/builds/meta/":{"maxAge":31536000},"/_nuxt/builds/":{"maxAge":1},"/_nuxt/":{"maxAge":31536000}};
|
|
|
+
|
|
|
+function isPublicAssetURL(id = '') {
|
|
|
+ if (assets$1[id]) {
|
|
|
+ return true
|
|
|
+ }
|
|
|
+ for (const base in publicAssetBases) {
|
|
|
+ if (id.startsWith(base)) { return true }
|
|
|
+ }
|
|
|
+ return false
|
|
|
+}
|
|
|
+
|
|
|
+function getAsset (id) {
|
|
|
+ return assets$1[id]
|
|
|
+}
|
|
|
+
|
|
|
+const METHODS = /* @__PURE__ */ new Set(["HEAD", "GET"]);
|
|
|
+const EncodingMap = { gzip: ".gz", br: ".br" };
|
|
|
+const _bGkbJv = eventHandler((event) => {
|
|
|
+ if (event.method && !METHODS.has(event.method)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ let id = decodePath(
|
|
|
+ withLeadingSlash(withoutTrailingSlash(parseURL(event.path).pathname))
|
|
|
+ );
|
|
|
+ let asset;
|
|
|
+ const encodingHeader = String(
|
|
|
+ getRequestHeader(event, "accept-encoding") || ""
|
|
|
+ );
|
|
|
+ const encodings = [
|
|
|
+ ...encodingHeader.split(",").map((e) => EncodingMap[e.trim()]).filter(Boolean).sort(),
|
|
|
+ ""
|
|
|
+ ];
|
|
|
+ if (encodings.length > 1) {
|
|
|
+ appendResponseHeader(event, "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)) {
|
|
|
+ removeResponseHeader(event, "Cache-Control");
|
|
|
+ throw createError({
|
|
|
+ statusMessage: "Cannot find static asset " + id,
|
|
|
+ statusCode: 404
|
|
|
+ });
|
|
|
+ }
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ const ifNotMatch = getRequestHeader(event, "if-none-match") === asset.etag;
|
|
|
+ if (ifNotMatch) {
|
|
|
+ setResponseStatus(event, 304, "Not Modified");
|
|
|
+ return "";
|
|
|
+ }
|
|
|
+ const ifModifiedSinceH = getRequestHeader(event, "if-modified-since");
|
|
|
+ const mtimeDate = new Date(asset.mtime);
|
|
|
+ if (ifModifiedSinceH && asset.mtime && new Date(ifModifiedSinceH) >= mtimeDate) {
|
|
|
+ setResponseStatus(event, 304, "Not Modified");
|
|
|
+ return "";
|
|
|
+ }
|
|
|
+ if (asset.type && !getResponseHeader(event, "Content-Type")) {
|
|
|
+ setResponseHeader(event, "Content-Type", asset.type);
|
|
|
+ }
|
|
|
+ if (asset.etag && !getResponseHeader(event, "ETag")) {
|
|
|
+ setResponseHeader(event, "ETag", asset.etag);
|
|
|
+ }
|
|
|
+ if (asset.mtime && !getResponseHeader(event, "Last-Modified")) {
|
|
|
+ setResponseHeader(event, "Last-Modified", mtimeDate.toUTCString());
|
|
|
+ }
|
|
|
+ if (asset.encoding && !getResponseHeader(event, "Content-Encoding")) {
|
|
|
+ setResponseHeader(event, "Content-Encoding", asset.encoding);
|
|
|
+ }
|
|
|
+ if (asset.size > 0 && !getResponseHeader(event, "Content-Length")) {
|
|
|
+ setResponseHeader(event, "Content-Length", asset.size);
|
|
|
+ }
|
|
|
+ return readAsset(id);
|
|
|
+});
|
|
|
+
|
|
|
+const _lazy_jrhRVs = () => import('../routes/index.mjs').then(function (n) { return n.i; });
|
|
|
+const _lazy_rdHII7 = () => import('./renderer.mjs').then(function (n) { return n.r; });
|
|
|
+
|
|
|
+const handlers = [
|
|
|
+ { route: '', handler: _bGkbJv, lazy: false, middleware: true, method: undefined },
|
|
|
+ { route: '/api', handler: _lazy_jrhRVs, lazy: true, middleware: false, method: undefined },
|
|
|
+ { route: '/**', handler: _lazy_rdHII7, lazy: true, middleware: false, method: undefined }
|
|
|
+];
|
|
|
+
|
|
|
+const serverAssets = [{"baseName":"server","dir":"D:/dev/nuxt/sannongzixunwang_web/server/assets"}];
|
|
|
+
|
|
|
+const assets = createStorage();
|
|
|
+
|
|
|
+for (const asset of serverAssets) {
|
|
|
+ assets.mount(asset.baseName, unstorage_47drivers_47fs({ base: asset.dir, ignore: (asset?.ignore || []) }));
|
|
|
+}
|
|
|
+
|
|
|
+const storage = createStorage({});
|
|
|
+
|
|
|
+storage.mount('/assets', assets);
|
|
|
+
|
|
|
+storage.mount('internal:nuxt:prerender', file_58_47_47_47D_58_47dev_47nuxt_47sannongzixunwang_web_47node_modules_47nuxt_47dist_47core_47runtime_47nitro_47cache_45driver_46js({"driver":"file:///D:/dev/nuxt/sannongzixunwang_web/node_modules/nuxt/dist/core/runtime/nitro/cache-driver.js","base":"D:/dev/nuxt/sannongzixunwang_web/.nuxt/cache/nitro/prerender"}));
|
|
|
+storage.mount('data', unstorage_47drivers_47fs_45lite({"driver":"fsLite","base":"D:\\dev\\nuxt\\sannongzixunwang_web\\.data\\kv"}));
|
|
|
+storage.mount('root', unstorage_47drivers_47fs({"driver":"fs","readOnly":true,"base":"D:\\dev\\nuxt\\sannongzixunwang_web","ignore":["**/node_modules/**","**/.git/**"]}));
|
|
|
+storage.mount('src', unstorage_47drivers_47fs({"driver":"fs","readOnly":true,"base":"D:\\dev\\nuxt\\sannongzixunwang_web\\server","ignore":["**/node_modules/**","**/.git/**"]}));
|
|
|
+storage.mount('build', unstorage_47drivers_47fs({"driver":"fs","readOnly":false,"base":"D:\\dev\\nuxt\\sannongzixunwang_web\\.nuxt","ignore":["**/node_modules/**","**/.git/**"]}));
|
|
|
+storage.mount('cache', unstorage_47drivers_47fs({"driver":"fs","readOnly":false,"base":"D:\\dev\\nuxt\\sannongzixunwang_web\\.nuxt\\cache","ignore":["**/node_modules/**","**/.git/**"]}));
|
|
|
+
|
|
|
+function useStorage(base = "") {
|
|
|
+ return base ? prefixStorage(storage, base) : storage;
|
|
|
+}
|
|
|
+
|
|
|
+function defaultCacheOptions() {
|
|
|
+ return {
|
|
|
+ name: "_",
|
|
|
+ base: "/cache",
|
|
|
+ swr: true,
|
|
|
+ maxAge: 1
|
|
|
+ };
|
|
|
+}
|
|
|
+function defineCachedFunction(fn, opts = {}) {
|
|
|
+ opts = { ...defaultCacheOptions(), ...opts };
|
|
|
+ const pending = {};
|
|
|
+ const group = opts.group || "nitro/functions";
|
|
|
+ const name = opts.name || fn.name || "_";
|
|
|
+ const integrity = opts.integrity || hash([fn, opts]);
|
|
|
+ const validate = opts.validate || ((entry) => entry.value !== undefined);
|
|
|
+ async function get(key, resolver, shouldInvalidateCache, event) {
|
|
|
+ const cacheKey = [opts.base, group, name, key + ".json"].filter(Boolean).join(":").replace(/:\/$/, ":index");
|
|
|
+ let entry = await useStorage().getItem(cacheKey).catch((error) => {
|
|
|
+ console.error(`[nitro] [cache] Cache read error.`, error);
|
|
|
+ useNitroApp().captureError(error, { event, tags: ["cache"] });
|
|
|
+ }) || {};
|
|
|
+ if (typeof entry !== "object") {
|
|
|
+ entry = {};
|
|
|
+ const error = new Error("Malformed data read from cache.");
|
|
|
+ console.error("[nitro] [cache]", error);
|
|
|
+ useNitroApp().captureError(error, { event, tags: ["cache"] });
|
|
|
+ }
|
|
|
+ const ttl = (opts.maxAge ?? 0) * 1e3;
|
|
|
+ if (ttl) {
|
|
|
+ entry.expires = Date.now() + ttl;
|
|
|
+ }
|
|
|
+ const expired = shouldInvalidateCache || entry.integrity !== integrity || ttl && Date.now() - (entry.mtime || 0) > ttl || validate(entry) === false;
|
|
|
+ const _resolve = async () => {
|
|
|
+ const isPending = pending[key];
|
|
|
+ if (!isPending) {
|
|
|
+ if (entry.value !== undefined && (opts.staleMaxAge || 0) >= 0 && opts.swr === false) {
|
|
|
+ entry.value = undefined;
|
|
|
+ entry.integrity = undefined;
|
|
|
+ entry.mtime = undefined;
|
|
|
+ entry.expires = undefined;
|
|
|
+ }
|
|
|
+ pending[key] = Promise.resolve(resolver());
|
|
|
+ }
|
|
|
+ try {
|
|
|
+ entry.value = await pending[key];
|
|
|
+ } catch (error) {
|
|
|
+ if (!isPending) {
|
|
|
+ delete pending[key];
|
|
|
+ }
|
|
|
+ throw error;
|
|
|
+ }
|
|
|
+ if (!isPending) {
|
|
|
+ entry.mtime = Date.now();
|
|
|
+ entry.integrity = integrity;
|
|
|
+ delete pending[key];
|
|
|
+ if (validate(entry) !== false) {
|
|
|
+ let setOpts;
|
|
|
+ if (opts.maxAge && !opts.swr) {
|
|
|
+ setOpts = { ttl: opts.maxAge };
|
|
|
+ }
|
|
|
+ const promise = useStorage().setItem(cacheKey, entry, setOpts).catch((error) => {
|
|
|
+ console.error(`[nitro] [cache] Cache write error.`, error);
|
|
|
+ useNitroApp().captureError(error, { event, tags: ["cache"] });
|
|
|
+ });
|
|
|
+ if (event?.waitUntil) {
|
|
|
+ event.waitUntil(promise);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ const _resolvePromise = expired ? _resolve() : Promise.resolve();
|
|
|
+ if (entry.value === undefined) {
|
|
|
+ await _resolvePromise;
|
|
|
+ } else if (expired && event && event.waitUntil) {
|
|
|
+ event.waitUntil(_resolvePromise);
|
|
|
+ }
|
|
|
+ if (opts.swr && validate(entry) !== false) {
|
|
|
+ _resolvePromise.catch((error) => {
|
|
|
+ console.error(`[nitro] [cache] SWR handler error.`, error);
|
|
|
+ useNitroApp().captureError(error, { event, tags: ["cache"] });
|
|
|
+ });
|
|
|
+ return entry;
|
|
|
+ }
|
|
|
+ return _resolvePromise.then(() => entry);
|
|
|
+ }
|
|
|
+ return async (...args) => {
|
|
|
+ const shouldBypassCache = await opts.shouldBypassCache?.(...args);
|
|
|
+ if (shouldBypassCache) {
|
|
|
+ return fn(...args);
|
|
|
+ }
|
|
|
+ const key = await (opts.getKey || getKey)(...args);
|
|
|
+ const shouldInvalidateCache = await opts.shouldInvalidateCache?.(...args);
|
|
|
+ const entry = await get(
|
|
|
+ key,
|
|
|
+ () => fn(...args),
|
|
|
+ shouldInvalidateCache,
|
|
|
+ args[0] && isEvent(args[0]) ? args[0] : undefined
|
|
|
+ );
|
|
|
+ let value = entry.value;
|
|
|
+ if (opts.transform) {
|
|
|
+ value = await opts.transform(entry, ...args) || value;
|
|
|
+ }
|
|
|
+ return value;
|
|
|
+ };
|
|
|
+}
|
|
|
+function cachedFunction(fn, opts = {}) {
|
|
|
+ return defineCachedFunction(fn, opts);
|
|
|
+}
|
|
|
+function getKey(...args) {
|
|
|
+ return args.length > 0 ? hash(args, {}) : "";
|
|
|
+}
|
|
|
+function escapeKey(key) {
|
|
|
+ return String(key).replace(/\W/g, "");
|
|
|
+}
|
|
|
+function defineCachedEventHandler(handler, opts = defaultCacheOptions()) {
|
|
|
+ const variableHeaderNames = (opts.varies || []).filter(Boolean).map((h) => h.toLowerCase()).sort();
|
|
|
+ const _opts = {
|
|
|
+ ...opts,
|
|
|
+ getKey: async (event) => {
|
|
|
+ const customKey = await opts.getKey?.(event);
|
|
|
+ if (customKey) {
|
|
|
+ return escapeKey(customKey);
|
|
|
+ }
|
|
|
+ const _path = event.node.req.originalUrl || event.node.req.url || event.path;
|
|
|
+ let _pathname;
|
|
|
+ try {
|
|
|
+ _pathname = escapeKey(decodeURI(parseURL(_path).pathname)).slice(0, 16) || "index";
|
|
|
+ } catch {
|
|
|
+ _pathname = "-";
|
|
|
+ }
|
|
|
+ const _hashedPath = `${_pathname}.${hash(_path)}`;
|
|
|
+ const _headers = variableHeaderNames.map((header) => [header, event.node.req.headers[header]]).map(([name, value]) => `${escapeKey(name)}.${hash(value)}`);
|
|
|
+ return [_hashedPath, ..._headers].join(":");
|
|
|
+ },
|
|
|
+ validate: (entry) => {
|
|
|
+ if (!entry.value) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (entry.value.code >= 400) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (entry.value.body === undefined) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ if (entry.value.headers.etag === "undefined" || entry.value.headers["last-modified"] === "undefined") {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ },
|
|
|
+ group: opts.group || "nitro/handlers",
|
|
|
+ integrity: opts.integrity || hash([handler, opts])
|
|
|
+ };
|
|
|
+ const _cachedHandler = cachedFunction(
|
|
|
+ async (incomingEvent) => {
|
|
|
+ const variableHeaders = {};
|
|
|
+ for (const header of variableHeaderNames) {
|
|
|
+ const value = incomingEvent.node.req.headers[header];
|
|
|
+ if (value !== undefined) {
|
|
|
+ variableHeaders[header] = value;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ const reqProxy = cloneWithProxy(incomingEvent.node.req, {
|
|
|
+ headers: variableHeaders
|
|
|
+ });
|
|
|
+ const resHeaders = {};
|
|
|
+ let _resSendBody;
|
|
|
+ const resProxy = cloneWithProxy(incomingEvent.node.res, {
|
|
|
+ statusCode: 200,
|
|
|
+ writableEnded: false,
|
|
|
+ writableFinished: false,
|
|
|
+ headersSent: false,
|
|
|
+ closed: false,
|
|
|
+ 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(undefined);
|
|
|
+ }
|
|
|
+ if (typeof arg3 === "function") {
|
|
|
+ arg3();
|
|
|
+ }
|
|
|
+ return true;
|
|
|
+ },
|
|
|
+ writeHead(statusCode, headers2) {
|
|
|
+ this.statusCode = statusCode;
|
|
|
+ if (headers2) {
|
|
|
+ if (Array.isArray(headers2) || typeof headers2 === "string") {
|
|
|
+ throw new TypeError("Raw headers is not supported.");
|
|
|
+ }
|
|
|
+ for (const header in headers2) {
|
|
|
+ const value = headers2[header];
|
|
|
+ if (value !== undefined) {
|
|
|
+ this.setHeader(
|
|
|
+ header,
|
|
|
+ value
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return this;
|
|
|
+ }
|
|
|
+ });
|
|
|
+ const event = createEvent(reqProxy, resProxy);
|
|
|
+ event.fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
|
|
|
+ fetch: useNitroApp().localFetch
|
|
|
+ });
|
|
|
+ event.$fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
|
|
|
+ fetch: globalThis.$fetch
|
|
|
+ });
|
|
|
+ event.context = incomingEvent.context;
|
|
|
+ event.context.cache = {
|
|
|
+ options: _opts
|
|
|
+ };
|
|
|
+ const body = await handler(event) || _resSendBody;
|
|
|
+ const headers = event.node.res.getHeaders();
|
|
|
+ headers.etag = String(
|
|
|
+ headers.Etag || headers.etag || `W/"${hash(body)}"`
|
|
|
+ );
|
|
|
+ headers["last-modified"] = String(
|
|
|
+ headers["Last-Modified"] || headers["last-modified"] || (/* @__PURE__ */ 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 > 0) {
|
|
|
+ headers["cache-control"] = cacheControl.join(", ");
|
|
|
+ }
|
|
|
+ const cacheEntry = {
|
|
|
+ code: event.node.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.node.res.headersSent || event.node.res.writableEnded) {
|
|
|
+ return response.body;
|
|
|
+ }
|
|
|
+ if (handleCacheHeaders(event, {
|
|
|
+ modifiedTime: new Date(response.headers["last-modified"]),
|
|
|
+ etag: response.headers.etag,
|
|
|
+ maxAge: opts.maxAge
|
|
|
+ })) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ event.node.res.statusCode = response.code;
|
|
|
+ for (const name in response.headers) {
|
|
|
+ const value = response.headers[name];
|
|
|
+ if (name === "set-cookie") {
|
|
|
+ event.node.res.appendHeader(
|
|
|
+ name,
|
|
|
+ splitCookiesString(value)
|
|
|
+ );
|
|
|
+ } else {
|
|
|
+ if (value !== undefined) {
|
|
|
+ event.node.res.setHeader(name, value);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ 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);
|
|
|
+ }
|
|
|
+ });
|
|
|
+}
|
|
|
+const cachedEventHandler = defineCachedEventHandler;
|
|
|
+
|
|
|
+const inlineAppConfig = {
|
|
|
+ "nuxt": {}
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+const appConfig = defuFn(inlineAppConfig);
|
|
|
+
|
|
|
+function getEnv(key, opts) {
|
|
|
+ const envKey = snakeCase(key).toUpperCase();
|
|
|
+ return destr(
|
|
|
+ process.env[opts.prefix + envKey] ?? process.env[opts.altPrefix + envKey]
|
|
|
+ );
|
|
|
+}
|
|
|
+function _isObject(input) {
|
|
|
+ return typeof input === "object" && !Array.isArray(input);
|
|
|
+}
|
|
|
+function applyEnv(obj, opts, parentKey = "") {
|
|
|
+ for (const key in obj) {
|
|
|
+ const subKey = parentKey ? `${parentKey}_${key}` : key;
|
|
|
+ const envValue = getEnv(subKey, opts);
|
|
|
+ if (_isObject(obj[key])) {
|
|
|
+ if (_isObject(envValue)) {
|
|
|
+ obj[key] = { ...obj[key], ...envValue };
|
|
|
+ applyEnv(obj[key], opts, subKey);
|
|
|
+ } else if (envValue === undefined) {
|
|
|
+ applyEnv(obj[key], opts, subKey);
|
|
|
+ } else {
|
|
|
+ obj[key] = envValue ?? obj[key];
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ obj[key] = envValue ?? obj[key];
|
|
|
+ }
|
|
|
+ if (opts.envExpansion && typeof obj[key] === "string") {
|
|
|
+ obj[key] = _expandFromEnv(obj[key]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return obj;
|
|
|
+}
|
|
|
+const envExpandRx = /{{(.*?)}}/g;
|
|
|
+function _expandFromEnv(value) {
|
|
|
+ return value.replace(envExpandRx, (match, key) => {
|
|
|
+ return process.env[key] || match;
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+const _inlineRuntimeConfig = {
|
|
|
+ "app": {
|
|
|
+ "baseURL": "/",
|
|
|
+ "buildId": "ad691110-e557-47eb-957f-c6a011ee5ae6",
|
|
|
+ "buildAssetsDir": "/_nuxt/",
|
|
|
+ "cdnURL": ""
|
|
|
+ },
|
|
|
+ "nitro": {
|
|
|
+ "envPrefix": "NUXT_",
|
|
|
+ "routeRules": {
|
|
|
+ "/__nuxt_error": {
|
|
|
+ "cache": false
|
|
|
+ },
|
|
|
+ "/_nuxt/builds/meta/**": {
|
|
|
+ "headers": {
|
|
|
+ "cache-control": "public, max-age=31536000, immutable"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ "/_nuxt/builds/**": {
|
|
|
+ "headers": {
|
|
|
+ "cache-control": "public, max-age=1, immutable"
|
|
|
+ }
|
|
|
+ },
|
|
|
+ "/_nuxt/**": {
|
|
|
+ "headers": {
|
|
|
+ "cache-control": "public, max-age=31536000, immutable"
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ "public": {}
|
|
|
+};
|
|
|
+const envOptions = {
|
|
|
+ prefix: "NITRO_",
|
|
|
+ altPrefix: _inlineRuntimeConfig.nitro.envPrefix ?? process.env.NITRO_ENV_PREFIX ?? "_",
|
|
|
+ envExpansion: _inlineRuntimeConfig.nitro.envExpansion ?? process.env.NITRO_ENV_EXPANSION ?? false
|
|
|
+};
|
|
|
+const _sharedRuntimeConfig = _deepFreeze(
|
|
|
+ applyEnv(klona(_inlineRuntimeConfig), envOptions)
|
|
|
+);
|
|
|
+function useRuntimeConfig(event) {
|
|
|
+ if (!event) {
|
|
|
+ return _sharedRuntimeConfig;
|
|
|
+ }
|
|
|
+ if (event.context.nitro.runtimeConfig) {
|
|
|
+ return event.context.nitro.runtimeConfig;
|
|
|
+ }
|
|
|
+ const runtimeConfig = klona(_inlineRuntimeConfig);
|
|
|
+ applyEnv(runtimeConfig, envOptions);
|
|
|
+ event.context.nitro.runtimeConfig = runtimeConfig;
|
|
|
+ return runtimeConfig;
|
|
|
+}
|
|
|
+_deepFreeze(klona(appConfig));
|
|
|
+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);
|
|
|
+}
|
|
|
+new Proxy(/* @__PURE__ */ Object.create(null), {
|
|
|
+ get: (_, prop) => {
|
|
|
+ console.warn(
|
|
|
+ "Please use `useRuntimeConfig()` instead of accessing config directly."
|
|
|
+ );
|
|
|
+ const runtimeConfig = useRuntimeConfig();
|
|
|
+ if (prop in runtimeConfig) {
|
|
|
+ return runtimeConfig[prop];
|
|
|
+ }
|
|
|
+ return undefined;
|
|
|
+ }
|
|
|
+});
|
|
|
+
|
|
|
+const config = useRuntimeConfig();
|
|
|
+const _routeRulesMatcher = toRouteMatcher(
|
|
|
+ createRouter({ routes: config.nitro.routeRules })
|
|
|
+);
|
|
|
+function createRouteRulesHandler(ctx) {
|
|
|
+ return eventHandler((event) => {
|
|
|
+ const routeRules = getRouteRules(event);
|
|
|
+ if (routeRules.headers) {
|
|
|
+ setHeaders(event, routeRules.headers);
|
|
|
+ }
|
|
|
+ if (routeRules.redirect) {
|
|
|
+ let target = routeRules.redirect.to;
|
|
|
+ if (target.endsWith("/**")) {
|
|
|
+ let targetPath = event.path;
|
|
|
+ const strpBase = routeRules.redirect._redirectStripBase;
|
|
|
+ if (strpBase) {
|
|
|
+ targetPath = withoutBase(targetPath, strpBase);
|
|
|
+ }
|
|
|
+ target = joinURL(target.slice(0, -3), targetPath);
|
|
|
+ } else if (event.path.includes("?")) {
|
|
|
+ const query = getQuery(event.path);
|
|
|
+ target = withQuery(target, query);
|
|
|
+ }
|
|
|
+ return sendRedirect(event, target, routeRules.redirect.statusCode);
|
|
|
+ }
|
|
|
+ if (routeRules.proxy) {
|
|
|
+ let target = routeRules.proxy.to;
|
|
|
+ if (target.endsWith("/**")) {
|
|
|
+ let targetPath = event.path;
|
|
|
+ const strpBase = routeRules.proxy._proxyStripBase;
|
|
|
+ if (strpBase) {
|
|
|
+ targetPath = withoutBase(targetPath, strpBase);
|
|
|
+ }
|
|
|
+ target = joinURL(target.slice(0, -3), targetPath);
|
|
|
+ } else if (event.path.includes("?")) {
|
|
|
+ const query = getQuery(event.path);
|
|
|
+ target = withQuery(target, query);
|
|
|
+ }
|
|
|
+ return proxyRequest(event, target, {
|
|
|
+ fetch: ctx.localFetch,
|
|
|
+ ...routeRules.proxy
|
|
|
+ });
|
|
|
+ }
|
|
|
+ });
|
|
|
+}
|
|
|
+function getRouteRules(event) {
|
|
|
+ event.context._nitro = event.context._nitro || {};
|
|
|
+ if (!event.context._nitro.routeRules) {
|
|
|
+ event.context._nitro.routeRules = getRouteRulesForPath(
|
|
|
+ withoutBase(event.path.split("?")[0], useRuntimeConfig().app.baseURL)
|
|
|
+ );
|
|
|
+ }
|
|
|
+ return event.context._nitro.routeRules;
|
|
|
+}
|
|
|
+function getRouteRulesForPath(path) {
|
|
|
+ return defu({}, ..._routeRulesMatcher.matchAll(path).reverse());
|
|
|
+}
|
|
|
+
|
|
|
+function createNitroApp() {
|
|
|
+ const config = useRuntimeConfig();
|
|
|
+ const hooks = createHooks();
|
|
|
+ const captureError = (error, context = {}) => {
|
|
|
+ const promise = hooks.callHookParallel("error", error, context).catch((error_) => {
|
|
|
+ console.error("Error while capturing another error", error_);
|
|
|
+ });
|
|
|
+ if (context.event && isEvent(context.event)) {
|
|
|
+ const errors = context.event.context.nitro?.errors;
|
|
|
+ if (errors) {
|
|
|
+ errors.push({ error, context });
|
|
|
+ }
|
|
|
+ if (context.event.waitUntil) {
|
|
|
+ context.event.waitUntil(promise);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ const h3App = createApp({
|
|
|
+ debug: destr(false),
|
|
|
+ onError: (error, event) => {
|
|
|
+ captureError(error, { event, tags: ["request"] });
|
|
|
+ return errorHandler(error, event);
|
|
|
+ },
|
|
|
+ onRequest: async (event) => {
|
|
|
+ await nitroApp.hooks.callHook("request", event).catch((error) => {
|
|
|
+ captureError(error, { event, tags: ["request"] });
|
|
|
+ });
|
|
|
+ },
|
|
|
+ onBeforeResponse: async (event, response) => {
|
|
|
+ await nitroApp.hooks.callHook("beforeResponse", event, response).catch((error) => {
|
|
|
+ captureError(error, { event, tags: ["request", "response"] });
|
|
|
+ });
|
|
|
+ },
|
|
|
+ onAfterResponse: async (event, response) => {
|
|
|
+ await nitroApp.hooks.callHook("afterResponse", event, response).catch((error) => {
|
|
|
+ captureError(error, { event, tags: ["request", "response"] });
|
|
|
+ });
|
|
|
+ }
|
|
|
+ });
|
|
|
+ const router = createRouter$1({
|
|
|
+ preemptive: true
|
|
|
+ });
|
|
|
+ const localCall = createCall(toNodeListener(h3App));
|
|
|
+ const _localFetch = createFetch(localCall, globalThis.fetch);
|
|
|
+ const localFetch = (input, init) => _localFetch(input, init).then(
|
|
|
+ (response) => normalizeFetchResponse(response)
|
|
|
+ );
|
|
|
+ const $fetch = createFetch$1({
|
|
|
+ fetch: localFetch,
|
|
|
+ Headers: Headers$1,
|
|
|
+ defaults: { baseURL: config.app.baseURL }
|
|
|
+ });
|
|
|
+ globalThis.$fetch = $fetch;
|
|
|
+ h3App.use(createRouteRulesHandler({ localFetch }));
|
|
|
+ h3App.use(
|
|
|
+ eventHandler((event) => {
|
|
|
+ event.context.nitro = event.context.nitro || { errors: [] };
|
|
|
+ const envContext = event.node.req?.__unenv__;
|
|
|
+ if (envContext) {
|
|
|
+ Object.assign(event.context, envContext);
|
|
|
+ }
|
|
|
+ event.fetch = (req, init) => fetchWithEvent(event, req, init, { fetch: localFetch });
|
|
|
+ event.$fetch = (req, init) => fetchWithEvent(event, req, init, {
|
|
|
+ fetch: $fetch
|
|
|
+ });
|
|
|
+ event.waitUntil = (promise) => {
|
|
|
+ if (!event.context.nitro._waitUntilPromises) {
|
|
|
+ event.context.nitro._waitUntilPromises = [];
|
|
|
+ }
|
|
|
+ event.context.nitro._waitUntilPromises.push(promise);
|
|
|
+ if (envContext?.waitUntil) {
|
|
|
+ envContext.waitUntil(promise);
|
|
|
+ }
|
|
|
+ };
|
|
|
+ event.captureError = (error, context) => {
|
|
|
+ captureError(error, { event, ...context });
|
|
|
+ };
|
|
|
+ })
|
|
|
+ );
|
|
|
+ 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.handler);
|
|
|
+ const app = {
|
|
|
+ hooks,
|
|
|
+ h3App,
|
|
|
+ router,
|
|
|
+ localCall,
|
|
|
+ localFetch,
|
|
|
+ captureError
|
|
|
+ };
|
|
|
+ return app;
|
|
|
+}
|
|
|
+function runNitroPlugins(nitroApp2) {
|
|
|
+ for (const plugin of plugins) {
|
|
|
+ try {
|
|
|
+ plugin(nitroApp2);
|
|
|
+ } catch (error) {
|
|
|
+ nitroApp2.captureError(error, { tags: ["plugin"] });
|
|
|
+ throw error;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+const nitroApp = createNitroApp();
|
|
|
+function useNitroApp() {
|
|
|
+ return nitroApp;
|
|
|
+}
|
|
|
+runNitroPlugins(nitroApp);
|
|
|
+
|
|
|
+function defineRenderHandler(render) {
|
|
|
+ const runtimeConfig = useRuntimeConfig();
|
|
|
+ return eventHandler(async (event) => {
|
|
|
+ const nitroApp = useNitroApp();
|
|
|
+ const ctx = { event, render, response: undefined };
|
|
|
+ await nitroApp.hooks.callHook("render:before", ctx);
|
|
|
+ if (!ctx.response) {
|
|
|
+ if (event.path === `${runtimeConfig.app.baseURL}favicon.ico`) {
|
|
|
+ setResponseHeader(event, "Content-Type", "image/x-icon");
|
|
|
+ return send(
|
|
|
+ event,
|
|
|
+ "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
|
|
|
+ );
|
|
|
+ }
|
|
|
+ ctx.response = await ctx.render(event);
|
|
|
+ if (!ctx.response) {
|
|
|
+ const _currentStatus = getResponseStatus(event);
|
|
|
+ setResponseStatus(event, _currentStatus === 200 ? 500 : _currentStatus);
|
|
|
+ return send(
|
|
|
+ event,
|
|
|
+ "No response returned from render handler: " + event.path
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ await nitroApp.hooks.callHook("render:response", ctx.response, ctx);
|
|
|
+ if (ctx.response.headers) {
|
|
|
+ setResponseHeaders(event, ctx.response.headers);
|
|
|
+ }
|
|
|
+ if (ctx.response.statusCode || ctx.response.statusMessage) {
|
|
|
+ setResponseStatus(
|
|
|
+ event,
|
|
|
+ ctx.response.statusCode,
|
|
|
+ ctx.response.statusMessage
|
|
|
+ );
|
|
|
+ }
|
|
|
+ return ctx.response.body;
|
|
|
+ });
|
|
|
+}
|
|
|
+
|
|
|
+export { useStorage as a, useNitroApp as b, defineRenderHandler as d, getRouteRules as g, trapUnhandledNodeErrors as t, useRuntimeConfig as u };
|
|
|
+//# sourceMappingURL=nitro.mjs.map
|
Jing