astro 5.16.11 → 5.16.12

package/client.d.ts

@@ -54,9 +54,7 @@ declare module 'astro:assets' {
 		Image: typeof import('./components/Image.astro').default;
 		Picture: typeof import('./components/Picture.astro').default;
 		Font: typeof import('./components/Font.astro').default;
-		getFontData: (
-			cssVariable: import('astro:assets').CssVariable,
-		) => Array<import('astro:assets').FontData>;
+		fontData: Record<import('astro:assets').CssVariable, Array<import('astro:assets').FontData>>;
 	};
 
 	type ImgAttributes = import('./dist/type-utils.js').WithRequired<
@@ -78,7 +76,7 @@ declare module 'astro:assets' {
 		Picture,
 		Font,
 		inferRemoteSize,
-		getFontData,
+		fontData,
 	}: AstroAssets;
 }
 

package/components/Font.astro

@@ -1,6 +1,6 @@
 ---
 import * as mod from 'virtual:astro:assets/fonts/internal';
-import { filterPreloads } from 'astro/assets/fonts/runtime';
+import { filterPreloads } from '../dist/assets/fonts/core/filter-preloads.js';
 import { AstroError, AstroErrorData } from '../dist/core/errors/index.js';
 
 // TODO: remove check when fonts are stabilized

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

