astro 5.16.8 → 5.16.9

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

@@ -132,16 +132,76 @@ export declare const localFontFamilySchema: z.ZodObject<{
     fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
 }>;
+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) => {
+        fonts: Array<import("unifont").FontFaceData>;
+    } | Promise<{
+        fonts: Array<import("unifont").FontFaceData>;
+    } | undefined> | undefined, z.ZodTypeDef, (options: import("./types.js").ResolveFontOptions) => {
+        fonts: Array<import("unifont").FontFaceData>;
+    } | Promise<{
+        fonts: Array<import("unifont").FontFaceData>;
+    } | undefined> | undefined>;
+    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) => {
+        fonts: Array<import("unifont").FontFaceData>;
+    } | Promise<{
+        fonts: Array<import("unifont").FontFaceData>;
+    } | undefined> | undefined;
+    config?: Record<string, any> | undefined;
+    init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
+    listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
+}, {
+    name: string;
+    resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+        fonts: Array<import("unifont").FontFaceData>;
+    } | Promise<{
+        fonts: Array<import("unifont").FontFaceData>;
+    } | undefined> | undefined;
+    config?: Record<string, any> | undefined;
+    init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
+    listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
+}>;
 export declare const remoteFontFamilySchema: z.ZodObject<{
     provider: z.ZodObject<{
-        entrypoint: z.ZodUnion<[z.ZodString, z.ZodType<URL, z.ZodTypeDef, URL>]>;
+        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) => {
+            fonts: Array<import("unifont").FontFaceData>;
+        } | Promise<{
+            fonts: Array<import("unifont").FontFaceData>;
+        } | undefined> | undefined, z.ZodTypeDef, (options: import("./types.js").ResolveFontOptions) => {
+            fonts: Array<import("unifont").FontFaceData>;
+        } | Promise<{
+            fonts: Array<import("unifont").FontFaceData>;
+        } | undefined> | undefined>;
+        listFonts: z.ZodOptional<z.ZodType<(() => string[] | Promise<string[] | undefined> | undefined) | undefined, z.ZodTypeDef, (() => string[] | Promise<string[] | undefined> | undefined) | undefined>>;
     }, "strict", z.ZodTypeAny, {
-        entrypoint: string | URL;
+        name: string;
+        resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+            fonts: Array<import("unifont").FontFaceData>;
+        } | Promise<{
+            fonts: Array<import("unifont").FontFaceData>;
+        } | undefined> | undefined;
         config?: Record<string, any> | undefined;
+        init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
+        listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
     }, {
-        entrypoint: string | URL;
+        name: string;
+        resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+            fonts: Array<import("unifont").FontFaceData>;
+        } | Promise<{
+            fonts: Array<import("unifont").FontFaceData>;
+        } | undefined> | undefined;
         config?: Record<string, any> | undefined;
+        init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
+        listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
     }>;
     weights: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodNumber]>, "atleastone">>;
     styles: z.ZodOptional<z.ZodArray<z.ZodEnum<["normal", "italic", "oblique"]>, "atleastone">>;
@@ -158,8 +218,15 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
     cssVariable: z.ZodString;
 }, "strict", z.ZodTypeAny, {
     provider: {
-        entrypoint: string | URL;
+        name: string;
+        resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+            fonts: Array<import("unifont").FontFaceData>;
+        } | Promise<{
+            fonts: Array<import("unifont").FontFaceData>;
+        } | undefined> | undefined;
         config?: Record<string, any> | undefined;
+        init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
+        listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
     };
     name: string;
     cssVariable: string;
@@ -176,8 +243,15 @@ export declare const remoteFontFamilySchema: z.ZodObject<{
     unicodeRange?: [string, ...string[]] | undefined;
 }, {
     provider: {
-        entrypoint: string | URL;
+        name: string;
+        resolveFont: (options: import("./types.js").ResolveFontOptions) => {
+            fonts: Array<import("unifont").FontFaceData>;
+        } | Promise<{
+            fonts: Array<import("unifont").FontFaceData>;
+        } | undefined> | undefined;
         config?: Record<string, any> | undefined;
+        init?: ((context: import("./types.js").FontProviderInitContext) => void | Promise<void>) | undefined;
+        listFonts?: (() => string[] | Promise<string[] | undefined> | undefined) | undefined;
     };
     name: string;
     cssVariable: string;

package/dist/assets/fonts/config.js

@@ -38,6 +38,13 @@ const localFontFamilySchema = z.object({
     }).strict()
   ).nonempty()
 }).strict();
