Website Structure

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