Website Structure

Frontend-Learner/node_modules/vue-bundle-renderer/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 - Nuxt.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Frontend-Learner/node_modules/vue-bundle-renderer/README.md

@@ -0,0 +1,65 @@
+# Vue Bundle Renderer
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![Github Actions][github-actions-src]][github-actions-href]
+<!-- [![Codecov][codecov-src]][codecov-href] -->
+
+SSR Bundle Renderer for [Vue 3](https://vuejs.org/).
+
+## Install
+
+```sh
+yarn add vue-bundle-renderer
+
+npm install vue-bundle-renderer
+
+pnpm add vue-bundle-renderer
+```
+
+## Usage
+
+### `createRenderer`
+
+```ts
+import { createRenderer } from 'vue-bundle-renderer/runtime'
+
+declare function createRenderer(createApp, renderOptions: RenderOptions)
+```
+
+### `normalizeViteManifest`
+
+```ts
+import { normalizeViteManifest } from 'vue-bundle-renderer'
+
+declare function normalizeViteManifest(manifest: ViteManifest)
+```
+
+### `normalizeWebpackManifest`
+
+```ts
+import { normalizeWebpackManifest } from 'vue-bundle-renderer'
+
+declare function normalizeWebpackManifest(manifest: ViteManifest)
+```
+
+## Credits
+
+Based on [vue-server-renderer](https://www.npmjs.com/package/vue-server-renderer) made by [Evan You](https://github.com/yyx990803).
+
+## License
+
+MIT
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/vue-bundle-renderer?style=flat-square
+[npm-version-href]: https://npmjs.com/package/vue-bundle-renderer
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/vue-bundle-renderer?style=flat-square
+[npm-downloads-href]: https://npm.chart.dev/vue-bundle-renderer
+
+[github-actions-src]: https://img.shields.io/github/actions/workflow/status/nuxt-contrib/vue-bundle-renderer/ci.yml?branch=main&style=flat-square
+[github-actions-href]: https://github.com/nuxt-contrib/vue-bundle-renderer/actions/workflows/ci.yml
+
+[codecov-src]: https://img.shields.io/codecov/c/gh/nuxt-contrib/vue-bundle-renderer/master?style=flat-square
+[codecov-href]: https://codecov.io/gh/nuxt-contrib/vue-bundle-renderer

Frontend-Learner/node_modules/vue-bundle-renderer/dist/index.cjs

@@ -0,0 +1,265 @@
+'use strict';
+
+const IS_JS_RE = /\.[cm]?js(?:\?[^.]+)?$/;
+const HAS_EXT_RE = /[^./]+\.[^./]+$/;
+const IS_CSS_RE = /\.(?:css|postcss|pcss|sass|scss|less|stylus|styl)(?:\?[^.]+)?$/;
+function isJS(file) {
+  return IS_JS_RE.test(file) || !HAS_EXT_RE.test(file);
+}
+function isCSS(file) {
+  return IS_CSS_RE.test(file);
+}
+const IMAGE_RE = /^(?:jpe?g|png|svg|gif|webp|ico)$/;
+const FONT_RE = /^(?:woff2?|ttf|otf|eot)$/;
+const AUDIO_RE = /^(?:mp3|wav|ogg|flac|aac|m4a|wma|aiff|aif|au|raw|vox|opus)$/;
+const VIDEO_RE = /^(?:mp4|webm|ogv|mkv|avi|mov|flv|wmv|mpg|mpeg|m4v|3gp|3g2|mxf|rm|rmvb|asf|asx|m3u8|m3u|pls|cue)$/;
+const contentTypeMap = {
+  ico: "image/x-icon",
+  jpg: "image/jpeg",
+  svg: "image/svg+xml"
+};
+function getContentType(asType, extension) {
+  if (asType === "font") {
+    return `font/${extension}`;
+  }
+  if (asType === "image") {
+    return contentTypeMap[extension] || `image/${extension}`;
+  }
+}
+function getAsType(ext) {
+  if (ext === "js" || ext === "cjs" || ext === "mjs") {
+    return "script";
+  } else if (ext === "css") {
+    return "style";
+  } else if (IMAGE_RE.test(ext)) {
+    return "image";
+  } else if (FONT_RE.test(ext)) {
+    return "font";
+  } else if (AUDIO_RE.test(ext)) {
+    return "audio";
+  } else if (VIDEO_RE.test(ext)) {
+    return "video";
+  }
+}
+const parseResource = (path) => {
+  const chunk = {};
+  const extension = path.replace(/\?.*/, "").split(".").pop() || "";
+  const asType = getAsType(extension);
+  if (asType) {
+    chunk.resourceType = asType;
+    if (asType === "script" && extension !== "cjs") {
+      chunk.module = true;
+    }
+  }
+  if (chunk.resourceType !== "font") {
+    chunk.prefetch = true;
+  }
+  if (chunk.resourceType && ["module", "script", "style"].includes(chunk.resourceType)) {
+    chunk.preload = true;
+  }
+  const contentType = getContentType(asType, extension);
+  if (contentType) {
+    chunk.mimeType = contentType;
+  }
+  return chunk;
+};
+
+function normalizeViteManifest(manifest) {
+  const _manifest = {};
+  for (const file in manifest) {
+    const chunk = manifest[file];
+    _manifest[file] = { ...parseResource(chunk.file || file), ...chunk };
+    for (const item of chunk.css || []) {
+      if (!_manifest[item]) {
+        _manifest[item] = { file: item, resourceType: "style", ...parseResource(item) };
+      }
+    }
+    for (const item of chunk.assets || []) {
+      if (!_manifest[item]) {
+        _manifest[item] = { file: item, ...parseResource(item) };
+      }
+    }
+  }
+  return _manifest;
+}
+
+function normalizeWebpackManifest(manifest) {
+  const clientManifest = {};
+  for (const outfile of manifest.all) {
+    if (isJS(outfile)) {
+      clientManifest[getIdentifier(outfile)] = {
+        file: outfile,
+        ...parseResource(outfile)
+      };
+    }
+  }
+  const first = getIdentifier(manifest.initial.find(isJS));
+  if (first) {
+    if (!(first in clientManifest)) {
+      throw new Error(
+        `Invalid manifest - initial entrypoint not in \`all\`: ${manifest.initial.find(isJS)}`
+      );
+    }
+    clientManifest[first].css = [];
+    clientManifest[first].assets = [];
+    clientManifest[first].dynamicImports = [];
+  }
+  for (const outfile of manifest.initial) {
+    if (isJS(outfile)) {
+      clientManifest[getIdentifier(outfile)].isEntry = true;
+    } else if (isCSS(outfile) && first) {
+      clientManifest[first].css.push(outfile);
+      clientManifest[outfile] = { file: outfile, ...parseResource(outfile) };
+    } else if (first) {
+      clientManifest[first].assets.push(outfile);
+      clientManifest[outfile] = { file: outfile, ...parseResource(outfile) };
+    }
+  }
+  for (const outfile of manifest.async) {
+    if (isJS(outfile)) {
+      const identifier = getIdentifier(outfile);
+      if (!(identifier in clientManifest)) {
+        throw new Error(`Invalid manifest - async module not in \`all\`: ${outfile}`);
+      }
+      clientManifest[identifier].isDynamicEntry = true;
+      clientManifest[identifier].sideEffects = true;
+      clientManifest[first].dynamicImports.push(identifier);
+    } else if (first) {
+      const key = isCSS(outfile) ? "css" : "assets";
+      const identifier = getIdentifier(outfile);
+      clientManifest[identifier] = {
+        file: "",
+        [key]: [outfile]
+      };
+      clientManifest[outfile] = {
+        file: outfile,
+        ...parseResource(outfile)
+      };
+      clientManifest[first].dynamicImports.push(identifier);
+    }
+  }
+  for (const [moduleId, importIndexes] of Object.entries(manifest.modules)) {
+    const jsFiles = importIndexes.map((index) => manifest.all[index]).filter(isJS);
+    jsFiles.forEach((file) => {
+      const identifier = getIdentifier(file);
+      clientManifest[identifier] = {
+        ...clientManifest[identifier],
+        file
+      };
+    });
+    const mappedIndexes = importIndexes.map((index) => manifest.all[index]);
+    clientManifest[moduleId] = {
+      file: "",
+      ...parseResource(moduleId),
+      imports: jsFiles.map((id) => getIdentifier(id)),
+      css: mappedIndexes.filter(isCSS),
+      assets: mappedIndexes.filter((i) => !isJS(i) && !isCSS(i))
+    };
+    for (const key of ["css", "assets"]) {
+      for (const file of clientManifest[moduleId][key] || []) {
+        clientManifest[file] = clientManifest[file] || { file, ...parseResource(file) };
+      }
+    }
+  }
+  return clientManifest;
+}
+function getIdentifier(output) {
+  return output ? `_${output}` : null;
+}
+
+function precomputeDependencies(manifest) {
+  const dependencies = {};
+  const computing = /* @__PURE__ */ new Set();
+  function computeDependencies(id) {
+    if (dependencies[id]) {
+      return dependencies[id];
+    }
+    if (computing.has(id)) {
+      return { scripts: {}, styles: {}, preload: {}, prefetch: {} };
+    }
+    computing.add(id);
+    const deps = {
+      scripts: {},
+      styles: {},
+      preload: {},
+      prefetch: {}
+    };
+    const meta = manifest[id];
+    if (!meta) {
+      dependencies[id] = deps;
+      computing.delete(id);
+      return deps;
+    }
+    if (meta.file) {
+      deps.preload[id] = meta;
+      if (meta.isEntry || meta.sideEffects) {
+        deps.scripts[id] = meta;
+      }
+    }
+    for (const css of meta.css || []) {
+      const cssResource = manifest[css];
+      if (cssResource) {
+        deps.styles[css] = cssResource;
+        deps.preload[css] = cssResource;
+        deps.prefetch[css] = cssResource;
+      }
+    }
+    for (const asset of meta.assets || []) {
+      const assetResource = manifest[asset];
+      if (assetResource) {
+        deps.preload[asset] = assetResource;
+        deps.prefetch[asset] = assetResource;
+      }
+    }
+    for (const depId of meta.imports || []) {
+      const depDeps = computeDependencies(depId);
+      Object.assign(deps.styles, depDeps.styles);
+      Object.assign(deps.preload, depDeps.preload);
+      Object.assign(deps.prefetch, depDeps.prefetch);
+    }
+    const filteredPreload = {};
+    for (const depId in deps.preload) {
+      const dep = deps.preload[depId];
+      if (dep.preload) {
+        filteredPreload[depId] = dep;
+      }
+    }
+    deps.preload = filteredPreload;
+    dependencies[id] = deps;
+    computing.delete(id);
+    return deps;
+  }
+  for (const moduleId of Object.keys(manifest)) {
+    computeDependencies(moduleId);
+  }
+  const entrypoints = /* @__PURE__ */ new Set();
+  for (const key in manifest) {
+    const meta = manifest[key];
+    if (meta?.isEntry) {
+      entrypoints.add(key);
+    }
+  }
+  const modules = {};
+  for (const [moduleId, meta] of Object.entries(manifest)) {
+    modules[moduleId] = {
+      file: meta.file,
+      resourceType: meta.resourceType,
+      mimeType: meta.mimeType,
+      module: meta.module
+    };
+  }
+  return {
+    dependencies,
+    entrypoints: [...entrypoints],
+    modules
+  };
+}
+
+function defineManifest(manifest) {
+  return manifest;
+}
+
+exports.defineManifest = defineManifest;
+exports.normalizeViteManifest = normalizeViteManifest;
+exports.normalizeWebpackManifest = normalizeWebpackManifest;
+exports.precomputeDependencies = precomputeDependencies;

Frontend-Learner/node_modules/vue-bundle-renderer/dist/index.d.cts

@@ -0,0 +1,21 @@
+import { Manifest } from 'vite';
+import { M as Manifest$1 } from './shared/vue-bundle-renderer.lFgxeLN7.cjs';
+export { P as PrecomputedData, R as ResourceMeta, d as defineManifest, p as precomputeDependencies } from './shared/vue-bundle-renderer.lFgxeLN7.cjs';
+
+declare function normalizeViteManifest(manifest: Manifest | Manifest$1): Manifest$1;
+
+type Identifier = string;
+type OutputPath = string;
+interface WebpackClientManifest {
+    publicPath: string;
+    all: Array<OutputPath>;
+    initial: Array<OutputPath>;
+    async: Array<OutputPath>;
+    modules: Record<Identifier, Array<number>>;
+    hasNoCssVersion?: {
+        [file: string]: boolean;
+    };
+}
+declare function normalizeWebpackManifest(manifest: WebpackClientManifest): Manifest$1;
+
+export { Manifest$1 as Manifest, normalizeViteManifest, normalizeWebpackManifest };

Frontend-Learner/node_modules/vue-bundle-renderer/dist/index.d.mts

@@ -0,0 +1,21 @@
+import { Manifest } from 'vite';
+import { M as Manifest$1 } from './shared/vue-bundle-renderer.lFgxeLN7.mjs';
+export { P as PrecomputedData, R as ResourceMeta, d as defineManifest, p as precomputeDependencies } from './shared/vue-bundle-renderer.lFgxeLN7.mjs';
+
+declare function normalizeViteManifest(manifest: Manifest | Manifest$1): Manifest$1;
+
+type Identifier = string;
+type OutputPath = string;
+interface WebpackClientManifest {
+    publicPath: string;
+    all: Array<OutputPath>;
+    initial: Array<OutputPath>;
+    async: Array<OutputPath>;
+    modules: Record<Identifier, Array<number>>;
+    hasNoCssVersion?: {
+        [file: string]: boolean;
+    };
+}
+declare function normalizeWebpackManifest(manifest: WebpackClientManifest): Manifest$1;
+
+export { Manifest$1 as Manifest, normalizeViteManifest, normalizeWebpackManifest };

Frontend-Learner/node_modules/vue-bundle-renderer/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { Manifest } from 'vite';
+import { M as Manifest$1 } from './shared/vue-bundle-renderer.lFgxeLN7.js';
+export { P as PrecomputedData, R as ResourceMeta, d as defineManifest, p as precomputeDependencies } from './shared/vue-bundle-renderer.lFgxeLN7.js';
+
+declare function normalizeViteManifest(manifest: Manifest | Manifest$1): Manifest$1;
+
+type Identifier = string;
+type OutputPath = string;
+interface WebpackClientManifest {
+    publicPath: string;
+    all: Array<OutputPath>;
+    initial: Array<OutputPath>;
+    async: Array<OutputPath>;
+    modules: Record<Identifier, Array<number>>;
+    hasNoCssVersion?: {
+        [file: string]: boolean;
+    };
+}
+declare function normalizeWebpackManifest(manifest: WebpackClientManifest): Manifest$1;
+
+export { Manifest$1 as Manifest, normalizeViteManifest, normalizeWebpackManifest };

Frontend-Learner/node_modules/vue-bundle-renderer/dist/index.mjs

@@ -0,0 +1,260 @@
+const IS_JS_RE = /\.[cm]?js(?:\?[^.]+)?$/;
+const HAS_EXT_RE = /[^./]+\.[^./]+$/;
+const IS_CSS_RE = /\.(?:css|postcss|pcss|sass|scss|less|stylus|styl)(?:\?[^.]+)?$/;
+function isJS(file) {
+  return IS_JS_RE.test(file) || !HAS_EXT_RE.test(file);
+}
+function isCSS(file) {
+  return IS_CSS_RE.test(file);
+}
+const IMAGE_RE = /^(?:jpe?g|png|svg|gif|webp|ico)$/;
+const FONT_RE = /^(?:woff2?|ttf|otf|eot)$/;
+const AUDIO_RE = /^(?:mp3|wav|ogg|flac|aac|m4a|wma|aiff|aif|au|raw|vox|opus)$/;
+const VIDEO_RE = /^(?:mp4|webm|ogv|mkv|avi|mov|flv|wmv|mpg|mpeg|m4v|3gp|3g2|mxf|rm|rmvb|asf|asx|m3u8|m3u|pls|cue)$/;
+const contentTypeMap = {
+  ico: "image/x-icon",
+  jpg: "image/jpeg",
+  svg: "image/svg+xml"
+};
+function getContentType(asType, extension) {
+  if (asType === "font") {
+    return `font/${extension}`;
+  }
+  if (asType === "image") {
+    return contentTypeMap[extension] || `image/${extension}`;
+  }
+}
+function getAsType(ext) {
+  if (ext === "js" || ext === "cjs" || ext === "mjs") {
+    return "script";
+  } else if (ext === "css") {
+    return "style";
+  } else if (IMAGE_RE.test(ext)) {
+    return "image";
+  } else if (FONT_RE.test(ext)) {
+    return "font";
+  } else if (AUDIO_RE.test(ext)) {
+    return "audio";
+  } else if (VIDEO_RE.test(ext)) {
+    return "video";
+  }
+}
+const parseResource = (path) => {
+  const chunk = {};
+  const extension = path.replace(/\?.*/, "").split(".").pop() || "";
+  const asType = getAsType(extension);
+  if (asType) {
+    chunk.resourceType = asType;
+    if (asType === "script" && extension !== "cjs") {
+      chunk.module = true;
+    }
+  }
+  if (chunk.resourceType !== "font") {
+    chunk.prefetch = true;
+  }
+  if (chunk.resourceType && ["module", "script", "style"].includes(chunk.resourceType)) {
+    chunk.preload = true;
+  }
+  const contentType = getContentType(asType, extension);
+  if (contentType) {
+    chunk.mimeType = contentType;
+  }
+  return chunk;
+};
+
+function normalizeViteManifest(manifest) {
+  const _manifest = {};
+  for (const file in manifest) {
+    const chunk = manifest[file];
+    _manifest[file] = { ...parseResource(chunk.file || file), ...chunk };
+    for (const item of chunk.css || []) {
+      if (!_manifest[item]) {
+        _manifest[item] = { file: item, resourceType: "style", ...parseResource(item) };
+      }
+    }
+    for (const item of chunk.assets || []) {
+      if (!_manifest[item]) {
+        _manifest[item] = { file: item, ...parseResource(item) };
+      }
+    }
+  }
+  return _manifest;
+}
+
+function normalizeWebpackManifest(manifest) {
+  const clientManifest = {};
+  for (const outfile of manifest.all) {
+    if (isJS(outfile)) {
+      clientManifest[getIdentifier(outfile)] = {
+        file: outfile,
+        ...parseResource(outfile)
+      };
+    }
+  }
+  const first = getIdentifier(manifest.initial.find(isJS));
+  if (first) {
+    if (!(first in clientManifest)) {
+      throw new Error(
+        `Invalid manifest - initial entrypoint not in \`all\`: ${manifest.initial.find(isJS)}`
+      );
+    }
+    clientManifest[first].css = [];
+    clientManifest[first].assets = [];
+    clientManifest[first].dynamicImports = [];
+  }
+  for (const outfile of manifest.initial) {
+    if (isJS(outfile)) {
+      clientManifest[getIdentifier(outfile)].isEntry = true;
+    } else if (isCSS(outfile) && first) {
+      clientManifest[first].css.push(outfile);
+      clientManifest[outfile] = { file: outfile, ...parseResource(outfile) };
+    } else if (first) {
+      clientManifest[first].assets.push(outfile);
+      clientManifest[outfile] = { file: outfile, ...parseResource(outfile) };
+    }
+  }
+  for (const outfile of manifest.async) {
+    if (isJS(outfile)) {
+      const identifier = getIdentifier(outfile);
+      if (!(identifier in clientManifest)) {
+        throw new Error(`Invalid manifest - async module not in \`all\`: ${outfile}`);
+      }
+      clientManifest[identifier].isDynamicEntry = true;
+      clientManifest[identifier].sideEffects = true;
+      clientManifest[first].dynamicImports.push(identifier);
+    } else if (first) {
+      const key = isCSS(outfile) ? "css" : "assets";
+      const identifier = getIdentifier(outfile);
+      clientManifest[identifier] = {
+        file: "",
+        [key]: [outfile]
+      };
+      clientManifest[outfile] = {
+        file: outfile,
+        ...parseResource(outfile)
+      };
+      clientManifest[first].dynamicImports.push(identifier);
+    }
+  }
+  for (const [moduleId, importIndexes] of Object.entries(manifest.modules)) {
+    const jsFiles = importIndexes.map((index) => manifest.all[index]).filter(isJS);
+    jsFiles.forEach((file) => {
+      const identifier = getIdentifier(file);
+      clientManifest[identifier] = {
+        ...clientManifest[identifier],
+        file
+      };
+    });
+    const mappedIndexes = importIndexes.map((index) => manifest.all[index]);
+    clientManifest[moduleId] = {
+      file: "",
+      ...parseResource(moduleId),
+      imports: jsFiles.map((id) => getIdentifier(id)),
+      css: mappedIndexes.filter(isCSS),
+      assets: mappedIndexes.filter((i) => !isJS(i) && !isCSS(i))
+    };
+    for (const key of ["css", "assets"]) {
+      for (const file of clientManifest[moduleId][key] || []) {
+        clientManifest[file] = clientManifest[file] || { file, ...parseResource(file) };
+      }
+    }
+  }
+  return clientManifest;
+}
+function getIdentifier(output) {
+  return output ? `_${output}` : null;
+}
+
+function precomputeDependencies(manifest) {
+  const dependencies = {};
+  const computing = /* @__PURE__ */ new Set();
+  function computeDependencies(id) {
+    if (dependencies[id]) {
+      return dependencies[id];
+    }
+    if (computing.has(id)) {
+      return { scripts: {}, styles: {}, preload: {}, prefetch: {} };
+    }
+    computing.add(id);
+    const deps = {
+      scripts: {},
+      styles: {},
+      preload: {},
+      prefetch: {}
+    };
+    const meta = manifest[id];
+    if (!meta) {
+      dependencies[id] = deps;
+      computing.delete(id);
+      return deps;
+    }
+    if (meta.file) {
+      deps.preload[id] = meta;
+      if (meta.isEntry || meta.sideEffects) {
+        deps.scripts[id] = meta;
+      }
+    }
+    for (const css of meta.css || []) {
+      const cssResource = manifest[css];
+      if (cssResource) {
+        deps.styles[css] = cssResource;
+        deps.preload[css] = cssResource;
+        deps.prefetch[css] = cssResource;
+      }
+    }
+    for (const asset of meta.assets || []) {
+      const assetResource = manifest[asset];
+      if (assetResource) {
+        deps.preload[asset] = assetResource;
+        deps.prefetch[asset] = assetResource;
+      }
+    }
+    for (const depId of meta.imports || []) {
+      const depDeps = computeDependencies(depId);
+      Object.assign(deps.styles, depDeps.styles);
+      Object.assign(deps.preload, depDeps.preload);
+      Object.assign(deps.prefetch, depDeps.prefetch);
+    }
+    const filteredPreload = {};
+    for (const depId in deps.preload) {
+      const dep = deps.preload[depId];
+      if (dep.preload) {
+        filteredPreload[depId] = dep;
+      }
+    }
+    deps.preload = filteredPreload;
+    dependencies[id] = deps;
+    computing.delete(id);
+    return deps;
+  }
+  for (const moduleId of Object.keys(manifest)) {
+    computeDependencies(moduleId);
+  }
+  const entrypoints = /* @__PURE__ */ new Set();
+  for (const key in manifest) {
+    const meta = manifest[key];
+    if (meta?.isEntry) {
+      entrypoints.add(key);
+    }
+  }
+  const modules = {};
+  for (const [moduleId, meta] of Object.entries(manifest)) {
+    modules[moduleId] = {
+      file: meta.file,
+      resourceType: meta.resourceType,
+      mimeType: meta.mimeType,
+      module: meta.module
+    };
+  }
+  return {
+    dependencies,
+    entrypoints: [...entrypoints],
+    modules
+  };
+}
+
+function defineManifest(manifest) {
+  return manifest;
+}
+
+export { defineManifest, normalizeViteManifest, normalizeWebpackManifest, precomputeDependencies };

Frontend-Learner/node_modules/vue-bundle-renderer/dist/runtime.cjs

@@ -0,0 +1,314 @@
+'use strict';
+
+const ufo = require('ufo');
+
+function createRendererContext({ manifest, precomputed, buildAssetsURL }) {
+  if (!manifest && !precomputed) {
+    throw new Error("Either manifest or precomputed data must be provided");
+  }
+  const ctx = {
+    // Options
+    buildAssetsURL: buildAssetsURL || ufo.withLeadingSlash,
+    manifest,
+    precomputed,
+    updateManifest,
+    // Internal cache
+    _dependencies: {},
+    _dependencySets: {},
+    _entrypoints: []
+  };
+  function updateManifest(manifest2) {
+    const manifestEntries = Object.entries(manifest2);
+    ctx.manifest = manifest2;
+    ctx._dependencies = {};
+    ctx._dependencySets = {};
+    ctx._entrypoints = manifestEntries.filter((e) => e[1].isEntry).map(([module]) => module);
+  }
+  if (precomputed) {
+    ctx._dependencies = precomputed.dependencies;
+    ctx._entrypoints = precomputed.entrypoints;
+  } else if (manifest) {
+    updateManifest(manifest);
+  }
+  return ctx;
+}
+function getModuleDependencies(id, rendererContext) {
+  if (rendererContext._dependencies[id]) {
+    return rendererContext._dependencies[id];
+  }
+  const dependencies = rendererContext._dependencies[id] = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  if (!rendererContext.manifest) {
+    return dependencies;
+  }
+  const meta = rendererContext.manifest[id];
+  if (!meta) {
+    return dependencies;
+  }
+  if (meta.file) {
+    dependencies.preload[id] = meta;
+    if (meta.isEntry || meta.sideEffects) {
+      dependencies.scripts[id] = meta;
+    }
+  }
+  for (const css of meta.css || []) {
+    dependencies.styles[css] = dependencies.preload[css] = dependencies.prefetch[css] = rendererContext.manifest[css];
+  }
+  for (const asset of meta.assets || []) {
+    dependencies.preload[asset] = dependencies.prefetch[asset] = rendererContext.manifest[asset];
+  }
+  for (const depId of meta.imports || []) {
+    const depDeps = getModuleDependencies(depId, rendererContext);
+    for (const key in depDeps.styles) {
+      dependencies.styles[key] = depDeps.styles[key];
+    }
+    for (const key in depDeps.preload) {
+      dependencies.preload[key] = depDeps.preload[key];
+    }
+    for (const key in depDeps.prefetch) {
+      dependencies.prefetch[key] = depDeps.prefetch[key];
+    }
+  }
+  const filteredPreload = {};
+  for (const id2 in dependencies.preload) {
+    const dep = dependencies.preload[id2];
+    if (dep.preload) {
+      filteredPreload[id2] = dep;
+    }
+  }
+  dependencies.preload = filteredPreload;
+  return dependencies;
+}
+function getAllDependencies(ids, rendererContext) {
+  let cacheKey = "";
+  const sortedIds = [...ids].sort();
+  for (let i = 0; i < sortedIds.length; i++) {
+    if (i > 0) cacheKey += ",";
+    cacheKey += sortedIds[i];
+  }
+  if (rendererContext._dependencySets[cacheKey]) {
+    return rendererContext._dependencySets[cacheKey];
+  }
+  const allDeps = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  for (const id of ids) {
+    const deps = getModuleDependencies(id, rendererContext);
+    for (const key in deps.scripts) {
+      allDeps.scripts[key] = deps.scripts[key];
+    }
+    for (const key in deps.styles) {
+      allDeps.styles[key] = deps.styles[key];
+    }
+    for (const key in deps.preload) {
+      allDeps.preload[key] = deps.preload[key];
+    }
+    for (const key in deps.prefetch) {
+      allDeps.prefetch[key] = deps.prefetch[key];
+    }
+    for (const dynamicDepId of rendererContext.manifest?.[id]?.dynamicImports || []) {
+      const dynamicDeps = getModuleDependencies(dynamicDepId, rendererContext);
+      for (const key in dynamicDeps.scripts) {
+        allDeps.prefetch[key] = dynamicDeps.scripts[key];
+      }
+      for (const key in dynamicDeps.styles) {
+        allDeps.prefetch[key] = dynamicDeps.styles[key];
+      }
+      for (const key in dynamicDeps.preload) {
+        allDeps.prefetch[key] = dynamicDeps.preload[key];
+      }
+    }
+  }
+  const filteredPrefetch = {};
+  for (const id in allDeps.prefetch) {
+    const dep = allDeps.prefetch[id];
+    if (dep.prefetch) {
+      filteredPrefetch[id] = dep;
+    }
+  }
+  allDeps.prefetch = filteredPrefetch;
+  for (const id in allDeps.preload) {
+    delete allDeps.prefetch[id];
+  }
+  for (const style in allDeps.styles) {
+    delete allDeps.preload[style];
+    delete allDeps.prefetch[style];
+  }
+  rendererContext._dependencySets[cacheKey] = allDeps;
+  return allDeps;
+}
+function getRequestDependencies(ssrContext, rendererContext) {
+  if (ssrContext._requestDependencies) {
+    return ssrContext._requestDependencies;
+  }
+  const ids = new Set(Array.from([
+    ...rendererContext._entrypoints,
+    ...ssrContext.modules || ssrContext._registeredComponents || []
+  ]));
+  const deps = getAllDependencies(ids, rendererContext);
+  ssrContext._requestDependencies = deps;
+  return deps;
+}
+function renderStyles(ssrContext, rendererContext) {
+  const { styles } = getRequestDependencies(ssrContext, rendererContext);
+  let result = "";
+  for (const key in styles) {
+    const resource = styles[key];
+    result += `<link rel="stylesheet" href="${rendererContext.buildAssetsURL(resource.file)}" crossorigin>`;
+  }
+  return result;
+}
+function getResources(ssrContext, rendererContext) {
+  return [...getPreloadLinks(ssrContext, rendererContext), ...getPrefetchLinks(ssrContext, rendererContext)];
+}
+function renderResourceHints(ssrContext, rendererContext) {
+  const { preload, prefetch } = getRequestDependencies(ssrContext, rendererContext);
+  let result = "";
+  for (const key in preload) {
+    const resource = preload[key];
+    const href = rendererContext.buildAssetsURL(resource.file);
+    const rel = resource.module ? "modulepreload" : "preload";
+    const crossorigin = resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? " crossorigin" : "";
+    if (resource.resourceType && resource.mimeType) {
+      result += `<link rel="${rel}" as="${resource.resourceType}" type="${resource.mimeType}"${crossorigin} href="${href}">`;
+    } else if (resource.resourceType) {
+      result += `<link rel="${rel}" as="${resource.resourceType}"${crossorigin} href="${href}">`;
+    } else {
+      result += `<link rel="${rel}"${crossorigin} href="${href}">`;
+    }
+  }
+  for (const key in prefetch) {
+    const resource = prefetch[key];
+    const href = rendererContext.buildAssetsURL(resource.file);
+    const crossorigin = resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? " crossorigin" : "";
+    if (resource.resourceType && resource.mimeType) {
+      result += `<link rel="prefetch" as="${resource.resourceType}" type="${resource.mimeType}"${crossorigin} href="${href}">`;
+    } else if (resource.resourceType) {
+      result += `<link rel="prefetch" as="${resource.resourceType}"${crossorigin} href="${href}">`;
+    } else {
+      result += `<link rel="prefetch"${crossorigin} href="${href}">`;
+    }
+  }
+  return result;
+}
+function renderResourceHeaders(ssrContext, rendererContext) {
+  const { preload, prefetch } = getRequestDependencies(ssrContext, rendererContext);
+  const links = [];
+  for (const key in preload) {
+    const resource = preload[key];
+    const href = rendererContext.buildAssetsURL(resource.file);
+    const rel = resource.module ? "modulepreload" : "preload";
+    let header = `<${href}>; rel="${rel}"`;
+    if (resource.resourceType) {
+      header += `; as="${resource.resourceType}"`;
+    }
+    if (resource.mimeType) {
+      header += `; type="${resource.mimeType}"`;
+    }
+    if (resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module) {
+      header += "; crossorigin";
+    }
+    links.push(header);
+  }
+  for (const key in prefetch) {
+    const resource = prefetch[key];
+    const href = rendererContext.buildAssetsURL(resource.file);
+    let header = `<${href}>; rel="prefetch"`;
+    if (resource.resourceType) {
+      header += `; as="${resource.resourceType}"`;
+    }
+    if (resource.mimeType) {
+      header += `; type="${resource.mimeType}"`;
+    }
+    if (resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module) {
+      header += "; crossorigin";
+    }
+    links.push(header);
+  }
+  return {
+    link: links.join(", ")
+  };
+}
+function getPreloadLinks(ssrContext, rendererContext) {
+  const { preload } = getRequestDependencies(ssrContext, rendererContext);
+  const result = [];
+  for (const key in preload) {
+    const resource = preload[key];
+    result.push({
+      rel: resource.module ? "modulepreload" : "preload",
+      as: resource.resourceType,
+      type: resource.mimeType ?? null,
+      crossorigin: resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+      href: rendererContext.buildAssetsURL(resource.file)
+    });
+  }
+  return result;
+}
+function getPrefetchLinks(ssrContext, rendererContext) {
+  const { prefetch } = getRequestDependencies(ssrContext, rendererContext);
+  const result = [];
+  for (const key in prefetch) {
+    const resource = prefetch[key];
+    result.push({
+      rel: "prefetch",
+      as: resource.resourceType,
+      type: resource.mimeType ?? null,
+      crossorigin: resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+      href: rendererContext.buildAssetsURL(resource.file)
+    });
+  }
+  return result;
+}
+function renderScripts(ssrContext, rendererContext) {
+  const { scripts } = getRequestDependencies(ssrContext, rendererContext);
+  let result = "";
+  for (const key in scripts) {
+    const resource = scripts[key];
+    if (resource.module) {
+      result += `<script type="module" src="${rendererContext.buildAssetsURL(resource.file)}" crossorigin><\/script>`;
+    } else {
+      result += `<script src="${rendererContext.buildAssetsURL(resource.file)}" defer crossorigin><\/script>`;
+    }
+  }
+  return result;
+}
+function createRenderer(createApp, renderOptions) {
+  const rendererContext = createRendererContext(renderOptions);
+  return {
+    rendererContext,
+    async renderToString(ssrContext) {
+      ssrContext._registeredComponents = ssrContext._registeredComponents || /* @__PURE__ */ new Set();
+      const _createApp = await Promise.resolve(createApp).then((r) => "default" in r ? r.default : r);
+      const app = await _createApp(ssrContext);
+      const html = await renderOptions.renderToString(app, ssrContext);
+      const wrap = (fn) => () => fn(ssrContext, rendererContext);
+      return {
+        html,
+        renderResourceHeaders: wrap(renderResourceHeaders),
+        renderResourceHints: wrap(renderResourceHints),
+        renderStyles: wrap(renderStyles),
+        renderScripts: wrap(renderScripts)
+      };
+    }
+  };
+}
+
+exports.createRenderer = createRenderer;
+exports.createRendererContext = createRendererContext;
+exports.getAllDependencies = getAllDependencies;
+exports.getModuleDependencies = getModuleDependencies;
+exports.getPrefetchLinks = getPrefetchLinks;
+exports.getPreloadLinks = getPreloadLinks;
+exports.getRequestDependencies = getRequestDependencies;
+exports.getResources = getResources;
+exports.renderResourceHeaders = renderResourceHeaders;
+exports.renderResourceHints = renderResourceHints;
+exports.renderScripts = renderScripts;
+exports.renderStyles = renderStyles;

Frontend-Learner/node_modules/vue-bundle-renderer/dist/runtime.d.cts

@@ -0,0 +1 @@
+export { a as ModuleDependencies, o as RenderFunction, b as RenderOptions, c as RendererContext, S as SSRContext, q as createRenderer, e as createRendererContext, f as getAllDependencies, g as getModuleDependencies, m as getPrefetchLinks, l as getPreloadLinks, h as getRequestDependencies, i as getResources, k as renderResourceHeaders, j as renderResourceHints, n as renderScripts, r as renderStyles } from './shared/vue-bundle-renderer.lFgxeLN7.cjs';

Frontend-Learner/node_modules/vue-bundle-renderer/dist/runtime.d.mts

@@ -0,0 +1 @@
+export { a as ModuleDependencies, o as RenderFunction, b as RenderOptions, c as RendererContext, S as SSRContext, q as createRenderer, e as createRendererContext, f as getAllDependencies, g as getModuleDependencies, m as getPrefetchLinks, l as getPreloadLinks, h as getRequestDependencies, i as getResources, k as renderResourceHeaders, j as renderResourceHints, n as renderScripts, r as renderStyles } from './shared/vue-bundle-renderer.lFgxeLN7.mjs';

Frontend-Learner/node_modules/vue-bundle-renderer/dist/runtime.d.ts

@@ -0,0 +1 @@
+export { a as ModuleDependencies, o as RenderFunction, b as RenderOptions, c as RendererContext, S as SSRContext, q as createRenderer, e as createRendererContext, f as getAllDependencies, g as getModuleDependencies, m as getPrefetchLinks, l as getPreloadLinks, h as getRequestDependencies, i as getResources, k as renderResourceHeaders, j as renderResourceHints, n as renderScripts, r as renderStyles } from './shared/vue-bundle-renderer.lFgxeLN7.js';

Frontend-Learner/node_modules/vue-bundle-renderer/dist/runtime.mjs

@@ -0,0 +1,301 @@
+import { withLeadingSlash } from 'ufo';
+
+function createRendererContext({ manifest, precomputed, buildAssetsURL }) {
+  if (!manifest && !precomputed) {
+    throw new Error("Either manifest or precomputed data must be provided");
+  }
+  const ctx = {
+    // Options
+    buildAssetsURL: buildAssetsURL || withLeadingSlash,
+    manifest,
+    precomputed,
+    updateManifest,
+    // Internal cache
+    _dependencies: {},
+    _dependencySets: {},
+    _entrypoints: []
+  };
+  function updateManifest(manifest2) {
+    const manifestEntries = Object.entries(manifest2);
+    ctx.manifest = manifest2;
+    ctx._dependencies = {};
+    ctx._dependencySets = {};
+    ctx._entrypoints = manifestEntries.filter((e) => e[1].isEntry).map(([module]) => module);
+  }
+  if (precomputed) {
+    ctx._dependencies = precomputed.dependencies;
+    ctx._entrypoints = precomputed.entrypoints;
+  } else if (manifest) {
+    updateManifest(manifest);
+  }
+  return ctx;
+}
+function getModuleDependencies(id, rendererContext) {
+  if (rendererContext._dependencies[id]) {
+    return rendererContext._dependencies[id];
+  }
+  const dependencies = rendererContext._dependencies[id] = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  if (!rendererContext.manifest) {
+    return dependencies;
+  }
+  const meta = rendererContext.manifest[id];
+  if (!meta) {
+    return dependencies;
+  }
+  if (meta.file) {
+    dependencies.preload[id] = meta;
+    if (meta.isEntry || meta.sideEffects) {
+      dependencies.scripts[id] = meta;
+    }
+  }
+  for (const css of meta.css || []) {
+    dependencies.styles[css] = dependencies.preload[css] = dependencies.prefetch[css] = rendererContext.manifest[css];
+  }
+  for (const asset of meta.assets || []) {
+    dependencies.preload[asset] = dependencies.prefetch[asset] = rendererContext.manifest[asset];
+  }
+  for (const depId of meta.imports || []) {
+    const depDeps = getModuleDependencies(depId, rendererContext);
+    for (const key in depDeps.styles) {
+      dependencies.styles[key] = depDeps.styles[key];
+    }
+    for (const key in depDeps.preload) {
+      dependencies.preload[key] = depDeps.preload[key];
+    }
+    for (const key in depDeps.prefetch) {
+      dependencies.prefetch[key] = depDeps.prefetch[key];
+    }
+  }
+  const filteredPreload = {};
+  for (const id2 in dependencies.preload) {
+    const dep = dependencies.preload[id2];
+    if (dep.preload) {
+      filteredPreload[id2] = dep;
+    }
+  }
+  dependencies.preload = filteredPreload;
+  return dependencies;
+}
+function getAllDependencies(ids, rendererContext) {
+  let cacheKey = "";
+  const sortedIds = [...ids].sort();
+  for (let i = 0; i < sortedIds.length; i++) {
+    if (i > 0) cacheKey += ",";
+    cacheKey += sortedIds[i];
+  }
+  if (rendererContext._dependencySets[cacheKey]) {
+    return rendererContext._dependencySets[cacheKey];
+  }
+  const allDeps = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  for (const id of ids) {
+    const deps = getModuleDependencies(id, rendererContext);
+    for (const key in deps.scripts) {
+      allDeps.scripts[key] = deps.scripts[key];
+    }
+    for (const key in deps.styles) {
+      allDeps.styles[key] = deps.styles[key];
+    }
+    for (const key in deps.preload) {
+      allDeps.preload[key] = deps.preload[key];
+    }
+    for (const key in deps.prefetch) {
+      allDeps.prefetch[key] = deps.prefetch[key];
+    }
+    for (const dynamicDepId of rendererContext.manifest?.[id]?.dynamicImports || []) {
+      const dynamicDeps = getModuleDependencies(dynamicDepId, rendererContext);
+      for (const key in dynamicDeps.scripts) {
+        allDeps.prefetch[key] = dynamicDeps.scripts[key];
+      }
+      for (const key in dynamicDeps.styles) {
+        allDeps.prefetch[key] = dynamicDeps.styles[key];
+      }
+      for (const key in dynamicDeps.preload) {
+        allDeps.prefetch[key] = dynamicDeps.preload[key];
+      }
+    }
+  }
+  const filteredPrefetch = {};
+  for (const id in allDeps.prefetch) {
+    const dep = allDeps.prefetch[id];
+    if (dep.prefetch) {
+      filteredPrefetch[id] = dep;
+    }
+  }
+  allDeps.prefetch = filteredPrefetch;
+  for (const id in allDeps.preload) {
+    delete allDeps.prefetch[id];
+  }
+  for (const style in allDeps.styles) {
+    delete allDeps.preload[style];
+    delete allDeps.prefetch[style];
+  }
+  rendererContext._dependencySets[cacheKey] = allDeps;
+  return allDeps;
+}
+function getRequestDependencies(ssrContext, rendererContext) {
+  if (ssrContext._requestDependencies) {
+    return ssrContext._requestDependencies;
+  }
+  const ids = new Set(Array.from([
+    ...rendererContext._entrypoints,
+    ...ssrContext.modules || ssrContext._registeredComponents || []
+  ]));
+  const deps = getAllDependencies(ids, rendererContext);
+  ssrContext._requestDependencies = deps;
+  return deps;
+}
+function renderStyles(ssrContext, rendererContext) {
+  const { styles } = getRequestDependencies(ssrContext, rendererContext);
+  let result = "";
+  for (const key in styles) {
+    const resource = styles[key];
+    result += `<link rel="stylesheet" href="${rendererContext.buildAssetsURL(resource.file)}" crossorigin>`;
+  }
+  return result;
+}
+function getResources(ssrContext, rendererContext) {
+  return [...getPreloadLinks(ssrContext, rendererContext), ...getPrefetchLinks(ssrContext, rendererContext)];
+}
+function renderResourceHints(ssrContext, rendererContext) {
+  const { preload, prefetch } = getRequestDependencies(ssrContext, rendererContext);
+  let result = "";
+  for (const key in preload) {
+    const resource = preload[key];
+    const href = rendererContext.buildAssetsURL(resource.file);
+    const rel = resource.module ? "modulepreload" : "preload";
+    const crossorigin = resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? " crossorigin" : "";
+    if (resource.resourceType && resource.mimeType) {
+      result += `<link rel="${rel}" as="${resource.resourceType}" type="${resource.mimeType}"${crossorigin} href="${href}">`;
+    } else if (resource.resourceType) {
+      result += `<link rel="${rel}" as="${resource.resourceType}"${crossorigin} href="${href}">`;
+    } else {
+      result += `<link rel="${rel}"${crossorigin} href="${href}">`;
+    }
+  }
+  for (const key in prefetch) {
+    const resource = prefetch[key];
+    const href = rendererContext.buildAssetsURL(resource.file);
+    const crossorigin = resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? " crossorigin" : "";
+    if (resource.resourceType && resource.mimeType) {
+      result += `<link rel="prefetch" as="${resource.resourceType}" type="${resource.mimeType}"${crossorigin} href="${href}">`;
+    } else if (resource.resourceType) {
+      result += `<link rel="prefetch" as="${resource.resourceType}"${crossorigin} href="${href}">`;
+    } else {
+      result += `<link rel="prefetch"${crossorigin} href="${href}">`;
+    }
+  }
+  return result;
+}
+function renderResourceHeaders(ssrContext, rendererContext) {
+  const { preload, prefetch } = getRequestDependencies(ssrContext, rendererContext);
+  const links = [];
+  for (const key in preload) {
+    const resource = preload[key];
+    const href = rendererContext.buildAssetsURL(resource.file);
+    const rel = resource.module ? "modulepreload" : "preload";
+    let header = `<${href}>; rel="${rel}"`;
+    if (resource.resourceType) {
+      header += `; as="${resource.resourceType}"`;
+    }
+    if (resource.mimeType) {
+      header += `; type="${resource.mimeType}"`;
+    }
+    if (resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module) {
+      header += "; crossorigin";
+    }
+    links.push(header);
+  }
+  for (const key in prefetch) {
+    const resource = prefetch[key];
+    const href = rendererContext.buildAssetsURL(resource.file);
+    let header = `<${href}>; rel="prefetch"`;
+    if (resource.resourceType) {
+      header += `; as="${resource.resourceType}"`;
+    }
+    if (resource.mimeType) {
+      header += `; type="${resource.mimeType}"`;
+    }
+    if (resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module) {
+      header += "; crossorigin";
+    }
+    links.push(header);
+  }
+  return {
+    link: links.join(", ")
+  };
+}
+function getPreloadLinks(ssrContext, rendererContext) {
+  const { preload } = getRequestDependencies(ssrContext, rendererContext);
+  const result = [];
+  for (const key in preload) {
+    const resource = preload[key];
+    result.push({
+      rel: resource.module ? "modulepreload" : "preload",
+      as: resource.resourceType,
+      type: resource.mimeType ?? null,
+      crossorigin: resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+      href: rendererContext.buildAssetsURL(resource.file)
+    });
+  }
+  return result;
+}
+function getPrefetchLinks(ssrContext, rendererContext) {
+  const { prefetch } = getRequestDependencies(ssrContext, rendererContext);
+  const result = [];
+  for (const key in prefetch) {
+    const resource = prefetch[key];
+    result.push({
+      rel: "prefetch",
+      as: resource.resourceType,
+      type: resource.mimeType ?? null,
+      crossorigin: resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+      href: rendererContext.buildAssetsURL(resource.file)
+    });
+  }
+  return result;
+}
+function renderScripts(ssrContext, rendererContext) {
+  const { scripts } = getRequestDependencies(ssrContext, rendererContext);
+  let result = "";
+  for (const key in scripts) {
+    const resource = scripts[key];
+    if (resource.module) {
+      result += `<script type="module" src="${rendererContext.buildAssetsURL(resource.file)}" crossorigin><\/script>`;
+    } else {
+      result += `<script src="${rendererContext.buildAssetsURL(resource.file)}" defer crossorigin><\/script>`;
+    }
+  }
+  return result;
+}
+function createRenderer(createApp, renderOptions) {
+  const rendererContext = createRendererContext(renderOptions);
+  return {
+    rendererContext,
+    async renderToString(ssrContext) {
+      ssrContext._registeredComponents = ssrContext._registeredComponents || /* @__PURE__ */ new Set();
+      const _createApp = await Promise.resolve(createApp).then((r) => "default" in r ? r.default : r);
+      const app = await _createApp(ssrContext);
+      const html = await renderOptions.renderToString(app, ssrContext);
+      const wrap = (fn) => () => fn(ssrContext, rendererContext);
+      return {
+        html,
+        renderResourceHeaders: wrap(renderResourceHeaders),
+        renderResourceHints: wrap(renderResourceHints),
+        renderStyles: wrap(renderStyles),
+        renderScripts: wrap(renderScripts)
+      };
+    }
+  };
+}
+
+export { createRenderer, createRendererContext, getAllDependencies, getModuleDependencies, getPrefetchLinks, getPreloadLinks, getRequestDependencies, getResources, renderResourceHeaders, renderResourceHints, renderScripts, renderStyles };

Frontend-Learner/node_modules/vue-bundle-renderer/dist/shared/vue-bundle-renderer.lFgxeLN7.d.cts

@@ -0,0 +1,112 @@
+interface ResourceMeta {
+    src?: string;
+    file: string;
+    css?: string[];
+    assets?: string[];
+    isEntry?: boolean;
+    name?: string;
+    names?: string[];
+    isDynamicEntry?: boolean;
+    sideEffects?: boolean;
+    imports?: string[];
+    dynamicImports?: string[];
+    module?: boolean;
+    prefetch?: boolean;
+    preload?: boolean;
+    resourceType?: 'audio' | 'document' | 'embed' | 'fetch' | 'font' | 'image' | 'object' | 'script' | 'style' | 'track' | 'worker' | 'video';
+    mimeType?: string;
+}
+interface Manifest {
+    [key: string]: ResourceMeta;
+}
+declare function defineManifest(manifest: Manifest): Manifest;
+
+interface ModuleDependencies {
+    scripts: Record<string, ResourceMeta>;
+    styles: Record<string, ResourceMeta>;
+    preload: Record<string, ResourceMeta>;
+    prefetch: Record<string, ResourceMeta>;
+}
+interface SSRContext {
+    renderResourceHints?: (...args: unknown[]) => unknown;
+    renderScripts?: (...args: unknown[]) => unknown;
+    renderStyles?: (...args: unknown[]) => unknown;
+    modules?: Set<string>;
+    _registeredComponents?: Set<string>;
+    _requestDependencies?: ModuleDependencies;
+    [key: string]: unknown;
+}
+interface RenderOptions {
+    buildAssetsURL?: (id: string) => string;
+    /** @deprecated Use `precomputed` instead for better performance */
+    manifest?: Manifest;
+    /** Precomputed dependency data */
+    precomputed?: PrecomputedData;
+}
+interface RendererContext {
+    buildAssetsURL: (id: string) => string;
+    manifest?: Manifest;
+    precomputed?: PrecomputedData;
+    _dependencies: Record<string, ModuleDependencies>;
+    _dependencySets: Record<string, ModuleDependencies>;
+    _entrypoints: string[];
+    updateManifest: (manifest: Manifest) => void;
+}
+interface LinkAttributes {
+    rel: string | null;
+    href: string;
+    as?: string | null;
+    type?: string | null;
+    crossorigin?: '' | null;
+}
+declare function createRendererContext({ manifest, precomputed, buildAssetsURL }: RenderOptions): RendererContext;
+declare function getModuleDependencies(id: string, rendererContext: RendererContext): ModuleDependencies;
+declare function getAllDependencies(ids: Set<string>, rendererContext: RendererContext): ModuleDependencies;
+declare function getRequestDependencies(ssrContext: SSRContext, rendererContext: RendererContext): ModuleDependencies;
+declare function renderStyles(ssrContext: SSRContext, rendererContext: RendererContext): string;
+declare function getResources(ssrContext: SSRContext, rendererContext: RendererContext): LinkAttributes[];
+declare function renderResourceHints(ssrContext: SSRContext, rendererContext: RendererContext): string;
+declare function renderResourceHeaders(ssrContext: SSRContext, rendererContext: RendererContext): Record<string, string>;
+declare function getPreloadLinks(ssrContext: SSRContext, rendererContext: RendererContext): LinkAttributes[];
+declare function getPrefetchLinks(ssrContext: SSRContext, rendererContext: RendererContext): LinkAttributes[];
+declare function renderScripts(ssrContext: SSRContext, rendererContext: RendererContext): string;
+type RenderFunction = (ssrContext: SSRContext, rendererContext: RendererContext) => unknown;
+type CreateApp<App> = (ssrContext: SSRContext) => App | Promise<App>;
+type ImportOf<T> = T | {
+    default: T;
+} | Promise<T> | Promise<{
+    default: T;
+}>;
+type RenderToString<App> = (app: App, ssrContext: SSRContext) => string | Promise<string>;
+declare function createRenderer<App>(createApp: ImportOf<CreateApp<App>>, renderOptions: RenderOptions & {
+    renderToString: RenderToString<App>;
+}): {
+    rendererContext: RendererContext;
+    renderToString(ssrContext: SSRContext): Promise<{
+        html: string;
+        renderResourceHeaders: () => Record<string, string>;
+        renderResourceHints: () => string;
+        renderStyles: () => string;
+        renderScripts: () => string;
+    }>;
+};
+
+interface PrecomputedData {
+    /** Pre-resolved dependencies for each module */
+    dependencies: Record<string, ModuleDependencies>;
+    /** List of entry point module IDs */
+    entrypoints: string[];
+    /** Module metadata needed at runtime (file paths, etc.) */
+    modules: Record<string, Pick<ResourceMeta, 'file' | 'resourceType' | 'mimeType' | 'module'>>;
+}
+/**
+ * Build-time utility to precompute all module dependencies from a manifest.
+ * This eliminates recursive dependency resolution at runtime.
+ *
+ * @param manifest The build manifest
+ * @returns Serializable precomputed data for runtime use
+ */
+declare function precomputeDependencies(manifest: Manifest): PrecomputedData;
+
+export { defineManifest as d, createRendererContext as e, getAllDependencies as f, getModuleDependencies as g, getRequestDependencies as h, getResources as i, renderResourceHints as j, renderResourceHeaders as k, getPreloadLinks as l, getPrefetchLinks as m, renderScripts as n, precomputeDependencies as p, createRenderer as q, renderStyles as r };
+export type { Manifest as M, PrecomputedData as P, ResourceMeta as R, SSRContext as S, ModuleDependencies as a, RenderOptions as b, RendererContext as c, RenderFunction as o };

Frontend-Learner/node_modules/vue-bundle-renderer/dist/shared/vue-bundle-renderer.lFgxeLN7.d.mts

@@ -0,0 +1,112 @@
+interface ResourceMeta {
+    src?: string;
+    file: string;
+    css?: string[];
+    assets?: string[];
+    isEntry?: boolean;
+    name?: string;
+    names?: string[];
+    isDynamicEntry?: boolean;
+    sideEffects?: boolean;
+    imports?: string[];
+    dynamicImports?: string[];
+    module?: boolean;
+    prefetch?: boolean;
+    preload?: boolean;
+    resourceType?: 'audio' | 'document' | 'embed' | 'fetch' | 'font' | 'image' | 'object' | 'script' | 'style' | 'track' | 'worker' | 'video';
+    mimeType?: string;
+}
+interface Manifest {
+    [key: string]: ResourceMeta;
+}
+declare function defineManifest(manifest: Manifest): Manifest;
+
+interface ModuleDependencies {
+    scripts: Record<string, ResourceMeta>;
+    styles: Record<string, ResourceMeta>;
+    preload: Record<string, ResourceMeta>;
+    prefetch: Record<string, ResourceMeta>;
+}
+interface SSRContext {
+    renderResourceHints?: (...args: unknown[]) => unknown;
+    renderScripts?: (...args: unknown[]) => unknown;
+    renderStyles?: (...args: unknown[]) => unknown;
+    modules?: Set<string>;
+    _registeredComponents?: Set<string>;
+    _requestDependencies?: ModuleDependencies;
+    [key: string]: unknown;
+}
+interface RenderOptions {
+    buildAssetsURL?: (id: string) => string;
+    /** @deprecated Use `precomputed` instead for better performance */
+    manifest?: Manifest;
+    /** Precomputed dependency data */
+    precomputed?: PrecomputedData;
+}
+interface RendererContext {
+    buildAssetsURL: (id: string) => string;
+    manifest?: Manifest;
+    precomputed?: PrecomputedData;
+    _dependencies: Record<string, ModuleDependencies>;
+    _dependencySets: Record<string, ModuleDependencies>;
+    _entrypoints: string[];
+    updateManifest: (manifest: Manifest) => void;
+}
+interface LinkAttributes {
+    rel: string | null;
+    href: string;
+    as?: string | null;
+    type?: string | null;
+    crossorigin?: '' | null;
+}
+declare function createRendererContext({ manifest, precomputed, buildAssetsURL }: RenderOptions): RendererContext;
+declare function getModuleDependencies(id: string, rendererContext: RendererContext): ModuleDependencies;
+declare function getAllDependencies(ids: Set<string>, rendererContext: RendererContext): ModuleDependencies;
+declare function getRequestDependencies(ssrContext: SSRContext, rendererContext: RendererContext): ModuleDependencies;
+declare function renderStyles(ssrContext: SSRContext, rendererContext: RendererContext): string;
+declare function getResources(ssrContext: SSRContext, rendererContext: RendererContext): LinkAttributes[];
+declare function renderResourceHints(ssrContext: SSRContext, rendererContext: RendererContext): string;
+declare function renderResourceHeaders(ssrContext: SSRContext, rendererContext: RendererContext): Record<string, string>;
+declare function getPreloadLinks(ssrContext: SSRContext, rendererContext: RendererContext): LinkAttributes[];
+declare function getPrefetchLinks(ssrContext: SSRContext, rendererContext: RendererContext): LinkAttributes[];
+declare function renderScripts(ssrContext: SSRContext, rendererContext: RendererContext): string;
+type RenderFunction = (ssrContext: SSRContext, rendererContext: RendererContext) => unknown;
+type CreateApp<App> = (ssrContext: SSRContext) => App | Promise<App>;
+type ImportOf<T> = T | {
+    default: T;
+} | Promise<T> | Promise<{
+    default: T;
+}>;
+type RenderToString<App> = (app: App, ssrContext: SSRContext) => string | Promise<string>;
+declare function createRenderer<App>(createApp: ImportOf<CreateApp<App>>, renderOptions: RenderOptions & {
+    renderToString: RenderToString<App>;
+}): {
+    rendererContext: RendererContext;
+    renderToString(ssrContext: SSRContext): Promise<{
+        html: string;
+        renderResourceHeaders: () => Record<string, string>;
+        renderResourceHints: () => string;
+        renderStyles: () => string;
+        renderScripts: () => string;
+    }>;
+};
+
+interface PrecomputedData {
+    /** Pre-resolved dependencies for each module */
+    dependencies: Record<string, ModuleDependencies>;
+    /** List of entry point module IDs */
+    entrypoints: string[];
+    /** Module metadata needed at runtime (file paths, etc.) */
+    modules: Record<string, Pick<ResourceMeta, 'file' | 'resourceType' | 'mimeType' | 'module'>>;
+}
+/**
+ * Build-time utility to precompute all module dependencies from a manifest.
+ * This eliminates recursive dependency resolution at runtime.
+ *
+ * @param manifest The build manifest
+ * @returns Serializable precomputed data for runtime use
+ */
+declare function precomputeDependencies(manifest: Manifest): PrecomputedData;
+
+export { defineManifest as d, createRendererContext as e, getAllDependencies as f, getModuleDependencies as g, getRequestDependencies as h, getResources as i, renderResourceHints as j, renderResourceHeaders as k, getPreloadLinks as l, getPrefetchLinks as m, renderScripts as n, precomputeDependencies as p, createRenderer as q, renderStyles as r };
+export type { Manifest as M, PrecomputedData as P, ResourceMeta as R, SSRContext as S, ModuleDependencies as a, RenderOptions as b, RendererContext as c, RenderFunction as o };

Frontend-Learner/node_modules/vue-bundle-renderer/dist/shared/vue-bundle-renderer.lFgxeLN7.d.ts

@@ -0,0 +1,112 @@
+interface ResourceMeta {
+    src?: string;
+    file: string;
+    css?: string[];
+    assets?: string[];
+    isEntry?: boolean;
+    name?: string;
+    names?: string[];
+    isDynamicEntry?: boolean;
+    sideEffects?: boolean;
+    imports?: string[];
+    dynamicImports?: string[];
+    module?: boolean;
+    prefetch?: boolean;
+    preload?: boolean;
+    resourceType?: 'audio' | 'document' | 'embed' | 'fetch' | 'font' | 'image' | 'object' | 'script' | 'style' | 'track' | 'worker' | 'video';
+    mimeType?: string;
+}
+interface Manifest {
+    [key: string]: ResourceMeta;
+}
+declare function defineManifest(manifest: Manifest): Manifest;
+
+interface ModuleDependencies {
+    scripts: Record<string, ResourceMeta>;
+    styles: Record<string, ResourceMeta>;
+    preload: Record<string, ResourceMeta>;
+    prefetch: Record<string, ResourceMeta>;
+}
+interface SSRContext {
+    renderResourceHints?: (...args: unknown[]) => unknown;
+    renderScripts?: (...args: unknown[]) => unknown;
+    renderStyles?: (...args: unknown[]) => unknown;
+    modules?: Set<string>;
+    _registeredComponents?: Set<string>;
+    _requestDependencies?: ModuleDependencies;
+    [key: string]: unknown;
+}
+interface RenderOptions {
+    buildAssetsURL?: (id: string) => string;
+    /** @deprecated Use `precomputed` instead for better performance */
+    manifest?: Manifest;
+    /** Precomputed dependency data */
+    precomputed?: PrecomputedData;
+}
+interface RendererContext {
+    buildAssetsURL: (id: string) => string;
+    manifest?: Manifest;
+    precomputed?: PrecomputedData;
+    _dependencies: Record<string, ModuleDependencies>;
+    _dependencySets: Record<string, ModuleDependencies>;
+    _entrypoints: string[];
+    updateManifest: (manifest: Manifest) => void;
+}
+interface LinkAttributes {
+    rel: string | null;
+    href: string;
+    as?: string | null;
+    type?: string | null;
+    crossorigin?: '' | null;
+}
+declare function createRendererContext({ manifest, precomputed, buildAssetsURL }: RenderOptions): RendererContext;
+declare function getModuleDependencies(id: string, rendererContext: RendererContext): ModuleDependencies;
+declare function getAllDependencies(ids: Set<string>, rendererContext: RendererContext): ModuleDependencies;
+declare function getRequestDependencies(ssrContext: SSRContext, rendererContext: RendererContext): ModuleDependencies;
+declare function renderStyles(ssrContext: SSRContext, rendererContext: RendererContext): string;
+declare function getResources(ssrContext: SSRContext, rendererContext: RendererContext): LinkAttributes[];
+declare function renderResourceHints(ssrContext: SSRContext, rendererContext: RendererContext): string;
+declare function renderResourceHeaders(ssrContext: SSRContext, rendererContext: RendererContext): Record<string, string>;
+declare function getPreloadLinks(ssrContext: SSRContext, rendererContext: RendererContext): LinkAttributes[];
+declare function getPrefetchLinks(ssrContext: SSRContext, rendererContext: RendererContext): LinkAttributes[];
+declare function renderScripts(ssrContext: SSRContext, rendererContext: RendererContext): string;
+type RenderFunction = (ssrContext: SSRContext, rendererContext: RendererContext) => unknown;
+type CreateApp<App> = (ssrContext: SSRContext) => App | Promise<App>;
+type ImportOf<T> = T | {
+    default: T;
+} | Promise<T> | Promise<{
+    default: T;
+}>;
+type RenderToString<App> = (app: App, ssrContext: SSRContext) => string | Promise<string>;
+declare function createRenderer<App>(createApp: ImportOf<CreateApp<App>>, renderOptions: RenderOptions & {
+    renderToString: RenderToString<App>;
+}): {
+    rendererContext: RendererContext;
+    renderToString(ssrContext: SSRContext): Promise<{
+        html: string;
+        renderResourceHeaders: () => Record<string, string>;
+        renderResourceHints: () => string;
+        renderStyles: () => string;
+        renderScripts: () => string;
+    }>;
+};
+
+interface PrecomputedData {
+    /** Pre-resolved dependencies for each module */
+    dependencies: Record<string, ModuleDependencies>;
+    /** List of entry point module IDs */
+    entrypoints: string[];
+    /** Module metadata needed at runtime (file paths, etc.) */
+    modules: Record<string, Pick<ResourceMeta, 'file' | 'resourceType' | 'mimeType' | 'module'>>;
+}
+/**
+ * Build-time utility to precompute all module dependencies from a manifest.
+ * This eliminates recursive dependency resolution at runtime.
+ *
+ * @param manifest The build manifest
+ * @returns Serializable precomputed data for runtime use
+ */
+declare function precomputeDependencies(manifest: Manifest): PrecomputedData;
+
+export { defineManifest as d, createRendererContext as e, getAllDependencies as f, getModuleDependencies as g, getRequestDependencies as h, getResources as i, renderResourceHints as j, renderResourceHeaders as k, getPreloadLinks as l, getPrefetchLinks as m, renderScripts as n, precomputeDependencies as p, createRenderer as q, renderStyles as r };
+export type { Manifest as M, PrecomputedData as P, ResourceMeta as R, SSRContext as S, ModuleDependencies as a, RenderOptions as b, RendererContext as c, RenderFunction as o };

Frontend-Learner/node_modules/vue-bundle-renderer/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "vue-bundle-renderer",
+  "version": "2.2.0",
+  "description": "Bundle Renderer for Vue 3.0",
+  "repository": "nuxt-contrib/vue-bundle-renderer",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.mjs",
+      "require": "./dist/runtime.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "runtime.d.ts"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint src",
+    "prepack": "unbuild",
+    "test": "pnpm lint && pnpm vitest run --coverage && tsc --noEmit",
+    "bench": "vitest bench"
+  },
+  "dependencies": {
+    "ufo": "^1.6.1"
+  },
+  "devDependencies": {
+    "@codspeed/vitest-plugin": "^5.0.0",
+    "@nuxt/eslint-config": "^1.9.0",
+    "@types/node": "^22.18.6",
+    "@types/semver": "^7.7.1",
+    "@vitest/coverage-v8": "^3.2.4",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.36.0",
+    "pkg-pr-new": "^0.0.60",
+    "semver": "^7.7.2",
+    "std-env": "^3.9.0",
+    "typescript": "^5.9.2",
+    "unbuild": "^3.6.1",
+    "vite": "^7.1.7",
+    "vitest": "3.2.4",
+    "vue": "3.5.22"
+  },
+  "packageManager": "pnpm@10.17.1"
+}

Frontend-Learner/node_modules/vue-bundle-renderer/runtime.d.ts

@@ -0,0 +1 @@
+export * from './dist/runtime'