Website Structure

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/handlers/error.d.ts

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

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/handlers/error.js

@@ -0,0 +1,64 @@
+import { joinURL, withQuery, withoutBase } from "ufo";
+import { appendResponseHeader, getRequestHeaders, send, setResponseHeader, setResponseHeaders, setResponseStatus } from "h3";
+import { isJsonRequest } from "../utils/error.js";
+import { useRuntimeConfig } from "#internal/nitro";
+import { useNitroApp } from "#internal/nitro/app";
+import { generateErrorOverlayHTML } from "../utils/dev.js";
+export default (async function errorhandler(error, event, { defaultHandler }) {
+  if (event.handled || 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));
+  }
+  if (import.meta.dev && typeof defaultRes.body !== "string" && Array.isArray(defaultRes.body.stack)) {
+    defaultRes.body.stack = defaultRes.body.stack.join("\n");
+  }
+  const errorObject = defaultRes.body;
+  const url = new URL(errorObject.url);
+  errorObject.url = withoutBase(url.pathname, useRuntimeConfig(event).app.baseURL) + url.search + url.hash;
+  errorObject.message ||= "Server Error";
+  errorObject.data ||= error.data;
+  errorObject.statusMessage ||= error.statusMessage;
+  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("../templates/error-500.js");
+    if (import.meta.dev) {
+      errorObject.description = errorObject.message;
+    }
+    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()) {
+    if (header === "set-cookie") {
+      appendResponseHeader(event, header, value);
+      continue;
+    }
+    setResponseHeader(event, header, value);
+  }
+  setResponseStatus(event, res.status && res.status !== 200 ? res.status : defaultRes.status, res.statusText || defaultRes.statusText);
+  if (import.meta.dev && !import.meta.test && typeof html === "string") {
+    const prettyResponse = await defaultHandler(error, event, { json: false });
+    return send(event, html.replace("</body>", `${generateErrorOverlayHTML(prettyResponse.body, { startMinimized: 300 <= statusCode && statusCode < 500 })}</body>`));
+  }
+  return send(event, html);
+});

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/handlers/island.d.ts

@@ -0,0 +1,4 @@
+import type { RenderResponse } from 'nitropack';
+import type { NuxtIslandResponse } from 'nuxt/app';
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<NuxtIslandResponse | Partial<RenderResponse>>>;
+export default _default;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/handlers/island.js

@@ -0,0 +1,102 @@
+import { destr } from "destr";
+import { defineEventHandler, getQuery, readBody, setResponseHeaders } from "h3";
+import { resolveUnrefHeadInput } from "@unhead/vue";
+import { getRequestDependencies } from "vue-bundle-renderer/runtime";
+import { getQuery as getURLQuery } from "ufo";
+import { islandCache, islandPropCache } from "../utils/cache.js";
+import { createSSRContext } from "../utils/renderer/app.js";
+import { getSSRRenderer } from "../utils/renderer/build-files.js";
+import { renderInlineStyles } from "../utils/renderer/inline-styles.js";
+import { getClientIslandResponse, getServerComponentHTML, getSlotIslandResponse } from "../utils/renderer/islands.js";
+import { useNitroApp } from "#internal/nitro";
+const ISLAND_SUFFIX_RE = /\.json(?:\?.*)?$/;
+export default defineEventHandler(async (event) => {
+  const nitroApp = useNitroApp();
+  setResponseHeaders(event, {
+    "content-type": "application/json;charset=utf-8",
+    "x-powered-by": "Nuxt"
+  });
+  if (import.meta.prerender && event.path && await islandCache.hasItem(event.path)) {
+    return islandCache.getItem(event.path);
+  }
+  const islandContext = await getIslandContext(event);
+  const ssrContext = {
+    ...createSSRContext(event),
+    islandContext,
+    noSSR: false,
+    url: islandContext.url
+  };
+  const renderer = await getSSRRenderer();
+  const renderResult = await renderer.renderToString(ssrContext).catch(async (err) => {
+    await ssrContext.nuxt?.hooks.callHook("app:error", err);
+    throw err;
+  });
+  if (ssrContext.payload?.error) {
+    throw ssrContext.payload.error;
+  }
+  const inlinedStyles = await renderInlineStyles(ssrContext.modules ?? []);
+  await ssrContext.nuxt?.hooks.callHook("app:rendered", { ssrContext, renderResult });
+  if (inlinedStyles.length) {
+    ssrContext.head.push({ style: inlinedStyles });
+  }
+  if (import.meta.dev) {
+    const { styles } = getRequestDependencies(ssrContext, renderer.rendererContext);
+    const link = [];
+    for (const resource of Object.values(styles)) {
+      if ("inline" in getURLQuery(resource.file)) {
+        continue;
+      }
+      if (resource.file.includes("scoped") && !resource.file.includes("pages/")) {
+        link.push({ rel: "stylesheet", href: renderer.rendererContext.buildAssetsURL(resource.file), crossorigin: "" });
+      }
+    }
+    if (link.length) {
+      ssrContext.head.push({ link }, { mode: "server" });
+    }
+  }
+  const islandHead = {};
+  for (const entry of ssrContext.head.entries.values()) {
+    for (const [key, value] of Object.entries(resolveUnrefHeadInput(entry.input))) {
+      const currentValue = islandHead[key];
+      if (Array.isArray(currentValue)) {
+        currentValue.push(...value);
+      }
+      islandHead[key] = value;
+    }
+  }
+  islandHead.link ||= [];
+  islandHead.style ||= [];
+  const islandResponse = {
+    id: islandContext.id,
+    head: islandHead,
+    html: getServerComponentHTML(renderResult.html),
+    components: getClientIslandResponse(ssrContext),
+    slots: getSlotIslandResponse(ssrContext)
+  };
+  await nitroApp.hooks.callHook("render:island", islandResponse, { event, islandContext });
+  if (import.meta.prerender) {
+    await islandCache.setItem(`/__nuxt_island/${islandContext.name}_${islandContext.id}.json`, islandResponse);
+    await islandPropCache.setItem(`/__nuxt_island/${islandContext.name}_${islandContext.id}.json`, event.path);
+  }
+  return islandResponse;
+});
+async function getIslandContext(event) {
+  let url = event.path || "";
+  if (import.meta.prerender && event.path && await islandPropCache.hasItem(event.path)) {
+    url = await islandPropCache.getItem(event.path);
+  }
+  const componentParts = url.substring("/__nuxt_island".length + 1).replace(ISLAND_SUFFIX_RE, "").split("_");
+  const hashId = componentParts.length > 1 ? componentParts.pop() : void 0;
+  const componentName = componentParts.join("_");
+  const context = event.method === "GET" ? getQuery(event) : await readBody(event);
+  const ctx = {
+    url: "/",
+    ...context,
+    id: hashId,
+    name: componentName,
+    props: destr(context.props) || {},
+    slots: {},
+    components: {}
+  };
+  return ctx;
+}

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/handlers/renderer.d.ts

@@ -0,0 +1,8 @@
+export interface NuxtRenderResponse {
+    body: string;
+    statusCode: number;
+    statusMessage?: string;
+    headers: Record<string, string>;
+}
+declare const _default: any;
+export default _default;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/handlers/renderer.js

