astro 5.6.1 → 5.7.0

package/dist/assets/fonts/utils.js

@@ -0,0 +1,215 @@
+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 } from "./constants.js";
+import { resolveProvider } from "./providers/utils.js";
+function generateFontFace(family, font) {
+  return [
+    "@font-face {",
+    `  font-family: ${family};`,
+    `  src: ${renderFontSrc(font.src)};`,
+    `  font-display: ${font.display ?? "swap"};`,
+    font.unicodeRange && `  unicode-range: ${font.unicodeRange};`,
+    font.weight && `  font-weight: ${Array.isArray(font.weight) ? font.weight.join(" ") : font.weight};`,
+    font.style && `  font-style: ${font.style};`,
+    font.stretch && `  font-stretch: ${font.stretch};`,
+    font.featureSettings && `  font-feature-settings: ${font.featureSettings};`,
+    font.variationSettings && `  font-variation-settings: ${font.variationSettings};`,
+    `}`
+  ].filter(Boolean).join("\n");
+}
+function renderFontSrc(sources) {
+  return sources.map((src) => {
+    if ("url" in src) {
+      let rendered = `url("${src.url}")`;
+      for (const key of ["format", "tech"]) {
+        if (key in src) {
+          rendered += ` ${key}(${src[key]})`;
+        }
+      }
+      return rendered;
+    }
+    return `local("${src.name}")`;
+  }).join(", ");
+}
+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);
+}
+async function cache(storage, key, cb) {
+  const existing = await storage.getItemRaw(key);
+  if (existing) {
+    return { cached: true, data: existing };
+  }
+  const data = await cb();
+  await storage.setItemRaw(key, data);
+  return { cached: false, 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;
+  }
+  let css = "";
+  if (!metrics) {
+    return { css, fallbacks };
+  }
+  const lastFallback = fallbacks[fallbacks.length - 1];
+  if (!isGenericFontFamily(lastFallback)) {
+    return { css, fallbacks };
+  }
+  const localFonts = DEFAULT_FALLBACKS[lastFallback];
+  if (localFonts.length === 0) {
+    return { css, fallbacks };
+  }
+  const foundMetrics = await metrics.getMetricsForFamily(family.name, fontData);
+  if (!foundMetrics) {
+    return { css, fallbacks };
+  }
+  const localFontsMappings = localFonts.map((font) => ({
+    font,
+    name: `"${family.nameWithHash} fallback: ${font}"`
+  }));
+  fallbacks = [.../* @__PURE__ */ new Set([...localFontsMappings.map((m) => m.name), ...fallbacks])];
+  for (const { font, name } of localFontsMappings) {
+    css += metrics.generateFontFace(foundMetrics, { font, name });
+  }
+  return { css, fallbacks };
+}
+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];
+    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
+        })
+      )
+    );
+    if (hashes.has(hash)) {
+      continue;
+    }
+    unifontProvider._name += `-${hash}`;
+    provider.name = unifontProvider._name;
+    hashes.add(hash);
+    providers.push(unifontProvider);
+  }
+  return { families, providers };
+}
+function resolveEntrypoint(root, entrypoint) {
+  const require2 = createRequire(root);
+  try {
+    return pathToFileURL(require2.resolve(entrypoint));
+  } catch {
+    return new URL(entrypoint, root);
+  }
+}
+export {
+  cache,
+  extractFontType,
+  familiesToUnifontProviders,
+  generateFallbacksCSS,
+  generateFontFace,
+  isFontType,
+  isGenericFontFamily,
+  proxyURL,
+  resolveEntrypoint,
+  resolveFontFamily,
+  sortObjectByKey
+};

package/dist/assets/fonts/vite-plugin-fonts.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vite';
+import type { Logger } from '../../core/logger/core.js';
+import type { AstroSettings } from '../../types/astro.js';
+interface Options {
+    settings: AstroSettings;
+    sync: boolean;
+    logger: Logger;
+}
+export declare function fontsPlugin({ settings, sync, logger }: Options): Plugin;
+export {};

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