+const fontProviderSchema = z.object({
+  name: z.string(),
+  config: z.record(z.string(), z.any()).optional(),
+  init: z.custom((v) => typeof v === "function").optional(),
+  resolveFont: z.custom((v) => typeof v === "function"),
+  listFonts: z.custom((v) => typeof v === "function").optional()
+}).strict();
 const remoteFontFamilySchema = z.object({
   ...requiredFamilyAttributesSchema.shape,
   ...fallbacksSchema.shape,
@@ -45,10 +52,7 @@ const remoteFontFamilySchema = z.object({
     weight: true,
     style: true
   }).shape,
-  provider: z.object({
-    entrypoint: entrypointSchema,
-    config: z.record(z.string(), z.any()).optional()
-  }).strict(),
+  provider: fontProviderSchema,
   weights: z.array(weightSchema).nonempty().optional(),
   styles: z.array(styleSchema).nonempty().optional(),
   subsets: z.array(z.string()).nonempty().optional(),
@@ -56,6 +60,7 @@ const remoteFontFamilySchema = z.object({
 }).strict();
 export {
   displaySchema,
+  fontProviderSchema,
   localFontFamilySchema,
   remoteFontFamilySchema,
   styleSchema,

package/dist/assets/fonts/core/resolve-families.d.ts

@@ -1,17 +1,16 @@
-import type { Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver } from '../definitions.js';
+import type { Hasher, LocalProviderUrlResolver } from '../definitions.js';
 import type { FontFamily, ResolvedFontFamily } from '../types.js';
 /**
  * Dedupes properties if applicable and resolves entrypoints.
  */
-export declare function resolveFamily({ family, hasher, remoteFontProviderResolver, localProviderUrlResolver, }: {
+export declare function resolveFamily({ family, hasher, localProviderUrlResolver, }: {
     family: FontFamily;
     hasher: Hasher;
-    remoteFontProviderResolver: RemoteFontProviderResolver;
     localProviderUrlResolver: LocalProviderUrlResolver;
-}): Promise<ResolvedFontFamily>;
+}): ResolvedFontFamily;
 /**
  * A function for convenience. The actual logic lives in resolveFamily
  */
 export declare function resolveFamilies({ families, ...dependencies }: {
     families: Array<FontFamily>;
-} & Omit<Parameters<typeof resolveFamily>[0], 'family'>): Promise<Array<ResolvedFontFamily>>;
+} & Omit<Parameters<typeof resolveFamily>[0], 'family'>): Array<ResolvedFontFamily>;

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

@@ -18,10 +18,9 @@ function resolveVariants({
     })
   }));
 }