@@ -0,0 +1,238 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import process from "node:process";
+import {
+  getPrefetchLinks,
+  getPreloadLinks,
+  getRequestDependencies,
+  renderResourceHeaders
+} from "vue-bundle-renderer/runtime";
+import { appendResponseHeader, createError, getQuery, getResponseStatus, getResponseStatusText, writeEarlyHints } from "h3";
+import { getQuery as getURLQuery, joinURL } from "ufo";
+import { propsToString, renderSSRHead } from "@unhead/vue/server";
+import destr from "destr";
+import { getRenderer } from "../utils/renderer/build-files.js";
+import { payloadCache } from "../utils/cache.js";
+import { renderPayloadJsonScript, renderPayloadResponse, renderPayloadScript, splitPayload } from "../utils/renderer/payload.js";
+import { createSSRContext, setSSRError } from "../utils/renderer/app.js";
+import { renderInlineStyles } from "../utils/renderer/inline-styles.js";
+import { replaceIslandTeleports } from "../utils/renderer/islands.js";
+import { defineRenderHandler, getRouteRules, useNitroApp } from "#internal/nitro";
+import { renderSSRHeadOptions } from "#internal/unhead.config.mjs";
+import { appHead, appTeleportAttrs, appTeleportTag, componentIslands, appManifest as isAppManifestEnabled } from "#internal/nuxt.config.mjs";
+import entryIds from "#internal/nuxt/entry-ids.mjs";
+import { entryFileName } from "#internal/entry-chunk.mjs";
+import { buildAssetsURL, publicAssetsURL } from "#internal/nuxt/paths";
+import { relative } from "pathe";
+globalThis.__buildAssetsURL = buildAssetsURL;
+globalThis.__publicAssetsURL = publicAssetsURL;
+if (process.env.NUXT_ASYNC_CONTEXT && !("AsyncLocalStorage" in globalThis)) {
+  globalThis.AsyncLocalStorage = AsyncLocalStorage;
+}
+const HAS_APP_TELEPORTS = !!(appTeleportTag && appTeleportAttrs.id);
+const APP_TELEPORT_OPEN_TAG = HAS_APP_TELEPORTS ? `<${appTeleportTag}${propsToString(appTeleportAttrs)}>` : "";
+const APP_TELEPORT_CLOSE_TAG = HAS_APP_TELEPORTS ? `</${appTeleportTag}>` : "";
+const PAYLOAD_URL_RE = process.env.NUXT_JSON_PAYLOADS ? /^[^?]*\/_payload.json(?:\?.*)?$/ : /^[^?]*\/_payload.js(?:\?.*)?$/;
+const PAYLOAD_FILENAME = process.env.NUXT_JSON_PAYLOADS ? "_payload.json" : "_payload.js";
+let entryPath;
+export default defineRenderHandler(async (event) => {
+  const nitroApp = useNitroApp();
+  const ssrError = event.path.startsWith("/__nuxt_error") ? getQuery(event) : null;
+  if (ssrError && !("__unenv__" in event.node.req)) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Page Not Found: /__nuxt_error"
+    });
+  }
+  const ssrContext = createSSRContext(event);
+  const headEntryOptions = { mode: "server" };
+  ssrContext.head.push(appHead, headEntryOptions);
+  if (ssrError) {
+    ssrError.statusCode &&= Number.parseInt(ssrError.statusCode);
+    if (process.env.PARSE_ERROR_DATA && typeof ssrError.data === "string") {
+      try {
+        ssrError.data = destr(ssrError.data);
+      } catch {
+      }
+    }
+    setSSRError(ssrContext, ssrError);
+  }
+  const isRenderingPayload = process.env.NUXT_PAYLOAD_EXTRACTION && PAYLOAD_URL_RE.test(ssrContext.url);
+  if (isRenderingPayload) {
+    const url = ssrContext.url.substring(0, ssrContext.url.lastIndexOf("/")) || "/";
+    ssrContext.url = url;
+    event._path = event.node.req.url = url;
+    if (import.meta.prerender && await payloadCache.hasItem(url)) {
+      return payloadCache.getItem(url);
+    }
+  }
+  const routeOptions = getRouteRules(event);
+  if (routeOptions.ssr === false) {
+    ssrContext.noSSR = true;
+  }
+  const _PAYLOAD_EXTRACTION = import.meta.prerender && process.env.NUXT_PAYLOAD_EXTRACTION && !ssrContext.noSSR;
+  const payloadURL = _PAYLOAD_EXTRACTION ? joinURL(ssrContext.runtimeConfig.app.cdnURL || ssrContext.runtimeConfig.app.baseURL, ssrContext.url.replace(/\?.*$/, ""), PAYLOAD_FILENAME) + "?" + ssrContext.runtimeConfig.app.buildId : void 0;
+  const renderer = await getRenderer(ssrContext);
+  if (process.env.NUXT_EARLY_HINTS && !isRenderingPayload && !import.meta.prerender) {
+    const { link: link2 } = renderResourceHeaders({}, renderer.rendererContext);
+    if (link2) {
+      writeEarlyHints(event, link2);
+    }
+  }
+  if (process.env.NUXT_INLINE_STYLES) {
+    for (const id of entryIds) {
+      ssrContext.modules.add(id);
+    }
+  }
+  const _rendered = await renderer.renderToString(ssrContext).catch(async (error) => {
+    if (ssrContext._renderResponse && error.message === "skipping render") {
+      return {};
+    }
+    const _err = !ssrError && ssrContext.payload?.error || error;
+    await ssrContext.nuxt?.hooks.callHook("app:error", _err);
+    throw _err;
+  });
+  const inlinedStyles = process.env.NUXT_INLINE_STYLES && !ssrContext._renderResponse && !isRenderingPayload ? await renderInlineStyles(ssrContext.modules ?? []) : [];
+  await ssrContext.nuxt?.hooks.callHook("app:rendered", { ssrContext, renderResult: _rendered });
+  if (ssrContext._renderResponse) {
+    return ssrContext._renderResponse;
+  }
+  if (ssrContext.payload?.error && !ssrError) {
+    throw ssrContext.payload.error;
+  }
+  if (isRenderingPayload) {
+    const response = renderPayloadResponse(ssrContext);
+    if (import.meta.prerender) {
+      await payloadCache.setItem(ssrContext.url, response);
+    }
+    return response;
+  }
+  if (_PAYLOAD_EXTRACTION) {
+    appendResponseHeader(event, "x-nitro-prerender", joinURL(ssrContext.url.replace(/\?.*$/, ""), PAYLOAD_FILENAME));
+    await payloadCache.setItem(ssrContext.url === "/" ? "/" : ssrContext.url.replace(/\/$/, ""), renderPayloadResponse(ssrContext));
+  }
+  const NO_SCRIPTS = process.env.NUXT_NO_SCRIPTS || routeOptions.noScripts;
+  const { styles, scripts } = getRequestDependencies(ssrContext, renderer.rendererContext);
+  if (entryFileName && !NO_SCRIPTS) {
+    let path = entryPath;
+    if (!path) {
+      path = buildAssetsURL(entryFileName);
+      if (ssrContext.runtimeConfig.app.cdnURL || /^(?:\/|\.+\/)/.test(path)) {
+        entryPath = path;
+      } else {
+        path = relative(event.path.replace(/\/[^/]+$/, "/"), joinURL("/", path));
+        if (!/^(?:\/|\.+\/)/.test(path)) {
+          path = `./${path}`;
+        }
+      }
+    }
+    ssrContext.head.push({
+      script: [{
+        tagPosition: "head",
+        tagPriority: -2,
+        type: "importmap",
+        innerHTML: JSON.stringify({ imports: { "#entry": path } })
+      }]
+    }, headEntryOptions);
+  }
+  if (_PAYLOAD_EXTRACTION && !NO_SCRIPTS) {
+    ssrContext.head.push({
+      link: [
+        process.env.NUXT_JSON_PAYLOADS ? { rel: "preload", as: "fetch", crossorigin: "anonymous", href: payloadURL } : { rel: "modulepreload", crossorigin: "", href: payloadURL }
+      ]
+    }, headEntryOptions);
+  }
+  if (isAppManifestEnabled && ssrContext._preloadManifest && !NO_SCRIPTS) {
+    ssrContext.head.push({
+      link: [
+        { rel: "preload", as: "fetch", fetchpriority: "low", crossorigin: "anonymous", href: buildAssetsURL(`builds/meta/${ssrContext.runtimeConfig.app.buildId}.json`) }
+      ]
+    }, { ...headEntryOptions, tagPriority: "low" });
+  }
+  if (inlinedStyles.length) {
+    ssrContext.head.push({ style: inlinedStyles });
+  }
+  const link = [];
+  for (const resource of Object.values(styles)) {
+    if (import.meta.dev && "inline" in getURLQuery(resource.file)) {
+      continue;
+    }
+    link.push({ rel: "stylesheet", href: renderer.rendererContext.buildAssetsURL(resource.file), crossorigin: "" });
+  }
+  if (link.length) {
+    ssrContext.head.push({ link }, headEntryOptions);
+  }
+  if (!NO_SCRIPTS) {
+    ssrContext.head.push({
+      link: getPreloadLinks(ssrContext, renderer.rendererContext)
+    }, headEntryOptions);
+    ssrContext.head.push({
+      link: getPrefetchLinks(ssrContext, renderer.rendererContext)
+    }, headEntryOptions);
+    ssrContext.head.push({
+      script: _PAYLOAD_EXTRACTION ? process.env.NUXT_JSON_PAYLOADS ? renderPayloadJsonScript({ ssrContext, data: splitPayload(ssrContext).initial, src: payloadURL }) : renderPayloadScript({ ssrContext, data: splitPayload(ssrContext).initial, src: payloadURL }) : process.env.NUXT_JSON_PAYLOADS ? renderPayloadJsonScript({ ssrContext, data: ssrContext.payload }) : renderPayloadScript({ ssrContext, data: ssrContext.payload })
+    }, {
+      ...headEntryOptions,
+      // this should come before another end of body scripts
+      tagPosition: "bodyClose",
+      tagPriority: "high"
+    });
+  }
+  if (!routeOptions.noScripts) {
+    const tagPosition = _PAYLOAD_EXTRACTION && !process.env.NUXT_JSON_PAYLOADS ? "bodyClose" : "head";
+    ssrContext.head.push({
+      script: Object.values(scripts).map((resource) => ({
+        type: resource.module ? "module" : null,
+        src: renderer.rendererContext.buildAssetsURL(resource.file),
+        defer: resource.module ? null : true,
+        // if we are rendering script tag payloads that import an async payload
+        // we need to ensure this resolves before executing the Nuxt entry
+        tagPosition,
+        crossorigin: ""
+      }))
+    }, headEntryOptions);
+  }
+  const { headTags, bodyTags, bodyTagsOpen, htmlAttrs, bodyAttrs } = await renderSSRHead(ssrContext.head, renderSSRHeadOptions);
+  const htmlContext = {
+    htmlAttrs: htmlAttrs ? [htmlAttrs] : [],
+    head: normalizeChunks([headTags]),
+    bodyAttrs: bodyAttrs ? [bodyAttrs] : [],
+    bodyPrepend: normalizeChunks([bodyTagsOpen, ssrContext.teleports?.body]),
+    body: [
+      componentIslands ? replaceIslandTeleports(ssrContext, _rendered.html) : _rendered.html,
+      APP_TELEPORT_OPEN_TAG + (HAS_APP_TELEPORTS ? joinTags([ssrContext.teleports?.[`#${appTeleportAttrs.id}`]]) : "") + APP_TELEPORT_CLOSE_TAG
+    ],
+    bodyAppend: [bodyTags]
+  };
+  await nitroApp.hooks.callHook("render:html", htmlContext, { event });
+  return {
+    body: renderHTMLDocument(htmlContext),
+    statusCode: getResponseStatus(event),
+    statusMessage: getResponseStatusText(event),
+    headers: {
+      "content-type": "text/html;charset=utf-8",
+      "x-powered-by": "Nuxt"
+    }
+  };
+});
+function normalizeChunks(chunks) {
+  const result = [];
+  for (const _chunk of chunks) {
+    const chunk = _chunk?.trim();
+    if (chunk) {
+      result.push(chunk);
+    }
+  }
+  return result;
+}
+function joinTags(tags) {
+  return tags.join("");
+}
+function joinAttrs(chunks) {
+  if (chunks.length === 0) {
+    return "";
+  }
+  return " " + chunks.join(" ");
+}
+function renderHTMLDocument(html) {
+  return `<!DOCTYPE html><html${joinAttrs(html.htmlAttrs)}><head>${joinTags(html.head)}</head><body${joinAttrs(html.bodyAttrs)}>${joinTags(html.bodyPrepend)}${joinTags(html.body)}${joinTags(html.bodyAppend)}</body></html>`;
+}

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/middleware/no-ssr.d.ts

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

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/middleware/no-ssr.js

