penambahan web socket

examples/nuxt3-websocket-client/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.

examples/nuxt3-websocket-client/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

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/dist/index.cjs

@@ -0,0 +1,176 @@
+'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 defineManifest(manifest) {
+  return manifest;
+}
+
+exports.defineManifest = defineManifest;
+exports.normalizeViteManifest = normalizeViteManifest;
+exports.normalizeWebpackManifest = normalizeWebpackManifest;

examples/nuxt3-websocket-client/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.DITmAFNH.cjs';
+export { R as ResourceMeta, d as defineManifest } from './shared/vue-bundle-renderer.DITmAFNH.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 };

examples/nuxt3-websocket-client/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.DITmAFNH.mjs';
+export { R as ResourceMeta, d as defineManifest } from './shared/vue-bundle-renderer.DITmAFNH.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 };

examples/nuxt3-websocket-client/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.DITmAFNH.js';
+export { R as ResourceMeta, d as defineManifest } from './shared/vue-bundle-renderer.DITmAFNH.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 };

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/dist/index.mjs

@@ -0,0 +1,172 @@
+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 defineManifest(manifest) {
+  return manifest;
+}
+
+export { defineManifest, normalizeViteManifest, normalizeWebpackManifest };

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/dist/runtime.cjs

@@ -0,0 +1,209 @@
+'use strict';
+
+const ufo = require('ufo');
+
+function createRendererContext({ manifest, buildAssetsURL }) {
+  const ctx = {
+    // Manifest
+    buildAssetsURL: buildAssetsURL || ufo.withLeadingSlash,
+    manifest: void 0,
+    updateManifest,
+    // Internal cache
+    _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 = rendererContext._dependencies[id] = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  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);
+    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 (dep.preload) {
+      filteredPreload[id2] = dep;
+    }
+  }
+  dependencies.preload = filteredPreload;
+  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 (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);
+  return Object.values(styles).map(
+    (resource) => renderLinkToString({ rel: "stylesheet", href: rendererContext.buildAssetsURL(resource.file), crossorigin: "" })
+  ).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 === "style" || resource.resourceType === "font" || resource.resourceType === "script" || 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 === "style" || resource.resourceType === "font" || resource.resourceType === "script" || 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) => "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)
+      };
+    }
+  };
+}
+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;

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/dist/runtime.d.cts

@@ -0,0 +1,68 @@
+import { R as ResourceMeta, M as Manifest } from './shared/vue-bundle-renderer.DITmAFNH.cjs';
+
+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;
+    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 }: 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;
+    }>;
+};
+
+export { createRenderer, createRendererContext, getAllDependencies, getModuleDependencies, getPrefetchLinks, getPreloadLinks, getRequestDependencies, getResources, renderResourceHeaders, renderResourceHints, renderScripts, renderStyles };
+export type { ModuleDependencies, RenderFunction, RenderOptions, RendererContext, SSRContext };

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/dist/runtime.d.mts

@@ -0,0 +1,68 @@
+import { R as ResourceMeta, M as Manifest } from './shared/vue-bundle-renderer.DITmAFNH.mjs';
+
+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;
+    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 }: 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;
+    }>;
+};
+
+export { createRenderer, createRendererContext, getAllDependencies, getModuleDependencies, getPrefetchLinks, getPreloadLinks, getRequestDependencies, getResources, renderResourceHeaders, renderResourceHints, renderScripts, renderStyles };
+export type { ModuleDependencies, RenderFunction, RenderOptions, RendererContext, SSRContext };

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/dist/runtime.d.ts

@@ -0,0 +1,68 @@
+import { R as ResourceMeta, M as Manifest } from './shared/vue-bundle-renderer.DITmAFNH.js';
+
+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;
+    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 }: 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;
+    }>;
+};
+
+export { createRenderer, createRendererContext, getAllDependencies, getModuleDependencies, getPrefetchLinks, getPreloadLinks, getRequestDependencies, getResources, renderResourceHeaders, renderResourceHints, renderScripts, renderStyles };
+export type { ModuleDependencies, RenderFunction, RenderOptions, RendererContext, SSRContext };

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/dist/runtime.mjs

@@ -0,0 +1,196 @@
+import { withLeadingSlash } from 'ufo';
+
+function createRendererContext({ manifest, buildAssetsURL }) {
+  const ctx = {
+    // Manifest
+    buildAssetsURL: buildAssetsURL || withLeadingSlash,
+    manifest: void 0,
+    updateManifest,
+    // Internal cache
+    _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 = rendererContext._dependencies[id] = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  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);
+    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 (dep.preload) {
+      filteredPreload[id2] = dep;
+    }
+  }
+  dependencies.preload = filteredPreload;
+  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 (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);
+  return Object.values(styles).map(
+    (resource) => renderLinkToString({ rel: "stylesheet", href: rendererContext.buildAssetsURL(resource.file), crossorigin: "" })
+  ).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 === "style" || resource.resourceType === "font" || resource.resourceType === "script" || 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 === "style" || resource.resourceType === "font" || resource.resourceType === "script" || 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) => "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)
+      };
+    }
+  };
+}
+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 };

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/dist/shared/vue-bundle-renderer.DITmAFNH.d.cts

@@ -0,0 +1,25 @@
+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;
+
+export { defineManifest as d };
+export type { Manifest as M, ResourceMeta as R };

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/dist/shared/vue-bundle-renderer.DITmAFNH.d.mts

@@ -0,0 +1,25 @@
+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;
+
+export { defineManifest as d };
+export type { Manifest as M, ResourceMeta as R };

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/dist/shared/vue-bundle-renderer.DITmAFNH.d.ts

@@ -0,0 +1,25 @@
+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;
+
+export { defineManifest as d };
+export type { Manifest as M, ResourceMeta as R };

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "vue-bundle-renderer",
+  "version": "2.1.2",
+  "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",
+    "release": "pnpm test && pnpm build && changelogen --release --push && npm publish",
+    "test": "pnpm lint && pnpm vitest run --coverage && tsc --noEmit"
+  },
+  "dependencies": {
+    "ufo": "^1.6.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.16.5",
+    "@vitest/coverage-v8": "^3.2.4",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.32.0",
+    "typescript": "^5.8.3",
+    "unbuild": "^3.6.0",
+    "vite": "^7.0.6",
+    "vitest": "3.2.4",
+    "vue": "3.5.18",
+    "@nuxt/eslint-config": "^1.7.1"
+  },
+  "packageManager": "[email protected]"
+}

examples/nuxt3-websocket-client/node_modules/vue-bundle-renderer/runtime.d.ts

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