initial commit

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

@@ -0,0 +1,169 @@
+'use strict';
+
+const IS_JS_RE = /\.[cm]?js(\?[^.]+)?$/;
+const HAS_EXT_RE = /[^./]+\.[^./]+$/;
+const IS_CSS_RE = /\.(css|postcss|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|m3u8$/;
+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;
+    }
+  }
+  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[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 defineManifest(manifest) {
+  return manifest;
+}
+
+exports.defineManifest = defineManifest;
+exports.normalizeViteManifest = normalizeViteManifest;
+exports.normalizeWebpackManifest = normalizeWebpackManifest;

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

@@ -0,0 +1,21 @@
+import { Manifest } from 'vite';
+import { M as Manifest$1 } from './types-dfcc483f.js';
+export { M as Manifest, R as ResourceMeta, d as defineManifest } from './types-dfcc483f.js';
+
+declare function normalizeViteManifest(manifest: Manifest | Manifest$1): Manifest$1;
+
+declare type Identifier = string;
+declare 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 { normalizeViteManifest, normalizeWebpackManifest };

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

@@ -0,0 +1,165 @@
+const IS_JS_RE = /\.[cm]?js(\?[^.]+)?$/;
+const HAS_EXT_RE = /[^./]+\.[^./]+$/;
+const IS_CSS_RE = /\.(css|postcss|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|m3u8$/;
+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;
+    }
+  }
+  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[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 defineManifest(manifest) {
+  return manifest;
+}
+
+export { defineManifest, normalizeViteManifest, normalizeWebpackManifest };

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

@@ -0,0 +1,208 @@
+'use strict';
+
+const ufo = require('ufo');
+
+const defaultShouldPrefetch = (resource) => resource.resourceType !== "font";
+const defaultShouldPreload = (resource) => ["module", "script", "style"].includes(resource.resourceType || "");
+function createRendererContext({ manifest, buildAssetsURL, shouldPrefetch, shouldPreload }) {
+  const ctx = {
+    shouldPrefetch: shouldPrefetch || defaultShouldPrefetch,
+    shouldPreload: shouldPreload || defaultShouldPreload,
+    buildAssetsURL: buildAssetsURL || ufo.withLeadingSlash,
+    manifest: void 0,
+    updateManifest,
+    _dependencies: void 0,
+    _dependencySets: void 0,
+    _entrypoints: void 0
+  };
+  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);
+  }
+  updateManifest(manifest);
+  return ctx;
+}
+function getModuleDependencies(id, rendererContext) {
+  if (rendererContext._dependencies[id]) {
+    return rendererContext._dependencies[id];
+  }
+  const dependencies = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  const meta = rendererContext.manifest[id];
+  if (!meta) {
+    rendererContext._dependencies[id] = dependencies;
+    return dependencies;
+  }
+  if (meta.file) {
+    dependencies.scripts[id] = dependencies.preload[id] = rendererContext.manifest[id];
+  }
+  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);
+    Object.assign(dependencies.styles, depDeps.styles);
+    Object.assign(dependencies.preload, depDeps.preload);
+    Object.assign(dependencies.prefetch, depDeps.prefetch);
+  }
+  const filteredPreload = {};
+  for (const id2 in dependencies.preload) {
+    const dep = dependencies.preload[id2];
+    if (rendererContext.shouldPreload(dep)) {
+      filteredPreload[id2] = dep;
+    }
+  }
+  dependencies.preload = filteredPreload;
+  rendererContext._dependencies[id] = dependencies;
+  return dependencies;
+}
+function getAllDependencies(ids, rendererContext) {
+  const cacheKey = Array.from(ids).sort().join(",");
+  if (rendererContext._dependencySets[cacheKey]) {
+    return rendererContext._dependencySets[cacheKey];
+  }
+  const allDeps = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  for (const id of ids) {
+    const deps = getModuleDependencies(id, rendererContext);
+    Object.assign(allDeps.scripts, deps.scripts);
+    Object.assign(allDeps.styles, deps.styles);
+    Object.assign(allDeps.preload, deps.preload);
+    Object.assign(allDeps.prefetch, deps.prefetch);
+    for (const dynamicDepId of rendererContext.manifest[id]?.dynamicImports || []) {
+      const dynamicDeps = getModuleDependencies(dynamicDepId, rendererContext);
+      Object.assign(allDeps.prefetch, dynamicDeps.scripts);
+      Object.assign(allDeps.prefetch, dynamicDeps.styles);
+      Object.assign(allDeps.prefetch, dynamicDeps.preload);
+    }
+  }
+  const filteredPrefetch = {};
+  for (const id in allDeps.prefetch) {
+    const dep = allDeps.prefetch[id];
+    if (rendererContext.shouldPrefetch(dep)) {
+      filteredPrefetch[id] = dep;
+    }
+  }
+  allDeps.prefetch = filteredPrefetch;
+  for (const id in allDeps.prefetch) {
+    if (id in allDeps.preload) {
+      delete allDeps.prefetch[id];
+    }
+  }
+  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);
+  return Object.values(styles).map(
+    (resource) => renderLinkToString({ rel: "stylesheet", href: rendererContext.buildAssetsURL(resource.file) })
+  ).join("");
+}
+function getResources(ssrContext, rendererContext) {
+  return [...getPreloadLinks(ssrContext, rendererContext), ...getPrefetchLinks(ssrContext, rendererContext)];
+}
+function renderResourceHints(ssrContext, rendererContext) {
+  return getResources(ssrContext, rendererContext).map(renderLinkToString).join("");
+}
+function renderResourceHeaders(ssrContext, rendererContext) {
+  return {
+    link: getResources(ssrContext, rendererContext).map(renderLinkToHeader).join(", ")
+  };
+}
+function getPreloadLinks(ssrContext, rendererContext) {
+  const { preload } = getRequestDependencies(ssrContext, rendererContext);
+  return Object.values(preload).map((resource) => ({
+    rel: resource.module ? "modulepreload" : "preload",
+    as: resource.resourceType,
+    type: resource.mimeType ?? null,
+    crossorigin: resource.resourceType === "font" || resource.module ? "" : null,
+    href: rendererContext.buildAssetsURL(resource.file)
+  }));
+}
+function getPrefetchLinks(ssrContext, rendererContext) {
+  const { prefetch } = getRequestDependencies(ssrContext, rendererContext);
+  return Object.values(prefetch).map((resource) => ({
+    rel: "prefetch",
+    as: resource.resourceType,
+    type: resource.mimeType ?? null,
+    crossorigin: resource.resourceType === "font" || resource.module ? "" : null,
+    href: rendererContext.buildAssetsURL(resource.file)
+  }));
+}
+function renderScripts(ssrContext, rendererContext) {
+  const { scripts } = getRequestDependencies(ssrContext, rendererContext);
+  return Object.values(scripts).map((resource) => renderScriptToString({
+    type: resource.module ? "module" : null,
+    src: rendererContext.buildAssetsURL(resource.file),
+    defer: resource.module ? null : "",
+    crossorigin: ""
+  })).join("");
+}
+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) => 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)
+      };
+    }
+  };
+}
+function renderScriptToString(attrs) {
+  return `<script${Object.entries(attrs).map(([key, value]) => value === null ? "" : value ? ` ${key}="${value}"` : " " + key).join("")}><\/script>`;
+}
+function renderLinkToString(attrs) {
+  return `<link${Object.entries(attrs).map(([key, value]) => value === null ? "" : value ? ` ${key}="${value}"` : " " + key).join("")}>`;
+}
+function renderLinkToHeader(attrs) {
+  return `<${attrs.href}>${Object.entries(attrs).map(([key, value]) => key === "href" || value === null ? "" : value ? `; ${key}="${value}"` : `; ${key}`).join("")}`;
+}
+
+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;

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

