astro 5.7.5 → 5.7.7

package/dist/assets/fonts/orchestrate.js

@@ -0,0 +1,125 @@
+import * as unifont from "unifont";
+import { LOCAL_PROVIDER_NAME } from "./constants.js";
+import { extractUnifontProviders } from "./logic/extract-unifont-providers.js";
+import { normalizeRemoteFontFaces } from "./logic/normalize-remote-font-faces.js";
+import { optimizeFallbacks } from "./logic/optimize-fallbacks.js";
+import { resolveFamilies } from "./logic/resolve-families.js";
+import { resolveLocalFont } from "./providers/local.js";
+import { pickFontFaceProperty, unifontFontFaceDataToProperties } from "./utils.js";
+async function orchestrate({
+  families,
+  hasher,
+  remoteFontProviderResolver,
+  localProviderUrlResolver,
+  storage,
+  cssRenderer,
+  systemFallbacksProvider,
+  fontMetricsResolver,
+  fontTypeExtractor,
+  createUrlProxy,
+  defaults
+}) {
+  let resolvedFamilies = await resolveFamilies({
+    families,
+    hasher,
+    remoteFontProviderResolver,
+    localProviderUrlResolver
+  });
+  const extractedUnifontProvidersResult = extractUnifontProviders({
+    families: resolvedFamilies,
+    hasher
+  });
+  resolvedFamilies = extractedUnifontProvidersResult.families;
+  const unifontProviders = extractedUnifontProvidersResult.providers;
+  const { resolveFont } = await unifont.createUnifont(unifontProviders, {
+    storage
+  });
+  const fontFileDataMap = /* @__PURE__ */ new Map();
+  const consumableMap = /* @__PURE__ */ new Map();
+  for (const family of resolvedFamilies) {
+    const preloadData = [];
+    let css = "";
+    const collectedFonts = [];
+    const fallbacks = family.fallbacks ?? defaults.fallbacks ?? [];
+    const urlProxy = createUrlProxy({
+      local: family.provider === LOCAL_PROVIDER_NAME,
+      hasUrl: (hash) => fontFileDataMap.has(hash),
+      saveUrl: ({ hash, url, init }) => {
+        fontFileDataMap.set(hash, { url, init });
+      },
+      savePreload: (preload) => {
+        preloadData.push(preload);
+      },
+      saveFontData: (collected) => {
+        if (fallbacks && fallbacks.length > 0 && // If the same data has already been sent for this family, we don't want to have
+        // duplicated fallbacks. Such scenario can occur with unicode ranges.
+        !collectedFonts.some((f) => JSON.stringify(f.data) === JSON.stringify(collected.data))) {
+          collectedFonts.push(collected);
+        }
+      }
+    });
+    let fonts;
+    if (family.provider === LOCAL_PROVIDER_NAME) {
+      const result = resolveLocalFont({
+        family,
+        urlProxy,
+        fontTypeExtractor
+      });
+      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 extractUnifontProviders).
+        [family.provider.name]
+      );
+      fonts = normalizeRemoteFontFaces({ fonts: result.fonts, urlProxy });
+    }
+    for (const data of fonts) {
+      css += cssRenderer.generateFontFace(
+        family.nameWithHash,
+        unifontFontFaceDataToProperties({
+          src: data.src,
+          weight: data.weight,
+          style: data.style,
+          // User settings override the generated font settings. We use a helper function
+          // because local and remote providers store this data in different places.
+          display: pickFontFaceProperty("display", { data, family }),
+          unicodeRange: pickFontFaceProperty("unicodeRange", { data, family }),
+          stretch: pickFontFaceProperty("stretch", { data, family }),
+          featureSettings: pickFontFaceProperty("featureSettings", { data, family }),
+          variationSettings: pickFontFaceProperty("variationSettings", { data, family })
+        })
+      );
+    }
+    const cssVarValues = [family.nameWithHash];
+    const optimizeFallbacksResult = await optimizeFallbacks({
+      family,
+      fallbacks,
+      collectedFonts,
+      enabled: family.optimizedFallbacks ?? defaults.optimizedFallbacks ?? false,
+      systemFallbacksProvider,
+      fontMetricsResolver
+    });
+    if (optimizeFallbacksResult) {
+      css += optimizeFallbacksResult.css;
+      cssVarValues.push(...optimizeFallbacksResult.fallbacks);
+    } else {
+      cssVarValues.push(...fallbacks);
+    }
+    css += cssRenderer.generateCssVariable(family.cssVariable, cssVarValues);
+    consumableMap.set(family.cssVariable, { preloadData, css });
+  }
+  return { fontFileDataMap, consumableMap };
+}
+export {
+  orchestrate
+};

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

