astro 5.7.6 → 5.7.8

package/dist/assets/fonts/vite-plugin-fonts.js

@@ -3,49 +3,38 @@ import { readFile } from "node:fs/promises";
 import { isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
 import { removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
-import { createStorage } from "unstorage";
-import fsLiteDriver from "unstorage/drivers/fs-lite";
-import xxhash from "xxhash-wasm";
 import { collectErrorMetadata } from "../../core/errors/dev/utils.js";
 import { AstroError, AstroErrorData, isAstroError } from "../../core/errors/index.js";
 import { formatErrorMessage } from "../../core/messages.js";
 import { getClientOutputDirectory } from "../../prerender/utils.js";
 import {
   CACHE_DIR,
+  DEFAULTS,
   RESOLVED_VIRTUAL_MODULE_ID,
   URL_PREFIX,
   VIRTUAL_MODULE_ID
 } from "./constants.js";
-import { loadFonts } from "./load.js";
-import { generateFallbackFontFace, readMetrics } from "./metrics.js";
+import { createMinifiableCssRenderer } from "./implementations/css-renderer.js";
+import { createDataCollector } from "./implementations/data-collector.js";
+import { createAstroErrorHandler } from "./implementations/error-handler.js";
+import { createCachedFontFetcher } from "./implementations/font-fetcher.js";
+import { createCapsizeFontMetricsResolver } from "./implementations/font-metrics-resolver.js";
+import { createFontTypeExtractor } from "./implementations/font-type-extractor.js";
+import { createXxHasher } from "./implementations/hasher.js";
+import { createRequireLocalProviderUrlResolver } from "./implementations/local-provider-url-resolver.js";
 import {
-  cache,
-  extractFontType,
-  resolveEntrypoint,
-  resolveFontFamily,
-  sortObjectByKey,
-  withoutQuotes
-} from "./utils.js";
-async function fetchFont(url) {
-  try {
-    if (isAbsolute(url)) {
-      return await readFile(url);
-    }
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Response was not successful, received status code ${response.status}`);
-    }
-    return Buffer.from(await response.arrayBuffer());
-  } catch (cause) {
-    throw new AstroError(
-      {
-        ...AstroErrorData.CannotFetchFontFile,
-        message: AstroErrorData.CannotFetchFontFile.message(url)
-      },
-      { cause }
-    );
-  }
-}
+  createBuildRemoteFontProviderModResolver,
+  createDevServerRemoteFontProviderModResolver
+} from "./implementations/remote-font-provider-mod-resolver.js";
+import { createRemoteFontProviderResolver } from "./implementations/remote-font-provider-resolver.js";
+import { createFsStorage } from "./implementations/storage.js";
+import { createSystemFallbacksProvider } from "./implementations/system-fallbacks-provider.js";
+import {
+  createLocalUrlProxyContentResolver,
+  createRemoteUrlProxyContentResolver
+} from "./implementations/url-proxy-content-resolver.js";
+import { createUrlProxy } from "./implementations/url-proxy.js";
+import { orchestrate } from "./orchestrate.js";
 function fontsPlugin({ settings, sync, logger }) {
   if (!settings.config.experimental.fonts) {
     return {
@@ -65,64 +54,75 @@ function fontsPlugin({ settings, sync, logger }) {
     };
   }
   const baseUrl = removeTrailingForwardSlash(settings.config.base) + URL_PREFIX;
-  let resolvedMap = null;
-  let hashToUrlMap = null;
+  let fontFileDataMap = null;
+  let consumableMap = null;
   let isBuild;
-  let storage = null;
+  let fontFetcher = null;
+  let fontTypeExtractor = null;
   const cleanup = () => {
-    resolvedMap = null;
-    hashToUrlMap = null;
-    storage = null;
+    consumableMap = null;
+    fontFileDataMap = null;
+    fontFetcher = null;
   };
-  async function initialize({ resolveMod, base }) {
-    const { h64ToString } = await xxhash();
-    storage = createStorage({
-      // Types are weirly exported
-      driver: fsLiteDriver({
-        base: fileURLToPath(base)
-      })
+  async function initialize({
+    cacheDir,
+    modResolver,
+    cssRenderer
+  }) {
+    const { root } = settings.config;
+    const hasher = await createXxHasher();
+    const errorHandler = createAstroErrorHandler();
+    const remoteFontProviderResolver = createRemoteFontProviderResolver({
+      root,
+      modResolver,
+      errorHandler
     });
-    hashToUrlMap = /* @__PURE__ */ new Map();
-    resolvedMap = /* @__PURE__ */ new Map();
-    const families = [];
-    const root = settings.config.root;
     const pathsToWarn = /* @__PURE__ */ new Set();
-    for (const family of settings.config.experimental.fonts) {
-      families.push(
-        await resolveFontFamily({
-          family,
-          root,
-          resolveMod,
-          generateNameWithHash: (_family) => `${withoutQuotes(_family.name)}-${h64ToString(JSON.stringify(sortObjectByKey(_family)))}`,
-          resolveLocalEntrypoint: (url) => {
-            const resolvedPath = fileURLToPath(resolveEntrypoint(root, url));
-            if (resolvedPath.startsWith(fileURLToPath(settings.config.publicDir))) {
-              pathsToWarn.add(resolvedPath);
-            }
-            return resolvedPath;
+    const localProviderUrlResolver = createRequireLocalProviderUrlResolver({
+      root,
+      intercept: (path) => {
+        if (path.startsWith(fileURLToPath(settings.config.publicDir))) {
+          if (pathsToWarn.has(path)) {
+            return;
           }
-        })
-      );
-    }
-    for (const path of [...pathsToWarn]) {
-      logger.warn(
-        "assets",
-        `Found a local font file ${JSON.stringify(path)} in the \`public/\` folder. To avoid duplicated files in the build output, move this file into \`src/\``
-      );
-    }
-    await loadFonts({
-      base: baseUrl,
-      families,
+          pathsToWarn.add(path);
+          logger.warn(
+            "assets",
+            `Found a local font file ${JSON.stringify(path)} in the \`public/\` folder. To avoid duplicated files in the build output, move this file into \`src/\``
+          );
+        }
+      }
+    });
+    const storage = createFsStorage({ base: cacheDir });
+    const systemFallbacksProvider = createSystemFallbacksProvider();
+    fontFetcher = createCachedFontFetcher({ storage, errorHandler, fetch, readFile });
+    const fontMetricsResolver = createCapsizeFontMetricsResolver({ fontFetcher, cssRenderer });
+    fontTypeExtractor = createFontTypeExtractor({ errorHandler });
+    const res = await orchestrate({
+      families: settings.config.experimental.fonts,
+      hasher,
+      remoteFontProviderResolver,
+      localProviderUrlResolver,
       storage,
-      hashToUrlMap,
-      resolvedMap,
-      hashString: h64ToString,
-      generateFallbackFontFace,
-      getMetricsForFamily: async (name, font) => {
-        return await readMetrics(name, await cache(storage, font.hash, () => fetchFont(font.url)));
+      cssRenderer,
+      systemFallbacksProvider,
+      fontMetricsResolver,
+      fontTypeExtractor,
+      createUrlProxy: ({ local, ...params }) => {
+        const dataCollector = createDataCollector(params);
+        const contentResolver = local ? createLocalUrlProxyContentResolver({ errorHandler }) : createRemoteUrlProxyContentResolver();
+        return createUrlProxy({
+          base: baseUrl,
+          contentResolver,
+          hasher,
+          dataCollector,
+          fontTypeExtractor
+        });
       },
-      log: (message) => logger.info("assets", message)
+      defaults: DEFAULTS
     });
+    fontFileDataMap = res.fontFileDataMap;
+    consumableMap = res.consumableMap;
   }
   return {
     name: "astro:fonts",
@@ -132,18 +132,20 @@ function fontsPlugin({ settings, sync, logger }) {
     async buildStart() {
       if (isBuild) {
         await initialize({
-          resolveMod: (id) => import(id),
-          base: new URL(CACHE_DIR, settings.config.cacheDir)
+          cacheDir: new URL(CACHE_DIR, settings.config.cacheDir),
+          modResolver: createBuildRemoteFontProviderModResolver(),
+          cssRenderer: createMinifiableCssRenderer({ minify: true })
         });
       }
     },
     async configureServer(server) {
       await initialize({
-        resolveMod: (id) => server.ssrLoadModule(id),
         // In dev, we cache fonts data in .astro so it can be easily inspected and cleared
-        base: new URL(CACHE_DIR, settings.dotAstroDir)
+        cacheDir: new URL(CACHE_DIR, settings.dotAstroDir),
+        modResolver: createDevServerRemoteFontProviderModResolver({ server }),
+        cssRenderer: createMinifiableCssRenderer({ minify: false })
       });
-      const localPaths = [...hashToUrlMap.values()].filter((url) => isAbsolute(url));
+      const localPaths = [...fontFileDataMap.values()].filter(({ url }) => isAbsolute(url)).map((v) => v.url);
       server.watcher.on("change", (path) => {
         if (localPaths.includes(path)) {
           logger.info("assets", "Font file updated");
@@ -163,17 +165,17 @@ function fontsPlugin({ settings, sync, logger }) {
           return next();
         }
         const hash = req.url.slice(1);
-        const url = hashToUrlMap?.get(hash);
-        if (!url) {
+        const associatedData = fontFileDataMap?.get(hash);
+        if (!associatedData) {
           return next();
         }
         res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
         res.setHeader("Pragma", "no-cache");
         res.setHeader("Expires", 0);
         try {
-          const data = await cache(storage, hash, () => fetchFont(url));
+          const data = await fontFetcher.fetch({ hash, ...associatedData });
           res.setHeader("Content-Length", data.length);
-          res.setHeader("Content-Type", `font/${extractFontType(hash)}`);
+          res.setHeader("Content-Type", `font/${fontTypeExtractor.extract(hash)}`);
           res.end(data);
         } catch (err) {
           logger.error("assets", "Cannot download font file");
@@ -196,7 +198,7 @@ function fontsPlugin({ settings, sync, logger }) {
     load(id) {
       if (id === RESOLVED_VIRTUAL_MODULE_ID) {
         return {
-          code: `export const fontsData = new Map(${JSON.stringify(Array.from(resolvedMap?.entries() ?? []))})`
+          code: `export const fontsData = new Map(${JSON.stringify(Array.from(consumableMap?.entries() ?? []))})`
         };
       }
     },
@@ -213,11 +215,11 @@ function fontsPlugin({ settings, sync, logger }) {
         } catch (cause) {
           throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
         }
-        if (hashToUrlMap) {
+        if (fontFileDataMap) {
           logger.info("assets", "Copying fonts...");
           await Promise.all(
-            Array.from(hashToUrlMap.entries()).map(async ([hash, url]) => {
-              const data = await cache(storage, hash, () => fetchFont(url));
+            Array.from(fontFileDataMap.entries()).map(async ([hash, associatedData]) => {
+              const data = await fontFetcher.fetch({ hash, ...associatedData });
               try {
                 writeFileSync(new URL(hash, fontsDir), data);
               } catch (cause) {

package/dist/content/content-layer.js

@@ -153,7 +153,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "5.7.6") {
+    if (previousAstroVersion && previousAstroVersion !== "5.7.8") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -161,8 +161,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.7.6") {
-      await this.#store.metaStore().set("astro-version", "5.7.6");
+    if ("5.7.8") {
+      await this.#store.metaStore().set("astro-version", "5.7.8");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "5.7.6";
+const ASTRO_VERSION = "5.7.8";
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";

package/dist/core/dev/dev.js

@@ -22,7 +22,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "5.7.6";
+  const currentVersion = "5.7.8";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/messages.js

@@ -37,7 +37,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "5.7.6";
+  const version = "5.7.8";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -274,7 +274,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"5.7.6"}`
+        `v${"5.7.8"}`
       )} ${headline}`
     );
   }

package/dist/types/public/config.d.ts

@@ -312,9 +312,9 @@ export interface ViteUserConfig extends OriginalViteUserConfig {
      * @see output
      * @description
      *
-     * Deploy to your favorite server, serverless, or edge host with build adapters. Import one of our first-party adapters for [Netlify](https://docs.astro.build/en/guides/deploy/netlify/#adapter-for-ssr), [Vercel](https://docs.astro.build/en/guides/deploy/vercel/#adapter-for-ssr), and more to engage Astro SSR.
+     * Deploy to your favorite server, serverless, or edge host with build adapters. Import one of our first-party adapters ([Cloudflare](/en/guides/integrations-guide/cloudflare/), [Netlify](/en/guides/integrations-guide/netlify/), [Node.js](/en/guides/integrations-guide/node/), [Vercel](/en/guides/integrations-guide/vercel/)) or explore [community adapters](https://astro.build/integrations/2/?search=&categories%5B%5D=adapters) to enable on-demand rendering in your Astro project.
      *
-     * [See our On-demand Rendering guide](https://docs.astro.build/en/guides/on-demand-rendering/) for more on SSR, and [our deployment guides](https://docs.astro.build/en/guides/deploy/) for a complete list of hosts.
+     * See our [on-demand rendering guide](/en/guides/on-demand-rendering/) for more on Astro's server rendering options.
      *
      * ```js
      * import netlify from '@astrojs/netlify';

package/dist/vite-plugin-markdown/images.js

@@ -6,7 +6,7 @@ function getMarkdownCodeForImages(localImagePaths, remoteImagePaths, html) {
 			const images = async function(html) {
 					const imageSources = {};
 					${localImagePaths.map((entry) => {
-    const rawUrl = JSON.stringify(entry.raw);
+    const rawUrl = JSON.stringify(entry.raw).replace(/'/g, "'");
     return `{
 											const regex = new RegExp('__ASTRO_IMAGE_="([^"]*' + ${rawUrl.replace(
       /[.*+?^${}()|[\]\\]/g,
@@ -16,7 +16,7 @@ function getMarkdownCodeForImages(localImagePaths, remoteImagePaths, html) {
 											let occurrenceCounter = 0;
 											while ((match = regex.exec(html)) !== null) {
 													const matchKey = ${rawUrl} + '_' + occurrenceCounter;
-													const imageProps = JSON.parse(match[1].replace(/"/g, '"'));
+													const imageProps = JSON.parse(match[1].replace(/"/g, '"').replace(/'/g, "'"));
 													const { src, ...props } = imageProps;
 													imageSources[matchKey] = await getImage({src: Astro__${entry.safeName}, ...props});
 													occurrenceCounter++;
@@ -24,7 +24,7 @@ function getMarkdownCodeForImages(localImagePaths, remoteImagePaths, html) {
 									}`;
   }).join("\n")}
 					${remoteImagePaths.map((raw) => {
-    const rawUrl = JSON.stringify(raw);
+    const rawUrl = JSON.stringify(raw).replace(/'/g, "'");
     return `{
 											const regex = new RegExp('__ASTRO_IMAGE_="([^"]*' + ${rawUrl.replace(
       /[.*+?^${}()|[\]\\]/g,
@@ -34,7 +34,7 @@ function getMarkdownCodeForImages(localImagePaths, remoteImagePaths, html) {
 											let occurrenceCounter = 0;
 											while ((match = regex.exec(html)) !== null) {
 													const matchKey = ${rawUrl} + '_' + occurrenceCounter;
-													const props = JSON.parse(match[1].replace(/"/g, '"'));
+													const props = JSON.parse(match[1].replace(/"/g, '"').replace(/'/g, "'"));
 													imageSources[matchKey] = await getImage(props);
 													occurrenceCounter++;
 											}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "5.7.6",
+  "version": "5.7.8",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -142,7 +142,7 @@
     "tinyglobby": "^0.2.12",
     "tsconfck": "^3.1.5",
     "ultrahtml": "^1.6.0",
-    "unifont": "~0.2.0",
+    "unifont": "~0.4.1",
     "unist-util-visit": "^5.0.0",
     "unstorage": "^1.15.0",
     "vfile": "^6.0.3",

package/types/content.d.ts

@@ -45,11 +45,18 @@ declare module 'astro:content' {
 		has: (key: string) => boolean;
 	}
 
+	type BaseAtomicSchema = import('astro/zod').AnyZodObject;
+
+	type BaseCompositeSchema =
+		| import('astro/zod').ZodUnion<[BaseAtomicSchema, ...BaseAtomicSchema[]]>
+		| import('astro/zod').ZodDiscriminatedUnion<string, BaseAtomicSchema[]>
+		// If we have a union of unions, give up on trying to type-check it all. You're on your own.
+		| import('astro/zod').ZodUnion<[import('astro/zod').ZodUnion<z.any>, ...z.any[]]>;
+
 	type BaseSchemaWithoutEffects =
-		| import('astro/zod').AnyZodObject
-		| import('astro/zod').ZodUnion<[BaseSchemaWithoutEffects, ...BaseSchemaWithoutEffects[]]>
-		| import('astro/zod').ZodDiscriminatedUnion<string, import('astro/zod').AnyZodObject[]>
-		| import('astro/zod').ZodIntersection<BaseSchemaWithoutEffects, BaseSchemaWithoutEffects>;
+		| BaseAtomicSchema
+		| BaseCompositeSchema
+		| import('astro/zod').ZodIntersection<BaseAtomicSchema, BaseAtomicSchema | BaseCompositeSchema>;
 
 	export type BaseSchema =
 		| BaseSchemaWithoutEffects

package/dist/assets/fonts/load.d.ts

@@ -1,20 +0,0 @@
-import type { Storage } from 'unstorage';
-import type { generateFallbackFontFace } from './metrics.js';
-import type { PreloadData, ResolvedFontFamily } from './types.js';
-import { type GetMetricsForFamily } from './utils.js';
-interface Options {
-    base: string;
-    families: Array<ResolvedFontFamily>;
-    storage: Storage;
-    hashToUrlMap: Map<string, string>;
-    resolvedMap: Map<string, {
-        preloadData: PreloadData;
-        css: string;
-    }>;
-    hashString: (value: string) => string;
-    log: (message: string) => void;
-    generateFallbackFontFace: typeof generateFallbackFontFace;
-    getMetricsForFamily: GetMetricsForFamily;
-}
-export declare function loadFonts({ base, families, storage, hashToUrlMap, resolvedMap, hashString, generateFallbackFontFace, getMetricsForFamily, log, }: Options): Promise<void>;
-export {};

package/dist/assets/fonts/load.js

@@ -1,162 +0,0 @@
-import { readFileSync } from "node:fs";
-import * as unifont from "unifont";
-import { AstroError, AstroErrorData } from "../../core/errors/index.js";
-import { DEFAULTS, LOCAL_PROVIDER_NAME } from "./constants.js";
-import { resolveLocalFont } from "./providers/local.js";
-import {
-  familiesToUnifontProviders,
-  generateFallbacksCSS,
-  generateFontFace,
-  proxyURL
-} from "./utils.js";
-async function loadFonts({
-  base,
-  families,
-  storage,
-  hashToUrlMap,
-  resolvedMap,
-  hashString,
-  generateFallbackFontFace,
-  getMetricsForFamily,
-  log
-}) {
-  const extractedProvidersResult = familiesToUnifontProviders({ families, hashString });
-  families = extractedProvidersResult.families;
-  const { resolveFont } = await unifont.createUnifont(extractedProvidersResult.providers, {
-    storage
-  });
-  for (const family of families) {
-    const preloadData = [];
-    let css = "";
-    const fallbacks = family.fallbacks ?? DEFAULTS.fallbacks;
-    const fallbackFontData = [];
-    const collect = ({ hash, type, value, data }, collectPreload) => {
-      const url = base + hash;
-      if (!hashToUrlMap.has(hash)) {
-        hashToUrlMap.set(hash, value);
-        if (collectPreload) {
-          preloadData.push({ url, type });
-        }
-      }
-      if (fallbacks && fallbacks.length > 0 && // If the same data has already been sent for this family, we don't want to have duplicate fallbacks
-      // Such scenario can occur with unicode ranges
-      !fallbackFontData.some((f) => JSON.stringify(f.data) === JSON.stringify(data))) {
-        fallbackFontData.push({
-          hash,
-          url: value,
-          data
-        });
-      }
-      return url;
-    };
-    let fonts;
-    if (family.provider === LOCAL_PROVIDER_NAME) {
-      const result = resolveLocalFont({
-        family,
-        proxyURL: ({ value, data }) => {
-          return proxyURL({
-            value,
-            // We hash based on the filepath and the contents, since the user could replace
-            // a given font file with completely different contents.
-            hashString: (v) => {
-              let content;
-              try {
-                content = readFileSync(value, "utf-8");
-              } catch (e) {
-                throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: e });
-              }
-              return hashString(v + content);
-            },
-            collect: (input) => collect({ ...input, data }, true)
-          });
-        }
-      });
-      fonts = result.fonts;
-    } else {
-      const result = await resolveFont(
-        family.name,
-        // We do not merge the defaults, we only provide defaults as a fallback
-        {
-          weights: family.weights ?? DEFAULTS.weights,
-          styles: family.styles ?? DEFAULTS.styles,
-          subsets: family.subsets ?? DEFAULTS.subsets,
-          fallbacks: family.fallbacks ?? DEFAULTS.fallbacks
-        },
-        // By default, unifont goes through all providers. We use a different approach
-        // where we specify a provider per font.
-        // Name has been set while extracting unifont providers from families (inside familiesToUnifontProviders)
-        [family.provider.name]
-      );
-      fonts = result.fonts.filter(
-        (font) => typeof font.meta?.priority === "number" ? font.meta.priority === 0 : true
-      ).map((font) => {
-        let index = 0;
-        return {
-          ...font,
-          src: font.src.map((source) => {
-            if ("name" in source) {
-              return source;
-            }
-            const proxied = {
-              ...source,
-              originalURL: source.url,
-              url: proxyURL({
-                value: source.url,
-                // We only use the url for hashing since the service returns urls with a hash already
-                hashString,
-                // We only collect the first URL to avoid preloading fallback sources (eg. we only
-                // preload woff2 if woff is available)
-                collect: (data) => collect(
-                  {
-                    ...data,
-                    data: {
-                      weight: font.weight,
-                      style: font.style
-                    }
-                  },
-                  index === 0
-                )
-              })
-            };
-            index++;
-            return proxied;
-          })
-        };
-      });
-    }
-    for (const data of fonts) {
-      css += generateFontFace(family.nameWithHash, {
-        src: data.src,
-        display: data.display ?? family.provider === LOCAL_PROVIDER_NAME ? void 0 : family.display,
-        unicodeRange: data.unicodeRange ?? family.provider === LOCAL_PROVIDER_NAME ? void 0 : family.unicodeRange,
-        weight: data.weight,
-        style: data.style,
-        stretch: data.stretch ?? family.provider === LOCAL_PROVIDER_NAME ? void 0 : family.stretch,
-        featureSettings: data.featureSettings ?? family.provider === LOCAL_PROVIDER_NAME ? void 0 : family.featureSettings,
-        variationSettings: data.variationSettings ?? family.provider === LOCAL_PROVIDER_NAME ? void 0 : family.variationSettings
-      });
-    }
-    const fallbackData = await generateFallbacksCSS({
-      family,
-      font: fallbackFontData,
-      fallbacks,
-      metrics: family.optimizedFallbacks ?? DEFAULTS.optimizedFallbacks ? {
-        getMetricsForFamily,
-        generateFontFace: generateFallbackFontFace
-      } : null
-    });
-    const cssVarValues = [family.nameWithHash];
-    if (fallbackData) {
-      if (fallbackData.css) {
-        css += fallbackData.css;
-      }
-      cssVarValues.push(...fallbackData.fallbacks);
-    }
-    css += `:root { ${family.cssVariable}: ${cssVarValues.join(", ")}; }`;
-    resolvedMap.set(family.cssVariable, { preloadData, css });
-  }
-  log("Fonts initialized");
-}
-export {
-  loadFonts
-};

package/dist/assets/fonts/metrics.d.ts

@@ -1,10 +0,0 @@
-import { type Font } from '@capsizecss/unpack';
-export type FontFaceMetrics = Pick<Font, 'ascent' | 'descent' | 'lineGap' | 'unitsPerEm' | 'xWidthAvg'>;
-export declare function readMetrics(family: string, buffer: Buffer): Promise<FontFaceMetrics>;
-export declare function generateFallbackFontFace({ metrics, fallbackMetrics, name: fallbackName, font: fallbackFontName, properties, }: {
-    metrics: FontFaceMetrics;
-    fallbackMetrics: FontFaceMetrics;
-    name: string;
-    font: string;
-    properties: Record<string, string | undefined>;
-}): string;

package/dist/assets/fonts/metrics.js

@@ -1,55 +0,0 @@
-import { fromBuffer } from "@capsizecss/unpack";
-import { renderFontFace, renderFontSrc } from "./utils.js";
-const metricCache = {};
-function filterRequiredMetrics({
-  ascent,
-  descent,
-  lineGap,
-  unitsPerEm,
-  xWidthAvg
-}) {
-  return {
-    ascent,
-    descent,
-    lineGap,
-    unitsPerEm,
-    xWidthAvg
-  };
-}
-async function readMetrics(family, buffer) {
-  const metrics = await fromBuffer(buffer);
-  metricCache[family] = filterRequiredMetrics(metrics);
-  return metricCache[family];
-}
-function toPercentage(value, fractionDigits = 4) {
-  const percentage = value * 100;
-  return `${+percentage.toFixed(fractionDigits)}%`;
-}
-function generateFallbackFontFace({
-  metrics,
-  fallbackMetrics,
-  name: fallbackName,
-  font: fallbackFontName,
-  properties
-}) {
-  const preferredFontXAvgRatio = metrics.xWidthAvg / metrics.unitsPerEm;
-  const fallbackFontXAvgRatio = fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm;
-  const sizeAdjust = preferredFontXAvgRatio / fallbackFontXAvgRatio;
-  const adjustedEmSquare = metrics.unitsPerEm * sizeAdjust;
-  const ascentOverride = metrics.ascent / adjustedEmSquare;
-  const descentOverride = Math.abs(metrics.descent) / adjustedEmSquare;
-  const lineGapOverride = metrics.lineGap / adjustedEmSquare;
-  return renderFontFace({
-    "font-family": fallbackName,
-    src: renderFontSrc([{ name: fallbackFontName }]),
-    "size-adjust": toPercentage(sizeAdjust),
-    "ascent-override": toPercentage(ascentOverride),
-    "descent-override": toPercentage(descentOverride),
-    "line-gap-override": toPercentage(lineGapOverride),
-    ...properties
-  });
-}
-export {
-  generateFallbackFontFace,
-  readMetrics
-};