@@ -0,0 +1,62 @@
+import { R as ResourceMeta, M as Manifest } from './types-dfcc483f.js';
+
+interface ModuleDependencies {
+    scripts: Record<string, ResourceMeta>;
+    styles: Record<string, ResourceMeta>;
+    preload: Record<string, ResourceMeta>;
+    prefetch: Record<string, ResourceMeta>;
+}
+interface SSRContext {
+    renderResourceHints?: Function;
+    renderScripts?: Function;
+    renderStyles?: Function;
+    modules?: Set<string>;
+    _registeredComponents?: Set<string>;
+    _requestDependencies?: ModuleDependencies;
+    [key: string]: any;
+}
+interface RenderOptions {
+    shouldPrefetch?: (resource: ResourceMeta) => boolean;
+    shouldPreload?: (resource: ResourceMeta) => boolean;
+    buildAssetsURL?: (id: string) => string;
+    manifest: Manifest;
+}
+interface RendererContext extends Required<RenderOptions> {
+    _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, buildAssetsURL, shouldPrefetch, shouldPreload }: 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;
+declare type RenderFunction = (ssrContext: SSRContext, rendererContext: RendererContext) => any;
+declare function createRenderer(createApp: any, renderOptions: RenderOptions & {
+    renderToString: Function;
+}): {
+    rendererContext: RendererContext;
+    renderToString(ssrContext: SSRContext): Promise<{
+        html: any;
+        renderResourceHeaders: () => Record<string, string>;
+        renderResourceHints: () => string;
+        renderStyles: () => string;
+        renderScripts: () => string;
+    }>;
+};
+
+export { ModuleDependencies, RenderFunction, RenderOptions, RendererContext, SSRContext, createRenderer, createRendererContext, getAllDependencies, getModuleDependencies, getPrefetchLinks, getPreloadLinks, getRequestDependencies, getResources, renderResourceHeaders, renderResourceHints, renderScripts, renderStyles };

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

