astro 5.16.6 → 5.16.7

package/components/Code.astro

@@ -3,8 +3,8 @@ import type { ThemePresets } from '@astrojs/markdown-remark';
 import type { ShikiTransformer, ThemeRegistration, ThemeRegistrationRaw } from 'shiki';
 import { bundledLanguages } from 'shiki/langs';
 import { getCachedHighlighter } from '../dist/core/shiki.js';
-import type { CodeLanguage } from '../dist/types/public';
-import type { HTMLAttributes } from '../types';
+import type { CodeLanguage } from '../dist/types/public/index.js';
+import type { HTMLAttributes } from '../types.js';
 
 interface Props extends Omit<HTMLAttributes<'pre'>, 'lang'> {
 	/** The code to highlight. Required. */

package/components/Image.astro

@@ -1,8 +1,8 @@
 ---
 import { getImage, imageConfig, type LocalImageProps, type RemoteImageProps } from 'astro:assets';
-import type { UnresolvedImageTransform } from '../dist/assets/types';
+import type { UnresolvedImageTransform } from '../dist/assets/types.js';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
-import type { HTMLAttributes } from '../types';
+import type { HTMLAttributes } from '../types.js';
 
 // The TypeScript diagnostic for JSX props uses the last member of the union to suggest props, so it would be better for
 // LocalImageProps to be last. Unfortunately, when we do this the error messages that remote images get are complete nonsense

package/components/Picture.astro

@@ -8,7 +8,7 @@ import type {
 	ImageOutputFormat,
 	UnresolvedImageTransform,
 } from '../dist/types/public/index.js';
-import type { HTMLAttributes } from '../types';
+import type { HTMLAttributes } from '../types.js';
 
 export type Props = (LocalImageProps | RemoteImageProps) & {
 	formats?: ImageOutputFormat[];

package/dist/assets/build/remote.js

@@ -21,7 +21,7 @@ async function revalidateRemoteImage(src, revalidationData) {
     ...revalidationData.etag && { "If-None-Match": revalidationData.etag },
     ...revalidationData.lastModified && { "If-Modified-Since": revalidationData.lastModified }
   };
-  const req = new Request(src, { headers });
+  const req = new Request(src, { headers, cache: "no-cache" });
   const res = await fetch(req);
   if (!res.ok && res.status !== 304) {
     throw new Error(

package/dist/assets/endpoint/dev.js

@@ -1,33 +1,61 @@
-import { root } from "astro:config/server";
+import { safeModulePaths, viteFSConfig } from "astro:assets";
 import { readFile } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-import { isParentDirectory } from "@astrojs/internal-helpers/path";
+import os from "node:os";
+import picomatch from "picomatch";
+import { isFileLoadingAllowed } from "vite";
 import { handleImageRequest, loadRemoteImage } from "./shared.js";
+function replaceFileSystemReferences(src) {
+  return os.platform().includes("win32") ? src.replace(/^\/@fs\//, "") : src.replace(/^\/@fs/, "");
+}
 async function loadLocalImage(src, url) {
+  let returnValue;
+  let fsPath;
   if (src.startsWith("/@fs/")) {
-    try {
-      const res = await fetch(new URL(src, url));
-      if (!res.ok) {
-        return void 0;
-      }
-      return Buffer.from(await res.arrayBuffer());
-    } catch {
-      return void 0;
-    }
+    fsPath = replaceFileSystemReferences(src);
   }
-  if (isParentDirectory(fileURLToPath(root), src)) {
+  if (fsPath && isFileLoadingAllowed(
+    {
+      fsDenyGlob: picomatch(
+        // matchBase: true does not work as it's documented
+        // https://github.com/micromatch/picomatch/issues/89
+        // convert patterns without `/` on our side for now
+        viteFSConfig.deny.map(
+          (pattern) => pattern.includes("/") ? pattern : `**/${pattern}`
+        ),
+        {
+          matchBase: false,
+          nocase: true,
+          dot: true
+        }
+      ),
+      server: { fs: viteFSConfig },
+      safeModulePaths
+    },
+    fsPath
+  )) {
     try {
-      return await readFile(src);
+      returnValue = await readFile(fsPath);
     } catch {
-      return void 0;
+      returnValue = void 0;
+    }
+    if (!returnValue) {
+      try {
+        const res = await fetch(new URL(src, url));
+        if (res.ok) {
+          returnValue = Buffer.from(await res.arrayBuffer());
+        }
+      } catch {
+        returnValue = void 0;
+      }
     }
   } else {
     const sourceUrl = new URL(src, url.origin);
     if (sourceUrl.origin !== url.origin) {
-      return void 0;
+      returnValue = void 0;
     }
     return loadRemoteImage(sourceUrl);
   }
+  return returnValue;
 }
 const GET = async ({ request }) => {
   if (!import.meta.env.DEV) {

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

@@ -146,6 +146,7 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
     weights: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "atleastone">>;
     styles: z.ZodOptional<z.ZodArray<z.ZodEnum<["normal", "italic", "oblique"]>, "atleastone">>;
     subsets: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
+    formats: z.ZodOptional<z.ZodArray<z.ZodEnum<["woff2", "woff", "otf", "ttf", "eot"]>, "atleastone">>;
     display: z.ZodOptional<z.ZodEnum<["auto", "block", "swap", "fallback", "optional"]>>;
     stretch: z.ZodOptional<z.ZodString>;
     featureSettings: z.ZodOptional<z.ZodString>;
@@ -167,6 +168,7 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
     subsets?: [string, ...string[]] | undefined;
     fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
+    formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
     display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
     stretch?: string | undefined;
     featureSettings?: string | undefined;
@@ -184,6 +186,7 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
     subsets?: [string, ...string[]] | undefined;
     fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
+    formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
     display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
     stretch?: string | undefined;
     featureSettings?: string | undefined;

package/dist/assets/fonts/config.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { LOCAL_PROVIDER_NAME } from "./constants.js";
+import { FONT_TYPES, LOCAL_PROVIDER_NAME } from "./constants.js";
 const weightSchema = z.union([z.string(), z.number()]);
 const styleSchema = z.enum(["normal", "italic", "oblique"]);
 const displaySchema = z.enum(["auto", "block", "swap", "fallback", "optional"]);
@@ -51,7 +51,8 @@ const remoteFontFamilySchema = z.object({
   }).strict(),
   weights: z.array(weightSchema).nonempty().optional(),
   styles: z.array(styleSchema).nonempty().optional(),
-  subsets: z.array(z.string()).nonempty().optional()
+  subsets: z.array(z.string()).nonempty().optional(),
+  formats: z.array(z.enum(FONT_TYPES)).nonempty().optional()
 }).strict();
 export {
   displaySchema,

package/dist/assets/fonts/constants.js

@@ -5,7 +5,8 @@ const DEFAULTS = {
   subsets: ["latin"],
   // Technically serif is the browser default but most websites these days use sans-serif
   fallbacks: ["sans-serif"],
-  optimizedFallbacks: true
+  optimizedFallbacks: true,
+  formats: ["woff2"]
 };
 const VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/internal";
 const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;

package/dist/assets/fonts/core/resolve-families.js

@@ -42,6 +42,7 @@ async function resolveFamily({
     weights: family.weights ? dedupe(family.weights.map((weight) => weight.toString())) : void 0,
     styles: family.styles ? dedupe(family.styles) : void 0,
     subsets: family.subsets ? dedupe(family.subsets) : void 0,
+    formats: family.formats ? dedupe(family.formats) : void 0,
     fallbacks: family.fallbacks ? dedupe(family.fallbacks) : void 0,
     unicodeRange: family.unicodeRange ? dedupe(family.unicodeRange) : void 0,
     // This will be Astro specific eventually

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

@@ -1,6 +1,6 @@
 import type * as unifont from 'unifont';
 import type { CollectedFontForMetrics } from './core/optimize-fallbacks.js';
-import type { AstroFontProvider, FontFaceMetrics, FontFileData, FontType, GenericFallbackName, PreloadData, ResolvedFontProvider, Style } from './types.js';
+import type { FontFaceMetrics, FontFileData, FontProvider, FontType, GenericFallbackName, PreloadData, ResolvedFontProvider, ResolveFontOptions, Style } from './types.js';
 export interface Hasher {
     hashString: (input: string) => string;
     hashObject: (input: Record<string, any>) => string;
@@ -9,7 +9,7 @@ export interface RemoteFontProviderModResolver {
     resolve: (id: string) => Promise<any>;
 }
 export interface RemoteFontProviderResolver {
-    resolve: (provider: AstroFontProvider) => Promise<ResolvedFontProvider>;
+    resolve: (provider: FontProvider) => Promise<ResolvedFontProvider>;
 }
 export interface LocalProviderUrlResolver {
     resolve: (input: string) => string;
@@ -90,3 +90,11 @@ export interface Storage {
     setItem: (key: string, value: any) => Promise<void>;
     setItemRaw: (key: string, value: any) => Promise<void>;
 }
+export interface FontResolver {
+    resolveFont: (options: ResolveFontOptions & {
+        provider: string;
+    }) => Promise<Array<unifont.FontFaceData>>;
+    listFonts: (options: {
+        provider: string;
+    }) => Promise<string[] | undefined>;
+}

package/dist/assets/fonts/infra/remote-font-provider-resolver.d.ts

@@ -1,10 +1,10 @@
 import type { RemoteFontProviderModResolver, RemoteFontProviderResolver } from '../definitions.js';
-import type { AstroFontProvider, ResolvedFontProvider } from '../types.js';
+import type { FontProvider, ResolvedFontProvider } from '../types.js';
 export declare class RealRemoteFontProviderResolver implements RemoteFontProviderResolver {
     #private;
     constructor({ root, modResolver, }: {
         root: URL;
         modResolver: RemoteFontProviderModResolver;
     });
-    resolve({ entrypoint, config }: AstroFontProvider): Promise<ResolvedFontProvider>;
+    resolve({ entrypoint, config }: FontProvider): Promise<ResolvedFontProvider>;
 }

package/dist/assets/fonts/infra/unifont-font-resolver.d.ts

@@ -0,0 +1,24 @@
+import type { FontFaceData, Provider } from 'unifont';
+import type { FontResolver, Hasher, Storage } from '../definitions.js';
+import type { ResolvedFontFamily, ResolveFontOptions } from '../types.js';
+type NonEmptyProviders = [Provider, ...Array<Provider>];
+export declare class UnifontFontResolver implements FontResolver {
+    #private;
+    private constructor();
+    static extractUnifontProviders({ families, hasher, }: {
+        families: Array<ResolvedFontFamily>;
+        hasher: Hasher;
+    }): NonEmptyProviders;
+    static create({ families, hasher, storage, }: {
+        families: Array<ResolvedFontFamily>;
+        hasher: Hasher;
+        storage: Storage;
+    }): Promise<UnifontFontResolver>;
+    resolveFont({ familyName, provider, ...rest }: ResolveFontOptions & {
+        provider: string;
+    }): Promise<Array<FontFaceData>>;
+    listFonts({ provider }: {
+        provider: string;
+    }): Promise<string[] | undefined>;
+}
+export {};

package/dist/assets/fonts/infra/unifont-font-resolver.js

@@ -0,0 +1,59 @@
+import { createUnifont } from "unifont";
+import { LOCAL_PROVIDER_NAME } from "../constants.js";
+class UnifontFontResolver {
+  #unifont;
+  constructor({ unifont }) {
+    this.#unifont = unifont;
+  }
+  static extractUnifontProviders({
+    families,
+    hasher
+  }) {
+    const hashes = /* @__PURE__ */ new Set();
+    const providers = [];
+    for (const { provider } of families) {
+      if (provider === LOCAL_PROVIDER_NAME) {
+        continue;
+      }
+      const unifontProvider = provider.provider(provider.config);
+      const hash = hasher.hashObject({
+        name: unifontProvider._name,
+        ...provider.config
+      });
+      unifontProvider._name += `-${hash}`;
+      provider.name = unifontProvider._name;
+      if (!hashes.has(hash)) {
+        hashes.add(hash);
+        providers.push(unifontProvider);
+      }
+    }
+    return providers;
+  }
+  static async create({
+    families,
+    hasher,
+    storage
+  }) {
+    return new UnifontFontResolver({
+      unifont: await createUnifont(this.extractUnifontProviders({ families, hasher }), {
+        storage,
+        // TODO: consider enabling, would require new astro errors
+        throwOnError: false
+      })
+    });
+  }
+  async resolveFont({
+    familyName,
+    provider,
+    ...rest
+  }) {
+    const { fonts } = await this.#unifont.resolveFont(familyName, rest, [provider]);
+    return fonts;
+  }
+  async listFonts({ provider }) {
+    return await this.#unifont.listFonts([provider]);
+  }
+}
+export {
+  UnifontFontResolver
+};

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

@@ -1,6 +1,6 @@
 import type { Logger } from '../../core/logger/core.js';
-import type { CssRenderer, FontFileReader, FontMetricsResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver, Storage, StringMatcher, SystemFallbacksProvider, UrlProxy } from './definitions.js';
-import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFileDataMap, InternalConsumableMap } from './types.js';
+import type { CssRenderer, FontFileReader, FontMetricsResolver, FontResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver, StringMatcher, SystemFallbacksProvider, UrlProxy } from './definitions.js';
+import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFileDataMap, InternalConsumableMap, ResolvedFontFamily } from './types.js';
 /**
  * Manages how fonts are resolved:
  *
@@ -19,12 +19,11 @@ import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFil
  *
  * Once that's done, the collected data is returned
  */
-export declare function orchestrate({ families, hasher, remoteFontProviderResolver, localProviderUrlResolver, storage, cssRenderer, systemFallbacksProvider, fontMetricsResolver, fontTypeExtractor, fontFileReader, logger, createUrlProxy, defaults, bold, stringMatcher, }: {
+export declare function orchestrate({ families, hasher, remoteFontProviderResolver, localProviderUrlResolver, cssRenderer, systemFallbacksProvider, fontMetricsResolver, fontTypeExtractor, fontFileReader, logger, createUrlProxy, defaults, bold, stringMatcher, createFontResolver, }: {
     families: Array<FontFamily>;
     hasher: Hasher;
     remoteFontProviderResolver: RemoteFontProviderResolver;
     localProviderUrlResolver: LocalProviderUrlResolver;
-    storage: Storage;
     cssRenderer: CssRenderer;
     systemFallbacksProvider: SystemFallbacksProvider;
     fontMetricsResolver: FontMetricsResolver;
@@ -35,6 +34,9 @@ export declare function orchestrate({ families, hasher, remoteFontProviderResolv
     defaults: Defaults;
     bold: (input: string) => string;
     stringMatcher: StringMatcher;
+    createFontResolver: (params: {
+        families: Array<ResolvedFontFamily>;
+    }) => Promise<FontResolver>;
 }): Promise<{
     fontFileDataMap: FontFileDataMap;
     internalConsumableMap: InternalConsumableMap;

package/dist/assets/fonts/orchestrate.js

@@ -1,7 +1,4 @@
-import * as unifont from "unifont";
 import { LOCAL_PROVIDER_NAME } from "./constants.js";
-import { dedupeFontFaces } from "./core/dedupe-font-faces.js";
-import { extractUnifontProviders } from "./core/extract-unifont-providers.js";
 import { normalizeRemoteFontFaces } from "./core/normalize-remote-font-faces.js";
 import { optimizeFallbacks } from "./core/optimize-fallbacks.js";
 import { resolveFamilies } from "./core/resolve-families.js";
@@ -16,7 +13,6 @@ async function orchestrate({
   hasher,
   remoteFontProviderResolver,
   localProviderUrlResolver,
-  storage,
   cssRenderer,
   systemFallbacksProvider,
   fontMetricsResolver,
@@ -26,23 +22,16 @@ async function orchestrate({
   createUrlProxy,
   defaults,
   bold,
-  stringMatcher
+  stringMatcher,
+  createFontResolver
 }) {
-  let resolvedFamilies = await resolveFamilies({
+  const resolvedFamilies = await resolveFamilies({
     families,
     hasher,
     remoteFontProviderResolver,
     localProviderUrlResolver
   });
-  const extractedUnifontProvidersResult = extractUnifontProviders({
-    families: resolvedFamilies,
-    hasher
-  });
-  resolvedFamilies = extractedUnifontProvidersResult.families;
-  const unifontProviders = extractedUnifontProvidersResult.providers;
-  const { resolveFont, listFonts } = await unifont.createUnifont(unifontProviders, {
-    storage
-  });
+  const fontResolver = await createFontResolver({ families: resolvedFamilies });
   const fontFileDataMap = /* @__PURE__ */ new Map();
   const internalConsumableMap = /* @__PURE__ */ new Map();
   const consumableMap = /* @__PURE__ */ new Map();
@@ -99,26 +88,24 @@ async function orchestrate({
       });
       resolvedFamily.fonts.push(...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
-        },
+      const fonts = await fontResolver.resolveFont({
+        familyName: family.name,
         // 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 extractUnifontProviders).
-        [family.provider.name]
-      );
-      if (result.fonts.length === 0) {
+        provider: family.provider.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,
+        formats: family.formats ?? defaults.formats
+      });
+      if (fonts.length === 0) {
         logger.warn(
           "assets",
           `No data found for font family ${bold(family.name)}. Review your configuration`
         );
-        const availableFamilies = await listFonts([family.provider.name]);
+        const availableFamilies = await fontResolver.listFonts({ provider: family.provider.name });
         if (availableFamilies && availableFamilies.length > 0 && !availableFamilies.includes(family.name)) {
           logger.warn(
             "assets",
@@ -126,10 +113,7 @@ async function orchestrate({
           );
         }
       }
-      resolvedFamily.fonts = dedupeFontFaces(
-        resolvedFamily.fonts,
-        normalizeRemoteFontFaces({ fonts: result.fonts, urlProxy, fontTypeExtractor })
-      );
+      resolvedFamily.fonts = normalizeRemoteFontFaces({ fonts, urlProxy, fontTypeExtractor });
     }
   }
   for (const {

package/dist/assets/fonts/providers/entrypoints/bunny.d.ts

@@ -1 +1 @@
-export declare const provider: () => import("unifont").Provider;
+export declare const provider: () => import("unifont").Provider<"bunny", never>;

package/dist/assets/fonts/providers/entrypoints/fontshare.d.ts

@@ -1 +1 @@
-export declare const provider: () => import("unifont").Provider;
+export declare const provider: () => import("unifont").Provider<"fontshare", never>;

package/dist/assets/fonts/providers/entrypoints/fontsource.d.ts

@@ -1 +1 @@
-export declare const provider: () => import("unifont").Provider;
+export declare const provider: () => import("unifont").Provider<"fontsource", never>;

package/dist/assets/fonts/providers/index.d.ts

@@ -1,15 +1,15 @@
 import type { providers } from 'unifont';
-import type { AstroFontProvider } from '../types.js';
+import type { FontProvider } from '../types.js';
 /** [Adobe](https://fonts.adobe.com/) */
-declare function adobe(config: Parameters<typeof providers.adobe>[0]): AstroFontProvider;
+declare function adobe(config: Parameters<typeof providers.adobe>[0]): FontProvider;
 /** [Bunny](https://fonts.bunny.net/) */
-declare function bunny(): AstroFontProvider;
+declare function bunny(): FontProvider;
 /** [Fontshare](https://www.fontshare.com/) */
-declare function fontshare(): AstroFontProvider;
+declare function fontshare(): FontProvider;
 /** [Fontsource](https://fontsource.org/) */
-declare function fontsource(): AstroFontProvider;
+declare function fontsource(): FontProvider;
 /** [Google](https://fonts.google.com/) */
-declare function google(config?: Parameters<typeof providers.google>[0]): AstroFontProvider;
+declare function google(config?: Parameters<typeof providers.google>[0]): FontProvider;
 /**
  * Astro re-exports most [unifont](https://github.com/unjs/unifont/) providers:
  * - [Adobe](https://fonts.adobe.com/)
@@ -25,6 +25,4 @@ export declare const fontProviders: {
     fontsource: typeof fontsource;
     google: typeof google;
 };
-/** A type helper for defining Astro font providers config objects */
-export declare function defineAstroFontProvider(provider: AstroFontProvider): AstroFontProvider;
 export {};

package/dist/assets/fonts/providers/index.js

@@ -1,29 +1,29 @@
 function adobe(config) {
-  return defineAstroFontProvider({
+  return {
     entrypoint: "astro/assets/fonts/providers/adobe",
     config
-  });
+  };
 }
 function bunny() {
-  return defineAstroFontProvider({
+  return {
     entrypoint: "astro/assets/fonts/providers/bunny"
-  });
+  };
 }
 function fontshare() {
-  return defineAstroFontProvider({
+  return {
     entrypoint: "astro/assets/fonts/providers/fontshare"
-  });
+  };
 }
 function fontsource() {
-  return defineAstroFontProvider({
+  return {
     entrypoint: "astro/assets/fonts/providers/fontsource"
-  });
+  };
 }
 function google(config) {
-  return defineAstroFontProvider({
+  return {
     entrypoint: "astro/assets/fonts/providers/google",
     config
-  });
+  };
 }
 const fontProviders = {
   adobe,
@@ -32,10 +32,6 @@ const fontProviders = {
   fontsource,
   google
 };
-function defineAstroFontProvider(provider) {
-  return provider;
-}
 export {
-  defineAstroFontProvider,
   fontProviders
 };

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

@@ -6,7 +6,7 @@ import type { FONT_TYPES, GENERIC_FALLBACK_NAMES, LOCAL_PROVIDER_NAME } from './
 import type { CollectedFontForMetrics } from './core/optimize-fallbacks.js';
 type Weight = z.infer<typeof weightSchema>;
 type Display = z.infer<typeof displaySchema>;
-export interface AstroFontProvider {
+export interface FontProvider {
     /**
      * URL, path relative to the root or package import.
      */
@@ -126,11 +126,11 @@ export interface ResolvedLocalFontFamily extends ResolvedFontFamilyAttributes, O
         }>;
     }>;
 }
-export interface RemoteFontFamily extends RequiredFamilyAttributes, Omit<FamilyProperties, 'weight' | 'style'>, Fallbacks {
+export interface RemoteFontFamily extends RequiredFamilyAttributes, Omit<FamilyProperties, 'weight' | 'style' | 'subsets' | 'formats'>, Fallbacks {
     /**
      * The source of your font files. You can use a built-in provider or write your own custom provider.
      */
-    provider: AstroFontProvider;
+    provider: FontProvider;
     /**
      * @default `[400]`
      *
@@ -153,6 +153,12 @@ export interface RemoteFontFamily extends RequiredFamilyAttributes, Omit<FamilyP
      * An array of [font subsets](https://knaap.dev/posts/font-subsetting/):
      */
     subsets?: [string, ...Array<string>] | undefined;
+    /**
+     * @default `["woff2"]`
+     *
+     * An array of [font formats](https://developer.mozilla.org/en-US/docs/Web/CSS/Reference/At-rules/@font-face/src#font_formats).
+     */
+    formats?: [FontType, ...Array<FontType>] | undefined;
 }
 /** @lintignore somehow required by pickFontFaceProperty in utils */
 export interface ResolvedRemoteFontFamily extends ResolvedFontFamilyAttributes, Omit<RemoteFontFamily, 'provider' | 'weights'> {
@@ -180,7 +186,7 @@ export interface PreloadData {
 }
 export type FontFaceMetrics = Pick<Font, 'ascent' | 'descent' | 'lineGap' | 'unitsPerEm' | 'xWidthAvg'>;
 export type GenericFallbackName = (typeof GENERIC_FALLBACK_NAMES)[number];
-export type Defaults = Partial<Pick<ResolvedRemoteFontFamily, 'weights' | 'styles' | 'subsets' | 'fallbacks' | 'optimizedFallbacks'>>;
+export type Defaults = Partial<Pick<ResolvedRemoteFontFamily, 'weights' | 'styles' | 'subsets' | 'fallbacks' | 'optimizedFallbacks' | 'formats'>>;
 export interface FontFileData {
     hash: string;
     url: string;
@@ -225,4 +231,11 @@ export type PreloadFilter = boolean | Array<{
     style?: string;
     subset?: string;
 }>;
+export interface ResolveFontOptions {
+    familyName: string;
+    weights: string[] | undefined;
+    styles: Style[] | undefined;
+    subsets: string[] | undefined;
+    formats: FontType[] | undefined;
+}
 export {};

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

@@ -35,6 +35,7 @@ import { RealRemoteFontProviderResolver } from "./infra/remote-font-provider-res
 import { RemoteUrlProxyContentResolver } from "./infra/remote-url-proxy-content-resolver.js";
 import { RequireLocalProviderUrlResolver } from "./infra/require-local-provider-url-resolver.js";
 import { RealSystemFallbacksProvider } from "./infra/system-fallbacks-provider.js";
+import { UnifontFontResolver } from "./infra/unifont-font-resolver.js";
 import { UnstorageFsStorage } from "./infra/unstorage-fs-storage.js";
 import { RealUrlProxy } from "./infra/url-proxy.js";
 import { XxhashHasher } from "./infra/xxhash-hasher.js";
@@ -114,7 +115,11 @@ function fontsPlugin({ settings, sync, logger }) {
       hasher,
       remoteFontProviderResolver,
       localProviderUrlResolver,
-      storage,
+      createFontResolver: async ({ families }) => await UnifontFontResolver.create({
+        families,
+        hasher,
+        storage
+      }),
       cssRenderer,
       systemFallbacksProvider,
       fontMetricsResolver,

package/dist/assets/utils/index.d.ts

@@ -4,6 +4,7 @@
  *
  * If some functions don't need to be exposed, just import the file that contains the functions.
  */
+export { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern, } from '@astrojs/internal-helpers/remote';
 export { isESMImportedImage, isRemoteImage, resolveSrc } from './imageKind.js';
 export { imageMetadata } from './metadata.js';
 export { 
@@ -12,6 +13,5 @@ export {
  */
 emitESMImage, emitImageMetadata, } from './node/emitAsset.js';
 export { getOrigQueryParams } from './queryParams.js';
-export { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern, } from './remotePattern.js';
 export { inferRemoteSize } from './remoteProbe.js';
 export { hashTransform, propsToFilename } from './transformToPath.js';

package/dist/assets/utils/index.js

@@ -1,10 +1,3 @@
-import { isESMImportedImage, isRemoteImage, resolveSrc } from "./imageKind.js";
-import { imageMetadata } from "./metadata.js";
-import {
-  emitESMImage,
-  emitImageMetadata
-} from "./node/emitAsset.js";
-import { getOrigQueryParams } from "./queryParams.js";
 import {
   isRemoteAllowed,
   matchHostname,
@@ -12,7 +5,14 @@ import {
   matchPattern,
   matchPort,
   matchProtocol
-} from "./remotePattern.js";
+} from "@astrojs/internal-helpers/remote";
+import { isESMImportedImage, isRemoteImage, resolveSrc } from "./imageKind.js";
+import { imageMetadata } from "./metadata.js";
+import {
+  emitESMImage,
+  emitImageMetadata
+} from "./node/emitAsset.js";
+import { getOrigQueryParams } from "./queryParams.js";
 import { inferRemoteSize } from "./remoteProbe.js";
 import { hashTransform, propsToFilename } from "./transformToPath.js";
 export {