astro 5.6.2 → 5.7.0

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

@@ -0,0 +1,20 @@
+import type { Storage } from 'unstorage';
+import type { generateFallbackFontFace } from './metrics.js';
+import type { PreloadData, ResolvedFontFamily } from './types.js';
+import { type GetMetricsForFamily } from './utils.js';
+interface Options {
+    base: string;
+    families: Array<ResolvedFontFamily>;
+    storage: Storage;
+    hashToUrlMap: Map<string, string>;
+    resolvedMap: Map<string, {
+        preloadData: PreloadData;
+        css: string;
+    }>;
+    hashString: (value: string) => string;
+    log: (message: string) => void;
+    generateFallbackFontFace: typeof generateFallbackFontFace;
+    getMetricsForFamily: GetMetricsForFamily;
+}
+export declare function loadFonts({ base, families, storage, hashToUrlMap, resolvedMap, hashString, generateFallbackFontFace, getMetricsForFamily, log, }: Options): Promise<void>;
+export {};

package/dist/assets/fonts/load.js

@@ -0,0 +1,133 @@
+import { readFileSync } from "node:fs";
+import * as unifont from "unifont";
+import { AstroError, AstroErrorData } from "../../core/errors/index.js";
+import { DEFAULTS, LOCAL_PROVIDER_NAME } from "./constants.js";
+import { resolveLocalFont } from "./providers/local.js";
+import {
+  familiesToUnifontProviders,
+  generateFallbacksCSS,
+  generateFontFace,
+  proxyURL
+} from "./utils.js";
+async function loadFonts({
+  base,
+  families,
+  storage,
+  hashToUrlMap,
+  resolvedMap,
+  hashString,
+  generateFallbackFontFace,
+  getMetricsForFamily,
+  log
+}) {
+  const extractedProvidersResult = familiesToUnifontProviders({ families, hashString });
+  families = extractedProvidersResult.families;
+  const { resolveFont } = await unifont.createUnifont(extractedProvidersResult.providers, {
+    storage
+  });
+  for (const family of families) {
+    const preloadData = [];
+    let css = "";
+    let fallbackFontData = null;
+    const collect = ({ hash, type, value }) => {
+      const url = base + hash;
+      if (!hashToUrlMap.has(hash)) {
+        hashToUrlMap.set(hash, value);
+        preloadData.push({ url, type });
+      }
+      if (family.fallbacks && family.fallbacks.length > 0) {
+        fallbackFontData ??= {
+          hash,
+          url: value
+        };
+      }
+      return url;
+    };
+    let fonts;
+    if (family.provider === LOCAL_PROVIDER_NAME) {
+      const result = resolveLocalFont({
+        family,
+        proxyURL: (value) => {
+          return proxyURL({
+            value,
+            // We hash based on the filepath and the contents, since the user could replace
+            // a given font file with completely different contents.
+            hashString: (v) => {
+              let content;
+              try {
+                content = readFileSync(value, "utf-8");
+              } catch (e) {
+                throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: e });
+              }
+              return hashString(v + content);
+            },
+            collect
+          });
+        }
+      });
+      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 familiesToUnifontProviders)
+        [family.provider.name]
+      );
+      fonts = result.fonts.map((font) => ({
+        ...font,
+        src: font.src.map(
+          (source) => "name" in source ? source : {
+            ...source,
+            originalURL: source.url,
+            url: proxyURL({
+              value: source.url,
+              // We only use the url for hashing since the service returns urls with a hash already
+              hashString,
+              collect
+            })
+          }
+        )
+      }));
+    }
+    for (const data of fonts) {
+      css += generateFontFace(family.nameWithHash, {
+        src: data.src,
+        display: data.display ?? family.provider === LOCAL_PROVIDER_NAME ? void 0 : family.display,
+        unicodeRange: data.unicodeRange ?? family.provider === LOCAL_PROVIDER_NAME ? void 0 : family.unicodeRange,
+        weight: data.weight,
+        style: data.style,
+        stretch: data.stretch ?? family.provider === LOCAL_PROVIDER_NAME ? void 0 : family.stretch,
+        featureSettings: data.featureSettings ?? family.provider === LOCAL_PROVIDER_NAME ? void 0 : family.featureSettings,
+        variationSettings: data.variationSettings ?? family.provider === LOCAL_PROVIDER_NAME ? void 0 : family.variationSettings
+      });
+    }
+    const fallbackData = await generateFallbacksCSS({
+      family,
+      font: fallbackFontData,
+      fallbacks: family.fallbacks ?? DEFAULTS.fallbacks,
+      metrics: family.optimizedFallbacks ?? DEFAULTS.optimizedFallbacks ? {
+        getMetricsForFamily,
+        generateFontFace: generateFallbackFontFace
+      } : null
+    });
+    const cssVarValues = [family.nameWithHash];
+    if (fallbackData) {
+      css += fallbackData.css;
+      cssVarValues.push(...fallbackData.fallbacks);
+    }
+    css += `:root { ${family.cssVariable}: ${cssVarValues.join(", ")}; }`;
+    resolvedMap.set(family.cssVariable, { preloadData, css });
+  }
+  log("Fonts initialized");
+}
+export {
+  loadFonts
+};

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