@@ -0,0 +1,7 @@
+import { defineEventHandler, getRequestHeader } from "h3";
+export default defineEventHandler((event) => {
+  if (getRequestHeader(event, "x-nuxt-no-ssr")) {
+    event.context.nuxt ||= {};
+    event.context.nuxt.noSSR = true;
+  }
+});

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/plugins/dev-server-logs.d.ts

@@ -0,0 +1,3 @@
+import type { NitroApp } from '#internal/nitro/app';
+declare const _default: (nitroApp: NitroApp) => void;
+export default _default;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/plugins/dev-server-logs.js

@@ -0,0 +1,82 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { consola } from "consola";
+import { stringify } from "devalue";
+import { withTrailingSlash } from "ufo";
+import { getContext } from "unctx";
+import { captureRawStackTrace, parseRawStackTrace } from "errx";
+import { isVNode } from "vue";
+import { rootDir } from "#internal/dev-server-logs-options";
+import { appId } from "#internal/nuxt.config.mjs";
+const devReducers = {
+  VNode: (data) => isVNode(data) ? { type: data.type, props: data.props } : void 0,
+  URL: (data) => data instanceof URL ? data.toString() : void 0
+};
+const asyncContext = getContext("nuxt-dev", { asyncContext: true, AsyncLocalStorage });
+export default (nitroApp) => {
+  const handler = nitroApp.h3App.handler;
+  nitroApp.h3App.handler = (event) => {
+    return asyncContext.callAsync({ logs: [], event }, () => handler(event));
+  };
+  onConsoleLog((_log) => {
+    const ctx = asyncContext.tryUse();
+    if (!ctx) {
+      return;
+    }
+    const rawStack = captureRawStackTrace();
+    if (!rawStack || rawStack.includes("runtime/vite-node.mjs")) {
+      return;
+    }
+    const trace = [];
+    let filename = "";
+    for (const entry of parseRawStackTrace(rawStack)) {
+      if (entry.source === import.meta.url) {
+        continue;
+      }
+      if (EXCLUDE_TRACE_RE.test(entry.source)) {
+        continue;
+      }
+      filename ||= entry.source.replace(withTrailingSlash(rootDir), "");
+      trace.push({
+        ...entry,
+        source: entry.source.startsWith("file://") ? entry.source.replace("file://", "") : entry.source
+      });
+    }
+    const log = {
+      ..._log,
+      // Pass along filename to allow the client to display more info about where log comes from
+      filename,
+      // Clean up file names in stack trace
+      stack: trace
+    };
+    ctx.logs.push(log);
+  });
+  nitroApp.hooks.hook("afterResponse", () => {
+    const ctx = asyncContext.tryUse();
+    if (!ctx) {
+      return;
+    }
+    return nitroApp.hooks.callHook("dev:ssr-logs", { logs: ctx.logs, path: ctx.event.path });
+  });
+  nitroApp.hooks.hook("render:html", (htmlContext) => {
+    const ctx = asyncContext.tryUse();
+    if (!ctx) {
+      return;
+    }
+    try {
+      const reducers = Object.assign(/* @__PURE__ */ Object.create(null), devReducers, ctx.event.context._payloadReducers);
+      htmlContext.bodyAppend.unshift(`<script type="application/json" data-nuxt-logs="${appId}">${stringify(ctx.logs, reducers)}<\/script>`);
+    } catch (e) {
+      const shortError = e instanceof Error && "toString" in e ? ` Received \`${e.toString()}\`.` : "";
+      console.warn(`[nuxt] Failed to stringify dev server logs.${shortError} You can define your own reducer/reviver for rich types following the instructions in https://nuxt.com/docs/api/composables/use-nuxt-app#payload.`);
+    }
+  });
+};
+const EXCLUDE_TRACE_RE = /\/node_modules\/(?:.*\/)?(?:nuxt|nuxt-nightly|nuxt-edge|nuxt3|consola|@vue)\/|core\/runtime\/nitro/;
+function onConsoleLog(callback) {
+  consola.addReporter({
+    log(logObj) {
+      callback(logObj);
+    }
+  });
+  consola.wrapConsole();
+}

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/templates/error-500.d.ts

