astro 5.16.2 → 5.16.4

package/dist/actions/runtime/server.d.ts

@@ -6,19 +6,20 @@ export * from './shared.js';
 export type ActionAccept = 'form' | 'json';
 export type ActionHandler<TInputSchema, TOutput> = TInputSchema extends z.ZodType ? (input: z.infer<TInputSchema>, context: ActionAPIContext) => MaybePromise<TOutput> : (input: any, context: ActionAPIContext) => MaybePromise<TOutput>;
 export type ActionReturnType<T extends ActionHandler<any, any>> = Awaited<ReturnType<T>>;
-declare const inferSymbol: unique symbol;
+export type InferKey = '__internalInfer';
 /**
  * Infers the type of an action's input based on its Zod schema
  *
  * @see https://docs.astro.build/en/reference/modules/astro-actions/#actioninputschema
  */
 export type ActionInputSchema<T extends ActionClient<any, any, any>> = T extends {
-    [inferSymbol]: any;
-} ? T[typeof inferSymbol] : never;
+    [key in InferKey]: any;
+} ? T[InferKey] : never;
 export type ActionClient<TOutput, TAccept extends ActionAccept | undefined, TInputSchema extends z.ZodType | undefined> = TInputSchema extends z.ZodType ? ((input: TAccept extends 'form' ? FormData : z.input<TInputSchema>) => Promise<SafeResult<z.input<TInputSchema> extends ErrorInferenceObject ? z.input<TInputSchema> : ErrorInferenceObject, Awaited<TOutput>>>) & {
     queryString: string;
     orThrow: (input: TAccept extends 'form' ? FormData : z.input<TInputSchema>) => Promise<Awaited<TOutput>>;
-    [inferSymbol]: TInputSchema;
+} & {
+    [key in InferKey]: TInputSchema;
 } : ((input?: any) => Promise<SafeResult<never, Awaited<TOutput>>>) & {
     orThrow: (input?: any) => Promise<Awaited<TOutput>>;
 };

package/dist/actions/runtime/server.js

@@ -20,7 +20,6 @@ import {
   isActionAPIContext
 } from "./utils.js";
 export * from "./shared.js";
