astro 5.7.5 → 5.7.7

package/components/image.css

@@ -1,17 +1,10 @@
-[data-astro-image] {
-	width: 100%;
-	height: auto;
+:where([data-astro-image]) {
 	object-fit: var(--fit);
 	object-position: var(--pos);
-	aspect-ratio: var(--w) / var(--h);
 }
-/* Styles for responsive layout */
-[data-astro-image='responsive'] {
-	max-width: calc(var(--w) * 1px);
-	max-height: calc(var(--h) * 1px);
+:where([data-astro-image='full-width']) {
+	width: 100%;
 }
-/* Styles for fixed layout */
-[data-astro-image='fixed'] {
-	width: calc(var(--w) * 1px);
-	height: calc(var(--h) * 1px);
+:where([data-astro-image='constrained']) {
+	max-width: 100%;
 }

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

@@ -41,9 +41,9 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
      * ```
      *
 
-     * If the last font in the `fallbacks` array is a [generic family name](https://developer.mozilla.org/en-US/docs/Web/CSS/font-family#generic-name), an [optimized fallback](https://developer.chrome.com/blog/font-fallbacks) using font metrics will be generated. To disable this optimization, set `optimizedFallbacks` to false.
+     * If the last font in the `fallbacks` array is a [generic family name](https://developer.mozilla.org/en-US/docs/Web/CSS/font-family#generic-name), Astro will attempt to generate [optimized fallbacks](https://developer.chrome.com/blog/font-fallbacks) using font metrics will be generated. To disable this optimization, set `optimizedFallbacks` to false.
      */
-    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
+    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     /**
      * @default `true`
      *
@@ -173,7 +173,7 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
         featureSettings?: string | undefined;
         variationSettings?: string | undefined;
     }[]];
-    fallbacks?: [string, ...string[]] | undefined;
+    fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
 }, {
     name: string;
@@ -210,7 +210,7 @@ export declare const localFontFamilySchema: z.ZodObject<z.objectUtil.extendShape
         featureSettings?: string | undefined;
         variationSettings?: string | undefined;
     }[]];
-    fallbacks?: [string, ...string[]] | undefined;
+    fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
 }>;
 export declare const remoteFontFamilySchema: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
@@ -274,9 +274,9 @@ export declare const remoteFontFamilySchema: z.ZodObject<z.objectUtil.extendShap
      * ```
      *
 
-     * If the last font in the `fallbacks` array is a [generic family name](https://developer.mozilla.org/en-US/docs/Web/CSS/font-family#generic-name), an [optimized fallback](https://developer.chrome.com/blog/font-fallbacks) using font metrics will be generated. To disable this optimization, set `optimizedFallbacks` to false.
+     * If the last font in the `fallbacks` array is a [generic family name](https://developer.mozilla.org/en-US/docs/Web/CSS/font-family#generic-name), Astro will attempt to generate [optimized fallbacks](https://developer.chrome.com/blog/font-fallbacks) using font metrics will be generated. To disable this optimization, set `optimizedFallbacks` to false.
      */
-    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
+    fallbacks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     /**
      * @default `true`
      *
@@ -322,7 +322,7 @@ export declare const remoteFontFamilySchema: z.ZodObject<z.objectUtil.extendShap
     /**
      * @default `["cyrillic-ext", "cyrillic", "greek-ext", "greek", "vietnamese", "latin-ext", "latin"]`
      *
-     * An array of [font subsets](https://fonts.google.com/knowledge/glossary/subsetting):
+     * An array of [font subsets](https://knaap.dev/posts/font-subsetting/):
      */
     subsets: z.ZodOptional<z.ZodArray<z.ZodString, "atleastone">>;
 }>, "strict", z.ZodTypeAny, {
@@ -332,7 +332,7 @@ export declare const remoteFontFamilySchema: z.ZodObject<z.objectUtil.extendShap
         entrypoint: string | URL;
         config?: Record<string, any> | undefined;
     };
-    fallbacks?: [string, ...string[]] | undefined;
+    fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
     display?: "fallback" | "auto" | "optional" | "block" | "swap" | undefined;
     unicodeRange?: [string, ...string[]] | undefined;
@@ -349,7 +349,7 @@ export declare const remoteFontFamilySchema: z.ZodObject<z.objectUtil.extendShap
         entrypoint: string | URL;
         config?: Record<string, any> | undefined;
     };
-    fallbacks?: [string, ...string[]] | undefined;
+    fallbacks?: string[] | undefined;
     optimizedFallbacks?: boolean | undefined;
     display?: "fallback" | "auto" | "optional" | "block" | "swap" | undefined;
     unicodeRange?: [string, ...string[]] | undefined;

package/dist/assets/fonts/config.js

@@ -55,9 +55,9 @@ const fallbacksSchema = z.object({
   	 * ```
   	 *
   
-  	 * If the last font in the `fallbacks` array is a [generic family name](https://developer.mozilla.org/en-US/docs/Web/CSS/font-family#generic-name), an [optimized fallback](https://developer.chrome.com/blog/font-fallbacks) using font metrics will be generated. To disable this optimization, set `optimizedFallbacks` to false.
+  	 * If the last font in the `fallbacks` array is a [generic family name](https://developer.mozilla.org/en-US/docs/Web/CSS/font-family#generic-name), Astro will attempt to generate [optimized fallbacks](https://developer.chrome.com/blog/font-fallbacks) using font metrics will be generated. To disable this optimization, set `optimizedFallbacks` to false.
   	 */
-  fallbacks: z.array(z.string()).nonempty().optional(),
+  fallbacks: z.array(z.string()).optional(),
   /**
    * @default `true`
    *
@@ -140,11 +140,10 @@ const remoteFontFamilySchema = requiredFamilyAttributesSchema.merge(
      * An array of [font styles](https://developer.mozilla.org/en-US/docs/Web/CSS/font-style).
      */
     styles: z.array(styleSchema).nonempty().optional(),
-    // TODO: better link
     /**
      * @default `["cyrillic-ext", "cyrillic", "greek-ext", "greek", "vietnamese", "latin-ext", "latin"]`
      *
-     * An array of [font subsets](https://fonts.google.com/knowledge/glossary/subsetting):
+     * An array of [font subsets](https://knaap.dev/posts/font-subsetting/):
      */
     subsets: z.array(z.string()).nonempty().optional()
   })

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

@@ -1,81 +1,11 @@
+import type { Defaults } from './types.js';
 export declare const LOCAL_PROVIDER_NAME = "local";
-export declare const DEFAULTS: {
-    weights: string[];
-    styles: ["normal", "italic"];
-    subsets: [string, string, string, string, string, string, string];
-    fallbacks: [string];
-    optimizedFallbacks: true;
-};
+export declare const DEFAULTS: Defaults;
 export declare const VIRTUAL_MODULE_ID = "virtual:astro:assets/fonts/internal";
 export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
 export declare const URL_PREFIX = "/_astro/fonts/";
 export declare const CACHE_DIR = "./fonts/";
 export declare const FONT_TYPES: readonly ["woff2", "woff", "otf", "ttf", "eot"];
 export declare const FONT_FORMAT_MAP: Record<(typeof FONT_TYPES)[number], string>;
-export declare const SYSTEM_METRICS: {
-    'Times New Roman': {
-        ascent: number;
-        descent: number;
-        lineGap: number;
-        unitsPerEm: number;
-        xWidthAvg: number;
-    };
-    Arial: {
-        ascent: number;
-        descent: number;
-        lineGap: number;
-        unitsPerEm: number;
-        xWidthAvg: number;
-    };
-    'Courier New': {
-        ascent: number;
-        descent: number;
-        lineGap: number;
-        unitsPerEm: number;
-        xWidthAvg: number;
-    };
-    BlinkMacSystemFont: {
-        ascent: number;
-        descent: number;
-        lineGap: number;
-        unitsPerEm: number;
-        xWidthAvg: number;
-    };
-    'Segoe UI': {
-        ascent: number;
-        descent: number;
-        lineGap: number;
-        unitsPerEm: number;
-        xWidthAvg: number;
-    };
-    Roboto: {
-        ascent: number;
-        descent: number;
-        lineGap: number;
-        unitsPerEm: number;
-        xWidthAvg: number;
-    };
-    'Helvetica Neue': {
-        ascent: number;
-        descent: number;
-        lineGap: number;
-        unitsPerEm: number;
-        xWidthAvg: number;
-    };
-};
-export declare const DEFAULT_FALLBACKS: {
-    readonly serif: ["Times New Roman"];
-    readonly 'sans-serif': ["Arial"];
-    readonly monospace: ["Courier New"];
-    readonly cursive: [];
-    readonly fantasy: [];
-    readonly 'system-ui': ["BlinkMacSystemFont", "Segoe UI", "Roboto", "Helvetica Neue", "Arial"];
-    readonly 'ui-serif': ["Times New Roman"];
-    readonly 'ui-sans-serif': ["Arial"];
-    readonly 'ui-monospace': ["Courier New"];
-    readonly 'ui-rounded': [];
-    readonly emoji: [];
-    readonly math: [];
-    readonly fangsong: [];
-};
+export declare const GENERIC_FALLBACK_NAMES: readonly ["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui", "ui-serif", "ui-sans-serif", "ui-monospace", "ui-rounded", "emoji", "math", "fangsong"];
 export declare const FONTS_TYPES_FILE = "fonts.d.ts";

package/dist/assets/fonts/constants.js

@@ -19,83 +19,31 @@ const FONT_FORMAT_MAP = {
   ttf: "truetype",
   eot: "embedded-opentype"
 };
-const SYSTEM_METRICS = {
-  "Times New Roman": {
-    ascent: 1825,
-    descent: -443,
-    lineGap: 87,
-    unitsPerEm: 2048,
-    xWidthAvg: 832
-  },
-  Arial: {
-    ascent: 1854,
-    descent: -434,
-    lineGap: 67,
-    unitsPerEm: 2048,
-    xWidthAvg: 913
-  },
-  "Courier New": {
-    ascent: 1705,
-    descent: -615,
-    lineGap: 0,
-    unitsPerEm: 2048,
-    xWidthAvg: 1229
-  },
-  BlinkMacSystemFont: {
-    ascent: 1980,
-    descent: -432,
-    lineGap: 0,
-    unitsPerEm: 2048,
-    xWidthAvg: 853
-  },
-  "Segoe UI": {
-    ascent: 2210,
-    descent: -514,
-    lineGap: 0,
-    unitsPerEm: 2048,
-    xWidthAvg: 908
-  },
-  Roboto: {
-    ascent: 1900,
-    descent: -500,
-    lineGap: 0,
-    unitsPerEm: 2048,
-    xWidthAvg: 911
-  },
-  "Helvetica Neue": {
-    ascent: 952,
-    descent: -213,
-    lineGap: 28,
-    unitsPerEm: 1e3,
-    xWidthAvg: 450
-  }
-};
-const DEFAULT_FALLBACKS = {
-  serif: ["Times New Roman"],
-  "sans-serif": ["Arial"],
-  monospace: ["Courier New"],
-  cursive: [],
-  fantasy: [],
-  "system-ui": ["BlinkMacSystemFont", "Segoe UI", "Roboto", "Helvetica Neue", "Arial"],
-  "ui-serif": ["Times New Roman"],
-  "ui-sans-serif": ["Arial"],
-  "ui-monospace": ["Courier New"],
-  "ui-rounded": [],
-  emoji: [],
-  math: [],
-  fangsong: []
-};
+const GENERIC_FALLBACK_NAMES = [
+  "serif",
+  "sans-serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-serif",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-rounded",
+  "emoji",
+  "math",
+  "fangsong"
+];
 const FONTS_TYPES_FILE = "fonts.d.ts";
 export {
   CACHE_DIR,
   DEFAULTS,
-  DEFAULT_FALLBACKS,
   FONTS_TYPES_FILE,
   FONT_FORMAT_MAP,
   FONT_TYPES,
+  GENERIC_FALLBACK_NAMES,
   LOCAL_PROVIDER_NAME,
   RESOLVED_VIRTUAL_MODULE_ID,
-  SYSTEM_METRICS,
   URL_PREFIX,
   VIRTUAL_MODULE_ID
 };

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

@@ -0,0 +1,73 @@
+import type * as unifont from 'unifont';
+import type { CollectedFontForMetrics } from './logic/optimize-fallbacks.js';
+import type { AstroFontProvider, FontFileData, FontType, PreloadData, ResolvedFontProvider } from './types.js';
+import type { FontFaceMetrics, GenericFallbackName } 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: AstroFontProvider) => Promise<ResolvedFontProvider>;
+}
+export interface LocalProviderUrlResolver {
+    resolve: (input: string) => string;
+}
+type SingleErrorInput<TType extends string, TData extends Record<string, any>> = {
+    type: TType;
+    data: TData;
+    cause: unknown;
+};
+export type ErrorHandlerInput = SingleErrorInput<'cannot-load-font-provider', {
+    entrypoint: string;
+}> | SingleErrorInput<'unknown-fs-error', {}> | SingleErrorInput<'cannot-fetch-font-file', {
+    url: string;
+}> | SingleErrorInput<'cannot-extract-font-type', {
+    url: string;
+}>;
+export interface ErrorHandler {
+    handle: (input: ErrorHandlerInput) => Error;
+}
+export interface UrlProxy {
+    proxy: (input: Pick<FontFileData, 'url' | 'init'> & {
+        collectPreload: boolean;
+        data: Partial<unifont.FontFaceData>;
+    }) => string;
+}
+export interface UrlProxyContentResolver {
+    resolve: (url: string) => string;
+}
+export interface DataCollector {
+    collect: (input: FontFileData & {
+        data: Partial<unifont.FontFaceData>;
+        preload: PreloadData | null;
+    }) => void;
+}
+export type CssProperties = Record<string, string | undefined>;
+export interface CssRenderer {
+    generateFontFace: (family: string, properties: CssProperties) => string;
+    generateCssVariable: (key: string, values: Array<string>) => string;
+}
+export interface FontMetricsResolver {
+    getMetrics: (name: string, font: CollectedFontForMetrics) => Promise<FontFaceMetrics>;
+    generateFontFace: (input: {
+        metrics: FontFaceMetrics;
+        fallbackMetrics: FontFaceMetrics;
+        name: string;
+        font: string;
+        properties: CssProperties;
+    }) => string;
+}
+export interface SystemFallbacksProvider {
+    getLocalFonts: (fallback: GenericFallbackName) => Array<string> | null;
+    getMetricsForLocalFont: (family: string) => FontFaceMetrics;
+}
+export interface FontFetcher {
+    fetch: (input: FontFileData) => Promise<Buffer>;
+}
+export interface FontTypeExtractor {
+    extract: (url: string) => FontType;
+}
+export {};

package/dist/assets/fonts/implementations/css-renderer.d.ts

@@ -0,0 +1,9 @@
+import type { CssProperties, CssRenderer } from '../definitions.js';
+export declare function renderFontFace(properties: CssProperties, minify: boolean): string;
+export declare function renderCssVariable(key: string, values: Array<string>, minify: boolean): string;
+export declare function withFamily(family: string, properties: CssProperties): CssProperties;
+/** If the value contains spaces (which would be incorrectly interpreted), we wrap it in quotes. */
+export declare function handleValueWithSpaces(value: string): string;
+export declare function createMinifiableCssRenderer({ minify }: {
+    minify: boolean;
+}): CssRenderer;

package/dist/assets/fonts/implementations/css-renderer.js

@@ -0,0 +1,42 @@
+function renderFontFace(properties, minify) {
+  const lf = minify ? "" : `
+`;
+  const sp = minify ? "" : " ";
+  return `@font-face${sp}{${lf}${Object.entries(properties).filter(([, value]) => Boolean(value)).map(([key, value]) => `${sp}${sp}${key}:${sp}${value};`).join(lf)}${lf}}${lf}`;
+}
+function renderCssVariable(key, values, minify) {
+  const lf = minify ? "" : `
+`;
+  const sp = minify ? "" : " ";
+  return `:root${sp}{${lf}${sp}${sp}${key}:${sp}${values.map((v) => handleValueWithSpaces(v)).join(`,${sp}`)};${lf}}${lf}`;
+}
+function withFamily(family, properties) {
+  return {
+    "font-family": handleValueWithSpaces(family),
+    ...properties
+  };
+}
+const SPACE_RE = /\s/;
+function handleValueWithSpaces(value) {
+  if (SPACE_RE.test(value)) {
+    return JSON.stringify(value);
+  }
+  return value;
+}
+function createMinifiableCssRenderer({ minify }) {
+  return {
+    generateFontFace(family, properties) {
+      return renderFontFace(withFamily(family, properties), minify);
+    },
+    generateCssVariable(key, values) {
+      return renderCssVariable(key, values, minify);
+    }
+  };
+}
+export {
+  createMinifiableCssRenderer,
+  handleValueWithSpaces,
+  renderCssVariable,
+  renderFontFace,
+  withFamily
+};

package/dist/assets/fonts/implementations/data-collector.d.ts

@@ -0,0 +1,3 @@
+import type { DataCollector } from '../definitions.js';
+import type { CreateUrlProxyParams } from '../types.js';
+export declare function createDataCollector({ hasUrl, saveUrl, savePreload, saveFontData, }: Omit<CreateUrlProxyParams, 'local'>): DataCollector;

package/dist/assets/fonts/implementations/data-collector.js

@@ -0,0 +1,21 @@
+function createDataCollector({
+  hasUrl,
+  saveUrl,
+  savePreload,
+  saveFontData
+}) {
+  return {
+    collect({ hash, url, init, preload, data }) {
+      if (!hasUrl(hash)) {
+        saveUrl({ hash, url, init });
+        if (preload) {
+          savePreload(preload);
+        }
+      }
+      saveFontData({ hash, url, data, init });
+    }
+  };
+}
+export {
+  createDataCollector
+};

package/dist/assets/fonts/implementations/error-handler.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorHandler } from '../definitions.js';
+export declare function createAstroErrorHandler(): ErrorHandler;

package/dist/assets/fonts/implementations/error-handler.js

@@ -0,0 +1,33 @@
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+function getProps(input) {
+  if (input.type === "cannot-load-font-provider") {
+    return {
+      ...AstroErrorData.CannotLoadFontProvider,
+      message: AstroErrorData.CannotLoadFontProvider.message(input.data.entrypoint)
+    };
+  } else if (input.type === "unknown-fs-error") {
+    return AstroErrorData.UnknownFilesystemError;
+  } else if (input.type === "cannot-fetch-font-file") {
+    return {
+      ...AstroErrorData.CannotFetchFontFile,
+      message: AstroErrorData.CannotFetchFontFile.message(input.data.url)
+    };
+  } else if (input.type === "cannot-extract-font-type") {
+    return {
+      ...AstroErrorData.CannotExtractFontType,
+      message: AstroErrorData.CannotExtractFontType.message(input.data.url)
+    };
+  }
+  input;
+  return AstroErrorData.UnknownError;
+}
+function createAstroErrorHandler() {
+  return {
+    handle(input) {
+      return new AstroError(getProps(input), { cause: input.cause });
+    }
+  };
+}
+export {
+  createAstroErrorHandler
+};

package/dist/assets/fonts/implementations/font-fetcher.d.ts

@@ -0,0 +1,8 @@
+import type { Storage } from 'unstorage';
+import type { ErrorHandler, FontFetcher } from '../definitions.js';
+export declare function createCachedFontFetcher({ storage, errorHandler, fetch, readFile, }: {
+    storage: Storage;
+    errorHandler: ErrorHandler;
+    fetch: (url: string, init?: RequestInit) => Promise<Response>;
+    readFile: (url: string) => Promise<Buffer>;
+}): FontFetcher;

package/dist/assets/fonts/implementations/font-fetcher.js

@@ -0,0 +1,34 @@
+import { isAbsolute } from "node:path";
+import { cache } from "../utils.js";
+function createCachedFontFetcher({
+  storage,
+  errorHandler,
+  fetch,
+  readFile
+}) {
+  return {
+    async fetch({ hash, url, init }) {
+      return await cache(storage, hash, async () => {
+        try {
+          if (isAbsolute(url)) {
+            return await readFile(url);
+          }
+          const response = await fetch(url, init ?? void 0);
+          if (!response.ok) {
+            throw new Error(`Response was not successful, received status code ${response.status}`);
+          }
+          return Buffer.from(await response.arrayBuffer());
+        } catch (cause) {
+          throw errorHandler.handle({
+            type: "cannot-fetch-font-file",
+            data: { url },
+            cause
+          });
+        }
+      });
+    }
+  };
+}
+export {
+  createCachedFontFetcher
+};

package/dist/assets/fonts/implementations/font-metrics-resolver.d.ts

@@ -0,0 +1,5 @@
+import type { CssRenderer, FontFetcher, FontMetricsResolver } from '../definitions.js';
+export declare function createCapsizeFontMetricsResolver({ fontFetcher, cssRenderer, }: {
+    fontFetcher: FontFetcher;
+    cssRenderer: CssRenderer;
+}): FontMetricsResolver;

package/dist/assets/fonts/implementations/font-metrics-resolver.js

@@ -0,0 +1,60 @@
+import { fromBuffer } from "@capsizecss/unpack";
+import { renderFontSrc } from "../utils.js";
+function filterRequiredMetrics({
+  ascent,
+  descent,
+  lineGap,
+  unitsPerEm,
+  xWidthAvg
+}) {
+  return {
+    ascent,
+    descent,
+    lineGap,
+    unitsPerEm,
+    xWidthAvg
+  };
+}
+function toPercentage(value, fractionDigits = 4) {
+  const percentage = value * 100;
+  return `${+percentage.toFixed(fractionDigits)}%`;
+}
+function createCapsizeFontMetricsResolver({
+  fontFetcher,
+  cssRenderer
+}) {
+  const cache = {};
+  return {
+    async getMetrics(name, input) {
+      cache[name] ??= filterRequiredMetrics(await fromBuffer(await fontFetcher.fetch(input)));
+      return cache[name];
+    },
+    // Source: https://github.com/unjs/fontaine/blob/f00f84032c5d5da72c8798eae4cd68d3ddfbf340/src/css.ts#L170
+    generateFontFace({
+      metrics,
+      fallbackMetrics,
+      name: fallbackName,
+      font: fallbackFontName,
+      properties
+    }) {
+      const preferredFontXAvgRatio = metrics.xWidthAvg / metrics.unitsPerEm;
+      const fallbackFontXAvgRatio = fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm;
+      const sizeAdjust = preferredFontXAvgRatio / fallbackFontXAvgRatio;
+      const adjustedEmSquare = metrics.unitsPerEm * sizeAdjust;
+      const ascentOverride = metrics.ascent / adjustedEmSquare;
+      const descentOverride = Math.abs(metrics.descent) / adjustedEmSquare;
+      const lineGapOverride = metrics.lineGap / adjustedEmSquare;
+      return cssRenderer.generateFontFace(fallbackName, {
+        src: renderFontSrc([{ name: fallbackFontName }]),
+        "size-adjust": toPercentage(sizeAdjust),
+        "ascent-override": toPercentage(ascentOverride),
+        "descent-override": toPercentage(descentOverride),
+        "line-gap-override": toPercentage(lineGapOverride),
+        ...properties
+      });
+    }
+  };
+}
+export {
+  createCapsizeFontMetricsResolver
+};

package/dist/assets/fonts/implementations/font-type-extractor.d.ts

@@ -0,0 +1,4 @@
+import type { ErrorHandler, FontTypeExtractor } from '../definitions.js';
+export declare function createFontTypeExtractor({ errorHandler, }: {
+    errorHandler: ErrorHandler;
+}): FontTypeExtractor;

package/dist/assets/fonts/implementations/font-type-extractor.js

@@ -0,0 +1,22 @@
+import { extname } from "node:path";
+import { isFontType } from "../utils.js";
+function createFontTypeExtractor({
+  errorHandler
+}) {
+  return {
+    extract(url) {
+      const extension = extname(url).slice(1);
+      if (!isFontType(extension)) {
+        throw errorHandler.handle({
+          type: "cannot-extract-font-type",
+          data: { url },
+          cause: `Unexpected extension, got "${extension}"`
+        });
+      }
+      return extension;
+    }
+  };
+}
+export {
+  createFontTypeExtractor
+};

package/dist/assets/fonts/implementations/hasher.d.ts

@@ -0,0 +1,2 @@
+import type { Hasher } from '../definitions.js';
+export declare function createXxHasher(): Promise<Hasher>;

package/dist/assets/fonts/implementations/hasher.js

@@ -0,0 +1,14 @@
+import xxhash from "xxhash-wasm";
+import { sortObjectByKey } from "../utils.js";
+async function createXxHasher() {
+  const { h64ToString: hashString } = await xxhash();
+  return {
+    hashString,
+    hashObject(input) {
+      return hashString(JSON.stringify(sortObjectByKey(input)));
+    }
+  };
+}
+export {
+  createXxHasher
+};

package/dist/assets/fonts/implementations/local-provider-url-resolver.d.ts

@@ -0,0 +1,5 @@
+import type { LocalProviderUrlResolver } from '../definitions.js';
+export declare function createRequireLocalProviderUrlResolver({ root, intercept, }: {
+    root: URL;
+    intercept?: (path: string) => void;
+}): LocalProviderUrlResolver;