@@ -58,9 +58,9 @@ export declare const localFontFamilySchema: z.ZodObject<{
     name: z.ZodString;
     cssVariable: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    provider: "local";
     name: string;
     cssVariable: string;
+    provider: "local";
     variants: [{
         src: [string | URL | {
             url: string | URL;
@@ -95,9 +95,9 @@ export declare const localFontFamilySchema: z.ZodObject<{
     fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
 }, {
-    provider: "local";
     name: string;
     cssVariable: string;
+    provider: "local";
     variants: [{
         src: [string | URL | {
             url: string | URL;
@@ -136,11 +136,11 @@ export declare const fontProviderSchema: z.ZodObject<{
     name: z.ZodString;
     config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     init: z.ZodOptional<z.ZodType<((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined, z.ZodTypeDef, ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined>>;
-    resolveFont: z.ZodType<(options: import("./types.js").ResolveFontOptions) => {
+    resolveFont: z.ZodType<(options: import("./types.js").ResolveFontOptions<never>) => {
         fonts: Array<import("unifont").FontFaceData>;
     } | Promise<{
         fonts: Array<import("unifont").FontFaceData>;
-    } | undefined> | undefined, z.ZodTypeDef, (options: import("./types.js").ResolveFontOptions) => {
+    } | undefined> | undefined, z.ZodTypeDef, (options: import("./types.js").ResolveFontOptions<never>) => {
         fonts: Array<import("unifont").FontFaceData>;
     } | Promise<{
         fonts: Array<import("unifont").FontFaceData>;
@@ -148,7 +148,7 @@ export declare const fontProviderSchema: z.ZodObject<{
     listFonts: z.ZodOptional<z.ZodType<(() => string[] | Promise<string[] | undefined> | undefined) | undefined, z.ZodTypeDef, (() => string[] | Promise<string[] | undefined> | undefined) | undefined>>;
 }, "strict", z.ZodTypeAny, {
     name: string;
-    resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+    resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
         fonts: Array<import("unifont").FontFaceData>;
     } | Promise<{
         fonts: Array<import("unifont").FontFaceData>;
@@ -158,7 +158,7 @@ export declare const fontProviderSchema: z.ZodObject<{
     listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
 }, {
     name: string;
-    resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+    resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
         fonts: Array<import("unifont").FontFaceData>;
     } | Promise<{
         fonts: Array<import("unifont").FontFaceData>;
@@ -172,11 +172,11 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
         name: z.ZodString;
         config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
         init: z.ZodOptional<z.ZodType<((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined, z.ZodTypeDef, ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined>>;
-        resolveFont: z.ZodType<(options: import("./types.js").ResolveFontOptions) => {
+        resolveFont: z.ZodType<(options: import("./types.js").ResolveFontOptions<never>) => {
             fonts: Array<import("unifont").FontFaceData>;
         } | Promise<{
             fonts: Array<import("unifont").FontFaceData>;
-        } | undefined> | undefined, z.ZodTypeDef, (options: import("./types.js").ResolveFontOptions) => {
+        } | undefined> | undefined, z.ZodTypeDef, (options: import("./types.js").ResolveFontOptions<never>) => {
             fonts: Array<import("unifont").FontFaceData>;
         } | Promise<{
             fonts: Array<import("unifont").FontFaceData>;
@@ -184,7 +184,7 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
         listFonts: z.ZodOptional<z.ZodType<(() => string[] | Promise<string[] | undefined> | undefined) | undefined, z.ZodTypeDef, (() => string[] | Promise<string[] | undefined> | undefined) | undefined>>;
     }, "strict", z.ZodTypeAny, {
         name: string;
-        resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+        resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
             fonts: Array<import("unifont").FontFaceData>;
         } | Promise<{
             fonts: Array<import("unifont").FontFaceData>;
@@ -194,7 +194,7 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
         listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
     }, {
         name: string;
-        resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+        resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
             fonts: Array<import("unifont").FontFaceData>;
         } | Promise<{
             fonts: Array<import("unifont").FontFaceData>;
@@ -203,6 +203,7 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
         init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
         listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
     }>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     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">>;
@@ -217,9 +218,11 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
     name: z.ZodString;
     cssVariable: z.ZodString;
 }, "strict", z.ZodTypeAny, {
+    name: string;
+    cssVariable: string;
     provider: {
         name: string;
-        resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+        resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
             fonts: Array<import("unifont").FontFaceData>;
         } | Promise<{
             fonts: Array<import("unifont").FontFaceData>;
@@ -228,23 +231,24 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
         init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
         listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
     };
-    name: string;
-    cssVariable: string;
-    weights?: [string | number, ...(string | number)[]] | undefined;
-    styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
-    subsets?: [string, ...string[]] | undefined;
-    fallbacks?: string[] | undefined;
-    optimizedFallbacks?: boolean | undefined;
-    formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
+    options?: Record<string, any> | undefined;
     display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
     stretch?: string | undefined;
     featureSettings?: string | undefined;
     variationSettings?: string | undefined;
     unicodeRange?: [string, ...string[]] | undefined;
+    fallbacks?: string[] | undefined;
+    optimizedFallbacks?: boolean | undefined;
+    weights?: [string | number, ...(string | number)[]] | undefined;
+    styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
+    subsets?: [string, ...string[]] | undefined;
+    formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
 }, {
+    name: string;
+    cssVariable: string;
     provider: {
         name: string;
-        resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+        resolveFont: (options: import("./types.js").ResolveFontOptions<never>) => {
             fonts: Array<import("unifont").FontFaceData>;
         } | Promise<{
             fonts: Array<import("unifont").FontFaceData>;
@@ -253,17 +257,16 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
         init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
         listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
     };
-    name: string;
-    cssVariable: string;
-    weights?: [string | number, ...(string | number)[]] | undefined;
-    styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
-    subsets?: [string, ...string[]] | undefined;
-    fallbacks?: string[] | undefined;
-    optimizedFallbacks?: boolean | undefined;
-    formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
+    options?: Record<string, any> | undefined;
     display?: "auto" | "block" | "swap" | "fallback" | "optional" | undefined;
     stretch?: string | undefined;
     featureSettings?: string | undefined;
     variationSettings?: string | undefined;
     unicodeRange?: [string, ...string[]] | undefined;
+    fallbacks?: string[] | undefined;
+    optimizedFallbacks?: boolean | undefined;
+    weights?: [string | number, ...(string | number)[]] | undefined;
+    styles?: ["normal" | "italic" | "oblique", ...("normal" | "italic" | "oblique")[]] | undefined;
+    subsets?: [string, ...string[]] | undefined;
+    formats?: ["woff2" | "woff" | "otf" | "ttf" | "eot", ...("woff2" | "woff" | "otf" | "ttf" | "eot")[]] | undefined;
 }>;

package/dist/assets/fonts/config.js

@@ -53,6 +53,7 @@ const remoteFontFamilySchema = z.object({
     style: true
   }).shape,
   provider: fontProviderSchema,
+  options: z.record(z.string(), z.any()).optional(),
   weights: z.array(weightSchema).nonempty().optional(),
   styles: z.array(styleSchema).nonempty().optional(),
   subsets: z.array(z.string()).nonempty().optional(),

package/dist/assets/fonts/core/filter-preloads.d.ts

@@ -0,0 +1,2 @@
+import type { PreloadData, PreloadFilter } from '../types.js';
+export declare function filterPreloads(data: Array<PreloadData>, preload: PreloadFilter): Array<PreloadData> | null;

package/dist/assets/fonts/core/filter-preloads.js

@@ -0,0 +1,37 @@
+function filterPreloads(data, preload) {
+  if (!preload) {
+    return null;
+  }
+  if (preload === true) {
+    return data;
+  }
+  return data.filter(
+    ({ weight, style, subset }) => preload.some((p) => {
+      if (p.weight !== void 0 && weight !== void 0 && !checkWeight(p.weight.toString(), weight)) {
+        return false;
+      }
+      if (p.style !== void 0 && p.style !== style) {
+        return false;
+      }
+      if (p.subset !== void 0 && p.subset !== subset) {
+        return false;
+      }
+      return true;
+    })
+  );
+}
+function checkWeight(input, target) {
+  const trimmedInput = input.trim();
+  if (trimmedInput.includes(" ")) {
+    return trimmedInput === target;
+  }
+  if (target.includes(" ")) {
+    const [a, b] = target.split(" ");
+    const parsedInput = Number.parseInt(input);
+    return parsedInput >= Number.parseInt(a) && parsedInput <= Number.parseInt(b);
+  }
+  return input === target;
+}
+export {
+  filterPreloads
+};

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 { FontFaceMetrics, FontFileData, FontType, GenericFallbackName, PreloadData, ResolveFontOptions, Style } from './types.js';
+import type { FontFaceMetrics, FontFileData, FontProvider, FontType, GenericFallbackName, PreloadData, ResolveFontOptions, Style } from './types.js';
 export interface Hasher {
     hashString: (input: string) => string;
     hashObject: (input: Record<string, any>) => string;
@@ -85,10 +85,10 @@ export interface Storage {
     setItemRaw: (key: string, value: any) => Promise<void>;
 }
 export interface FontResolver {
-    resolveFont: (options: ResolveFontOptions & {
-        provider: string;
+    resolveFont: (options: ResolveFontOptions<Record<string, any>> & {
+        provider: FontProvider;
     }) => Promise<Array<unifont.FontFaceData>>;
     listFonts: (options: {
-        provider: string;
+        provider: FontProvider;
     }) => Promise<string[] | undefined>;
 }

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

@@ -1,10 +1,17 @@
 import type { FontFaceData, Provider } from 'unifont';
 import type { FontResolver, Hasher, Storage } from '../definitions.js';
 import type { FontProvider, ResolvedFontFamily, ResolveFontOptions } from '../types.js';
-type NonEmptyProviders = [Provider, ...Array<Provider>];
+type NonEmptyProviders = [
+    Provider<string, Record<string, any>>,
+    ...Array<Provider<string, Record<string, any>>>
+];
 export declare class UnifontFontResolver implements FontResolver {
     #private;
     private constructor();
+    static idFromProvider({ hasher, provider }: {
+        hasher: Hasher;
+        provider: FontProvider;
+    }): string;
     static astroToUnifontProvider(astroProvider: FontProvider): Provider;
     static extractUnifontProviders({ families, hasher, }: {
         families: Array<ResolvedFontFamily>;
@@ -15,11 +22,11 @@ export declare class UnifontFontResolver implements FontResolver {
         hasher: Hasher;
         storage: Storage;
     }): Promise<UnifontFontResolver>;
-    resolveFont({ familyName, provider, ...rest }: ResolveFontOptions & {
-        provider: string;
+    resolveFont({ familyName, provider, options, ...rest }: ResolveFontOptions<Record<string, any>> & {
+        provider: FontProvider;
     }): Promise<Array<FontFaceData>>;
     listFonts({ provider }: {
-        provider: string;
+        provider: FontProvider;
     }): Promise<string[] | undefined>;
 }
 export {};

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

@@ -2,15 +2,27 @@ import { createUnifont, defineFontProvider } from "unifont";
 import { LOCAL_PROVIDER_NAME } from "../constants.js";
 class UnifontFontResolver {
   #unifont;
-  constructor({ unifont }) {
+  #hasher;
+  constructor({
+    unifont,
+    hasher
+  }) {
     this.#unifont = unifont;
+    this.#hasher = hasher;
+  }
+  static idFromProvider({ hasher, provider }) {
+    const hash = hasher.hashObject({
+      name: provider.name,
+      ...provider.config
+    });
+    return `${provider.name}-${hash}`;
   }
   static astroToUnifontProvider(astroProvider) {
     return defineFontProvider(astroProvider.name, async (_options, ctx) => {
       await astroProvider?.init?.(ctx);
       return {
-        async resolveFont(familyName, options) {
-          return await astroProvider.resolveFont({ familyName, ...options });
+        async resolveFont(familyName, { options, ...rest }) {
+          return await astroProvider.resolveFont({ familyName, options, ...rest });
         },
         async listFonts() {
           return astroProvider.listFonts?.();
@@ -22,25 +34,19 @@ class UnifontFontResolver {
     families,
     hasher
   }) {
-    const hashes = /* @__PURE__ */ new Set();
-    const providers = [];
+    const providers = /* @__PURE__ */ new Map();
     for (const { provider } of families) {
       if (provider === LOCAL_PROVIDER_NAME) {
         continue;
       }
-      const unifontProvider = this.astroToUnifontProvider(provider);
-      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);
+      const id = this.idFromProvider({ hasher, provider });
+      if (!providers.has(id)) {
+        const unifontProvider = this.astroToUnifontProvider(provider);
+        unifontProvider._name = this.idFromProvider({ hasher, provider });
+        providers.set(id, unifontProvider);
       }
     }
-    return providers;
+    return Array.from(providers.values());
   }
   static async create({
     families,
@@ -52,19 +58,42 @@ class UnifontFontResolver {
         storage,
         // TODO: consider enabling, would require new astro errors
         throwOnError: false
-      })
+      }),
+      hasher
     });
   }
   async resolveFont({
     familyName,
     provider,
+    options,
     ...rest
   }) {
-    const { fonts } = await this.#unifont.resolveFont(familyName, rest, [provider]);
+    const { fonts } = await this.#unifont.resolveFont(
+      familyName,
+      {
+        // Options are currently namespaced by provider name, it may change in
+        // https://github.com/unjs/unifont/pull/287
+        options: {
+          [provider.name]: options
+        },
+        ...rest
+      },
+      [
+        UnifontFontResolver.idFromProvider({
+          hasher: this.#hasher,
+          provider
+        })
+      ]
+    );
     return fonts;
   }
   async listFonts({ provider }) {
-    return await this.#unifont.listFonts([provider]);
+    return await this.#unifont.listFonts([
+      UnifontFontResolver.idFromProvider({
+        hasher: this.#hasher,
+        provider
+      })
+    ]);
   }
 }
 export {

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

@@ -1,6 +1,6 @@
 import type { Logger } from '../../core/logger/core.js';
 import type { CssRenderer, FontFileReader, FontMetricsResolver, FontResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, StringMatcher, SystemFallbacksProvider, UrlProxy } from './definitions.js';
-import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFileDataMap, InternalConsumableMap, ResolvedFontFamily } from './types.js';
+import type { CreateUrlProxyParams, Defaults, FontDataRecord, FontFamily, FontFileDataMap, InternalConsumableMap, ResolvedFontFamily } from './types.js';
 /**
  * Manages how fonts are resolved:
  *
@@ -38,5 +38,5 @@ export declare function orchestrate({ families, hasher, localProviderUrlResolver
 }): Promise<{
     fontFileDataMap: FontFileDataMap;
     internalConsumableMap: InternalConsumableMap;
-    consumableMap: ConsumableMap;
+    fontData: FontDataRecord;
 }>;

package/dist/assets/fonts/orchestrate.js

@@ -32,7 +32,7 @@ async function orchestrate({
   const fontResolver = await createFontResolver({ families: resolvedFamilies });
   const fontFileDataMap = /* @__PURE__ */ new Map();
   const internalConsumableMap = /* @__PURE__ */ new Map();
-  const consumableMap = /* @__PURE__ */ new Map();
+  const fontData = {};
   const resolvedFamiliesMap = /* @__PURE__ */ new Map();
   for (const family of resolvedFamilies) {
     const key = `${family.cssVariable}:${family.name}:${typeof family.provider === "string" ? family.provider : family.provider.name}`;
@@ -88,19 +88,20 @@ async function orchestrate({
     } else {
       const fonts = await fontResolver.resolveFont({
         familyName: family.name,
-        provider: family.provider.name,
+        provider: family.provider,
         // 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
+        formats: family.formats ?? defaults.formats,
+        options: family.options
       });
       if (fonts.length === 0) {
         logger.warn(
           "assets",
           `No data found for font family ${bold(family.name)}. Review your configuration`
         );
-        const availableFamilies = await fontResolver.listFonts({ provider: family.provider.name });
+        const availableFamilies = await fontResolver.listFonts({ provider: family.provider });
         if (availableFamilies && availableFamilies.length > 0 && !availableFamilies.includes(family.name)) {
           logger.warn(
             "assets",
@@ -118,7 +119,7 @@ async function orchestrate({
     collectedFonts,
     preloadData
   } of resolvedFamiliesMap.values()) {
-    const consumableMapValue = [];
+    const fontDataValue = [];
     let css = "";
     for (const data of fonts) {
       css += cssRenderer.generateFontFace(
@@ -136,7 +137,7 @@ async function orchestrate({
           variationSettings: pickFontFaceProperty("variationSettings", { data, family })
         })
       );
-      consumableMapValue.push({
+      fontDataValue.push({
         weight: renderFontWeight(data.weight),
         style: data.style,
         src: data.src.filter((src) => "url" in src).map((src) => ({
@@ -163,9 +164,9 @@ async function orchestrate({
     }
     css += cssRenderer.generateCssVariable(family.cssVariable, cssVarValues);
     internalConsumableMap.set(family.cssVariable, { preloadData, css });
-    consumableMap.set(family.cssVariable, consumableMapValue);
+    fontData[family.cssVariable] = fontDataValue;
   }
-  return { fontFileDataMap, internalConsumableMap, consumableMap };
+  return { fontFileDataMap, internalConsumableMap, fontData };
 }
 export {
   orchestrate

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

@@ -1,4 +1,4 @@
-import { type AdobeProviderOptions, type GoogleiconsOptions, type GoogleOptions } from 'unifont';
+import { type AdobeProviderOptions, type GoogleFamilyOptions, type GoogleiconsFamilyOptions } from 'unifont';
 import type { FontProvider } from '../types.js';
 /** [Adobe](https://fonts.adobe.com/) */
 declare function adobe(config: AdobeProviderOptions): FontProvider;
@@ -9,9 +9,9 @@ declare function fontshare(): FontProvider;
 /** [Fontsource](https://fontsource.org/) */
 declare function fontsource(): FontProvider;
 /** [Google](https://fonts.google.com/) */
-declare function google(config?: GoogleOptions): FontProvider;
+declare function google(): FontProvider<GoogleFamilyOptions | undefined>;
 /** [Google Icons](https://fonts.google.com/icons) */
-declare function googleicons(config?: GoogleiconsOptions): FontProvider;
+declare function googleicons(): FontProvider<GoogleiconsFamilyOptions | undefined>;
 /**
  * Astro re-exports most [unifont](https://github.com/unjs/unifont/) providers:
  * - [Adobe](https://fonts.adobe.com/)

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

@@ -66,12 +66,11 @@ function fontsource() {
     }
   };
 }
-function google(config) {
-  const provider = providers.google(config);
+function google() {
+  const provider = providers.google();
   let initializedProvider;
   return {
     name: provider._name,
-    config,
     async init(context) {
       initializedProvider = await provider(context);
     },
@@ -83,12 +82,11 @@ function google(config) {
     }
   };
 }
-function googleicons(config) {
-  const provider = providers.googleicons(config);
+function googleicons() {
+  const provider = providers.googleicons();
   let initializedProvider;
   return {
     name: provider._name,
-    config,
     async init(context) {
       initializedProvider = await provider(context);
     },

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

@@ -1,5 +1 @@
-import type { ConsumableMap, PreloadData, PreloadFilter } from './types.js';
-export declare function createGetFontData({ consumableMap }: {
-    consumableMap?: ConsumableMap;
-}): (cssVariable: string) => import("./types.js").FontData[];
-export declare function filterPreloads(data: Array<PreloadData>, preload: PreloadFilter): Array<PreloadData> | null;
+export declare const fontData: import("./types.js").FontDataRecord;

package/dist/assets/fonts/runtime.js

@@ -1,54 +1,5 @@
-import { AstroError, AstroErrorData } from "../../core/errors/index.js";
-function createGetFontData({ consumableMap }) {
-  return function getFontData(cssVariable) {
-    if (!consumableMap) {
-      throw new AstroError(AstroErrorData.ExperimentalFontsNotEnabled);
-    }
-    const data = consumableMap.get(cssVariable);
-    if (!data) {
-      throw new AstroError({
-        ...AstroErrorData.FontFamilyNotFound,
-        message: AstroErrorData.FontFamilyNotFound.message(cssVariable)
-      });
-    }
-    return data;
-  };
-}
-function filterPreloads(data, preload) {
-  if (!preload) {
-    return null;
-  }
-  if (preload === true) {
-    return data;
-  }
-  return data.filter(
-    ({ weight, style, subset }) => preload.some((p) => {
-      if (p.weight !== void 0 && weight !== void 0 && !checkWeight(p.weight.toString(), weight)) {
-        return false;
-      }
-      if (p.style !== void 0 && p.style !== style) {
-        return false;
-      }
-      if (p.subset !== void 0 && p.subset !== subset) {
-        return false;
-      }
-      return true;
-    })
-  );
-}
-function checkWeight(input, target) {
-  const trimmedInput = input.trim();
-  if (trimmedInput.includes(" ")) {
-    return trimmedInput === target;
-  }
-  if (target.includes(" ")) {
-    const [a, b] = target.split(" ");
-    const parsedInput = Number.parseInt(input);
-    return parsedInput >= Number.parseInt(a) && parsedInput <= Number.parseInt(b);
-  }
-  return input === target;
-}
+import * as fontsMod from "virtual:astro:assets/fonts/internal";
+const fontData = fontsMod.fontData ?? {};
 export {
-  createGetFontData,
-  filterPreloads
+  fontData
 };