@@ -0,0 +1,195 @@
+import { withLeadingSlash } from 'ufo';
+
+const defaultShouldPrefetch = (resource) => resource.resourceType !== "font";
+const defaultShouldPreload = (resource) => ["module", "script", "style"].includes(resource.resourceType || "");
+function createRendererContext({ manifest, buildAssetsURL, shouldPrefetch, shouldPreload }) {
+  const ctx = {
+    shouldPrefetch: shouldPrefetch || defaultShouldPrefetch,
+    shouldPreload: shouldPreload || defaultShouldPreload,
+    buildAssetsURL: buildAssetsURL || withLeadingSlash,
+    manifest: void 0,
+    updateManifest,
+    _dependencies: void 0,
+    _dependencySets: void 0,
+    _entrypoints: void 0
+  };
+  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);
+  }
+  updateManifest(manifest);
+  return ctx;
+}
+function getModuleDependencies(id, rendererContext) {
+  if (rendererContext._dependencies[id]) {
+    return rendererContext._dependencies[id];
+  }
+  const dependencies = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  const meta = rendererContext.manifest[id];
+  if (!meta) {
+    rendererContext._dependencies[id] = dependencies;
+    return dependencies;
+  }
+  if (meta.file) {
+    dependencies.scripts[id] = dependencies.preload[id] = rendererContext.manifest[id];
+  }
+  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);
+    Object.assign(dependencies.styles, depDeps.styles);
+    Object.assign(dependencies.preload, depDeps.preload);
+    Object.assign(dependencies.prefetch, depDeps.prefetch);
+  }
+  const filteredPreload = {};
+  for (const id2 in dependencies.preload) {
+    const dep = dependencies.preload[id2];
+    if (rendererContext.shouldPreload(dep)) {
+      filteredPreload[id2] = dep;
+    }
+  }
+  dependencies.preload = filteredPreload;
+  rendererContext._dependencies[id] = dependencies;
+  return dependencies;
+}
+function getAllDependencies(ids, rendererContext) {
+  const cacheKey = Array.from(ids).sort().join(",");
+  if (rendererContext._dependencySets[cacheKey]) {
+    return rendererContext._dependencySets[cacheKey];
+  }
+  const allDeps = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  for (const id of ids) {
+    const deps = getModuleDependencies(id, rendererContext);
+    Object.assign(allDeps.scripts, deps.scripts);
+    Object.assign(allDeps.styles, deps.styles);
+    Object.assign(allDeps.preload, deps.preload);
+    Object.assign(allDeps.prefetch, deps.prefetch);
+    for (const dynamicDepId of rendererContext.manifest[id]?.dynamicImports || []) {
+      const dynamicDeps = getModuleDependencies(dynamicDepId, rendererContext);
+      Object.assign(allDeps.prefetch, dynamicDeps.scripts);
+      Object.assign(allDeps.prefetch, dynamicDeps.styles);
+      Object.assign(allDeps.prefetch, dynamicDeps.preload);
+    }
+  }
+  const filteredPrefetch = {};
+  for (const id in allDeps.prefetch) {
+    const dep = allDeps.prefetch[id];
+    if (rendererContext.shouldPrefetch(dep)) {
+      filteredPrefetch[id] = dep;
+    }
+  }
+  allDeps.prefetch = filteredPrefetch;
+  for (const id in allDeps.prefetch) {
+    if (id in allDeps.preload) {
+      delete allDeps.prefetch[id];
+    }
+  }
+  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);
+  return Object.values(styles).map(
+    (resource) => renderLinkToString({ rel: "stylesheet", href: rendererContext.buildAssetsURL(resource.file) })
+  ).join("");
+}
+function getResources(ssrContext, rendererContext) {
+  return [...getPreloadLinks(ssrContext, rendererContext), ...getPrefetchLinks(ssrContext, rendererContext)];
+}
+function renderResourceHints(ssrContext, rendererContext) {
+  return getResources(ssrContext, rendererContext).map(renderLinkToString).join("");
+}
+function renderResourceHeaders(ssrContext, rendererContext) {
+  return {
+    link: getResources(ssrContext, rendererContext).map(renderLinkToHeader).join(", ")
+  };
+}
+function getPreloadLinks(ssrContext, rendererContext) {
+  const { preload } = getRequestDependencies(ssrContext, rendererContext);
+  return Object.values(preload).map((resource) => ({
+    rel: resource.module ? "modulepreload" : "preload",
+    as: resource.resourceType,
+    type: resource.mimeType ?? null,
+    crossorigin: resource.resourceType === "font" || resource.module ? "" : null,
+    href: rendererContext.buildAssetsURL(resource.file)
+  }));
+}
+function getPrefetchLinks(ssrContext, rendererContext) {
+  const { prefetch } = getRequestDependencies(ssrContext, rendererContext);
+  return Object.values(prefetch).map((resource) => ({
+    rel: "prefetch",
+    as: resource.resourceType,
+    type: resource.mimeType ?? null,
+    crossorigin: resource.resourceType === "font" || resource.module ? "" : null,
+    href: rendererContext.buildAssetsURL(resource.file)
+  }));
+}
+function renderScripts(ssrContext, rendererContext) {
+  const { scripts } = getRequestDependencies(ssrContext, rendererContext);
+  return Object.values(scripts).map((resource) => renderScriptToString({
+    type: resource.module ? "module" : null,
+    src: rendererContext.buildAssetsURL(resource.file),
+    defer: resource.module ? null : "",
+    crossorigin: ""
+  })).join("");
+}
+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) => 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)
+      };
+    }
+  };
+}
+function renderScriptToString(attrs) {
+  return `<script${Object.entries(attrs).map(([key, value]) => value === null ? "" : value ? ` ${key}="${value}"` : " " + key).join("")}><\/script>`;
+}
+function renderLinkToString(attrs) {
+  return `<link${Object.entries(attrs).map(([key, value]) => value === null ? "" : value ? ` ${key}="${value}"` : " " + key).join("")}>`;
+}
+function renderLinkToHeader(attrs) {
+  return `<${attrs.href}>${Object.entries(attrs).map(([key, value]) => key === "href" || value === null ? "" : value ? `; ${key}="${value}"` : `; ${key}`).join("")}`;
+}
+
+export { createRenderer, createRendererContext, getAllDependencies, getModuleDependencies, getPrefetchLinks, getPreloadLinks, getRequestDependencies, getResources, renderResourceHeaders, renderResourceHints, renderScripts, renderStyles };

node_modules/vue-bundle-renderer/dist/types-dfcc483f.d.ts

@@ -0,0 +1,19 @@
+interface ResourceMeta {
+    src?: string;
+    file: string;
+    css?: string[];
+    assets?: string[];
+    isEntry?: boolean;
+    isDynamicEntry?: boolean;
+    imports?: string[];
+    dynamicImports?: string[];
+    module?: 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;
+
+export { Manifest as M, ResourceMeta as R, defineManifest as d };