@@ -0,0 +1,2 @@
+export type DefaultMessages = Record<"appName" | "version" | "statusCode" | "statusMessage" | "description", string | boolean | number>;
+export declare const template: (messages: Partial<DefaultMessages>) => string;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/templates/error-500.js

@@ -0,0 +1,6 @@
+import { escapeHtml } from "@vue/shared";
+const _messages = { "appName": "Nuxt", "version": "", "statusCode": 500, "statusMessage": "Server error", "description": "This page is temporarily unavailable." };
+export const template = (messages) => {
+  messages = { ..._messages, ...messages };
+  return '<!DOCTYPE html><html lang="en"><head><title>' + escapeHtml(messages.statusCode) + " - " + escapeHtml(messages.statusMessage) + " | " + escapeHtml(messages.appName) + `</title><meta charset="utf-8"><meta content="width=device-width,initial-scale=1.0,minimum-scale=1.0" name="viewport"><style>.spotlight{background:linear-gradient(45deg,#00dc82,#36e4da 50%,#0047e1);filter:blur(20vh)}*,:after,:before{border-color:var(--un-default-border-color,#e5e7eb);border-style:solid;border-width:0;box-sizing:border-box}:after,:before{--un-content:""}html{line-height:1.5;-webkit-text-size-adjust:100%;font-family:ui-sans-serif,system-ui,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;font-feature-settings:normal;font-variation-settings:normal;-moz-tab-size:4;tab-size:4;-webkit-tap-highlight-color:transparent}body{line-height:inherit;margin:0}h1{font-size:inherit;font-weight:inherit}h1,p{margin:0}*,:after,:before{--un-rotate:0;--un-rotate-x:0;--un-rotate-y:0;--un-rotate-z:0;--un-scale-x:1;--un-scale-y:1;--un-scale-z:1;--un-skew-x:0;--un-skew-y:0;--un-translate-x:0;--un-translate-y:0;--un-translate-z:0;--un-pan-x: ;--un-pan-y: ;--un-pinch-zoom: ;--un-scroll-snap-strictness:proximity;--un-ordinal: ;--un-slashed-zero: ;--un-numeric-figure: ;--un-numeric-spacing: ;--un-numeric-fraction: ;--un-border-spacing-x:0;--un-border-spacing-y:0;--un-ring-offset-shadow:0 0 transparent;--un-ring-shadow:0 0 transparent;--un-shadow-inset: ;--un-shadow:0 0 transparent;--un-ring-inset: ;--un-ring-offset-width:0px;--un-ring-offset-color:#fff;--un-ring-width:0px;--un-ring-color:rgba(147,197,253,.5);--un-blur: ;--un-brightness: ;--un-contrast: ;--un-drop-shadow: ;--un-grayscale: ;--un-hue-rotate: ;--un-invert: ;--un-saturate: ;--un-sepia: ;--un-backdrop-blur: ;--un-backdrop-brightness: ;--un-backdrop-contrast: ;--un-backdrop-grayscale: ;--un-backdrop-hue-rotate: ;--un-backdrop-invert: ;--un-backdrop-opacity: ;--un-backdrop-saturate: ;--un-backdrop-sepia: }.fixed{position:fixed}.-bottom-1\\/2{bottom:-50%}.left-0{left:0}.right-0{right:0}.grid{display:grid}.mb-16{margin-bottom:4rem}.mb-8{margin-bottom:2rem}.h-1\\/2{height:50%}.max-w-520px{max-width:520px}.min-h-screen{min-height:100vh}.place-content-center{place-content:center}.overflow-hidden{overflow:hidden}.bg-white{--un-bg-opacity:1;background-color:rgb(255 255 255/var(--un-bg-opacity))}.px-8{padding-left:2rem;padding-right:2rem}.text-center{text-align:center}.text-8xl{font-size:6rem;line-height:1}.text-xl{font-size:1.25rem;line-height:1.75rem}.text-black{--un-text-opacity:1;color:rgb(0 0 0/var(--un-text-opacity))}.font-light{font-weight:300}.font-medium{font-weight:500}.leading-tight{line-height:1.25}.font-sans{font-family:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,Noto Sans,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji}.antialiased{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}@media(prefers-color-scheme:dark){.dark\\:bg-black{--un-bg-opacity:1;background-color:rgb(0 0 0/var(--un-bg-opacity))}.dark\\:text-white{--un-text-opacity:1;color:rgb(255 255 255/var(--un-text-opacity))}}@media(min-width:640px){.sm\\:px-0{padding-left:0;padding-right:0}.sm\\:text-4xl{font-size:2.25rem;line-height:2.5rem}}</style><script>!function(){const e=document.createElement("link").relList;if(!(e&&e.supports&&e.supports("modulepreload"))){for(const e of document.querySelectorAll('link[rel="modulepreload"]'))r(e);new MutationObserver((e=>{for(const o of e)if("childList"===o.type)for(const e of o.addedNodes)"LINK"===e.tagName&&"modulepreload"===e.rel&&r(e)})).observe(document,{childList:!0,subtree:!0})}function r(e){if(e.ep)return;e.ep=!0;const r=function(e){const r={};return e.integrity&&(r.integrity=e.integrity),e.referrerPolicy&&(r.referrerPolicy=e.referrerPolicy),"use-credentials"===e.crossOrigin?r.credentials="include":"anonymous"===e.crossOrigin?r.credentials="omit":r.credentials="same-origin",r}(e);fetch(e.href,r)}}();<\/script></head><body class="antialiased bg-white dark:bg-black dark:text-white font-sans grid min-h-screen overflow-hidden place-content-center text-black"><div class="-bottom-1/2 fixed h-1/2 left-0 right-0 spotlight"></div><div class="max-w-520px text-center"><h1 class="font-medium mb-8 sm:text-10xl text-8xl">` + escapeHtml(messages.statusCode) + '</h1><p class="font-light leading-tight mb-16 px-8 sm:px-0 sm:text-4xl text-xl">' + escapeHtml(messages.description) + "</p></div></body></html>";
+};

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/cache-driver.d.ts

@@ -0,0 +1,6 @@
+declare const _default: (opts: {
+    base?: string;
+}) => import("unstorage").Driver<{
+    base?: string;
+}, never>;
+export default _default;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/cache-driver.js

@@ -0,0 +1,42 @@
+// @ts-check
+
+import crypto from 'node:crypto'
+import { defineDriver } from 'unstorage'
+import fsDriver from 'unstorage/drivers/fs-lite'
+import lruCache from 'unstorage/drivers/lru-cache'
+
+/**
+ * @param {string} item
+ */
+function normalizeFsKey (item) {
+  const safe = item.replace(/[^\w.-]/g, '_')
+  const prefix = safe.slice(0, 20)
+  const hash = crypto.createHash('sha256').update(item).digest('hex')
+  return `${prefix}-${hash}`
+}
+
+export default defineDriver(
+  /**
+   * @param {{ base?: string }} opts
+   */
+  (opts) => {
+    const fs = fsDriver({ base: opts.base })
+    const lru = lruCache({ max: 1000 })
+
+    return {
+      ...fs, // fall back to file system - only the bottom three methods are used in renderer
+      async setItem (key, value, opts) {
+        await Promise.all([
+          fs.setItem?.(normalizeFsKey(key), value, opts),
+          lru.setItem?.(key, value, opts),
+        ])
+      },
+      async hasItem (key, opts) {
+        return await lru.hasItem(key, opts) || await fs.hasItem(normalizeFsKey(key), opts)
+      },
+      async getItem (key, opts) {
+        return await lru.getItem(key, opts) || await fs.getItem(normalizeFsKey(key), opts)
+      },
+    }
+  },
+)

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/cache.d.ts