@@ -0,0 +1,10 @@
+import { type Font } from '@capsizecss/unpack';
+export type FontFaceMetrics = Pick<Font, 'ascent' | 'descent' | 'lineGap' | 'unitsPerEm' | 'xWidthAvg'>;
+export declare function getMetricsForFamily(family: string): Promise<FontFaceMetrics | null>;
+export declare function readMetrics(family: string, buffer: Buffer): Promise<FontFaceMetrics>;
+export declare function generateFallbackFontFace(metrics: FontFaceMetrics, fallback: {
+    name: string;
+    font: string;
+    metrics?: FontFaceMetrics;
+    [key: string]: any;
+}): string;

package/dist/assets/fonts/metrics.js

@@ -0,0 +1,84 @@
+import { fontFamilyToCamelCase } from "@capsizecss/metrics";
+import { fromBuffer } from "@capsizecss/unpack";
+const QUOTES_RE = /^["']|["']$/g;
+const withoutQuotes = (str) => str.trim().replace(QUOTES_RE, "");
+const metricCache = {};
+function filterRequiredMetrics({
+  ascent,
+  descent,
+  lineGap,
+  unitsPerEm,
+  xWidthAvg
+}) {
+  return {
+    ascent,
+    descent,
+    lineGap,
+    unitsPerEm,
+    xWidthAvg
+  };
+}
+async function getMetricsForFamily(family) {
+  family = withoutQuotes(family);
+  if (family in metricCache) return metricCache[family];
+  try {
+    const name = fontFamilyToCamelCase(family);
+    const { entireMetricsCollection } = await import("@capsizecss/metrics/entireMetricsCollection");
+    const metrics = entireMetricsCollection[name];
+    if (!("descent" in metrics)) {
+      metricCache[family] = null;
+      return null;
+    }
+    const filteredMetrics = filterRequiredMetrics(metrics);
+    metricCache[family] = filteredMetrics;
+    return filteredMetrics;
+  } catch {
+    metricCache[family] = null;
+    return null;
+  }
+}
+async function readMetrics(family, buffer) {
+  const metrics = await fromBuffer(buffer);
+  metricCache[family] = filterRequiredMetrics(metrics);
+  return metricCache[family];
+}
+function toPercentage(value, fractionDigits = 4) {
+  const percentage = value * 100;
+  return `${+percentage.toFixed(fractionDigits)}%`;
+}
+function toCSS(properties, indent = 2) {
+  return Object.entries(properties).map(([key, value]) => `${" ".repeat(indent)}${key}: ${value};`).join("\n");
+}
+function generateFallbackFontFace(metrics, fallback) {
+  const {
+    name: fallbackName,
+    font: fallbackFontName,
+    metrics: fallbackMetrics,
+    ...properties
+  } = fallback;
+  const preferredFontXAvgRatio = metrics.xWidthAvg / metrics.unitsPerEm;
+  const fallbackFontXAvgRatio = fallbackMetrics ? fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm : 1;
+  const sizeAdjust = fallbackMetrics && preferredFontXAvgRatio && fallbackFontXAvgRatio ? preferredFontXAvgRatio / fallbackFontXAvgRatio : 1;
+  const adjustedEmSquare = metrics.unitsPerEm * sizeAdjust;
+  const ascentOverride = metrics.ascent / adjustedEmSquare;
+  const descentOverride = Math.abs(metrics.descent) / adjustedEmSquare;
+  const lineGapOverride = metrics.lineGap / adjustedEmSquare;
+  const declaration = {
+    "font-family": JSON.stringify(fallbackName),
+    src: `local(${JSON.stringify(fallbackFontName)})`,
+    "size-adjust": toPercentage(sizeAdjust),
+    "ascent-override": toPercentage(ascentOverride),
+    "descent-override": toPercentage(descentOverride),
+    "line-gap-override": toPercentage(lineGapOverride),
+    ...properties
+  };
+  return `@font-face {
+${toCSS(declaration)}
+}
+`;
+}
+export {
+  generateFallbackFontFace,
+  getMetricsForFamily,
+  readMetrics
+};

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

@@ -0,0 +1,2 @@
+import { providers } from 'unifont';
+export declare const provider: typeof providers.adobe;

package/dist/assets/fonts/providers/entrypoints/adobe.js

@@ -0,0 +1,5 @@
+import { providers } from "unifont";
+const provider = providers.adobe;
+export {
+  provider
+};

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

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

package/dist/assets/fonts/providers/entrypoints/bunny.js

@@ -0,0 +1,5 @@
+import { providers } from "unifont";
+const provider = providers.bunny;
+export {
+  provider
+};

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

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

package/dist/assets/fonts/providers/entrypoints/fontshare.js

@@ -0,0 +1,5 @@
+import { providers } from "unifont";
+const provider = providers.fontshare;
+export {
+  provider
+};

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

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

package/dist/assets/fonts/providers/entrypoints/fontsource.js

@@ -0,0 +1,5 @@
+import { providers } from "unifont";
+const provider = providers.fontsource;
+export {
+  provider
+};

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

@@ -0,0 +1,2 @@
+import { providers } from 'unifont';
+export declare const provider: typeof providers.google;

package/dist/assets/fonts/providers/entrypoints/google.js

@@ -0,0 +1,5 @@
+import { providers } from "unifont";
+const provider = providers.google;
+export {
+  provider
+};

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

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

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

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

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

@@ -0,0 +1,10 @@
+import type * as unifont from 'unifont';
+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: (value: string) => string;
+}
+export declare function resolveLocalFont({ family, proxyURL }: Options): ResolveFontResult;
+export {};

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

