import process from 'node:process';globalThis._importMeta_=globalThis._importMeta_||{url:"file:///_entry.js",env:process.env};import { defineEventHandler, handleCacheHeaders, splitCookiesString, createEvent, fetchWithEvent, isEvent, eventHandler, setHeaders, sendRedirect, proxyRequest, getRequestHeader, setResponseHeaders, setResponseStatus, send, getRequestHeaders, setResponseHeader, getRequestURL, getResponseHeader, appendResponseHeader, removeResponseHeader, createError, createApp, createRouter as createRouter$1, toNodeListener, lazyEventHandler, getResponseStatus } from 'file://D:/doc/workspace/web3/node_modules/h3/dist/index.mjs'; import destr from 'file://D:/doc/workspace/web3/node_modules/destr/dist/index.mjs'; import { createHooks } from 'file://D:/doc/workspace/web3/node_modules/hookable/dist/index.mjs'; import { createFetch, Headers as Headers$1 } from 'file://D:/doc/workspace/web3/node_modules/ofetch/dist/node.mjs'; import { fetchNodeRequestHandler, callNodeRequestHandler } from 'file://D:/doc/workspace/web3/node_modules/node-mock-http/dist/index.mjs'; import { parseURL, withoutBase, joinURL, getQuery, withQuery, decodePath, withLeadingSlash, withoutTrailingSlash } from 'file://D:/doc/workspace/web3/node_modules/ufo/dist/index.mjs'; import { createStorage, prefixStorage } from 'file://D:/doc/workspace/web3/node_modules/unstorage/dist/index.mjs'; import unstorage_47drivers_47fs from 'file://D:/doc/workspace/web3/node_modules/unstorage/drivers/fs.mjs'; import file_58_47_47_47D_58_47doc_47workspace_47web3_47node_modules_47nuxt_47dist_47core_47runtime_47nitro_47utils_47cache_45driver_46js from 'file:///D:/doc/workspace/web3/node_modules/nuxt/dist/core/runtime/nitro/utils/cache-driver.js'; import unstorage_47drivers_47fs_45lite from 'file://D:/doc/workspace/web3/node_modules/unstorage/drivers/fs-lite.mjs'; import { digest } from 'file://D:/doc/workspace/web3/node_modules/ohash/dist/index.mjs'; import { klona } from 'file://D:/doc/workspace/web3/node_modules/klona/dist/index.mjs'; import defu, { defuFn } from 'file://D:/doc/workspace/web3/node_modules/defu/dist/defu.mjs'; import { snakeCase } from 'file://D:/doc/workspace/web3/node_modules/scule/dist/index.mjs'; import { toRouteMatcher, createRouter } from 'file://D:/doc/workspace/web3/node_modules/radix3/dist/index.mjs'; import { promises } from 'node:fs'; import { fileURLToPath } from 'node:url'; import { dirname, resolve } from 'file://D:/doc/workspace/web3/node_modules/pathe/dist/index.mjs'; const serverAssets = [{"baseName":"server","dir":"D:/doc/workspace/web3/server/assets"}]; const assets$1 = createStorage(); for (const asset of serverAssets) { assets$1.mount(asset.baseName, unstorage_47drivers_47fs({ base: asset.dir, ignore: (asset?.ignore || []) })); } const storage = createStorage({}); storage.mount('/assets', assets$1); storage.mount('internal:nuxt:prerender', file_58_47_47_47D_58_47doc_47workspace_47web3_47node_modules_47nuxt_47dist_47core_47runtime_47nitro_47utils_47cache_45driver_46js({"driver":"file:///D:/doc/workspace/web3/node_modules/nuxt/dist/core/runtime/nitro/utils/cache-driver.js","base":"D:/doc/workspace/web3/.nuxt/cache/nitro/prerender"})); storage.mount('data', unstorage_47drivers_47fs_45lite({"driver":"fsLite","base":"./.data/kv"})); storage.mount('root', unstorage_47drivers_47fs({"driver":"fs","readOnly":true,"base":"D:/doc/workspace/web3","watchOptions":{"ignored":[null]}})); storage.mount('src', unstorage_47drivers_47fs({"driver":"fs","readOnly":true,"base":"D:/doc/workspace/web3/server","watchOptions":{"ignored":[null]}})); storage.mount('build', unstorage_47drivers_47fs({"driver":"fs","readOnly":false,"base":"D:/doc/workspace/web3/.nuxt"})); storage.mount('cache', unstorage_47drivers_47fs({"driver":"fs","readOnly":false,"base":"D:/doc/workspace/web3/.nuxt/cache"})); function useStorage(base = "") { return base ? prefixStorage(storage, base) : storage; } const Hasher = /* @__PURE__ */ (() => { class Hasher2 { buff = ""; #context = /* @__PURE__ */ new Map(); write(str) { this.buff += str; } dispatch(value) { const type = value === null ? "null" : typeof value; return this[type](value); } object(object) { if (object && typeof object.toJSON === "function") { return this.object(object.toJSON()); } const objString = Object.prototype.toString.call(object); let objType = ""; const objectLength = objString.length; objType = objectLength < 10 ? "unknown:[" + objString + "]" : objString.slice(8, objectLength - 1); objType = objType.toLowerCase(); let objectNumber = null; if ((objectNumber = this.#context.get(object)) === void 0) { this.#context.set(object, this.#context.size); } else { return this.dispatch("[CIRCULAR:" + objectNumber + "]"); } if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) { this.write("buffer:"); return this.write(object.toString("utf8")); } if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") { if (this[objType]) { this[objType](object); } else { this.unknown(object, objType); } } else { const keys = Object.keys(object).sort(); const extraKeys = []; this.write("object:" + (keys.length + extraKeys.length) + ":"); const dispatchForKey = (key) => { this.dispatch(key); this.write(":"); this.dispatch(object[key]); this.write(","); }; for (const key of keys) { dispatchForKey(key); } for (const key of extraKeys) { dispatchForKey(key); } } } array(arr, unordered) { unordered = unordered === void 0 ? false : unordered; this.write("array:" + arr.length + ":"); if (!unordered || arr.length <= 1) { for (const entry of arr) { this.dispatch(entry); } return; } const contextAdditions = /* @__PURE__ */ new Map(); const entries = arr.map((entry) => { const hasher = new Hasher2(); hasher.dispatch(entry); for (const [key, value] of hasher.#context) { contextAdditions.set(key, value); } return hasher.toString(); }); this.#context = contextAdditions; entries.sort(); return this.array(entries, false); } date(date) { return this.write("date:" + date.toJSON()); } symbol(sym) { return this.write("symbol:" + sym.toString()); } unknown(value, type) { this.write(type); if (!value) { return; } this.write(":"); if (value && typeof value.entries === "function") { return this.array( [...value.entries()], true /* ordered */ ); } } error(err) { return this.write("error:" + err.toString()); } boolean(bool) { return this.write("bool:" + bool); } string(string) { this.write("string:" + string.length + ":"); this.write(string); } function(fn) { this.write("fn:"); if (isNativeFunction(fn)) { this.dispatch("[native]"); } else { this.dispatch(fn.toString()); } } number(number) { return this.write("number:" + number); } null() { return this.write("Null"); } undefined() { return this.write("Undefined"); } regexp(regex) { return this.write("regex:" + regex.toString()); } arraybuffer(arr) { this.write("arraybuffer:"); return this.dispatch(new Uint8Array(arr)); } url(url) { return this.write("url:" + url.toString()); } map(map) { this.write("map:"); const arr = [...map]; return this.array(arr, false); } set(set) { this.write("set:"); const arr = [...set]; return this.array(arr, false); } bigint(number) { return this.write("bigint:" + number.toString()); } } for (const type of [ "uint8array", "uint8clampedarray", "unt8array", "uint16array", "unt16array", "uint32array", "unt32array", "float32array", "float64array" ]) { Hasher2.prototype[type] = function(arr) { this.write(type + ":"); return this.array([...arr], false); }; } function isNativeFunction(f) { if (typeof f !== "function") { return false; } return Function.prototype.toString.call(f).slice( -15 /* "[native code] }".length */ ) === "[native code] }"; } return Hasher2; })(); function serialize(object) { const hasher = new Hasher(); hasher.dispatch(object); return hasher.buff; } function hash(value) { return digest(typeof value === "string" ? value : serialize(value)).replace(/[-_]/g, "").slice(0, 10); } 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 !== void 0); 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(`[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("[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 !== void 0 && (opts.staleMaxAge || 0) >= 0 && opts.swr === false) { entry.value = void 0; entry.integrity = void 0; entry.mtime = void 0; entry.expires = void 0; } 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(`[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 === void 0) { await _resolvePromise; } else if (expired && event && event.waitUntil) { event.waitUntil(_resolvePromise); } if (opts.swr && validate(entry) !== false) { _resolvePromise.catch((error) => { console.error(`[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] : void 0 ); 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 === void 0) { 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 !== void 0) { 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(void 0); } 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 !== void 0) { 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.waitUntil = incomingEvent.waitUntil; 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 !== void 0) { 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 === void 0) { 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": "295e2927-5908-4c75-87ca-ed5550175fd5", "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 void 0; } }); 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 _captureError(error, type) { console.error(`[${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; } 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 hasReqHeader(event, name, includes) { const value = getRequestHeader(event, name); return value && typeof value === "string" && value.toLowerCase().includes(includes); } const errorHandler$0 = (async function errorhandler(error, event, { defaultHandler }) { if (isJsonRequest(event)) { return; } const defaultRes = await defaultHandler(error, event, { json: true }); const statusCode = error.statusCode || 500; if (statusCode === 404 && defaultRes.status === 302) { setResponseHeaders(event, defaultRes.headers); setResponseStatus(event, defaultRes.status, defaultRes.statusText); return send(event, JSON.stringify(defaultRes.body, null, 2)); } const errorObject = defaultRes.body; const url = new URL(errorObject.url); errorObject.url = url.pathname + url.search + url.hash; errorObject.message ||= "Server Error"; errorObject.data ||= error.data; delete defaultRes.headers["content-type"]; delete defaultRes.headers["content-security-policy"]; setResponseHeaders(event, defaultRes.headers); 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 (event.handled) { return; } if (!res) { const { template } = await import('./error-500.mjs'); setResponseHeader(event, "Content-Type", "text/html;charset=UTF-8"); return send(event, template(errorObject)); } const html = await res.text(); for (const [header, value] of res.headers.entries()) { setResponseHeader(event, header, value); } setResponseStatus(event, res.status && res.status !== 200 ? res.status : defaultRes.status, res.statusText || defaultRes.statusText); return send(event, html); }); function defineNitroErrorHandler(handler) { return handler; } const errorHandler$1 = defineNitroErrorHandler( function defaultNitroErrorHandler(error, event) { const res = defaultHandler(error, event); setResponseHeaders(event, res.headers); setResponseStatus(event, res.status, res.statusText); return send(event, JSON.stringify(res.body, null, 2)); } ); function defaultHandler(error, event, opts) { const isSensitive = error.unhandled || error.fatal; const statusCode = error.statusCode || 500; const statusMessage = error.statusMessage || "Server Error"; const url = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true }); if (statusCode === 404) { const baseURL = "/"; if (/^\/[^/]/.test(baseURL) && !url.pathname.startsWith(baseURL)) { const redirectTo = `${baseURL}${url.pathname.slice(1)}${url.search}`; return { status: 302, statusText: "Found", headers: { location: redirectTo }, body: `Redirecting...` }; } } if (isSensitive && !opts?.silent) { const tags = [error.unhandled && "[unhandled]", error.fatal && "[fatal]"].filter(Boolean).join(" "); console.error(`[request error] ${tags} [${event.method}] ${url} `, error); } const headers = { "content-type": "application/json", // Prevent browser from guessing the MIME types of resources. "x-content-type-options": "nosniff", // Prevent error page from being embedded in an iframe "x-frame-options": "DENY", // Prevent browsers from sending the Referer header "referrer-policy": "no-referrer", // Disable the execution of any js "content-security-policy": "script-src 'none'; frame-ancestors 'none';" }; setResponseStatus(event, statusCode, statusMessage); if (statusCode === 404 || !getResponseHeader(event, "cache-control")) { headers["cache-control"] = "no-cache"; } const body = { error: true, url: url.href, statusCode, statusMessage, message: isSensitive ? "Server Error" : error.message, data: isSensitive ? void 0 : error.data }; return { status: statusCode, statusText: statusMessage, headers, body }; } const errorHandlers = [errorHandler$0, errorHandler$1]; async function errorHandler(error, event) { for (const handler of errorHandlers) { try { await handler(error, event, { defaultHandler }); if (event.handled) { return; // Response handled } } catch(error) { // Handler itself thrown, log and continue console.error(error); } } // H3 will handle fallback } const plugins = [ ]; const assets = {}; function readAsset (id) { const serverDir = dirname(fileURLToPath(globalThis._importMeta_.url)); return promises.readFile(resolve(serverDir, assets[id].path)) } const publicAssetBases = {"/_nuxt/builds/meta/":{"maxAge":31536000},"/_nuxt/builds/":{"maxAge":1},"/_nuxt/":{"maxAge":31536000}}; function isPublicAssetURL(id = '') { if (assets[id]) { return true } for (const base in publicAssetBases) { if (id.startsWith(base)) { return true } } return false } function getAsset (id) { return assets[id] } const METHODS = /* @__PURE__ */ new Set(["HEAD", "GET"]); const EncodingMap = { gzip: ".gz", br: ".br" }; const _Uab4KT = 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__GP_Gl = () => import('./renderer.mjs').then(function (n) { return n.r; }); const handlers = [ { route: '', handler: _Uab4KT, lazy: false, middleware: true, method: undefined }, { route: '/**', handler: _lazy__GP_Gl, lazy: true, middleware: false, method: undefined } ]; 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) => { event.context.nitro = event.context.nitro || { errors: [] }; const fetchContext = event.node.req?.__unenv__; if (fetchContext?._platform) { event.context = { ...fetchContext._platform, ...event.context }; } if (!event.context.waitUntil && fetchContext?.waitUntil) { event.context.waitUntil = fetchContext.waitUntil; } 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 (event.context.waitUntil) { event.context.waitUntil(promise); } }; event.captureError = (error, context) => { captureError(error, { event, ...context }); }; 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 nodeHandler = toNodeListener(h3App); const localCall = (aRequest) => callNodeRequestHandler(nodeHandler, aRequest); const localFetch = (input, init) => { if (!input.toString().startsWith("/")) { return globalThis.fetch(input, init); } return fetchNodeRequestHandler( nodeHandler, input, init ).then((response) => normalizeFetchResponse(response)); }; const $fetch = createFetch({ fetch: localFetch, Headers: Headers$1, defaults: { baseURL: config.app.baseURL } }); globalThis.$fetch = $fetch; h3App.use(createRouteRulesHandler({ localFetch })); 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: void 0 }; 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 { useRuntimeConfig as a, useStorage as b, defineRenderHandler as d, getRouteRules as g, trapUnhandledNodeErrors as t, useNitroApp as u }; //# sourceMappingURL=nitro.mjs.map