@@ -0,0 +1,8 @@
+export declare const payloadCache: any;
+export declare const islandCache: any;
+export declare const islandPropCache: any;
+export declare const sharedPrerenderPromises: Map<string, Promise<any>> | null;
+export declare const sharedPrerenderCache: {
+    get<T = unknown>(key: string): Promise<T> | undefined;
+    set<T>(key: string, value: Promise<T>): Promise<void>;
+} | null;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/cache.js

@@ -0,0 +1,19 @@
+import { useStorage } from "#internal/nitro";
+import process from "node:process";
+export const payloadCache = import.meta.prerender ? useStorage("internal:nuxt:prerender:payload") : null;
+export const islandCache = import.meta.prerender ? useStorage("internal:nuxt:prerender:island") : null;
+export const islandPropCache = import.meta.prerender ? useStorage("internal:nuxt:prerender:island-props") : null;
+export const sharedPrerenderPromises = import.meta.prerender && process.env.NUXT_SHARED_DATA ? /* @__PURE__ */ new Map() : null;
+const sharedPrerenderKeys = /* @__PURE__ */ new Set();
+export const sharedPrerenderCache = import.meta.prerender && process.env.NUXT_SHARED_DATA ? {
+  get(key) {
+    if (sharedPrerenderKeys.has(key)) {
+      return sharedPrerenderPromises.get(key) ?? useStorage("internal:nuxt:prerender:shared").getItem(key);
+    }
+  },
+  async set(key, value) {
+    sharedPrerenderKeys.add(key);
+    sharedPrerenderPromises.set(key, value);
+    useStorage("internal:nuxt:prerender:shared").setItem(key, await value).finally(() => sharedPrerenderPromises.delete(key));
+  }
+} : null;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/config.d.ts

@@ -0,0 +1 @@
+export declare const defineAppConfig: (config: any) => any;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/config.js

@@ -0,0 +1 @@
+export const defineAppConfig = (config) => config;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/dev.d.ts

@@ -0,0 +1,3 @@
+export declare function generateErrorOverlayHTML(html: string, options?: {
+    startMinimized?: boolean;
+}): string;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/dev.js

@@ -0,0 +1,334 @@
+const iframeStorageBridge = (nonce) => (
+  /* js */
+  `
+(function() {
+  const memoryStore = {};
+
+  const NONCE = ${JSON.stringify(nonce)}
+  
+  const mockStorage = {
+    getItem: function(key) {
+      return memoryStore[key] !== undefined ? memoryStore[key] : null;
+    },
+    setItem: function(key, value) {
+      memoryStore[key] = String(value);
+      window.parent.postMessage({
+        type: 'storage-set',
+        key: key,
+        value: String(value),
+        nonce: NONCE
+      }, '*');
+    },
+    removeItem: function(key) {
+      delete memoryStore[key];
+      window.parent.postMessage({
+        type: 'storage-remove',
+        key: key,
+        nonce: NONCE
+      }, '*');
+    },
+    clear: function() {
+      for (const key in memoryStore) {
+        delete memoryStore[key];
+      }
+      window.parent.postMessage({
+        type: 'storage-clear',
+        nonce: NONCE
+      }, '*');
+    },
+    key: function(index) {
+      const keys = Object.keys(memoryStore);
+      return keys[index] !== undefined ? keys[index] : null;
+    },
+    get length() {
+      return Object.keys(memoryStore).length;
+    }
+  };
+  
+  try {
+    Object.defineProperty(window, 'localStorage', {
+      value: mockStorage,
+      writable: false,
+      configurable: true
+    });
+  } catch (e) {
+    window.localStorage = mockStorage;
+  }
+  
+  window.addEventListener('message', function(event) {
+    if (event.data.type === 'storage-sync-data' && event.data.nonce === NONCE) {
+      const data = event.data.data;
+      for (const key in data) {
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+          memoryStore[key] = data[key];
+        }
+      }
+      if (typeof window.initTheme === 'function') {
+        window.initTheme();
+      }
+      window.dispatchEvent(new Event('storage-ready'));
+    }
+  });
+  
+  window.parent.postMessage({ 
+    type: 'storage-sync-request',
+    nonce: NONCE
+  }, '*');
+})();
+`
+);
+const parentStorageBridge = (nonce) => (
+  /* js */
+  `
+(function() {
+  const host = document.querySelector('nuxt-error-overlay');
+  if (!host) return;
+  
+  // Wait for shadow root to be attached
+  const checkShadow = setInterval(function() {
+    if (host.shadowRoot) {
+      clearInterval(checkShadow);
+      const iframe = host.shadowRoot.getElementById('frame');
+      if (!iframe) return;
+
+      const NONCE = ${JSON.stringify(nonce)}
+      
+      window.addEventListener('message', function(event) {
+        if (!event.data || event.data.nonce !== NONCE) return;
+        
+        const data = event.data;
+        
+        if (data.type === 'storage-set') {
+          localStorage.setItem(data.key, data.value);
+        } else if (data.type === 'storage-remove') {
+          localStorage.removeItem(data.key);
+        } else if (data.type === 'storage-clear') {
+          localStorage.clear();
+        } else if (data.type === 'storage-sync-request') {
+          const allData = {};
+          for (let i = 0; i < localStorage.length; i++) {
+            const key = localStorage.key(i);
+            allData[key] = localStorage.getItem(key);
+          }
+          iframe.contentWindow.postMessage({
+            type: 'storage-sync-data',
+            data: allData,
+            nonce: NONCE
+          }, '*');
+        }
+      });
+    }
+  }, 10);
+})();
+`
+);
+const errorCSS = (
+  /* css */
+  `
+:host {
+  --preview-width: 240px;
+  --preview-height: 180px;
+  --base-width: 1200px;
+  --base-height: 900px;
+  --z-base: 999999998;
+  all: initial;
+  display: contents;
+}
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border-width: 0;
+}
+#frame {
+  position: fixed;
+  left: 0;
+  top: 0;
+  width: 100vw;
+  height: 100vh;
+  border: none;
+  z-index: var(--z-base);
+}
+#frame[inert] {
+  right: 5px;
+  bottom: 5px;
+  left: auto;
+  top: auto;
+  width: var(--base-width);
+  height: var(--base-height);
+  transform: scale(calc(240 / 1200));
+  transform-origin: bottom right;
+  overflow: hidden;
+  border-radius: calc(1200 * 8px / 240);
+}
+#preview {
+  position: fixed;
+  right: 5px;
+  bottom: 5px;
+  width: var(--preview-width);
+  height: var(--preview-height);
+  overflow: hidden;
+  border-radius: 8px;
+  pointer-events: none;
+  z-index: var(--z-base);
+  background: white;
+  display: none;
+}
+#frame:not([inert]) + #preview {
+  display: block;
+}
+#toggle {
+  position: fixed;
+  right: 5px;
+  bottom: 5px;
+  width: var(--preview-width);
+  height: var(--preview-height);
+  background: none;
+  border: 3px solid #00DC82;
+  border-radius: 8px;
+  cursor: pointer;
+  opacity: 0.8;
+  transition: opacity 0.2s, box-shadow 0.2s;
+  z-index: calc(var(--z-base) + 1);
+}
+#toggle:hover,
+#toggle:focus {
+  opacity: 1;
+  box-shadow: 0 0 20px rgba(0, 220, 130, 0.6);
+}
+#toggle:focus-visible {
+  outline: 3px solid #00DC82;
+  outline-offset: 3px;
+  box-shadow: 0 0 24px rgba(0, 220, 130, 0.8);
+}
+@media (prefers-reduced-motion: reduce) {
+  #toggle {
+    transition: none;
+  }
+}
+`
+);
+function webComponentScript(base64HTML, startMinimized) {
+  return (
+    /* js */
+    `
+  (function() {
+    try {
+      const host = document.querySelector('nuxt-error-overlay');
+      if (!host) return;
+      
+      const shadow = host.attachShadow({ mode: 'open' });
+      
+      // Create elements
+      const style = document.createElement('style');
+      style.textContent = ${JSON.stringify(errorCSS)};
+      
+      const iframe = document.createElement('iframe');
+      iframe.id = 'frame';
+      iframe.src = 'data:text/html;base64,${base64HTML}';
+      iframe.title = 'Detailed error stack trace';
+      iframe.setAttribute('sandbox', 'allow-scripts allow-same-origin');
+      
+      const preview = document.createElement('div');
+      preview.id = 'preview';
+      
+      const button = document.createElement('button');
+      button.id = 'toggle';
+      button.setAttribute('aria-expanded', 'true');
+      button.setAttribute('type', 'button');
+      button.innerHTML = '<span class="sr-only">Toggle detailed error view</span>';
+      
+      const liveRegion = document.createElement('div');
+      liveRegion.setAttribute('role', 'status');
+      liveRegion.setAttribute('aria-live', 'polite');
+      liveRegion.className = 'sr-only';
+      
+      // Update preview snapshot
+      function updatePreview() {
+        try {
+          let previewIframe = preview.querySelector('iframe');
+          if (!previewIframe) {
+            previewIframe = document.createElement('iframe');
+            previewIframe.style.cssText = 'width: 1200px; height: 900px; transform: scale(0.2); transform-origin: top left; border: none;';
+            previewIframe.setAttribute('sandbox', 'allow-scripts allow-same-origin');
+            preview.appendChild(previewIframe);
+          }
+          
+          const doctype = document.doctype ? '<!DOCTYPE ' + document.doctype.name + '>' : '';
+          const cleanedHTML = document.documentElement.outerHTML
+            .replace(/<nuxt-error-overlay[^>]*>.*?<\\/nuxt-error-overlay>/gs, '')
+            .replace(/<script[^>]*>.*?<\\/script>/gs, '');
+          
+          const iframeDoc = previewIframe.contentDocument || previewIframe.contentWindow.document;
+          iframeDoc.open();
+          iframeDoc.write(doctype + cleanedHTML);
+          iframeDoc.close();
+        } catch (error) {
+          console.error('Failed to update preview:', error);
+        }
+      }
+      
+      function toggleView() {
+        const isMinimized = iframe.hasAttribute('inert');
+        
+        if (isMinimized) {
+          updatePreview();
+          iframe.removeAttribute('inert');
+          button.setAttribute('aria-expanded', 'true');
+          liveRegion.textContent = 'Showing detailed error view';
+          setTimeout(function() {
+            try { iframe.contentWindow.focus(); } catch {}
+          }, 100);
+        } else {
+          iframe.setAttribute('inert', '');
+          button.setAttribute('aria-expanded', 'false');
+          liveRegion.textContent = 'Showing error page';
+          button.focus();
+        }
+      }
+      
+      button.onclick = toggleView;
+      
+      document.addEventListener('keydown', function(e) {
+        if ((e.key === 'Escape' || e.key === 'Esc') && !iframe.hasAttribute('inert')) {
+          toggleView();
+        }
+      });
+      
+      // Append to shadow DOM
+      shadow.appendChild(style);
+      shadow.appendChild(liveRegion);
+      shadow.appendChild(iframe);
+      shadow.appendChild(preview);
+      shadow.appendChild(button);
+      
+      if (${startMinimized}) {
+        iframe.setAttribute('inert', '');
+        button.setAttribute('aria-expanded', 'false');
+      }
+      
+      // Initialize preview
+      setTimeout(updatePreview, 100);
+      
+    } catch (error) {
+      console.error('Failed to initialize Nuxt error overlay:', error);
+    }
+  })();
+  `
+  );
+}
+export function generateErrorOverlayHTML(html, options) {
+  const nonce = Array.from(crypto.getRandomValues(new Uint8Array(16)), (b) => b.toString(16).padStart(2, "0")).join("");
+  const errorPage = html.replace("<head>", `<head><script>${iframeStorageBridge(nonce)}<\/script>`);
+  const base64HTML = Buffer.from(errorPage, "utf8").toString("base64");
+  return `
+    <script>${parentStorageBridge(nonce)}<\/script>
+    <nuxt-error-overlay></nuxt-error-overlay>
+    <script>${webComponentScript(base64HTML, options?.startMinimized ?? false)}<\/script>
+  `;
+}

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/error.d.ts