@@ -0,0 +1,30 @@
+import { extractFontType } from "../utils.js";
+function resolveLocalFont({ family, proxyURL }) {
+  const fonts = [];
+  for (const variant of family.variants) {
+    const data = {
+      weight: variant.weight,
+      style: variant.style,
+      src: variant.src.map(({ url: originalURL, tech }) => {
+        return {
+          originalURL,
+          url: proxyURL(originalURL),
+          format: 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
+  };
+}
+export {
+  resolveLocalFont
+};

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

@@ -0,0 +1,9 @@
+import type { AstroFontProvider, ResolvedFontProvider } from '../types.js';
+export declare function validateMod(mod: any, entrypoint: string): Pick<ResolvedFontProvider, 'provider'>;
+export type ResolveMod = (id: string) => Promise<any>;
+export interface ResolveProviderOptions {
+    root: URL;
+    provider: AstroFontProvider;
+    resolveMod: ResolveMod;
+}
+export declare function resolveProvider({ root, provider: { entrypoint, config }, resolveMod, }: ResolveProviderOptions): Promise<ResolvedFontProvider>;

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

@@ -0,0 +1,37 @@
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+import { resolveEntrypoint } from "../utils.js";
+function validateMod(mod, entrypoint) {
+  try {
+    if (typeof mod !== "object" || mod === null) {
+      throw new Error(`Expected an object for the module, but received ${typeof mod}.`);
+    }
+    if (typeof mod.provider !== "function") {
+      throw new Error(`Invalid provider export in module, expected a function.`);
+    }
+    return {
+      provider: mod.provider
+    };
+  } catch (cause) {
+    throw new AstroError(
+      {
+        ...AstroErrorData.CannotLoadFontProvider,
+        message: AstroErrorData.CannotLoadFontProvider.message(entrypoint)
+      },
+      { cause }
+    );
+  }
+}
+async function resolveProvider({
+  root,
+  provider: { entrypoint, config },
+  resolveMod
+}) {
+  const id = resolveEntrypoint(root, entrypoint.toString()).href;
+  const mod = await resolveMod(id);
+  const { provider } = validateMod(mod, id);
+  return { config, provider };
+}
+export {
+  resolveProvider,
+  validateMod
+};

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

@@ -0,0 +1,2 @@
+import type { AstroSettings } from '../../types/astro.js';
+export declare function syncFonts(settings: AstroSettings): void;

package/dist/assets/fonts/sync.js

@@ -0,0 +1,17 @@
+import { FONTS_TYPES_FILE } from "./constants.js";
+function syncFonts(settings) {
+  if (!settings.config.experimental.fonts) {
+    return;
+  }
+  settings.injectedTypes.push({
+    filename: FONTS_TYPES_FILE,
+    content: `declare module 'astro:assets' {
+	/** @internal */
+	export type FontFamily = (${JSON.stringify(settings.config.experimental.fonts.map((family) => family.cssVariable))})[number];
+}
+`
+  });
+}
+export {
+  syncFonts
+};

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

@@ -0,0 +1,45 @@
+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';
+export type AstroFontProvider = z.infer<typeof fontProviderSchema>;
+export interface ResolvedFontProvider {
+    name?: string;
+    provider: (config?: Record<string, any>) => unifont.Provider;
+    config?: Record<string, any>;
+}
+export type LocalFontFamily = z.infer<typeof localFontFamilySchema>;
+interface ResolvedFontFamilyAttributes {
+    nameWithHash: string;
+}
+export interface ResolvedLocalFontFamily extends ResolvedFontFamilyAttributes, Omit<LocalFontFamily, 'variants'> {
+    variants: Array<Omit<LocalFontFamily['variants'][number], 'weight' | 'src'> & {
+        weight: string;
+        src: Array<{
+            url: string;
+            tech?: string;
+        }>;
+    }>;
+}
+type RemoteFontFamily = z.infer<typeof remoteFontFamilySchema>;
+export interface ResolvedRemoteFontFamily extends ResolvedFontFamilyAttributes, Omit<z.output<typeof remoteFontFamilySchema>, 'provider' | 'weights'> {
+    provider: ResolvedFontProvider;
+    weights?: Array<string>;
+}
+export type FontFamily = LocalFontFamily | RemoteFontFamily;
+export type ResolvedFontFamily = ResolvedLocalFontFamily | ResolvedRemoteFontFamily;
+export type FontType = (typeof FONT_TYPES)[number];
+/**
+ * Preload data is used for links generation inside the <Font /> component
+ */
+export type PreloadData = Array<{
+    /**
+     * Absolute link to a font file, eg. /_astro/fonts/abc.woff
+     */
+    url: string;
+    /**
+     * A font type, eg. woff2, woff, ttf...
+     */
+    type: FontType;
+}>;
+export {};

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

@@ -0,0 +1,95 @@
+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 generateFontFace(family: string, font: unifont.FontFaceData): 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<{
+    cached: boolean;
+    data: 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;
+}
+/**
+ * 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`
+ */
+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;
+} | null;
+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 | null>;
+/**
+ * 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.
+ */
+export declare function generateFallbacksCSS({ family, fallbacks: _fallbacks, font: fontData, metrics, }: {
+    family: Pick<ResolvedFontFamily, 'name' | 'nameWithHash'>;
+    /** The family fallbacks */
+    fallbacks: Array<string>;
+    font: GetMetricsForFamilyFont;
+    metrics: {
+        getMetricsForFamily: GetMetricsForFamily;
+        generateFontFace: typeof generateFallbackFontFace;
+    } | null;
+}): Promise<null | {
+    css: string;
+    fallbacks: Array<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.
+ */
+export declare function resolveFontFamily({ family, generateNameWithHash, root, resolveMod, }: Omit<ResolveProviderOptions, 'provider'> & {
+    family: FontFamily;
+    generateNameWithHash: (family: FontFamily) => string;
+}): Promise<ResolvedFontFamily>;
+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;