@@ -1,13 +1,12 @@
 import type * as unifont from 'unifont';
+import type { FontTypeExtractor, UrlProxy } from '../definitions.js';
 import type { ResolvedLocalFontFamily } from '../types.js';
-type InitializedProvider = NonNullable<Awaited<ReturnType<unifont.Provider>>>;
-type ResolveFontResult = NonNullable<Awaited<ReturnType<InitializedProvider['resolveFont']>>>;
 interface Options {
     family: ResolvedLocalFontFamily;
-    proxyURL: (params: {
-        value: string;
-        data: Partial<unifont.FontFaceData>;
-    }) => string;
+    urlProxy: UrlProxy;
+    fontTypeExtractor: FontTypeExtractor;
 }
-export declare function resolveLocalFont({ family, proxyURL }: Options): ResolveFontResult;
+export declare function resolveLocalFont({ family, urlProxy, fontTypeExtractor }: Options): {
+    fonts: Array<unifont.FontFaceData>;
+};
 export {};

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

@@ -1,35 +1,32 @@
 import { FONT_FORMAT_MAP } from "../constants.js";
-import { extractFontType } from "../utils.js";
-function resolveLocalFont({ family, proxyURL }) {
-  const fonts = [];
-  for (const variant of family.variants) {
-    const data = {
+function resolveLocalFont({ family, urlProxy, fontTypeExtractor }) {
+  return {
+    fonts: family.variants.map((variant) => ({
       weight: variant.weight,
       style: variant.style,
-      src: variant.src.map(({ url: originalURL, tech }) => {
-        return {
-          originalURL,
-          url: proxyURL({
-            value: originalURL,
-            data: {
-              weight: variant.weight,
-              style: variant.style
-            }
-          }),
-          format: FONT_FORMAT_MAP[extractFontType(originalURL)],
-          tech
-        };
-      })
-    };
-    if (variant.display) data.display = variant.display;
-    if (variant.unicodeRange) data.unicodeRange = variant.unicodeRange;
-    if (variant.stretch) data.stretch = variant.stretch;
-    if (variant.featureSettings) data.featureSettings = variant.featureSettings;
-    if (variant.variationSettings) data.variationSettings = variant.variationSettings;
-    fonts.push(data);
-  }
-  return {
-    fonts
+      // We proxy each source
+      src: variant.src.map((source, index) => ({
+        originalURL: source.url,
+        url: urlProxy.proxy({
+          url: source.url,
+          // 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: variant.weight,
+            style: variant.style
+          },
+          init: null
+        }),
+        format: FONT_FORMAT_MAP[fontTypeExtractor.extract(source.url)],
+        tech: source.tech
+      })),
+      display: variant.display,
+      unicodeRange: variant.unicodeRange,
+      stretch: variant.stretch,
+      featureSettings: variant.featureSettings,
+      variationSettings: variant.variationSettings
+    }))
   };
 }
 export {

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

@@ -1,7 +1,9 @@
+import type { Font } from '@capsizecss/unpack';
 import type * as unifont from 'unifont';
 import type { z } from 'zod';
 import type { fontProviderSchema, localFontFamilySchema, remoteFontFamilySchema } from './config.js';
-import type { FONT_TYPES } from './constants.js';
+import type { FONT_TYPES, GENERIC_FALLBACK_NAMES } from './constants.js';
+import type { CollectedFontForMetrics } from './logic/optimize-fallbacks.js';
 export type AstroFontProvider = z.infer<typeof fontProviderSchema>;
 export interface ResolvedFontProvider {
     name?: string;
@@ -22,6 +24,7 @@ export interface ResolvedLocalFontFamily extends ResolvedFontFamilyAttributes, O
     }>;
 }
 type RemoteFontFamily = z.infer<typeof remoteFontFamilySchema>;
+/** @lintignore somehow required by pickFontFaceProperty in utils */
 export interface ResolvedRemoteFontFamily extends ResolvedFontFamilyAttributes, Omit<z.output<typeof remoteFontFamilySchema>, 'provider' | 'weights'> {
     provider: ResolvedFontProvider;
     weights?: Array<string>;
@@ -32,7 +35,7 @@ export type FontType = (typeof FONT_TYPES)[number];
 /**
  * Preload data is used for links generation inside the <Font /> component
  */
-export type PreloadData = Array<{
+export interface PreloadData {
     /**
      * Absolute link to a font file, eg. /_astro/fonts/abc.woff
      */
@@ -41,5 +44,32 @@ export type PreloadData = Array<{
      * A font type, eg. woff2, woff, ttf...
      */
     type: FontType;
+}
+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 interface FontFileData {
+    hash: string;
+    url: string;
+    init: RequestInit | null;
+}
+export interface CreateUrlProxyParams {
+    local: boolean;
+    hasUrl: (hash: string) => boolean;
+    saveUrl: (input: FontFileData) => void;
+    savePreload: (preload: PreloadData) => void;
+    saveFontData: (collected: CollectedFontForMetrics) => void;
+}
+/**
+ * Holds associations of hash and original font file URLs, so they can be
+ * downloaded whenever the hash is requested.
+ */
+export type FontFileDataMap = Map<FontFileData['hash'], Pick<FontFileData, 'url' | 'init'>>;
+/**
+ * Holds associations of CSS variables and preloadData/css to be passed to the virtual module.
+ */
+export type ConsumableMap = Map<string, {
+    preloadData: Array<PreloadData>;
+    css: string;
 }>;
 export {};

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

@@ -1,97 +1,27 @@
 import type * as unifont from 'unifont';
 import type { Storage } from 'unstorage';
-import { DEFAULT_FALLBACKS } from './constants.js';
-import type { FontFaceMetrics, generateFallbackFontFace } from './metrics.js';
-import { type ResolveProviderOptions } from './providers/utils.js';
-import type { FontFamily, FontType, ResolvedFontFamily } from './types.js';
-export declare function toCSS(properties: Record<string, string | undefined>, indent?: number): string;
-export declare function renderFontFace(properties: Record<string, string | undefined>): string;
-export declare function generateFontFace(family: string, font: unifont.FontFaceData): string;
-export declare function renderFontSrc(sources: Exclude<unifont.FontFaceData['src'][number], string>[]): string;
-export declare function withoutQuotes(str: string): string;
-export declare function extractFontType(str: string): FontType;
-export declare function isFontType(str: string): str is FontType;
-export declare function cache(storage: Storage, key: string, cb: () => Promise<Buffer>): Promise<Buffer>;
-export interface ProxyURLOptions {
-    /**
-     * The original URL
-     */
-    value: string;
-    /**
-     * Specifies how the hash is computed. Can be based on the value,
-     * a specific string for testing etc
-     */
-    hashString: (value: string) => string;
-    /**
-     * Use the hook to save the associated value and hash, and possibly
-     * transform it (eg. apply a base)
-     */
-    collect: (data: {
-        hash: string;
-        type: FontType;
-        value: string;
-    }) => string;
-}
+import type { CssProperties } from './definitions.js';
+import type { FontType, GenericFallbackName, ResolvedFontFamily } from './types.js';
 /**
- * The fonts data we receive contains urls or file paths we do no control.
- * However, we will emit font files ourselves so we store the original value
- * and replace it with a url we control. For example with the value "https://foo.bar/file.woff2":
- * - font type is woff2
- * - hash will be "<hash>.woff2"
- * - `collect` will save the association of the original url and the new hash for later use
- * - the returned url will be `/_astro/fonts/<hash>.woff2`
+ * Turns unifont font face data into generic CSS properties, to be consumed by the CSS renderer.
  */
-export declare function proxyURL({ value, hashString, collect }: ProxyURLOptions): string;
-export declare function isGenericFontFamily(str: string): str is keyof typeof DEFAULT_FALLBACKS;
-export type GetMetricsForFamilyFont = {
-    hash: string;
-    url: string;
-    data: Partial<unifont.FontFaceData>;
-};
-export type GetMetricsForFamily = (name: string, 
-/** A remote url or local filepath to a font file. Used if metrics can't be resolved purely from the family name */
-font: GetMetricsForFamilyFont) => Promise<FontFaceMetrics>;
+export declare function unifontFontFaceDataToProperties(font: Partial<unifont.FontFaceData>): CssProperties;
 /**
- * Generates CSS for a given family fallbacks if possible.
- *
- * It works by trying to get metrics (using capsize) of the provided font family.
- * If some can be computed, they will be applied to the eligible fallbacks to match
- * the original font shape as close as possible.
+ * Turns unifont font face data src into a valid CSS property.
+ * Adapted from https://github.com/nuxt/fonts/blob/main/src/css/render.ts#L68-L81
  */
-export declare function generateFallbacksCSS({ family, fallbacks: _fallbacks, font: fontData, metrics, }: {
-    family: Pick<ResolvedFontFamily, 'name' | 'nameWithHash'>;
-    /** The family fallbacks */
-    fallbacks: Array<string>;
-    font: Array<GetMetricsForFamilyFont>;
-    metrics: {
-        getMetricsForFamily: GetMetricsForFamily;
-        generateFontFace: typeof generateFallbackFontFace;
-    } | null;
-}): Promise<null | {
-    css?: string;
-    fallbacks: Array<string>;
-}>;
+export declare function renderFontSrc(sources: Exclude<unifont.FontFaceData['src'][number], string>[]): string;
 /**
- * Resolves the font family provider. If none is provided, it will infer the provider as
- * one of the built-in providers and resolve it. The most important part is that if a
- * provider is not provided but `src` is, then it's inferred as the local provider.
+ * Removes the quotes from a string. Used for family names
  */
-export declare function resolveFontFamily({ family, generateNameWithHash, root, resolveMod, }: Omit<ResolveProviderOptions, 'provider'> & {
-    family: FontFamily;
-    generateNameWithHash: (family: FontFamily) => string;
-}): Promise<ResolvedFontFamily>;
+export declare function withoutQuotes(str: string): string;
+export declare function isFontType(str: string): str is FontType;
+export declare function cache(storage: Storage, key: string, cb: () => Promise<Buffer>): Promise<Buffer>;
+export declare function isGenericFontFamily(str: string): str is GenericFallbackName;
+export declare function dedupe<const T extends Array<any>>(arr: T): T;
 export declare function sortObjectByKey<T extends Record<string, any>>(unordered: T): T;
-/**
- * Extracts providers from families so they can be consumed by unifont.
- * It deduplicates them based on their config and provider name:
- * - If several families use the same provider (by value, not by reference), we only use one provider
- * - If one provider is used with different settings for 2 families, we make sure there are kept as 2 providers
- */
-export declare function familiesToUnifontProviders({ families, hashString, }: {
-    families: Array<ResolvedFontFamily>;
-    hashString: (value: string) => string;
-}): {
-    families: Array<ResolvedFontFamily>;
-    providers: Array<unifont.Provider>;
-};
 export declare function resolveEntrypoint(root: URL, entrypoint: string): URL;
+export declare function pickFontFaceProperty<T extends keyof Pick<unifont.FontFaceData, 'display' | 'unicodeRange' | 'stretch' | 'featureSettings' | 'variationSettings'>>(property: T, { data, family }: {
+    data: unifont.FontFaceData;
+    family: ResolvedFontFamily;
+}): import("./types.js").ResolvedRemoteFontFamily[T] | NonNullable<unifont.FontFaceData[T]> | undefined;

package/dist/assets/fonts/utils.js

@@ -1,18 +1,6 @@
 import { createRequire } from "node:module";
-import { extname } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { AstroError, AstroErrorData } from "../../core/errors/index.js";
-import { DEFAULT_FALLBACKS, FONT_TYPES, LOCAL_PROVIDER_NAME, SYSTEM_METRICS } from "./constants.js";
-import { resolveProvider } from "./providers/utils.js";
-function toCSS(properties, indent = 2) {
-  return Object.entries(properties).filter(([, value]) => Boolean(value)).map(([key, value]) => `${" ".repeat(indent)}${key}: ${value};`).join("\n");
-}
-function renderFontFace(properties) {
-  return `@font-face {
-	${toCSS(properties)}
-}
-`;
-}
+import { pathToFileURL } from "node:url";
+import { FONT_TYPES, GENERIC_FALLBACK_NAMES, LOCAL_PROVIDER_NAME } from "./constants.js";
 function unifontFontFaceDataToProperties(font) {
   return {
     src: font.src ? renderFontSrc(font.src) : void 0,
@@ -25,46 +13,25 @@ function unifontFontFaceDataToProperties(font) {
     "font-variation-settings": font.variationSettings
   };
 }
-function generateFontFace(family, font) {
-  return renderFontFace({
-    "font-family": family,
-    ...unifontFontFaceDataToProperties(font)
-  });
-}
 function renderFontSrc(sources) {
   return sources.map((src) => {
-    if ("url" in src) {
-      let rendered = `url("${src.url}")`;
-      if (src.format) {
-        rendered += ` format("${src.format}")`;
-      }
-      if (src.tech) {
-        rendered += ` tech(${src.tech})`;
-      }
-      return rendered;
+    if ("name" in src) {
+      return `local("${src.name}")`;
     }
-    return `local("${src.name}")`;
+    let rendered = `url("${src.url}")`;
+    if (src.format) {
+      rendered += ` format("${src.format}")`;
+    }
+    if (src.tech) {
+      rendered += ` tech(${src.tech})`;
+    }
+    return rendered;
   }).join(", ");
 }
 const QUOTES_RE = /^["']|["']$/g;
 function withoutQuotes(str) {
   return str.trim().replace(QUOTES_RE, "");
 }
-function extractFontType(str) {
-  const extension = extname(str).slice(1);
-  if (!isFontType(extension)) {
-    throw new AstroError(
-      {
-        ...AstroErrorData.CannotExtractFontType,
-        message: AstroErrorData.CannotExtractFontType.message(str)
-      },
-      {
-        cause: `Unexpected extension, got "${extension}"`
-      }
-    );
-  }
-  return extension;
-}
 function isFontType(str) {
   return FONT_TYPES.includes(str);
 }
@@ -77,147 +44,20 @@ async function cache(storage, key, cb) {
   await storage.setItemRaw(key, data);
   return data;
 }
-function proxyURL({ value, hashString, collect }) {
-  const type = extractFontType(value);
-  const hash = `${hashString(value)}.${type}`;
-  const url = collect({ hash, type, value });
-  return url;
-}
 function isGenericFontFamily(str) {
-  return Object.keys(DEFAULT_FALLBACKS).includes(str);
-}
-async function generateFallbacksCSS({
-  family,
-  fallbacks: _fallbacks,
-  font: fontData,
-  metrics
-}) {
-  let fallbacks = [..._fallbacks];
-  if (fallbacks.length === 0) {
-    return null;
-  }
-  if (fontData.length === 0 || !metrics) {
-    return { fallbacks };
-  }
-  const lastFallback = fallbacks[fallbacks.length - 1];
-  if (!isGenericFontFamily(lastFallback)) {
-    return { fallbacks };
-  }
-  const localFonts = DEFAULT_FALLBACKS[lastFallback];
-  if (localFonts.length === 0) {
-    return { fallbacks };
-  }
-  if (localFonts.includes(
-    // @ts-expect-error TS is not smart enough
-    family.name
-  )) {
-    return { fallbacks };
-  }
-  const localFontsMappings = localFonts.map((font) => ({
-    font,
-    name: `"${family.nameWithHash} fallback: ${font}"`
-  }));
-  fallbacks = [.../* @__PURE__ */ new Set([...localFontsMappings.map((m) => m.name), ...fallbacks])];
-  let css = "";
-  for (const { font, name } of localFontsMappings) {
-    for (const { hash, url, data } of fontData) {
-      css += metrics.generateFontFace({
-        metrics: await metrics.getMetricsForFamily(family.name, { hash, url, data }),
-        fallbackMetrics: SYSTEM_METRICS[font],
-        font,
-        name,
-        properties: unifontFontFaceDataToProperties(data)
-      });
-    }
-  }
-  return { css, fallbacks };
+  return GENERIC_FALLBACK_NAMES.includes(str);
 }
 function dedupe(arr) {
   return [...new Set(arr)];
 }
-function resolveVariants({
-  variants,
-  root
-}) {
-  return variants.map((variant) => ({
-    ...variant,
-    weight: variant.weight.toString(),
-    src: variant.src.map((value) => {
-      const isValue = typeof value === "string" || value instanceof URL;
-      const url = (isValue ? value : value.url).toString();
-      const tech = isValue ? void 0 : value.tech;
-      return {
-        url: fileURLToPath(resolveEntrypoint(root, url)),
-        tech
-      };
-    })
-  }));
-}
-async function resolveFontFamily({
-  family,
-  generateNameWithHash,
-  root,
-  resolveMod
-}) {
-  const nameWithHash = generateNameWithHash(family);
-  if (family.provider === LOCAL_PROVIDER_NAME) {
-    return {
-      ...family,
-      nameWithHash,
-      variants: resolveVariants({ variants: family.variants, root }),
-      fallbacks: family.fallbacks ? dedupe(family.fallbacks) : void 0
-    };
-  }
-  return {
-    ...family,
-    nameWithHash,
-    provider: await resolveProvider({
-      root,
-      resolveMod,
-      provider: family.provider
-    }),
-    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,
-    fallbacks: family.fallbacks ? dedupe(family.fallbacks) : void 0,
-    unicodeRange: family.unicodeRange ? dedupe(family.unicodeRange) : void 0
-  };
-}
 function sortObjectByKey(unordered) {
   const ordered = Object.keys(unordered).sort().reduce((obj, key) => {
-    obj[key] = unordered[key];
+    const value = unordered[key];
+    obj[key] = Array.isArray(value) ? value.map((v) => typeof v === "object" && v !== null ? sortObjectByKey(v) : v) : typeof value === "object" && value !== null ? sortObjectByKey(value) : value;
     return obj;
   }, {});
   return ordered;
 }
-function familiesToUnifontProviders({
-  families,
-  hashString
-}) {
-  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 = hashString(
-      JSON.stringify(
-        sortObjectByKey({
-          name: unifontProvider._name,
-          ...provider.config
-        })
-      )
-    );
-    unifontProvider._name += `-${hash}`;
-    provider.name = unifontProvider._name;
-    if (!hashes.has(hash)) {
-      hashes.add(hash);
-      providers.push(unifontProvider);
-    }
-  }
-  return { families, providers };
-}
 function resolveEntrypoint(root, entrypoint) {
   const require2 = createRequire(root);
   try {
@@ -226,20 +66,18 @@ function resolveEntrypoint(root, entrypoint) {
     return new URL(entrypoint, root);
   }
 }
+function pickFontFaceProperty(property, { data, family }) {
+  return data[property] ?? (family.provider === LOCAL_PROVIDER_NAME ? void 0 : family[property]);
+}
 export {
   cache,
-  extractFontType,
-  familiesToUnifontProviders,
-  generateFallbacksCSS,
-  generateFontFace,
+  dedupe,
   isFontType,
   isGenericFontFamily,
-  proxyURL,
-  renderFontFace,
+  pickFontFaceProperty,
   renderFontSrc,
   resolveEntrypoint,
-  resolveFontFamily,
   sortObjectByKey,
-  toCSS,
+  unifontFontFaceDataToProperties,
   withoutQuotes
 };