@@ -0,0 +1,6 @@
+import type { H3Event } from 'h3';
+/**
+ * Nitro internal functions extracted from https://github.com/nitrojs/nitro/blob/v2/src/runtime/internal/utils.ts
+ */
+export declare function isJsonRequest(event: H3Event): boolean;
+export declare function hasReqHeader(event: H3Event, name: string, includes: string): boolean | "" | undefined;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/error.js

@@ -0,0 +1,11 @@
+import { getRequestHeader } from "h3";
+export 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");
+}
+export function hasReqHeader(event, name, includes) {
+  const value = getRequestHeader(event, name);
+  return value && typeof value === "string" && value.toLowerCase().includes(includes);
+}

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function baseURL(): string;
+export declare function buildAssetsDir(): string;
+export declare function buildAssetsURL(...path: string[]): string;
+export declare function publicAssetsURL(...path: string[]): string;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/paths.js

@@ -0,0 +1,16 @@
+import { joinRelativeURL } from "ufo";
+import { useRuntimeConfig } from "#internal/nitro";
+export function baseURL() {
+  return useRuntimeConfig().app.baseURL;
+}
+export function buildAssetsDir() {
+  return useRuntimeConfig().app.buildAssetsDir;
+}
+export function buildAssetsURL(...path) {
+  return joinRelativeURL(publicAssetsURL(), buildAssetsDir(), ...path);
+}
+export function publicAssetsURL(...path) {
+  const app = useRuntimeConfig().app;
+  const publicBase = app.cdnURL || app.baseURL;
+  return path.length ? joinRelativeURL(publicBase, ...path) : publicBase;
+}

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/renderer/app.d.ts

@@ -0,0 +1,6 @@
+import type { H3Event } from 'h3';
+import type { NuxtPayload, NuxtSSRContext } from 'nuxt/app';
+export declare function createSSRContext(event: H3Event): NuxtSSRContext;
+export declare function setSSRError(ssrContext: NuxtSSRContext, error: NuxtPayload['error'] & {
+    url: string;
+}): void;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/renderer/app.js

@@ -0,0 +1,33 @@
+import process from "node:process";
+import { createHead } from "@unhead/vue/server";
+import { sharedPrerenderCache } from "../cache.js";
+import { useRuntimeConfig } from "#internal/nitro";
+import unheadOptions from "#internal/unhead-options.mjs";
+const PRERENDER_NO_SSR_ROUTES = /* @__PURE__ */ new Set(["/index.html", "/200.html", "/404.html"]);
+export function createSSRContext(event) {
+  const ssrContext = {
+    url: event.path,
+    event,
+    runtimeConfig: useRuntimeConfig(event),
+    noSSR: !!process.env.NUXT_NO_SSR || event.context.nuxt?.noSSR || (import.meta.prerender ? PRERENDER_NO_SSR_ROUTES.has(event.path) : false),
+    head: createHead(unheadOptions),
+    error: false,
+    nuxt: void 0,
+    /* NuxtApp */
+    payload: {},
+    _payloadReducers: /* @__PURE__ */ Object.create(null),
+    modules: /* @__PURE__ */ new Set()
+  };
+  if (import.meta.prerender) {
+    if (process.env.NUXT_SHARED_DATA) {
+      ssrContext._sharedPrerenderCache = sharedPrerenderCache;
+    }
+    ssrContext.payload.prerenderedAt = Date.now();
+  }
+  return ssrContext;
+}
+export function setSSRError(ssrContext, error) {
+  ssrContext.error = true;
+  ssrContext.payload = { error };
+  ssrContext.url = error.url;
+}

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/renderer/build-files.d.ts