-async function resolveFamily({
+function resolveFamily({
   family,
   hasher,
-  remoteFontProviderResolver,
   localProviderUrlResolver
 }) {
   const name = withoutQuotes(family.name);
@@ -44,22 +43,18 @@ async function resolveFamily({
     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
-    provider: await remoteFontProviderResolver.resolve(family.provider)
+    unicodeRange: family.unicodeRange ? dedupe(family.unicodeRange) : void 0
   };
 }
-async function resolveFamilies({
+function resolveFamilies({
   families,
   ...dependencies
 }) {
-  return await Promise.all(
-    families.map(
-      (family) => resolveFamily({
-        family,
-        ...dependencies
-      })
-    )
+  return families.map(
+    (family) => resolveFamily({
+      family,
+      ...dependencies
+    })
   );
 }
 export {

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

@@ -1,16 +1,10 @@
 import type * as unifont from 'unifont';
 import type { CollectedFontForMetrics } from './core/optimize-fallbacks.js';
-import type { FontFaceMetrics, FontFileData, FontProvider, FontType, GenericFallbackName, PreloadData, ResolvedFontProvider, ResolveFontOptions, Style } from './types.js';
+import type { FontFaceMetrics, FontFileData, FontType, GenericFallbackName, PreloadData, ResolveFontOptions, Style } from './types.js';
 export interface Hasher {
     hashString: (input: string) => string;
     hashObject: (input: Record<string, any>) => string;
 }
-export interface RemoteFontProviderModResolver {
-    resolve: (id: string) => Promise<any>;
-}
-export interface RemoteFontProviderResolver {
-    resolve: (provider: FontProvider) => Promise<ResolvedFontProvider>;
-}
 export interface LocalProviderUrlResolver {
     resolve: (input: string) => string;
 }

package/dist/assets/fonts/infra/require-local-provider-url-resolver.js

@@ -1,5 +1,5 @@
-import { fileURLToPath } from "node:url";
-import { resolveEntrypoint } from "../utils.js";
+import { createRequire } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
 class RequireLocalProviderUrlResolver {
   #root;
   // TODO: remove when stabilizing
@@ -11,8 +11,16 @@ class RequireLocalProviderUrlResolver {
     this.#root = root;
     this.#intercept = intercept;
   }
+  #resolveEntrypoint(root, entrypoint) {
+    const require2 = createRequire(root);
+    try {
+      return pathToFileURL(require2.resolve(entrypoint));
+    } catch {
+      return new URL(entrypoint, root);
+    }
+  }
   resolve(input) {
-    const path = fileURLToPath(resolveEntrypoint(this.#root, input));
+    const path = fileURLToPath(this.#resolveEntrypoint(this.#root, input));
     this.#intercept?.(path);
     return path;
   }

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

@@ -1,10 +1,11 @@
 import type { FontFaceData, Provider } from 'unifont';
 import type { FontResolver, Hasher, Storage } from '../definitions.js';
-import type { ResolvedFontFamily, ResolveFontOptions } from '../types.js';
+import type { FontProvider, ResolvedFontFamily, ResolveFontOptions } from '../types.js';
 type NonEmptyProviders = [Provider, ...Array<Provider>];
 export declare class UnifontFontResolver implements FontResolver {
     #private;
     private constructor();
+    static astroToUnifontProvider(astroProvider: FontProvider): Provider;
     static extractUnifontProviders({ families, hasher, }: {
         families: Array<ResolvedFontFamily>;
         hasher: Hasher;

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

@@ -1,10 +1,23 @@
-import { createUnifont } from "unifont";
+import { createUnifont, defineFontProvider } from "unifont";
 import { LOCAL_PROVIDER_NAME } from "../constants.js";
 class UnifontFontResolver {
   #unifont;
   constructor({ unifont }) {
     this.#unifont = unifont;
   }
+  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 listFonts() {
+          return astroProvider.listFonts?.();
+        }
+      };
+    })(astroProvider.config);
+  }
   static extractUnifontProviders({
     families,
     hasher
@@ -15,7 +28,7 @@ class UnifontFontResolver {
       if (provider === LOCAL_PROVIDER_NAME) {
         continue;
       }
-      const unifontProvider = provider.provider(provider.config);
+      const unifontProvider = this.astroToUnifontProvider(provider);
       const hash = hasher.hashObject({
         name: unifontProvider._name,
         ...provider.config

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

@@ -1,12 +1,11 @@
 import type { Logger } from '../../core/logger/core.js';
-import type { CssRenderer, FontFileReader, FontMetricsResolver, FontResolver, FontTypeExtractor, Hasher, LocalProviderUrlResolver, RemoteFontProviderResolver, StringMatcher, SystemFallbacksProvider, UrlProxy } from './definitions.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';
 /**
  * Manages how fonts are resolved:
  *
  * - families are resolved
- * - unifont providers are extracted from families
- * - unifont is initialized
+ * - font resolver is initialized
  *
  * For each family:
  * - We create a URL proxy
@@ -19,10 +18,9 @@ import type { ConsumableMap, CreateUrlProxyParams, Defaults, FontFamily, FontFil
  *
  * Once that's done, the collected data is returned
  */
-export declare function orchestrate({ families, hasher, remoteFontProviderResolver, localProviderUrlResolver, cssRenderer, systemFallbacksProvider, fontMetricsResolver, fontTypeExtractor, fontFileReader, logger, createUrlProxy, defaults, bold, stringMatcher, createFontResolver, }: {
+export declare function orchestrate({ families, hasher, localProviderUrlResolver, cssRenderer, systemFallbacksProvider, fontMetricsResolver, fontTypeExtractor, fontFileReader, logger, createUrlProxy, defaults, bold, stringMatcher, createFontResolver, }: {
     families: Array<FontFamily>;
     hasher: Hasher;
-    remoteFontProviderResolver: RemoteFontProviderResolver;
     localProviderUrlResolver: LocalProviderUrlResolver;
     cssRenderer: CssRenderer;
     systemFallbacksProvider: SystemFallbacksProvider;

package/dist/assets/fonts/orchestrate.js

@@ -11,7 +11,6 @@ import {
 async function orchestrate({
   families,
   hasher,
-  remoteFontProviderResolver,
   localProviderUrlResolver,
   cssRenderer,
   systemFallbacksProvider,
@@ -25,10 +24,9 @@ async function orchestrate({
   stringMatcher,
   createFontResolver
 }) {
-  const resolvedFamilies = await resolveFamilies({
+  const resolvedFamilies = resolveFamilies({
     families,
     hasher,
-    remoteFontProviderResolver,
     localProviderUrlResolver
   });
   const fontResolver = await createFontResolver({ families: resolvedFamilies });
@@ -80,19 +78,16 @@ async function orchestrate({
       cssVariable: family.cssVariable
     });
     if (family.provider === LOCAL_PROVIDER_NAME) {
-      const result = resolveLocalFont({
+      const fonts = resolveLocalFont({
         family,
         urlProxy,
         fontTypeExtractor,
         fontFileReader
       });
-      resolvedFamily.fonts.push(...result.fonts);
+      resolvedFamily.fonts.push(...fonts);
     } else {
       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).
         provider: family.provider.name,
         // We do not merge the defaults, we only provide defaults as a fallback
         weights: family.weights ?? defaults.weights,

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

@@ -1,7 +1,7 @@
-import type { providers } from 'unifont';
+import { type AdobeProviderOptions, type GoogleiconsOptions, type GoogleOptions } from 'unifont';
 import type { FontProvider } from '../types.js';
 /** [Adobe](https://fonts.adobe.com/) */
-declare function adobe(config: Parameters<typeof providers.adobe>[0]): FontProvider;
+declare function adobe(config: AdobeProviderOptions): FontProvider;
 /** [Bunny](https://fonts.bunny.net/) */
 declare function bunny(): FontProvider;
 /** [Fontshare](https://www.fontshare.com/) */
@@ -9,7 +9,9 @@ declare function fontshare(): FontProvider;
 /** [Fontsource](https://fontsource.org/) */
 declare function fontsource(): FontProvider;
 /** [Google](https://fonts.google.com/) */
-declare function google(config?: Parameters<typeof providers.google>[0]): FontProvider;
+declare function google(config?: GoogleOptions): FontProvider;
+/** [Google Icons](https://fonts.google.com/icons) */
+declare function googleicons(config?: GoogleiconsOptions): FontProvider;
 /**
  * Astro re-exports most [unifont](https://github.com/unjs/unifont/) providers:
  * - [Adobe](https://fonts.adobe.com/)
@@ -17,6 +19,7 @@ declare function google(config?: Parameters<typeof providers.google>[0]): FontPr
  * - [Fontshare](https://www.fontshare.com/)
  * - [Fontsource](https://fontsource.org/)
  * - [Google](https://fonts.google.com/)
+ * - [Google Icons](https://fonts.google.com/icons)
  */
 export declare const fontProviders: {
     adobe: typeof adobe;
@@ -24,5 +27,6 @@ export declare const fontProviders: {
     fontshare: typeof fontshare;
     fontsource: typeof fontsource;
     google: typeof google;
+    googleicons: typeof googleicons;
 };
 export {};

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

@@ -1,28 +1,103 @@
+import {
+  providers
+} from "unifont";
 function adobe(config) {
+  const provider = providers.adobe(config);
+  let initializedProvider;
   return {
-    entrypoint: "astro/assets/fonts/providers/adobe",
-    config
+    name: provider._name,
+    config,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
   };
 }
 function bunny() {
+  const provider = providers.bunny();
+  let initializedProvider;
   return {
-    entrypoint: "astro/assets/fonts/providers/bunny"
+    name: provider._name,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
   };
 }
 function fontshare() {
+  const provider = providers.fontshare();
+  let initializedProvider;
   return {
-    entrypoint: "astro/assets/fonts/providers/fontshare"
+    name: provider._name,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
   };
 }
 function fontsource() {
+  const provider = providers.fontsource();
+  let initializedProvider;
   return {
-    entrypoint: "astro/assets/fonts/providers/fontsource"
+    name: provider._name,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
   };
 }
 function google(config) {
+  const provider = providers.google(config);
+  let initializedProvider;
   return {
-    entrypoint: "astro/assets/fonts/providers/google",
-    config
+    name: provider._name,
+    config,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
+  };
+}
+function googleicons(config) {
+  const provider = providers.googleicons(config);
+  let initializedProvider;
+  return {
+    name: provider._name,
+    config,
+    async init(context) {
+      initializedProvider = await provider(context);
+    },
+    async resolveFont({ familyName, ...rest }) {
+      return await initializedProvider?.resolveFont(familyName, rest);
+    },
+    async listFonts() {
+      return await initializedProvider?.listFonts?.();
+    }
   };
 }
 const fontProviders = {
@@ -30,7 +105,8 @@ const fontProviders = {
   bunny,
   fontshare,
   fontsource,
-  google
+  google,
+  googleicons
 };
 export {
   fontProviders

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

@@ -7,7 +7,5 @@ interface Options {
     fontTypeExtractor: FontTypeExtractor;
     fontFileReader: FontFileReader;
 }
-export declare function resolveLocalFont({ family, urlProxy, fontTypeExtractor, fontFileReader, }: Options): {
-    fonts: Array<unifont.FontFaceData>;
-};
+export declare function resolveLocalFont({ family, urlProxy, fontTypeExtractor, fontFileReader, }: Options): Array<unifont.FontFaceData>;
 export {};

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

@@ -5,49 +5,47 @@ function resolveLocalFont({
   fontTypeExtractor,
   fontFileReader
 }) {
-  return {
-    fonts: family.variants.map((variant) => {
-      const shouldInfer = variant.weight === void 0 || variant.style === void 0;
-      const data = {
-        // If it should be inferred, we don't want to set the value
-        weight: variant.weight,
-        style: variant.style,
-        src: [],
-        unicodeRange: variant.unicodeRange,
-        display: variant.display,
-        stretch: variant.stretch,
-        featureSettings: variant.featureSettings,
-        variationSettings: variant.variationSettings
+  return family.variants.map((variant) => {
+    const shouldInfer = variant.weight === void 0 || variant.style === void 0;
+    const data = {
+      // If it should be inferred, we don't want to set the value
+      weight: variant.weight,
+      style: variant.style,
+      src: [],
+      unicodeRange: variant.unicodeRange,
+      display: variant.display,
+      stretch: variant.stretch,
+      featureSettings: variant.featureSettings,
+      variationSettings: variant.variationSettings
+    };
+    data.src = variant.src.map((source, index) => {
+      if (shouldInfer && index === 0) {
+        const result = fontFileReader.extract({ family: family.name, url: source.url });
+        if (variant.weight === void 0) data.weight = result.weight;
+        if (variant.style === void 0) data.style = result.style;
+      }
+      const type = fontTypeExtractor.extract(source.url);
+      return {
+        originalURL: source.url,
+        url: urlProxy.proxy({
+          url: source.url,
+          type,
+          // We only use the first source for preloading. For example if woff2 and woff
+          // are available, we only keep woff2.
+          collectPreload: index === 0,
+          data: {
+            weight: data.weight,
+            style: data.style,
+            subset: void 0
+          },
+          init: null
+        }),
+        format: FONT_FORMATS.find((e) => e.type === type)?.format,
+        tech: source.tech
       };
-      data.src = variant.src.map((source, index) => {
-        if (shouldInfer && index === 0) {
-          const result = fontFileReader.extract({ family: family.name, url: source.url });
-          if (variant.weight === void 0) data.weight = result.weight;
-          if (variant.style === void 0) data.style = result.style;
-        }
-        const type = fontTypeExtractor.extract(source.url);
-        return {
-          originalURL: source.url,
-          url: urlProxy.proxy({
-            url: source.url,
-            type,
-            // We only use the first source for preloading. For example if woff2 and woff
-            // are available, we only keep woff2.
-            collectPreload: index === 0,
-            data: {
-              weight: data.weight,
-              style: data.style,
-              subset: void 0
-            },
-            init: null
-          }),
-          format: FONT_FORMATS.find((e) => e.type === type)?.format,
-          tech: source.tech
-        };
-      });
-      return data;
-    })
-  };
+    });
+    return data;
+  });
 }
 export {
   resolveLocalFont