Tracking de l'application VApp (IHM du jeu)

VApp/node_modules/unplugin-fonts/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Sacha Stafyniak
+
+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.

VApp/node_modules/unplugin-fonts/README.md

@@ -0,0 +1,470 @@
+# unplugin-fonts
+
+㊗️ Universal Webfont loader - Unfonts
+
+[![npm](https://img.shields.io/npm/v/unplugin-fonts.svg)](https://www.npmjs.com/package/unplugin-fonts)
+
+This plugin goes beyond just generating font-face rules - it also takes care of link preload and prefetch, optimizing font loading for a faster and more efficient user experience.
+
+Unfonts currently supports popular font providers like Typekit, Google Fonts, and Fontsource, as well as custom fonts. This gives you the flexibility to choose from a vast range of fonts and seamlessly integrate them into your projects.
+
+With Unfonts, you no longer have to manually manage font files and font-face rules, or worry about slow loading times. Our package does all the heavy lifting for you, so you can focus on creating amazing content with ease.
+
+View configuration:
+- [Typekit](#typekit)
+- [Google Fonts](#google-fonts)
+- [Custom Fonts](#custom-fonts)
+- [Fontsource](#fontsource)
+
+
+## Install
+
+```bash
+npm i --save-dev unplugin-fonts # pnpm add -D unplugin-fonts
+```
+
+<details>
+<summary>Vite</summary><br>
+
+```ts
+// vite.config.ts
+import Unfonts from 'unplugin-fonts/vite'
+
+export default defineConfig({
+  plugins: [
+    Unfonts({ /* options */ }),
+  ],
+})
+```
+
+Example: [`examples/vite`](./examples/vite)
+
+<br></details>
+
+<!-- <details>
+<summary>Rollup</summary><br>
+
+```ts
+// rollup.config.js
+import Starter from 'unplugin-fonts/rollup'
+
+export default {
+  plugins: [
+    Starter({ /* options */ }),
+  ],
+}
+```
+
+<br></details> -->
+
+
+<details>
+<summary>Webpack</summary><br>
+
+> **Warning**  
+> Not implemented yet
+
+```ts
+// webpack.config.js
+module.exports = {
+  /* ... */
+  plugins: [
+    require('unplugin-fonts/webpack')({ /* options */ })
+  ]
+}
+```
+
+<br></details>
+
+<details>
+<summary>Nuxt</summary><br>
+
+```ts
+// nuxt.config.js
+export default {
+  modules: [
+    ['unplugin-fonts/nuxt'],
+  ],
+  unfonts: {
+    /* options */
+  }
+}
+```
+
+Example: [`examples/nuxt`](./examples/nuxt)
+
+<br></details>
+
+<!-- <details>
+<summary>Vue CLI</summary><br>
+
+```ts
+// vue.config.js
+module.exports = {
+  configureWebpack: {
+    plugins: [
+      require('unplugin-fonts/webpack')({ /* options */ }),
+    ],
+  },
+}
+```
+
+<br></details> -->
+
+
+<details>
+<summary>SvelteKit</summary><br>
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite'
+import { sveltekit } from '@sveltejs/kit/vite'
+import Unfonts from 'unplugin-fonts/vite'
+
+export default defineConfig({
+  plugins: [
+    sveltekit(),
+    Unfonts({
+      /* options */
+    })
+  ]
+})
+```
+
+Example: [`examples/sveltekit`](./examples/sveltekit)
+
+<br></details>
+
+<details>
+<summary>Astro</summary><br>
+
+```ts
+// astro.config.js
+import { defineConfig } from 'astro/config'
+import Unfonts from 'unplugin-fonts/astro'
+
+export default defineConfig({
+  integrations: [
+    Unfonts({
+      /* options */
+    })
+  ]
+})
+```
+
+```astro
+---
+// src/pages/index.astro
+import Unfont from 'unplugin-fonts/astro/component.astro';
+---
+
+<html>
+  <head>
+    <Unfont />
+  </head>
+  <body>
+    <!-- ... -->
+  </body>
+</html>
+```
+
+Example: [`examples/astro`](./examples/astro)
+
+<br></details>
+
+---
+
+
+<details>
+<summary>Migrating from <code>vite-plugin-fonts</code></summary><br>
+
+```diff
+// vite.config.ts
+-import { VitePluginFonts } from 'vite-plugin-fonts'
++import Unfonts from 'unplugin-fonts/vite'
+
+export default defineConfig({
+  plugins: [
+-    VitePluginFonts({ 
++    Unfonts({ 
+      /* options */ 
+    }),
+  ],
+})
+```
+
+
+```diff
+// main.ts
+-import 'virtual:fonts.css'
++import 'unfonts.css'
+```
+
+
+<br></details>
+
+
+## Import generated `@font-rules` CSS
+
+> **Note**  
+> Required if using **custom** or **fontsource** providers
+
+```ts
+import 'unfonts.css'
+```
+
+
+
+## Providers
+
+
+### Typekit
+
+Load fonts from [Typekit](https://typekit.com/).
+
+```ts
+Unfonts({
+  // Typekit API
+  typekit: {
+    /**
+     * Typekit project id
+     */
+    id: '<projectId>',
+
+    /**
+     * enable non-blocking renderer
+     *   <link rel="preload" href="xxx" as="style" onload="this.rel='stylesheet'">
+     * default: true
+     */
+    defer: true,
+
+    /**
+     * define where the font load tags should be inserted
+     * default: 'head-prepend'
+     *   values: 'head' | 'body' | 'head-prepend' | 'body-prepend'
+     */
+    injectTo: 'head-prepend',
+  },
+})
+``` 
+
+
+### Google Fonts
+
+Load fonts from [Google Fonts](https://fonts.google.com/).
+
+```ts
+Unfonts({
+  // Google Fonts API V2
+  google: {
+    /**
+     * enable preconnect link injection
+     *   <link rel="preconnect" href="https://fonts.gstatic.com/" crossorigin>
+     * default: true
+     */
+    preconnect: false,
+
+    /**
+     * values: auto, block, swap(default), fallback, optional
+     * default: 'swap'
+     */
+    display: 'block',
+
+    /**
+     * define which characters to load
+     * default: undefined (load all characters)
+     */
+    text: 'ViteAwsom',
+
+    /**
+     * define where the font load tags should be inserted
+     * default: 'head-prepend'
+     *   values: 'head' | 'body' | 'head-prepend' | 'body-prepend'
+     */
+    injectTo: 'head-prepend',
+
+    /**
+     * Fonts families lists
+     */
+    families: [
+      // families can be either strings (only regular 400 will be loaded)
+      'Source Sans Pro',
+
+      // or objects
+      {
+        /**
+         * Family name (required)
+         */
+        name: 'Roboto',
+
+        /**
+         * Family styles
+         */
+        styles: 'ital,wght@0,400;1,200',
+
+        /**
+         * enable non-blocking renderer
+         *   <link rel="preload" href="xxx" as="style" onload="this.rel='stylesheet'">
+         * default: true
+         */
+        defer: true,
+      },
+    ],
+  },
+})
+``` 
+
+### Custom Fonts
+
+Load custom fonts from files.
+
+```ts
+Unfonts({
+  // Custom fonts.
+  custom: {
+    /**
+     * Fonts families lists
+     */
+    families: [{
+      /**
+       * Name of the font family.
+       */
+      name: 'Roboto',
+      /**
+       * Local name of the font. Used to add `src: local()` to `@font-rule`.
+       */
+      local: 'Roboto',
+      /**
+       * Regex(es) of font files to import. The names of the files will
+       * predicate the `font-style` and `font-weight` values of the `@font-rule`'s.
+       */
+      src: './src/assets/fonts/*.ttf',
+
+      /**
+       * This function allow you to transform the font object before it is used
+       * to generate the `@font-rule` and head tags.
+       */
+      transform(font) {
+        if (font.basename === 'Roboto-Bold') {
+          // update the font weight
+          font.weight = 700
+        }
+
+        // we can also return null to skip the font
+        return font
+      }
+    }],
+
+    /**
+     * Defines the default `font-display` value used for the generated
+     * `@font-rule` classes.
+     */
+    display: 'auto',
+
+    /**
+     * Using `<link rel="preload">` will trigger a request for the WebFont
+     * early in the critical rendering path, without having to wait for the
+     * CSSOM to be created.
+     */
+    preload: true,
+
+    /**
+     * Using `<link rel="prefetch">` is intended for prefetching resources
+     * that will be used in the next navigation/page load
+     * (e.g. when you go to the next page)
+     *
+     * Note: this can not be used with `preload`
+     */
+    prefetch: false,
+
+    /**
+     * define where the font load tags should be inserted
+     * default: 'head-prepend'
+     *   values: 'head' | 'body' | 'head-prepend' | 'body-prepend'
+     */
+    injectTo: 'head-prepend',
+  },
+
+})
+``` 
+
+### Fontsource
+
+Load fonts from [Fontsource](https://fontsource.org/) packages.
+
+> **Note**
+> You will need to install `@fontsource/<font>` packages.
+
+```ts
+Unfonts({
+  // Fontsource API
+  fontsource: {
+    /**
+     * Fonts families lists
+     */
+    families: [
+      // families can be either strings (load default font set)
+      // Require the `@fontsource/abeezee` package to be installed.
+      'ABeeZee',
+      'Inter Variable', // Require the `@fontsource-variable/inter` package to be installed.
+      {
+        /**
+         * Name of the font family.
+         * Require the `@fontsource/roboto` package to be installed.
+         */
+        name: 'Roboto',
+        /**
+         * Load only a subset of the font family.
+         */
+        weights: [400, 700],
+        /**
+         * Restrict the font styles to load.
+         */
+        styles: ['italic', 'normal'],
+        /**
+         * Use another font subset.
+         */
+        subset: 'latin-ext',
+      },
+      {
+        /**
+         * Name of the font family.
+         * Require the `@fontsource-variable/cabin` package to be installed.
+         */
+        name: 'Cabin',
+        /**
+         * When using variable fonts, you can choose which axes to load.
+         */
+        variable: {
+          wght: true,
+          slnt: true,
+          ital: true,
+        },
+      },
+    ],
+  },
+})
+```
+
+## Typescript Definitions
+
+```json
+{
+  "compilerOptions": {
+    "types": ["unplugin-fonts/client"]
+  }
+}
+```
+
+or 
+
+```ts	
+// declaration.d.ts
+/// <reference types="unplugin-fonts/client" />
+```
+
+## Resources
+
+- https://web.dev/optimize-webfont-loading/
+- https://csswizardry.com/2020/05/the-fastest-google-fonts/
+- _(unmaintained)_ https://www.npmjs.com/package/webfontloader

VApp/node_modules/unplugin-fonts/client.d.ts

@@ -0,0 +1,9 @@
+declare module 'unfonts.css' {
+  const content: string
+  export default content
+}
+
+declare module 'unplugin-fonts/head' {
+  import { HtmlTagDescriptor } from "vite"
+  export const links: HtmlTagDescriptor[]
+}

VApp/node_modules/unplugin-fonts/dist/astro.d.ts

@@ -0,0 +1,6 @@
+import { AstroIntegration } from 'astro';
+import { Options } from './types.js';
+
+declare function export_default(options: Options): AstroIntegration;
+
+export { export_default as default };

VApp/node_modules/unplugin-fonts/dist/astro.mjs

@@ -0,0 +1,23 @@
+import {
+  src_default
+} from "./chunk-CJR2JQI7.mjs";
+
+// src/astro.ts
+function astro_default(options) {
+  return {
+    name: "unplugin-fonts",
+    hooks: {
+      "astro:config:setup": async (astro) => {
+        var _a;
+        if (options == null ? void 0 : options.custom)
+          options.custom.stripPrefix = "public/";
+        (_a = astro.config.vite).plugins || (_a.plugins = []);
+        astro.config.vite.plugins.push(src_default.vite(options));
+        astro.injectScript("page-ssr", 'import "unfonts.css";');
+      }
+    }
+  };
+}
+export {
+  astro_default as default
+};

VApp/node_modules/unplugin-fonts/dist/astro/component.astro

@@ -0,0 +1,12 @@
+---
+import { links } from 'unplugin-fonts/head'
+---
+
+<>
+  {links.map((link) => {
+    const attrs = link?.attrs || {}
+    return (
+      <link {...attrs} />
+    )
+  })}
+</>

VApp/node_modules/unplugin-fonts/dist/astro/component.d.ts

@@ -0,0 +1,2 @@
+
+export { }

VApp/node_modules/unplugin-fonts/dist/esbuild.d.ts

@@ -0,0 +1,6 @@
+import * as esbuild from 'esbuild';
+import { Options } from './types.js';
+
+declare const _default: (options?: Options | undefined) => esbuild.Plugin;
+
+export { _default as default };

VApp/node_modules/unplugin-fonts/dist/esbuild.mjs

@@ -0,0 +1,9 @@
+import {
+  src_default
+} from "./chunk-CJR2JQI7.mjs";
+
+// src/esbuild.ts
+var esbuild_default = src_default.esbuild;
+export {
+  esbuild_default as default
+};

VApp/node_modules/unplugin-fonts/dist/index.d.ts

@@ -0,0 +1,6 @@
+import * as unplugin from 'unplugin';
+import { Options } from './types.js';
+
+declare const _default: unplugin.UnpluginInstance<Options | undefined, boolean>;
+
+export { _default as default };

VApp/node_modules/unplugin-fonts/dist/index.mjs

@@ -0,0 +1,6 @@
+import {
+  src_default
+} from "./chunk-CJR2JQI7.mjs";
+export {
+  src_default as default
+};

VApp/node_modules/unplugin-fonts/dist/nuxt.d.ts

@@ -0,0 +1,6 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { Options } from './types.js';
+
+declare const _default: _nuxt_schema.NuxtModule<Options>;
+
+export { _default as default };

VApp/node_modules/unplugin-fonts/dist/nuxt.mjs

@@ -0,0 +1,40 @@
+import {
+  __spreadValues,
+  fontsourceImports,
+  getHeadLinkTags,
+  src_default
+} from "./chunk-CJR2JQI7.mjs";
+
+// src/nuxt.ts
+import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from "@nuxt/kit";
+var nuxt_default = defineNuxtModule({
+  meta: {
+    name: "unplugin-fonts",
+    configKey: "unfonts"
+  },
+  setup(options, nuxt) {
+    var _a, _b, _c;
+    if ("fontsource" in options || "custom" in options) {
+      (_a = nuxt.options).css || (_a.css = []);
+      nuxt.options.css.push("unfonts.css");
+      if ("fontsource" in options) {
+        for (const src of fontsourceImports(options.fontsource))
+          nuxt.options.css.push(src);
+        delete options.fontsource;
+      }
+    }
+    if (options.custom)
+      options.custom.prefetchPrefix = nuxt.options.runtimeConfig.app.buildAssetsDir;
+    const links = getHeadLinkTags(options);
+    (_b = nuxt.options.app).head || (_b.head = {});
+    (_c = nuxt.options.app.head).link || (_c.link = []);
+    for (const link of links) {
+      nuxt.options.app.head.link.push(__spreadValues({}, link.attrs));
+    }
+    addWebpackPlugin(src_default.webpack(options));
+    addVitePlugin(src_default.vite(options));
+  }
+});
+export {
+  nuxt_default as default
+};

VApp/node_modules/unplugin-fonts/dist/rollup.d.ts

@@ -0,0 +1,6 @@
+import * as rollup from 'rollup';
+import { Options } from './types.js';
+
+declare const _default: (options?: Options | undefined) => rollup.Plugin | rollup.Plugin[];
+
+export { _default as default };

VApp/node_modules/unplugin-fonts/dist/rollup.mjs

@@ -0,0 +1,9 @@
+import {
+  src_default
+} from "./chunk-CJR2JQI7.mjs";
+
+// src/rollup.ts
+var rollup_default = src_default.rollup;
+export {
+  rollup_default as default
+};

VApp/node_modules/unplugin-fonts/dist/types.d.ts

@@ -0,0 +1,148 @@
+interface Options {
+    custom?: CustomFonts;
+    fontsource?: FontsourceFonts;
+    google?: GoogleFonts;
+    typekit?: TypeKitFonts;
+    sourcemap?: string;
+}
+interface CustomFontFace {
+    source: string;
+    name: string;
+    basename: string;
+    weight: number;
+    style: string;
+    display: string;
+    local?: string | string[];
+    files: {
+        src: string;
+        ext: string;
+        path: string;
+        format: string;
+    }[];
+}
+interface CustomFontFamily {
+    /**
+     * Name of the font family.
+     * @example 'Comic Sans MS'
+     */
+    name: string;
+    /**
+     * Regex(es) of font files to import. The names of the files will
+     * predicate the `font-style` and `font-weight` values of the `@font-rule`'s.
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight#common_weight_name_mapping
+     *
+     * @example
+     * A value of `./RobotoBoldItalic.*` will create this `@font-rule`:
+     *
+     * ```css
+     * font-face {
+     *    font-family: 'Roboto';
+     *    src: url(./RobotoBoldItalic.ttf) format('truetype')
+     *         url(./RobotoBoldItalic.woff) format('woff')
+     *         url(./RobotoBoldItalic.woff2) format('woff2');
+     *    font-weight: bold;
+     *    font-style: italic;
+     *    font-display: auto;
+     * }
+     * ```
+     */
+    src: string | string[];
+    /**
+     * Local name of the font. Used to add `src: local()` to `@font-rule`.
+     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@font-face#description
+     */
+    local?: string | string[];
+    /**
+     * Allows to transform the generated config for any font face.
+     *
+     * @param font
+     * @returns
+     */
+    transform?: (font: CustomFontFace) => CustomFontFace | null;
+}
+interface CustomFonts {
+    /**
+     * Font families.
+     */
+    families: CustomFontFamily[] | Record<string, string | string[] | Omit<CustomFontFamily, 'name'>>;
+    /**
+     * Defines the default `font-display` value used for the generated
+     * `@font-rule` classes.
+     * @see https://developer.mozilla.org/fr/docs/Web/CSS/@font-face/font-display
+     * @default 'auto'
+     */
+    display?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+    /**
+     * Using `<link rel="preload">` will trigger a request for the WebFont
+     * early in the critical rendering path, without having to wait for the
+     * CSSOM to be created.
+     * @see https://web.dev/optimize-webfont-loading/#preload-your-webfont-resources
+     * @default true
+     */
+    preload?: boolean;
+    /**
+     * Using `<link rel="prefetch">` is intended for prefetching resources
+     * that will be used in the next navigation/page load
+     * (e.g. when you go to the next page)
+     *
+     * Note: this can not be used with `preload`
+     * @default false
+     */
+    prefetch?: boolean;
+    prefetchPrefix?: string;
+    /**
+     * @default: 'head-prepend'
+     */
+    injectTo?: 'head' | 'body' | 'head-prepend' | 'body-prepend';
+    /**
+     * Remove the prefix from the front path
+     * @default: 'public/'
+     */
+    stripPrefix?: string;
+}
+interface BaseFontsourceFontFamily {
+    name: string;
+    styles?: ('italic' | 'normal')[];
+    subset?: string;
+}
+interface WeightsFontsourceFontFamily extends BaseFontsourceFontFamily {
+    weights: (100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900)[];
+}
+interface VariableFontsourceFontFamily extends BaseFontsourceFontFamily {
+    variable: true | {
+        wght?: boolean;
+        wdth?: boolean;
+        slnt?: boolean;
+        opsz?: boolean;
+        ital?: boolean;
+    };
+}
+type FontsourceFontFamily = WeightsFontsourceFontFamily | VariableFontsourceFontFamily;
+interface FontsourceFonts {
+    families: (string | FontsourceFontFamily)[];
+}
+interface GoogleFontFamily {
+    name: string;
+    styles?: string;
+    defer?: boolean;
+}
+interface GoogleFonts {
+    families: (string | GoogleFontFamily)[];
+    text?: string;
+    display?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+    preconnect?: boolean;
+    /**
+     * @default: 'head-prepend'
+     */
+    injectTo?: 'head' | 'body' | 'head-prepend' | 'body-prepend';
+}
+interface TypeKitFonts {
+    id: string;
+    defer?: boolean;
+    /**
+     * default: 'head-prepend'
+     */
+    injectTo?: 'head' | 'body' | 'head-prepend' | 'body-prepend';
+}
+
+export { CustomFontFace, CustomFontFamily, CustomFonts, FontsourceFontFamily, FontsourceFonts, GoogleFontFamily, GoogleFonts, Options, TypeKitFonts };

VApp/node_modules/unplugin-fonts/dist/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

VApp/node_modules/unplugin-fonts/dist/vite.d.ts

@@ -0,0 +1,6 @@
+import * as vite from 'vite';
+import { Options } from './types.js';
+
+declare const _default: (options?: Options | undefined) => vite.Plugin | vite.Plugin[];
+
+export { _default as default };

VApp/node_modules/unplugin-fonts/dist/vite.mjs

@@ -0,0 +1,9 @@
+import {
+  src_default
+} from "./chunk-CJR2JQI7.mjs";
+
+// src/vite.ts
+var vite_default = src_default.vite;
+export {
+  vite_default as default
+};

VApp/node_modules/unplugin-fonts/dist/webpack.d.ts

@@ -0,0 +1,6 @@
+import * as webpack from 'webpack';
+import { Options } from './types.js';
+
+declare const _default: (options?: Options | undefined) => webpack.WebpackPluginInstance;
+
+export { _default as default };

VApp/node_modules/unplugin-fonts/dist/webpack.mjs

@@ -0,0 +1,9 @@
+import {
+  src_default
+} from "./chunk-CJR2JQI7.mjs";
+
+// src/webpack.ts
+var webpack_default = src_default.webpack;
+export {
+  webpack_default as default
+};

VApp/node_modules/unplugin-fonts/package.json

@@ -0,0 +1,132 @@
+{
+  "name": "unplugin-fonts",
+  "version": "1.1.1",
+  "description": "Universal Webfont loader",
+  "author": {
+    "name": "cssninjaStudio <hello@cssninja.io> (https://cssninja.io)"
+  },
+  "license": "MIT",
+  "repository": "cssninjaStudio/unplugin-fonts",
+  "keywords": [
+    "fonts",
+    "google-fonts",
+    "typekit",
+    "fontsource",
+    "webfontloader",
+    "svelte",
+    "nuxt",
+    "vite",
+    "vitepress",
+    "astro-integration"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    },
+    "./astro": {
+      "types": "./dist/astro.d.ts",
+      "require": "./dist/astro.js",
+      "import": "./dist/astro.mjs"
+    },
+    "./astro/component.astro": {
+      "types": "./dist/astro/component.d.ts",
+      "import": "./dist/astro/component.astro"
+    },
+    "./esbuild": {
+      "types": "./dist/esbuild.d.ts",
+      "require": "./dist/esbuild.js",
+      "import": "./dist/esbuild.mjs"
+    },
+    "./nuxt": {
+      "types": "./dist/nuxt.d.ts",
+      "require": "./dist/nuxt.js",
+      "import": "./dist/nuxt.mjs"
+    },
+    "./rollup": {
+      "types": "./dist/rollup.d.ts",
+      "require": "./dist/rollup.js",
+      "import": "./dist/rollup.mjs"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "require": "./dist/types.js",
+      "import": "./dist/types.mjs"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "require": "./dist/vite.js",
+      "import": "./dist/vite.mjs"
+    },
+    "./webpack": {
+      "types": "./dist/webpack.d.ts",
+      "require": "./dist/webpack.js",
+      "import": "./dist/webpack.mjs"
+    },
+    "./client": {
+      "types": "./client.d.ts"
+    },
+    "./*": "./*"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./*"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "client.d.ts"
+  ],
+  "scripts": {
+    "prepack": "npm run build",
+    "build": "tsup",
+    "dev": "tsup --watch src",
+    "build:fix": "esno scripts/postbuild.ts",
+    "example:dev": "npm -C examples/vite run dev",
+    "example:build": "npm -C examples/vite run build",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "test": "vitest",
+    "release": "npm run lint && npx standard-version && git push --follow-tags origin main && npm publish"
+  },
+  "peerDependencies": {
+    "@nuxt/kit": "^3.0.0",
+    "vite": "^2.0.0 || ^3.0.0 || ^4.0.0 || ^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/kit": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "fast-glob": "^3.2.12",
+    "unplugin": "^1.3.1"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config-ts": "^0.38.4",
+    "@nuxt/kit": "^3.4.1",
+    "@types/node": "^18.15.11",
+    "@typescript-eslint/eslint-plugin": "^5.58.0",
+    "chalk": "^5.2.0",
+    "defu": "^6.1.2",
+    "eslint": "^8.38.0",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "esno": "^0.16.3",
+    "magic-string": "^0.30.0",
+    "pathe": "^1.1.0",
+    "rollup": "^3.20.2",
+    "standard-version": "^9.5.0",
+    "tsup": "^6.7.0",
+    "typescript": "^5.0.4",
+    "vite": "^4.2.1",
+    "vitest": "^0.30.1",
+    "webpack": "^5.79.0"
+  }
+}