@@ -0,0 +1,22 @@
+import type { NuxtSSRContext } from 'nuxt/app';
+export declare const getSSRRenderer: () => Promise<{
+    rendererContext: import("vue-bundle-renderer/runtime").RendererContext;
+    renderToString(ssrContext: import("vue-bundle-renderer/runtime").SSRContext): Promise<{
+        html: string;
+        renderResourceHeaders: () => Record<string, string>;
+        renderResourceHints: () => string;
+        renderStyles: () => string;
+        renderScripts: () => string;
+    }>;
+}>;
+export declare function getRenderer(ssrContext: NuxtSSRContext): Promise<{
+    rendererContext: import("vue-bundle-renderer/runtime").RendererContext;
+    renderToString(ssrContext: import("vue-bundle-renderer/runtime").SSRContext): Promise<{
+        html: string;
+        renderResourceHeaders: () => Record<string, string>;
+        renderResourceHints: () => string;
+        renderStyles: () => string;
+        renderScripts: () => string;
+    }>;
+}>;
+export declare const getSSRStyles: () => Promise<Record<string, () => Promise<string[]>>>;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/renderer/build-files.js

@@ -0,0 +1,85 @@
+import process from "node:process";
+import { createRenderer } from "vue-bundle-renderer/runtime";
+import { renderToString as _renderToString } from "vue/server-renderer";
+import { propsToString } from "@unhead/vue/server";
+import { useRuntimeConfig } from "#internal/nitro";
+import { appRootAttrs, appRootTag, appSpaLoaderAttrs, appSpaLoaderTag, spaLoadingTemplateOutside } from "#internal/nuxt.config.mjs";
+import { buildAssetsURL } from "#internal/nuxt/paths";
+const APP_ROOT_OPEN_TAG = `<${appRootTag}${propsToString(appRootAttrs)}>`;
+const APP_ROOT_CLOSE_TAG = `</${appRootTag}>`;
+const getServerEntry = () => import("#build/dist/server/server.mjs").then((r) => r.default || r);
+const getClientManifest = () => import("#build/dist/server/client.manifest.mjs").then((r) => r.default || r).then((r) => typeof r === "function" ? r() : r);
+const getPrecomputedDependencies = () => import("#build/dist/server/client.precomputed.mjs").then((r) => r.default || r).then((r) => typeof r === "function" ? r() : r);
+export const getSSRRenderer = lazyCachedFunction(async () => {
+  const createSSRApp = await getServerEntry();
+  if (!createSSRApp) {
+    throw new Error("Server bundle is not available");
+  }
+  const precomputed = import.meta.dev ? void 0 : await getPrecomputedDependencies();
+  const renderer = createRenderer(createSSRApp, {
+    precomputed,
+    manifest: import.meta.dev ? await getClientManifest() : void 0,
+    renderToString,
+    buildAssetsURL
+  });
+  async function renderToString(input, context) {
+    const html = await _renderToString(input, context);
+    if (import.meta.dev && process.env.NUXT_VITE_NODE_OPTIONS) {
+      renderer.rendererContext.updateManifest(await getClientManifest());
+    }
+    return APP_ROOT_OPEN_TAG + html + APP_ROOT_CLOSE_TAG;
+  }
+  return renderer;
+});
+const getSPARenderer = lazyCachedFunction(async () => {
+  const precomputed = import.meta.dev ? void 0 : await getPrecomputedDependencies();
+  const spaTemplate = await import("#spa-template").then((r) => r.template).catch(() => "").then((r) => {
+    if (spaLoadingTemplateOutside) {
+      const APP_SPA_LOADER_OPEN_TAG = `<${appSpaLoaderTag}${propsToString(appSpaLoaderAttrs)}>`;
+      const APP_SPA_LOADER_CLOSE_TAG = `</${appSpaLoaderTag}>`;
+      const appTemplate = APP_ROOT_OPEN_TAG + APP_ROOT_CLOSE_TAG;
+      const loaderTemplate = r ? APP_SPA_LOADER_OPEN_TAG + r + APP_SPA_LOADER_CLOSE_TAG : "";
+      return appTemplate + loaderTemplate;
+    } else {
+      return APP_ROOT_OPEN_TAG + r + APP_ROOT_CLOSE_TAG;
+    }
+  });
+  const renderer = createRenderer(() => () => {
+  }, {
+    precomputed,
+    manifest: import.meta.dev ? await getClientManifest() : void 0,
+    renderToString: () => spaTemplate,
+    buildAssetsURL
+  });
+  const result = await renderer.renderToString({});
+  const renderToString = (ssrContext) => {
+    const config = useRuntimeConfig(ssrContext.event);
+    ssrContext.modules ||= /* @__PURE__ */ new Set();
+    ssrContext.payload.serverRendered = false;
+    ssrContext.config = {
+      public: config.public,
+      app: config.app
+    };
+    return Promise.resolve(result);
+  };
+  return {
+    rendererContext: renderer.rendererContext,
+    renderToString
+  };
+});
+function lazyCachedFunction(fn) {
+  let res = null;
+  return () => {
+    if (res === null) {
+      res = fn().catch((err) => {
+        res = null;
+        throw err;
+      });
+    }
+    return res;
+  };
+}
+export function getRenderer(ssrContext) {
+  return process.env.NUXT_NO_SSR || ssrContext.noSSR ? getSPARenderer() : getSSRRenderer();
+}
+export const getSSRStyles = lazyCachedFunction(() => import("#build/dist/server/styles.mjs").then((r) => r.default || r));

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/renderer/inline-styles.d.ts

@@ -0,0 +1,2 @@
+import type { Style } from '@unhead/vue/types';
+export declare function renderInlineStyles(usedModules: Set<string> | string[]): Promise<Style[]>;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/renderer/inline-styles.js

@@ -0,0 +1,13 @@
+import { getSSRStyles } from "./build-files.js";
+export async function renderInlineStyles(usedModules) {
+  const styleMap = await getSSRStyles();
+  const inlinedStyles = /* @__PURE__ */ new Set();
+  for (const mod of usedModules) {
+    if (mod in styleMap && styleMap[mod]) {
+      for (const style of await styleMap[mod]()) {
+        inlinedStyles.add(style);
+      }
+    }
+  }
+  return Array.from(inlinedStyles).map((style) => ({ innerHTML: style }));
+}

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/renderer/islands.d.ts

@@ -0,0 +1,9 @@
+import type { NuxtIslandResponse, NuxtSSRContext } from 'nuxt/app';
+/**
+ * remove the root node from the html body
+ */
+export declare function getServerComponentHTML(body: string): string;
+export declare function getSlotIslandResponse(ssrContext: NuxtSSRContext): NuxtIslandResponse['slots'];
+export declare function getClientIslandResponse(ssrContext: NuxtSSRContext): NuxtIslandResponse['components'];
+export declare function getComponentSlotTeleport(clientUid: string, teleports: Record<string, string>): Record<string, string>;
+export declare function replaceIslandTeleports(ssrContext: NuxtSSRContext, html: string): string;

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/renderer/islands.js