@@ -0,0 +1,217 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import { removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
+import { createStorage } from "unstorage";
+import fsLiteDriver from "unstorage/drivers/fs-lite";
+import xxhash from "xxhash-wasm";
+import { collectErrorMetadata } from "../../core/errors/dev/utils.js";
+import { AstroError, AstroErrorData, isAstroError } from "../../core/errors/index.js";
+import { formatErrorMessage } from "../../core/messages.js";
+import { getClientOutputDirectory } from "../../prerender/utils.js";
+import {
+  CACHE_DIR,
+  RESOLVED_VIRTUAL_MODULE_ID,
+  URL_PREFIX,
+  VIRTUAL_MODULE_ID
+} from "./constants.js";
+import { loadFonts } from "./load.js";
+import { generateFallbackFontFace, getMetricsForFamily, readMetrics } from "./metrics.js";
+import { cache, extractFontType, resolveFontFamily, sortObjectByKey } from "./utils.js";
+async function fetchFont(url) {
+  try {
+    if (isAbsolute(url)) {
+      return await readFile(url);
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Response was not successful, received status code ${response.status}`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+  } catch (cause) {
+    throw new AstroError(
+      {
+        ...AstroErrorData.CannotFetchFontFile,
+        message: AstroErrorData.CannotFetchFontFile.message(url)
+      },
+      { cause }
+    );
+  }
+}
+function fontsPlugin({ settings, sync, logger }) {
+  if (!settings.config.experimental.fonts) {
+    return {
+      name: "astro:fonts:fallback",
+      config() {
+        return {
+          build: {
+            rollupOptions: {
+              external: [VIRTUAL_MODULE_ID]
+            }
+          }
+        };
+      }
+    };
+  }
+  const baseUrl = removeTrailingForwardSlash(settings.config.base) + URL_PREFIX;
+  let resolvedMap = null;
+  let hashToUrlMap = null;
+  let isBuild;
+  let storage = null;
+  const cleanup = () => {
+    resolvedMap = null;
+    hashToUrlMap = null;
+    storage = null;
+  };
+  async function initialize({ resolveMod, base }) {
+    const { h64ToString } = await xxhash();
+    storage = createStorage({
+      // Types are weirly exported
+      driver: fsLiteDriver({
+        base: fileURLToPath(base)
+      })
+    });
+    hashToUrlMap = /* @__PURE__ */ new Map();
+    resolvedMap = /* @__PURE__ */ new Map();
+    const families = [];
+    for (const family of settings.config.experimental.fonts) {
+      families.push(
+        await resolveFontFamily({
+          family,
+          root: settings.config.root,
+          resolveMod,
+          generateNameWithHash: (_family) => `${_family.name}-${h64ToString(JSON.stringify(sortObjectByKey(_family)))}`
+        })
+      );
+    }
+    await loadFonts({
+      base: baseUrl,
+      families,
+      storage,
+      hashToUrlMap,
+      resolvedMap,
+      hashString: h64ToString,
+      generateFallbackFontFace,
+      getMetricsForFamily: async (name, font) => {
+        let metrics = await getMetricsForFamily(name);
+        if (font && !metrics) {
+          const { data } = await cache(storage, font.hash, () => fetchFont(font.url));
+          metrics = await readMetrics(name, data);
+        }
+        return metrics;
+      },
+      log: (message) => logger.info("assets", message)
+    });
+  }
+  return {
+    name: "astro:fonts",
+    config(_, { command }) {
+      isBuild = command === "build";
+    },
+    async buildStart() {
+      if (isBuild) {
+        await initialize({
+          resolveMod: (id) => import(id),
+          base: new URL(CACHE_DIR, settings.config.cacheDir)
+        });
+      }
+    },
+    async configureServer(server) {
+      await initialize({
+        resolveMod: (id) => server.ssrLoadModule(id),
+        // In dev, we cache fonts data in .astro so it can be easily inspected and cleared
+        base: new URL(CACHE_DIR, settings.dotAstroDir)
+      });
+      const localPaths = [...hashToUrlMap.values()].filter((url) => isAbsolute(url));
+      server.watcher.on("change", (path) => {
+        if (localPaths.includes(path)) {
+          logger.info("assets", "Font file updated");
+          server.restart();
+        }
+      });
+      server.watcher.on("unlink", (path) => {
+        if (localPaths.includes(path)) {
+          logger.warn(
+            "assets",
+            `The font file ${JSON.stringify(path)} referenced in your config has been deleted. Restore the file or remove this font from your configuration if it is no longer needed.`
+          );
+        }
+      });
+      server.middlewares.use(URL_PREFIX, async (req, res, next) => {
+        if (!req.url) {
+          return next();
+        }
+        const hash = req.url.slice(1);
+        const url = hashToUrlMap?.get(hash);
+        if (!url) {
+          return next();
+        }
+        res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
+        res.setHeader("Pragma", "no-cache");
+        res.setHeader("Expires", 0);
+        try {
+          const { data } = await cache(storage, hash, () => fetchFont(url));
+          res.setHeader("Content-Length", data.length);
+          res.setHeader("Content-Type", `font/${extractFontType(hash)}`);
+          res.end(data);
+        } catch (err) {
+          logger.error("assets", "Cannot download font file");
+          if (isAstroError(err)) {
+            logger.error(
+              "SKIP_FORMAT",
+              formatErrorMessage(collectErrorMetadata(err), logger.level() === "debug")
+            );
+          }
+          res.statusCode = 500;
+          res.end();
+        }
+      });
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        return RESOLVED_VIRTUAL_MODULE_ID;
+      }
+    },
+    load(id, opts) {
+      if (id === RESOLVED_VIRTUAL_MODULE_ID && opts?.ssr) {
+        return {
+          code: `export const fontsData = new Map(${JSON.stringify(Array.from(resolvedMap?.entries() ?? []))})`
+        };
+      }
+    },
+    async buildEnd() {
+      if (sync || settings.config.experimental.fonts.length === 0) {
+        cleanup();
+        return;
+      }
+      try {
+        const dir = getClientOutputDirectory(settings);
+        const fontsDir = new URL("." + baseUrl, dir);
+        try {
+          mkdirSync(fontsDir, { recursive: true });
+        } catch (cause) {
+          throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
+        }
+        if (hashToUrlMap) {
+          logger.info("assets", "Copying fonts...");
+          await Promise.all(
+            Array.from(hashToUrlMap.entries()).map(async ([hash, url]) => {
+              const { data } = await cache(storage, hash, () => fetchFont(url));
+              try {
+                writeFileSync(new URL(hash, fontsDir), data);
+              } catch (cause) {
+                throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
+              }
+            })
+          );
+        }
+      } finally {
+        cleanup();
+      }
+    }
+  };
+}
+export {
+  fontsPlugin
+};

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

@@ -4,7 +4,11 @@
  *
  * If some functions don't need to be exposed, just import the file that contains the functions.
  */
-export { emitESMImage } from './node/emitAsset.js';
+export { 
+/**
+ * @deprecated
+ */
+emitESMImage, emitImageMetadata, } from './node/emitAsset.js';
 export { isESMImportedImage, isRemoteImage } from './imageKind.js';
 export { imageMetadata } from './metadata.js';
 export { getOrigQueryParams } from './queryParams.js';

package/dist/assets/utils/index.js

@@ -1,4 +1,7 @@
-import { emitESMImage } from "./node/emitAsset.js";
+import {
+  emitESMImage,
+  emitImageMetadata
+} from "./node/emitAsset.js";
 import { isESMImportedImage, isRemoteImage } from "./imageKind.js";
 import { imageMetadata } from "./metadata.js";
 import { getOrigQueryParams } from "./queryParams.js";
@@ -14,6 +17,7 @@ import {
 } from "./remotePattern.js";
 export {
   emitESMImage,
+  emitImageMetadata,
   getOrigQueryParams,
   hashTransform,
   imageMetadata,

package/dist/assets/utils/node/emitAsset.d.ts

@@ -9,11 +9,21 @@ type ImageMetadataWithContents = ImageMetadata & {
  *
  * @param {string | undefined} id - The identifier or path of the image file to process. If undefined, the function returns immediately.
  * @param {boolean} _watchMode - **Deprecated**: Indicates if the method is operating in watch mode. This parameter will be removed or updated in the future.
- * @param {boolean} experimentalSvgEnabled - A flag to enable experimental handling of SVG files. Embeds SVG file data if set to true.
+ * @param {boolean} _experimentalSvgEnabled - **Deprecated**: A flag to enable experimental handling of SVG files. Embeds SVG file data if set to true.
  * @param {FileEmitter | undefined} [fileEmitter] - Function for emitting files during the build process. May throw in certain scenarios.
  * @return {Promise<ImageMetadataWithContents | undefined>} Resolves to metadata with optional image contents or `undefined` if processing fails.
  */
 export declare function emitESMImage(id: string | undefined, 
 /** @deprecated */
-_watchMode: boolean, experimentalSvgEnabled: boolean, fileEmitter?: FileEmitter): Promise<ImageMetadataWithContents | undefined>;
+_watchMode: boolean, 
+/** @deprecated */
+_experimentalSvgEnabled: boolean, fileEmitter?: FileEmitter): Promise<ImageMetadataWithContents | undefined>;
+/**
+ * Processes an image file and emits its metadata and optionally its contents. This function supports both build and development modes.
+ *
+ * @param {string | undefined} id - The identifier or path of the image file to process. If undefined, the function returns immediately.
+ * @param {FileEmitter | undefined} [fileEmitter] - Function for emitting files during the build process. May throw in certain scenarios.
+ * @return {Promise<ImageMetadataWithContents | undefined>} Resolves to metadata with optional image contents or `undefined` if processing fails.
+ */
+export declare function emitImageMetadata(id: string | undefined, fileEmitter?: FileEmitter): Promise<ImageMetadataWithContents | undefined>;
 export {};

package/dist/assets/utils/node/emitAsset.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { prependForwardSlash, slash } from "../../../core/path.js";
 import { imageMetadata } from "../metadata.js";
-async function emitESMImage(id, _watchMode, experimentalSvgEnabled, fileEmitter) {
+async function emitESMImage(id, _watchMode, _experimentalSvgEnabled, fileEmitter) {
   if (!id) {
     return void 0;
   }
@@ -24,9 +24,50 @@ async function emitESMImage(id, _watchMode, experimentalSvgEnabled, fileEmitter)
     writable: false,
     value: id
   });
-  if (fileMetadata.format === "svg" && experimentalSvgEnabled) {
-    emittedImage.contents = fileData;
+  let isBuild = typeof fileEmitter === "function";
+  if (isBuild) {
+    const pathname = decodeURI(url.pathname);
+    const filename = path.basename(pathname, path.extname(pathname) + `.${fileMetadata.format}`);
+    try {
+      const handle = fileEmitter({
+        name: filename,
+        source: await fs.readFile(url),
+        type: "asset"
+      });
+      emittedImage.src = `__ASTRO_ASSET_IMAGE__${handle}__`;
+    } catch {
+      isBuild = false;
+    }
+  }
+  if (!isBuild) {
+    url.searchParams.append("origWidth", fileMetadata.width.toString());
+    url.searchParams.append("origHeight", fileMetadata.height.toString());
+    url.searchParams.append("origFormat", fileMetadata.format);
+    emittedImage.src = `/@fs` + prependForwardSlash(fileURLToNormalizedPath(url));
+  }
+  return emittedImage;
+}
+async function emitImageMetadata(id, fileEmitter) {
+  if (!id) {
+    return void 0;
+  }
+  const url = pathToFileURL(id);
+  let fileData;
+  try {
+    fileData = await fs.readFile(url);
+  } catch {
+    return void 0;
   }
+  const fileMetadata = await imageMetadata(fileData, id);
+  const emittedImage = {
+    src: "",
+    ...fileMetadata
+  };
+  Object.defineProperty(emittedImage, "fsPath", {
+    enumerable: false,
+    writable: false,
+    value: id
+  });
   let isBuild = typeof fileEmitter === "function";
   if (isBuild) {
     const pathname = decodeURI(url.pathname);
@@ -54,5 +95,6 @@ function fileURLToNormalizedPath(filePath) {
   return slash(fileURLToPath(filePath) + filePath.search).replace(/\\/g, "/");
 }
 export {
-  emitESMImage
+  emitESMImage,
+  emitImageMetadata
 };

package/dist/assets/utils/vendor/image-size/types/index.d.ts

@@ -1,3 +1,3 @@
-export declare const typeHandlers: Map<"svg" | "jpg" | "png" | "tiff" | "webp" | "gif" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "pnm" | "psd" | "tga", import("./interface.js").IImage>;
-export declare const types: ("svg" | "jpg" | "png" | "tiff" | "webp" | "gif" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "pnm" | "psd" | "tga")[];
+export declare const typeHandlers: Map<"jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "pnm" | "psd" | "tga", import("./interface.js").IImage>;
+export declare const types: ("jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "pnm" | "psd" | "tga")[];
 export type imageType = typeof types[number];

package/dist/assets/vite-plugin-assets.d.ts

@@ -1,5 +1,12 @@
+import type * as fsMod from 'node:fs';
 import type * as vite from 'vite';
+import type { Logger } from '../core/logger/core.js';
 import type { AstroSettings } from '../types/astro.js';
-export default function assets({ settings }: {
+interface Options {
     settings: AstroSettings;
-}): vite.Plugin[];
+    sync: boolean;
+    logger: Logger;
+    fs: typeof fsMod;
+}
+export default function assets({ fs, settings, sync, logger }: Options): vite.Plugin[];
+export {};

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

@@ -10,6 +10,7 @@ import {
 } from "../core/path.js";
 import { normalizePath } from "../core/viteUtils.js";
 import { VALID_INPUT_FORMATS, VIRTUAL_MODULE_ID, VIRTUAL_SERVICE_ID } from "./consts.js";
+import { fontsPlugin } from "./fonts/vite-plugin-fonts.js";
 import { getAssetsPrefix } from "./utils/getAssetsPrefix.js";
 import { isESMImportedImage } from "./utils/imageKind.js";
 import { emitESMImage } from "./utils/node/emitAsset.js";
@@ -63,7 +64,7 @@ const addStaticImageFactory = (settings) => {
     }
   };
 };
-function assets({ settings }) {
+function assets({ fs, settings, sync, logger }) {
   let resolvedConfig;
   let shouldEmitFile = false;
   let isBuild = false;
@@ -94,6 +95,7 @@ function assets({ settings }) {
 							import { getImage as getImageInternal } from "astro/assets";
 							export { default as Image } from "astro/components/${imageComponentPrefix}Image.astro";
 							export { default as Picture } from "astro/components/${imageComponentPrefix}Picture.astro";
+							export { default as Font } from "astro/components/Font.astro";
 							export { inferRemoteSize } from "astro/assets/utils/inferRemoteSize.js";
 
 							export const imageConfig = ${JSON.stringify({ ...settings.config.image, experimentalResponsiveImages: settings.config.experimental.responsiveImages })};
@@ -170,7 +172,7 @@ function assets({ settings }) {
           const imageMetadata = await emitESMImage(
             id,
             this.meta.watchMode,
-            !!settings.config.experimental.svg,
+            id.endsWith(".svg"),
             emitFile
           );
           if (!imageMetadata) {
@@ -179,9 +181,9 @@ function assets({ settings }) {
               message: AstroErrorData.ImageNotFound.message(id)
             });
           }
-          if (settings.config.experimental.svg && /\.svg$/.test(id)) {
-            const { contents, ...metadata } = imageMetadata;
-            return { code: makeSvgComponent(metadata, contents) };
+          if (id.endsWith(".svg")) {
+            const contents = await fs.promises.readFile(imageMetadata.fsPath, { encoding: "utf8" });
+            return { code: makeSvgComponent(imageMetadata, contents) };
           }
           if (options?.ssr) {
             return {
@@ -198,7 +200,8 @@ function assets({ settings }) {
           }
         }
       }
-    }
+    },
+    fontsPlugin({ settings, sync, logger })
   ];
 }
 export {

package/dist/cli/add/index.js

@@ -545,7 +545,9 @@ async function tryToInstallIntegrations({
   }).filter(Boolean).flat();
   const installCommand = resolveCommand(packageManager?.agent ?? "npm", "add", inheritedFlags);
   if (!installCommand) return 0 /* none */;
-  const installSpecifiers = await convertIntegrationsToInstallSpecifiers(integrations);
+  const installSpecifiers = await convertIntegrationsToInstallSpecifiers(integrations).then(
+    (specifiers) => installCommand.command === "deno" ? specifiers.map((specifier) => `npm:${specifier}`) : specifiers
+  );
   const coloredOutput = `${bold(installCommand.command)} ${installCommand.args.join(" ")} ${cyan(installSpecifiers.join(" "))}`;
   const message = `
 ${boxen(coloredOutput, {

package/dist/cli/install-package.js

@@ -43,6 +43,9 @@ async function installPackage(packageNames, options, logger) {
   });
   const installCommand = resolveCommand(packageManager?.agent ?? "npm", "add", []);
   if (!installCommand) return false;
+  if (installCommand.command === "deno") {
+    packageNames = packageNames.map((name) => `npm:${name}`);
+  }
   const coloredOutput = `${bold(installCommand.command)} ${installCommand.args.join(" ")} ${cyan(packageNames.join(" "))}`;
   const message = `
 ${boxen(coloredOutput, {

package/dist/config/entrypoint.d.ts

@@ -4,6 +4,8 @@ export { defineConfig, getViteConfig } from './index.js';
 export { envField } from '../env/config.js';
 export { mergeConfig } from '../core/config/merge.js';
 export { validateConfig } from '../core/config/validate.js';
+export { fontProviders, defineAstroFontProvider } from '../assets/fonts/providers/index.js';
+export type { AstroFontProvider as FontProvider } from '../assets/fonts/types.js';
 /**
  * Return the configuration needed to use the Sharp-based image service
  */