-const inferSymbol = Symbol("#infer");
 function defineAction({
   accept,
   input: inputSchema,

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

@@ -14,7 +14,7 @@ export interface RemoteFontProviderResolver {
 export interface LocalProviderUrlResolver {
     resolve: (input: string) => string;
 }
-interface ProxyData {
+export interface ProxyData {
     weight: unifont.FontFaceData['weight'];
     style: unifont.FontFaceData['style'];
     subset: NonNullable<unifont.FontFaceData['meta']>['subset'];
@@ -28,7 +28,7 @@ export interface UrlProxy {
 }
 export interface UrlResolver {
     resolve: (hash: string) => string;
-    getCspResources: () => Array<string>;
+    readonly cspResources: Array<string>;
 }
 export interface UrlProxyContentResolver {
     resolve: (url: string) => string;
@@ -84,4 +84,9 @@ export interface UrlProxyHashResolver {
 export interface StringMatcher {
     getClosestMatch: (target: string, candidates: Array<string>) => string;
 }
-export {};
+export interface Storage {
+    getItem: (key: string) => Promise<any | null>;
+    getItemRaw: (key: string) => Promise<Buffer | null>;
+    setItem: (key: string, value: any) => Promise<void>;
+    setItemRaw: (key: string, value: any) => Promise<void>;
+}

package/dist/assets/fonts/infra/build-remote-font-provider-mod-resolver.d.ts

@@ -1,2 +1,4 @@
 import type { RemoteFontProviderModResolver } from '../definitions.js';
-export declare function createBuildRemoteFontProviderModResolver(): RemoteFontProviderModResolver;
+export declare class BuildRemoteFontProviderModResolver implements RemoteFontProviderModResolver {
+    resolve(id: string): Promise<any>;
+}

package/dist/assets/fonts/infra/build-remote-font-provider-mod-resolver.js

@@ -1,10 +1,8 @@
-function createBuildRemoteFontProviderModResolver() {
-  return {
-    resolve(id) {
-      return import(id);
-    }
-  };
+class BuildRemoteFontProviderModResolver {
+  async resolve(id) {
+    return await import(id);
+  }
 }
 export {
-  createBuildRemoteFontProviderModResolver
+  BuildRemoteFontProviderModResolver
 };

package/dist/assets/fonts/infra/build-url-proxy-hash-resolver.d.ts

@@ -1,5 +1,15 @@
-import type { Hasher, UrlProxyContentResolver, UrlProxyHashResolver } from '../definitions.js';
-export declare function createBuildUrlProxyHashResolver({ hasher, contentResolver, }: {
-    hasher: Hasher;
-    contentResolver: UrlProxyContentResolver;
-}): UrlProxyHashResolver;
+import type { Hasher, ProxyData, UrlProxyContentResolver, UrlProxyHashResolver } from '../definitions.js';
+import type { FontType } from '../types.js';
+export declare class BuildUrlProxyHashResolver implements UrlProxyHashResolver {
+    #private;
+    constructor({ hasher, contentResolver, }: {
+        hasher: Hasher;
+        contentResolver: UrlProxyContentResolver;
+    });
+    resolve({ originalUrl, type, }: {
+        originalUrl: string;
+        type: FontType;
+        cssVariable: string;
+        data: ProxyData;
+    }): string;
+}

package/dist/assets/fonts/infra/build-url-proxy-hash-resolver.js

@@ -1,13 +1,20 @@
-function createBuildUrlProxyHashResolver({
-  hasher,
-  contentResolver
-}) {
-  return {
-    resolve({ originalUrl, type }) {
-      return `${hasher.hashString(contentResolver.resolve(originalUrl))}.${type}`;
-    }
-  };
+class BuildUrlProxyHashResolver {
+  #hasher;
+  #contentResolver;
+  constructor({
+    hasher,
+    contentResolver
+  }) {
+    this.#hasher = hasher;
+    this.#contentResolver = contentResolver;
+  }
+  resolve({
+    originalUrl,
+    type
+  }) {
+    return `${this.#hasher.hashString(this.#contentResolver.resolve(originalUrl))}.${type}`;
+  }
 }
 export {
-  createBuildUrlProxyHashResolver
+  BuildUrlProxyHashResolver
 };

package/dist/assets/fonts/infra/build-url-resolver.d.ts

@@ -1,7 +1,12 @@
 import type { AssetsPrefix } from '../../../types/public/index.js';
 import type { UrlResolver } from '../definitions.js';
-export declare function createBuildUrlResolver({ base, assetsPrefix, searchParams, }: {
-    base: string;
-    assetsPrefix: AssetsPrefix;
-    searchParams: URLSearchParams;
-}): UrlResolver;
+export declare class BuildUrlResolver implements UrlResolver {
+    #private;
+    constructor({ base, assetsPrefix, searchParams, }: {
+        base: string;
+        assetsPrefix: AssetsPrefix;
+        searchParams: URLSearchParams;
+    });
+    resolve(hash: string): string;
+    get cspResources(): Array<string>;
+}

package/dist/assets/fonts/infra/build-url-resolver.js

@@ -1,34 +1,40 @@
 import { fileExtension, joinPaths, prependForwardSlash } from "../../../core/path.js";
 import { getAssetsPrefix } from "../../utils/getAssetsPrefix.js";
 import { createPlaceholderURL, stringifyPlaceholderURL } from "../../utils/url.js";
-function createBuildUrlResolver({
-  base,
-  assetsPrefix,
-  searchParams
-}) {
-  const resources = /* @__PURE__ */ new Set();
-  return {
-    resolve(hash) {
-      const prefix = assetsPrefix ? getAssetsPrefix(fileExtension(hash), assetsPrefix) : void 0;
-      let urlPath;
-      if (prefix) {
-        resources.add(prefix);
-        urlPath = joinPaths(prefix, base, hash);
-      } else {
-        resources.add("'self'");
-        urlPath = prependForwardSlash(joinPaths(base, hash));
-      }
-      const url = createPlaceholderURL(urlPath);
-      searchParams.forEach((value, key) => {
-        url.searchParams.set(key, value);
-      });
-      return stringifyPlaceholderURL(url);
-    },
-    getCspResources() {
-      return Array.from(resources);
+class BuildUrlResolver {
+  #resources = /* @__PURE__ */ new Set();
+  #base;
+  #assetsPrefix;
+  #searchParams;
+  constructor({
+    base,
+    assetsPrefix,
+    searchParams
+  }) {
+    this.#base = base;
+    this.#assetsPrefix = assetsPrefix;
+    this.#searchParams = searchParams;
+  }
+  resolve(hash) {
+    const prefix = this.#assetsPrefix ? getAssetsPrefix(fileExtension(hash), this.#assetsPrefix) : void 0;
+    let urlPath;
+    if (prefix) {
+      this.#resources.add(prefix);
+      urlPath = joinPaths(prefix, this.#base, hash);
+    } else {
+      this.#resources.add("'self'");
+      urlPath = prependForwardSlash(joinPaths(this.#base, hash));
     }
-  };
+    const url = createPlaceholderURL(urlPath);
+    this.#searchParams.forEach((value, key) => {
+      url.searchParams.set(key, value);
+    });
+    return stringifyPlaceholderURL(url);
+  }
+  get cspResources() {
+    return Array.from(this.#resources);
+  }
 }
 export {
-  createBuildUrlResolver
+  BuildUrlResolver
 };

package/dist/assets/fonts/infra/cached-font-fetcher.d.ts

@@ -1,7 +1,11 @@
-import type { Storage } from 'unstorage';
-import type { FontFetcher } from '../definitions.js';
-export declare function createCachedFontFetcher({ storage, fetch, readFile, }: {
-    storage: Storage;
-    fetch: (url: string, init?: RequestInit) => Promise<Response>;
-    readFile: (url: string) => Promise<Buffer>;
-}): FontFetcher;
+import type { FontFetcher, Storage } from '../definitions.js';
+import type { FontFileData } from '../types.js';
+export declare class CachedFontFetcher implements FontFetcher {
+    #private;
+    constructor({ storage, fetch, readFile, }: {
+        storage: Storage;
+        fetch: (url: string, init?: RequestInit) => Promise<Response>;
+        readFile: (url: string) => Promise<Buffer>;
+    });
+    fetch({ hash, url, init }: FontFileData): Promise<Buffer>;
+}

package/dist/assets/fonts/infra/cached-font-fetcher.js

@@ -1,36 +1,42 @@
 import { isAbsolute } from "node:path";
 import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
 import { cache } from "../utils.js";
-function createCachedFontFetcher({
-  storage,
-  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 new AstroError(
-            {
-              ...AstroErrorData.CannotFetchFontFile,
-              message: AstroErrorData.CannotFetchFontFile.message(url)
-            },
-            { cause }
-          );
+class CachedFontFetcher {
+  #storage;
+  #fetch;
+  #readFile;
+  constructor({
+    storage,
+    fetch,
+    readFile
+  }) {
+    this.#storage = storage;
+    this.#fetch = fetch;
+    this.#readFile = readFile;
+  }
+  async fetch({ hash, url, init }) {
+    return await cache(this.#storage, hash, async () => {
+      try {
+        if (isAbsolute(url)) {
+          return await this.#readFile(url);
         }
-      });
-    }
-  };
+        const response = await this.#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 new AstroError(
+          {
+            ...AstroErrorData.CannotFetchFontFile,
+            message: AstroErrorData.CannotFetchFontFile.message(url)
+          },
+          { cause }
+        );
+      }
+    });
+  }
 }
 export {
-  createCachedFontFetcher
+  CachedFontFetcher
 };

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

@@ -1,5 +1,18 @@
-import type { CssRenderer, FontFetcher, FontMetricsResolver } from '../definitions.js';
-export declare function createCapsizeFontMetricsResolver({ fontFetcher, cssRenderer, }: {
-    fontFetcher: FontFetcher;
-    cssRenderer: CssRenderer;
-}): FontMetricsResolver;
+import type { CollectedFontForMetrics } from '../core/optimize-fallbacks.js';
+import type { CssProperties, CssRenderer, FontFetcher, FontMetricsResolver } from '../definitions.js';
+import type { FontFaceMetrics } from '../types.js';
+export declare class CapsizeFontMetricsResolver implements FontMetricsResolver {
+    #private;
+    constructor({ fontFetcher, cssRenderer, }: {
+        fontFetcher: FontFetcher;
+        cssRenderer: CssRenderer;
+    });
+    getMetrics(name: string, font: CollectedFontForMetrics): Promise<FontFaceMetrics>;
+    generateFontFace({ metrics, fallbackMetrics, name: fallbackName, font: fallbackFontName, properties, }: {
+        metrics: FontFaceMetrics;
+        fallbackMetrics: FontFaceMetrics;
+        name: string;
+        font: string;
+        properties: CssProperties;
+    }): string;
+}

package/dist/assets/fonts/infra/capsize-font-metrics-resolver.js

@@ -21,46 +21,51 @@ function round(value) {
 function toPercentString(value) {
   return `${round(value * 100)}%`;
 }
-function createCapsizeFontMetricsResolver({
-  fontFetcher,
-  cssRenderer
-}) {
-  const cache = {};
-  return {
-    async getMetrics(name, input) {
-      cache[name] ??= filterRequiredMetrics(await fromBuffer(await fontFetcher.fetch(input)));
-      return cache[name];
-    },
-    // Adapted from Capsize
-    // Source: https://github.com/seek-oss/capsize/blob/b752693428b45994442433f7e3476ca4e3e3c507/packages/core/src/createFontStack.ts
-    generateFontFace({
-      metrics,
-      fallbackMetrics,
-      name: fallbackName,
-      font: fallbackFontName,
-      properties
-    }) {
-      const preferredFontXAvgRatio = metrics.xWidthAvg / metrics.unitsPerEm;
-      const fallbackFontXAvgRatio = fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm;
-      const sizeAdjust = 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 fallbackAscentOverride = fallbackMetrics.ascent / adjustedEmSquare;
-      const fallbackDescentOverride = Math.abs(fallbackMetrics.descent) / adjustedEmSquare;
-      const fallbackLineGapOverride = fallbackMetrics.lineGap / adjustedEmSquare;
-      return cssRenderer.generateFontFace(fallbackName, {
-        ...properties,
-        src: renderFontSrc([{ name: fallbackFontName }]),
-        "size-adjust": sizeAdjust && sizeAdjust !== 1 ? toPercentString(sizeAdjust) : void 0,
-        "ascent-override": ascentOverride && ascentOverride !== fallbackAscentOverride ? toPercentString(ascentOverride) : void 0,
-        "descent-override": descentOverride && descentOverride !== fallbackDescentOverride ? toPercentString(descentOverride) : void 0,
-        "line-gap-override": lineGapOverride !== fallbackLineGapOverride ? toPercentString(lineGapOverride) : void 0
-      });
-    }
-  };
+class CapsizeFontMetricsResolver {
+  #cache = {};
+  #fontFetcher;
+  #cssRenderer;
+  constructor({
+    fontFetcher,
+    cssRenderer
+  }) {
+    this.#fontFetcher = fontFetcher;
+    this.#cssRenderer = cssRenderer;
+  }
+  async getMetrics(name, font) {
+    return this.#cache[name] ??= filterRequiredMetrics(
+      await fromBuffer(await this.#fontFetcher.fetch(font))
+    );
+  }
+  // Adapted from Capsize
+  // Source: https://github.com/seek-oss/capsize/blob/b752693428b45994442433f7e3476ca4e3e3c507/packages/core/src/createFontStack.ts
+  generateFontFace({
+    metrics,
+    fallbackMetrics,
+    name: fallbackName,
+    font: fallbackFontName,
+    properties
+  }) {
+    const preferredFontXAvgRatio = metrics.xWidthAvg / metrics.unitsPerEm;
+    const fallbackFontXAvgRatio = fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm;
+    const sizeAdjust = 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 fallbackAscentOverride = fallbackMetrics.ascent / adjustedEmSquare;
+    const fallbackDescentOverride = Math.abs(fallbackMetrics.descent) / adjustedEmSquare;
+    const fallbackLineGapOverride = fallbackMetrics.lineGap / adjustedEmSquare;
+    return this.#cssRenderer.generateFontFace(fallbackName, {
+      ...properties,
+      src: renderFontSrc([{ name: fallbackFontName }]),
+      "size-adjust": sizeAdjust && sizeAdjust !== 1 ? toPercentString(sizeAdjust) : void 0,
+      "ascent-override": ascentOverride && ascentOverride !== fallbackAscentOverride ? toPercentString(ascentOverride) : void 0,
+      "descent-override": descentOverride && descentOverride !== fallbackDescentOverride ? toPercentString(descentOverride) : void 0,
+      "line-gap-override": lineGapOverride !== fallbackLineGapOverride ? toPercentString(lineGapOverride) : void 0
+    });
+  }
 }
 export {
-  createCapsizeFontMetricsResolver
+  CapsizeFontMetricsResolver
 };

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

@@ -1,3 +1,10 @@
-import type { DataCollector } from '../definitions.js';
-import type { CreateUrlProxyParams } from '../types.js';
-export declare function createDataCollector({ hasUrl, saveUrl, savePreload, saveFontData, }: Pick<CreateUrlProxyParams, 'hasUrl' | 'saveUrl' | 'savePreload' | 'saveFontData'>): DataCollector;
+import type { DataCollector, ProxyData } from '../definitions.js';
+import type { CreateUrlProxyParams, FontFileData, PreloadData } from '../types.js';
+export declare class RealDataCollector implements DataCollector {
+    #private;
+    constructor({ hasUrl, saveUrl, savePreload, saveFontData, }: Pick<CreateUrlProxyParams, 'hasUrl' | 'saveUrl' | 'savePreload' | 'saveFontData'>);
+    collect({ hash, url, init, preload, data, }: FontFileData & {
+        data: ProxyData;
+        preload: PreloadData | null;
+    }): void;
+}

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

@@ -1,21 +1,35 @@
-function createDataCollector({
-  hasUrl,
-  saveUrl,
-  savePreload,
-  saveFontData
-}) {
-  return {
-    collect({ hash, url, init, preload, data }) {
-      if (!hasUrl(hash)) {
-        saveUrl({ hash, url, init });
-        if (preload) {
-          savePreload(preload);
-        }
+class RealDataCollector {
+  #hasUrl;
+  #saveUrl;
+  #savePreload;
+  #saveFontData;
+  constructor({
+    hasUrl,
+    saveUrl,
+    savePreload,
+    saveFontData
+  }) {
+    this.#hasUrl = hasUrl;
+    this.#saveUrl = saveUrl;
+    this.#savePreload = savePreload;
+    this.#saveFontData = saveFontData;
+  }
+  collect({
+    hash,
+    url,
+    init,
+    preload,
+    data
+  }) {
+    if (!this.#hasUrl(hash)) {
+      this.#saveUrl({ hash, url, init });
+      if (preload) {
+        this.#savePreload(preload);
       }
-      saveFontData({ hash, url, data, init });
     }
-  };
+    this.#saveFontData({ hash, url, data, init });
+  }
 }
 export {
-  createDataCollector
+  RealDataCollector
 };

package/dist/assets/fonts/infra/dev-remote-font-provider-mod-resolver.d.ts

@@ -1,5 +1,9 @@
 import type { ViteDevServer } from 'vite';
 import type { RemoteFontProviderModResolver } from '../definitions.js';
-export declare function createDevServerRemoteFontProviderModResolver({ server, }: {
-    server: ViteDevServer;
-}): RemoteFontProviderModResolver;
+export declare class DevServerRemoteFontProviderModResolver implements RemoteFontProviderModResolver {
+    #private;
+    constructor({ server, }: {
+        server: ViteDevServer;
+    });
+    resolve(id: string): Promise<any>;
+}

package/dist/assets/fonts/infra/dev-remote-font-provider-mod-resolver.js

@@ -1,12 +1,14 @@
-function createDevServerRemoteFontProviderModResolver({
-  server
-}) {
-  return {
-    resolve(id) {
-      return server.ssrLoadModule(id);
-    }
-  };
+class DevServerRemoteFontProviderModResolver {
+  #server;
+  constructor({
+    server
+  }) {
+    this.#server = server;
+  }
+  async resolve(id) {
+    return await this.#server.ssrLoadModule(id);
+  }
 }
 export {
-  createDevServerRemoteFontProviderModResolver
+  DevServerRemoteFontProviderModResolver
 };

package/dist/assets/fonts/infra/dev-url-proxy-hash-resolver.d.ts

@@ -1,5 +1,15 @@
-import type { Hasher, UrlProxyContentResolver, UrlProxyHashResolver } from '../definitions.js';
-export declare function createDevUrlProxyHashResolver({ hasher, contentResolver, }: {
-    hasher: Hasher;
-    contentResolver: UrlProxyContentResolver;
-}): UrlProxyHashResolver;
+import type { Hasher, ProxyData, UrlProxyContentResolver, UrlProxyHashResolver } from '../definitions.js';
+import type { FontType } from '../types.js';
+export declare class DevUrlProxyHashResolver implements UrlProxyHashResolver {
+    #private;
+    constructor({ hasher, contentResolver, }: {
+        hasher: Hasher;
+        contentResolver: UrlProxyContentResolver;
+    });
+    resolve({ cssVariable, data, originalUrl, type, }: {
+        originalUrl: string;
+        type: FontType;
+        cssVariable: string;
+        data: ProxyData;
+    }): string;
+}

package/dist/assets/fonts/infra/dev-url-proxy-hash-resolver.js

@@ -1,28 +1,37 @@
-function createDevUrlProxyHashResolver({
-  hasher,
-  contentResolver
-}) {
-  return {
-    resolve({ cssVariable, data, originalUrl, type }) {
-      return [
-        cssVariable.slice(2),
-        formatWeight(data.weight),
-        data.style,
-        data.subset,
-        `${hasher.hashString(contentResolver.resolve(originalUrl))}.${type}`
-      ].filter(Boolean).join("-");
+class DevUrlProxyHashResolver {
+  #hasher;
+  #contentResolver;
+  constructor({
+    hasher,
+    contentResolver
+  }) {
+    this.#hasher = hasher;
+    this.#contentResolver = contentResolver;
+  }
+  #formatWeight(weight) {
+    if (Array.isArray(weight)) {
+      return weight.join("-");
     }
-  };
-}
-function formatWeight(weight) {
-  if (Array.isArray(weight)) {
-    return weight.join("-");
+    if (typeof weight === "number") {
+      return weight.toString();
+    }
+    return weight?.replace(/\s+/g, "-");
   }
-  if (typeof weight === "number") {
-    return weight.toString();
+  resolve({
+    cssVariable,
+    data,
+    originalUrl,
+    type
+  }) {
+    return [
+      cssVariable.slice(2),
+      this.#formatWeight(data.weight),
+      data.style,
+      data.subset,
+      `${this.#hasher.hashString(this.#contentResolver.resolve(originalUrl))}.${type}`
+    ].filter(Boolean).join("-");
   }
-  return weight?.replace(/\s+/g, "-");
 }
 export {
-  createDevUrlProxyHashResolver
+  DevUrlProxyHashResolver
 };

package/dist/assets/fonts/infra/dev-url-resolver.d.ts

@@ -1,5 +1,10 @@
 import type { UrlResolver } from '../definitions.js';
-export declare function createDevUrlResolver({ base, searchParams, }: {
-    base: string;
-    searchParams: URLSearchParams;
-}): UrlResolver;
+export declare class DevUrlResolver implements UrlResolver {
+    #private;
+    constructor({ base, searchParams, }: {
+        base: string;
+        searchParams: URLSearchParams;
+    });
+    resolve(hash: string): string;
+    get cspResources(): Array<string>;
+}