@@ -0,0 +1,82 @@
+import { appRootTag } from "#internal/nuxt.config.mjs";
+const ROOT_NODE_REGEX = new RegExp(`^<${appRootTag}[^>]*>([\\s\\S]*)<\\/${appRootTag}>$`);
+export function getServerComponentHTML(body) {
+  const match = body.match(ROOT_NODE_REGEX);
+  return match?.[1] || body;
+}
+const SSR_SLOT_TELEPORT_MARKER = /^uid=([^;]*);slot=(.*)$/;
+const SSR_CLIENT_TELEPORT_MARKER = /^uid=([^;]*);client=(.*)$/;
+const SSR_CLIENT_SLOT_MARKER = /^island-slot=([^;]*);(.*)$/;
+export function getSlotIslandResponse(ssrContext) {
+  if (!ssrContext.islandContext || !Object.keys(ssrContext.islandContext.slots).length) {
+    return void 0;
+  }
+  const response = {};
+  for (const [name, slot] of Object.entries(ssrContext.islandContext.slots)) {
+    response[name] = {
+      ...slot,
+      fallback: ssrContext.teleports?.[`island-fallback=${name}`]
+    };
+  }
+  return response;
+}
+export function getClientIslandResponse(ssrContext) {
+  if (!ssrContext.islandContext || !Object.keys(ssrContext.islandContext.components).length) {
+    return void 0;
+  }
+  const response = {};
+  for (const [clientUid, component] of Object.entries(ssrContext.islandContext.components)) {
+    const html = ssrContext.teleports?.[clientUid]?.replaceAll("<!--teleport start anchor-->", "") || "";
+    response[clientUid] = {
+      ...component,
+      html,
+      slots: getComponentSlotTeleport(clientUid, ssrContext.teleports ?? {})
+    };
+  }
+  return response;
+}
+export function getComponentSlotTeleport(clientUid, teleports) {
+  const entries = Object.entries(teleports);
+  const slots = {};
+  for (const [key, value] of entries) {
+    const match = key.match(SSR_CLIENT_SLOT_MARKER);
+    if (match) {
+      const [, id, slot] = match;
+      if (!slot || clientUid !== id) {
+        continue;
+      }
+      slots[slot] = value;
+    }
+  }
+  return slots;
+}
+export function replaceIslandTeleports(ssrContext, html) {
+  const { teleports, islandContext } = ssrContext;
+  if (islandContext || !teleports) {
+    return html;
+  }
+  for (const key in teleports) {
+    const matchClientComp = key.match(SSR_CLIENT_TELEPORT_MARKER);
+    if (matchClientComp) {
+      const [, uid, clientId] = matchClientComp;
+      if (!uid || !clientId) {
+        continue;
+      }
+      html = html.replace(new RegExp(` data-island-uid="${uid}" data-island-component="${clientId}"[^>]*>`), (full) => {
+        return full + teleports[key];
+      });
+      continue;
+    }
+    const matchSlot = key.match(SSR_SLOT_TELEPORT_MARKER);
+    if (matchSlot) {
+      const [, uid, slot] = matchSlot;
+      if (!uid || !slot) {
+        continue;
+      }
+      html = html.replace(new RegExp(` data-island-uid="${uid}" data-island-slot="${slot}"[^>]*>`), (full) => {
+        return full + teleports[key];
+      });
+    }
+  }
+  return html;
+}

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/renderer/payload.d.ts

@@ -0,0 +1,37 @@
+import type { Script } from '@unhead/vue';
+import type { NuxtSSRContext } from 'nuxt/app';
+export declare function renderPayloadResponse(ssrContext: NuxtSSRContext): {
+    body: string;
+    statusCode: number;
+    statusMessage: string;
+    headers: {
+        'content-type': string;
+        'x-powered-by': string;
+    };
+};
+export declare function renderPayloadJsonScript(opts: {
+    ssrContext: NuxtSSRContext;
+    data?: any;
+    src?: string;
+}): Script[];
+export declare function renderPayloadScript(opts: {
+    ssrContext: NuxtSSRContext;
+    data?: any;
+    src?: string;
+}): Script[];
+export declare function splitPayload(ssrContext: NuxtSSRContext): {
+    initial: {
+        prerenderedAt: number | undefined;
+        path?: string | undefined;
+        serverRendered?: boolean | undefined;
+        state?: Record<string, any> | undefined;
+        once?: Set<string> | undefined;
+        config?: Pick<import("nuxt/schema").RuntimeConfig, "public" | "app"> | undefined;
+        error?: (import("nuxt/app").NuxtError | import("nuxt/app/defaults").DefaultErrorValue) | undefined;
+        _errors?: Record<string, import("nuxt/app").NuxtError<unknown> | null> | undefined;
+    };
+    payload: {
+        data: Record<string, any> | undefined;
+        prerenderedAt: number | undefined;
+    };
+};

Frontend-Learner/node_modules/@nuxt/nitro-server/dist/runtime/utils/renderer/payload.js

@@ -0,0 +1,67 @@
+import process from "node:process";
+import { getResponseStatus, getResponseStatusText } from "h3";
+import devalue from "@nuxt/devalue";
+import { stringify, uneval } from "devalue";
+import { appId, multiApp } from "#internal/nuxt.config.mjs";
+export function renderPayloadResponse(ssrContext) {
+  return {
+    body: process.env.NUXT_JSON_PAYLOADS ? stringify(splitPayload(ssrContext).payload, ssrContext._payloadReducers) : `export default ${devalue(splitPayload(ssrContext).payload)}`,
+    statusCode: getResponseStatus(ssrContext.event),
+    statusMessage: getResponseStatusText(ssrContext.event),
+    headers: {
+      "content-type": process.env.NUXT_JSON_PAYLOADS ? "application/json;charset=utf-8" : "text/javascript;charset=utf-8",
+      "x-powered-by": "Nuxt"
+    }
+  };
+}
+export function renderPayloadJsonScript(opts) {
+  const contents = opts.data ? stringify(opts.data, opts.ssrContext._payloadReducers) : "";
+  const payload = {
+    "type": "application/json",
+    "innerHTML": contents,
+    "data-nuxt-data": appId,
+    "data-ssr": !(process.env.NUXT_NO_SSR || opts.ssrContext.noSSR)
+  };
+  if (!multiApp) {
+    payload.id = "__NUXT_DATA__";
+  }
+  if (opts.src) {
+    payload["data-src"] = opts.src;
+  }
+  const config = uneval(opts.ssrContext.config);
+  return [
+    payload,
+    {
+      innerHTML: multiApp ? `window.__NUXT__=window.__NUXT__||{};window.__NUXT__[${JSON.stringify(appId)}]={config:${config}}` : `window.__NUXT__={};window.__NUXT__.config=${config}`
+    }
+  ];
+}
+export function renderPayloadScript(opts) {
+  opts.data.config = opts.ssrContext.config;
+  const _PAYLOAD_EXTRACTION = import.meta.prerender && process.env.NUXT_PAYLOAD_EXTRACTION && !opts.ssrContext.noSSR;
+  const nuxtData = devalue(opts.data);
+  if (_PAYLOAD_EXTRACTION) {
+    const singleAppPayload2 = `import p from "${opts.src}";window.__NUXT__={...p,...(${nuxtData})}`;
+    const multiAppPayload2 = `import p from "${opts.src}";window.__NUXT__=window.__NUXT__||{};window.__NUXT__[${JSON.stringify(appId)}]={...p,...(${nuxtData})}`;
+    return [
+      {
+        type: "module",
+        innerHTML: multiApp ? multiAppPayload2 : singleAppPayload2
+      }
+    ];
+  }
+  const singleAppPayload = `window.__NUXT__=${nuxtData}`;
+  const multiAppPayload = `window.__NUXT__=window.__NUXT__||{};window.__NUXT__[${JSON.stringify(appId)}]=${nuxtData}`;
+  return [
+    {
+      innerHTML: multiApp ? multiAppPayload : singleAppPayload
+    }
+  ];
+}
+export function splitPayload(ssrContext) {
+  const { data, prerenderedAt, ...initial } = ssrContext.payload;
+  return {
+    initial: { ...initial, prerenderedAt },
+    payload: { data, prerenderedAt }
+  };
+}