astro 5.16.2 → 5.16.4

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

@@ -1,25 +1,29 @@
 import { joinPaths, prependForwardSlash } from "../../../core/path.js";
 import { createPlaceholderURL, stringifyPlaceholderURL } from "../../utils/url.js";
-function createDevUrlResolver({
-  base,
-  searchParams
-}) {
-  let resolved = false;
-  return {
-    resolve(hash) {
-      resolved ||= true;
-      const urlPath = prependForwardSlash(joinPaths(base, hash));
-      const url = createPlaceholderURL(urlPath);
-      searchParams.forEach((value, key) => {
-        url.searchParams.set(key, value);
-      });
-      return stringifyPlaceholderURL(url);
-    },
-    getCspResources() {
-      return resolved ? ["'self'"] : [];
-    }
-  };
+class DevUrlResolver {
+  #resolved = false;
+  #base;
+  #searchParams;
+  constructor({
+    base,
+    searchParams
+  }) {
+    this.#base = base;
+    this.#searchParams = searchParams;
+  }
+  resolve(hash) {
+    this.#resolved ||= true;
+    const 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 this.#resolved ? ["'self'"] : [];
+  }
 }
 export {
-  createDevUrlResolver
+  DevUrlResolver
 };

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

@@ -1,2 +1,5 @@
 import type { FontTypeExtractor } from '../definitions.js';
-export declare function createFontTypeExtractor(): FontTypeExtractor;
+import type { FontType } from '../types.js';
+export declare class RealFontTypeExtractor implements FontTypeExtractor {
+    extract(url: string): FontType;
+}

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

@@ -1,23 +1,21 @@
 import { extname } from "node:path";
 import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
 import { isFontType } from "../utils.js";
-function createFontTypeExtractor() {
-  return {
-    extract(url) {
-      const extension = extname(url).slice(1);
-      if (!isFontType(extension)) {
-        throw new AstroError(
-          {
-            ...AstroErrorData.CannotExtractFontType,
-            message: AstroErrorData.CannotExtractFontType.message(url)
-          },
-          { cause: `Unexpected extension, got "${extension}"` }
-        );
-      }
-      return extension;
+class RealFontTypeExtractor {
+  extract(url) {
+    const extension = extname(url).slice(1);
+    if (!isFontType(extension)) {
+      throw new AstroError(
+        {
+          ...AstroErrorData.CannotExtractFontType,
+          message: AstroErrorData.CannotExtractFontType.message(url)
+        },
+        { cause: `Unexpected extension, got "${extension}"` }
+      );
     }
-  };
+    return extension;
+  }
 }
 export {
-  createFontTypeExtractor
+  RealFontTypeExtractor
 };

package/dist/assets/fonts/infra/fontace-font-file-reader.d.ts

@@ -1,2 +1,11 @@
 import type { FontFileReader } from '../definitions.js';
-export declare function createFontaceFontFileReader(): FontFileReader;
+import type { Style } from '../types.js';
+export declare class FontaceFontFileReader implements FontFileReader {
+    extract({ family, url }: {
+        family: string;
+        url: string;
+    }): {
+        weight: string;
+        style: Style;
+    };
+}

package/dist/assets/fonts/infra/fontace-font-file-reader.js

@@ -1,27 +1,25 @@
 import { readFileSync } from "node:fs";
 import { fontace } from "fontace";
 import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
-function createFontaceFontFileReader() {
-  return {
-    extract({ family, url }) {
-      try {
-        const data = fontace(readFileSync(url));
-        return {
-          weight: data.weight,
-          style: data.style
-        };
-      } catch (cause) {
-        throw new AstroError(
-          {
-            ...AstroErrorData.CannotDetermineWeightAndStyleFromFontFile,
-            message: AstroErrorData.CannotDetermineWeightAndStyleFromFontFile.message(family, url)
-          },
-          { cause }
-        );
-      }
+class FontaceFontFileReader {
+  extract({ family, url }) {
+    try {
+      const data = fontace(readFileSync(url));
+      return {
+        weight: data.weight,
+        style: data.style
+      };
+    } catch (cause) {
+      throw new AstroError(
+        {
+          ...AstroErrorData.CannotDetermineWeightAndStyleFromFontFile,
+          message: AstroErrorData.CannotDetermineWeightAndStyleFromFontFile.message(family, url)
+        },
+        { cause }
+      );
     }
-  };
+  }
 }
 export {
-  createFontaceFontFileReader
+  FontaceFontFileReader
 };

package/dist/assets/fonts/infra/levenshtein-string-matcher.d.ts

@@ -1,2 +1,5 @@
 import type { StringMatcher } from '../definitions.js';
-export declare function createLevenshteinStringMatcher(): StringMatcher;
+export declare class LevenshteinStringMatcher implements StringMatcher {
+    #private;
+    getClosestMatch(target: string, candidates: Array<string>): string;
+}

package/dist/assets/fonts/infra/levenshtein-string-matcher.js

@@ -1,65 +1,99 @@
-const peq = new Uint32Array(65536);
-const myers_32 = (a, b) => {
-  const n = a.length;
-  const m = b.length;
-  const lst = 1 << n - 1;
-  let pv = -1;
-  let mv = 0;
-  let sc = n;
-  let i = n;
-  while (i--) {
-    peq[a.charCodeAt(i)] |= 1 << i;
-  }
-  for (i = 0; i < m; i++) {
-    let eq = peq[b.charCodeAt(i)];
-    const xv = eq | mv;
-    eq |= (eq & pv) + pv ^ pv;
-    mv |= ~(eq | pv);
-    pv &= eq;
-    if (mv & lst) {
-      sc++;
+class LevenshteinStringMatcher {
+  #peq = new Uint32Array(65536);
+  #myers_32(a, b) {
+    const n = a.length;
+    const m = b.length;
+    const lst = 1 << n - 1;
+    let pv = -1;
+    let mv = 0;
+    let sc = n;
+    let i = n;
+    while (i--) {
+      this.#peq[a.charCodeAt(i)] |= 1 << i;
     }
-    if (pv & lst) {
-      sc--;
+    for (i = 0; i < m; i++) {
+      let eq = this.#peq[b.charCodeAt(i)];
+      const xv = eq | mv;
+      eq |= (eq & pv) + pv ^ pv;
+      mv |= ~(eq | pv);
+      pv &= eq;
+      if (mv & lst) {
+        sc++;
+      }
+      if (pv & lst) {
+        sc--;
+      }
+      mv = mv << 1 | 1;
+      pv = pv << 1 | ~(xv | mv);
+      mv &= xv;
     }
-    mv = mv << 1 | 1;
-    pv = pv << 1 | ~(xv | mv);
-    mv &= xv;
-  }
-  i = n;
-  while (i--) {
-    peq[a.charCodeAt(i)] = 0;
-  }
-  return sc;
-};
-const myers_x = (b, a) => {
-  const n = a.length;
-  const m = b.length;
-  const mhc = [];
-  const phc = [];
-  const hsize = Math.ceil(n / 32);
-  const vsize = Math.ceil(m / 32);
-  for (let i = 0; i < hsize; i++) {
-    phc[i] = -1;
-    mhc[i] = 0;
+    i = n;
+    while (i--) {
+      this.#peq[a.charCodeAt(i)] = 0;
+    }
+    return sc;
   }
-  let j = 0;
-  for (; j < vsize - 1; j++) {
-    let mv2 = 0;
-    let pv2 = -1;
-    const start2 = j * 32;
-    const vlen2 = Math.min(32, m) + start2;
-    for (let k = start2; k < vlen2; k++) {
-      peq[b.charCodeAt(k)] |= 1 << k;
+  #myers_x(b, a) {
+    const n = a.length;
+    const m = b.length;
+    const mhc = [];
+    const phc = [];
+    const hsize = Math.ceil(n / 32);
+    const vsize = Math.ceil(m / 32);
+    for (let i = 0; i < hsize; i++) {
+      phc[i] = -1;
+      mhc[i] = 0;
+    }
+    let j = 0;
+    for (; j < vsize - 1; j++) {
+      let mv2 = 0;
+      let pv2 = -1;
+      const start2 = j * 32;
+      const vlen2 = Math.min(32, m) + start2;
+      for (let k = start2; k < vlen2; k++) {
+        this.#peq[b.charCodeAt(k)] |= 1 << k;
+      }
+      for (let i = 0; i < n; i++) {
+        const eq = this.#peq[a.charCodeAt(i)];
+        const pb = phc[i / 32 | 0] >>> i & 1;
+        const mb = mhc[i / 32 | 0] >>> i & 1;
+        const xv = eq | mv2;
+        const xh = ((eq | mb) & pv2) + pv2 ^ pv2 | eq | mb;
+        let ph = mv2 | ~(xh | pv2);
+        let mh = pv2 & xh;
+        if (ph >>> 31 ^ pb) {
+          phc[i / 32 | 0] ^= 1 << i;
+        }
+        if (mh >>> 31 ^ mb) {
+          mhc[i / 32 | 0] ^= 1 << i;
+        }
+        ph = ph << 1 | pb;
+        mh = mh << 1 | mb;
+        pv2 = mh | ~(xv | ph);
+        mv2 = ph & xv;
+      }
+      for (let k = start2; k < vlen2; k++) {
+        this.#peq[b.charCodeAt(k)] = 0;
+      }
+    }
+    let mv = 0;
+    let pv = -1;
+    const start = j * 32;
+    const vlen = Math.min(32, m - start) + start;
+    for (let k = start; k < vlen; k++) {
+      this.#peq[b.charCodeAt(k)] |= 1 << k;
     }
+    let score = m;
     for (let i = 0; i < n; i++) {
-      const eq = peq[a.charCodeAt(i)];
+      const eq = this.#peq[a.charCodeAt(i)];
       const pb = phc[i / 32 | 0] >>> i & 1;
       const mb = mhc[i / 32 | 0] >>> i & 1;
-      const xv = eq | mv2;
-      const xh = ((eq | mb) & pv2) + pv2 ^ pv2 | eq | mb;
-      let ph = mv2 | ~(xh | pv2);
-      let mh = pv2 & xh;
+      const xv = eq | mv;
+      const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
+      let ph = mv | ~(xh | pv);
+      let mh = pv & xh;
+      score += ph >>> m - 1 & 1;
+      score -= mh >>> m - 1 & 1;
       if (ph >>> 31 ^ pb) {
         phc[i / 32 | 0] ^= 1 << i;
       }
@@ -68,80 +102,44 @@ const myers_x = (b, a) => {
       }
       ph = ph << 1 | pb;
       mh = mh << 1 | mb;
-      pv2 = mh | ~(xv | ph);
-      mv2 = ph & xv;
+      pv = mh | ~(xv | ph);
+      mv = ph & xv;
     }
-    for (let k = start2; k < vlen2; k++) {
-      peq[b.charCodeAt(k)] = 0;
+    for (let k = start; k < vlen; k++) {
+      this.#peq[b.charCodeAt(k)] = 0;
     }
+    return score;
   }
-  let mv = 0;
-  let pv = -1;
-  const start = j * 32;
-  const vlen = Math.min(32, m - start) + start;
-  for (let k = start; k < vlen; k++) {
-    peq[b.charCodeAt(k)] |= 1 << k;
-  }
-  let score = m;
-  for (let i = 0; i < n; i++) {
-    const eq = peq[a.charCodeAt(i)];
-    const pb = phc[i / 32 | 0] >>> i & 1;
-    const mb = mhc[i / 32 | 0] >>> i & 1;
-    const xv = eq | mv;
-    const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
-    let ph = mv | ~(xh | pv);
-    let mh = pv & xh;
-    score += ph >>> m - 1 & 1;
-    score -= mh >>> m - 1 & 1;
-    if (ph >>> 31 ^ pb) {
-      phc[i / 32 | 0] ^= 1 << i;
+  #distance(a, b) {
+    if (a.length < b.length) {
+      const tmp = b;
+      b = a;
+      a = tmp;
     }
-    if (mh >>> 31 ^ mb) {
-      mhc[i / 32 | 0] ^= 1 << i;
+    if (b.length === 0) {
+      return a.length;
     }
-    ph = ph << 1 | pb;
-    mh = mh << 1 | mb;
-    pv = mh | ~(xv | ph);
-    mv = ph & xv;
-  }
-  for (let k = start; k < vlen; k++) {
-    peq[b.charCodeAt(k)] = 0;
-  }
-  return score;
-};
-const distance = (a, b) => {
-  if (a.length < b.length) {
-    const tmp = b;
-    b = a;
-    a = tmp;
-  }
-  if (b.length === 0) {
-    return a.length;
-  }
-  if (a.length <= 32) {
-    return myers_32(a, b);
-  }
-  return myers_x(a, b);
-};
-const closest = (str, arr) => {
-  let min_distance = Infinity;
-  let min_index = 0;
-  for (let i = 0; i < arr.length; i++) {
-    const dist = distance(str, arr[i]);
-    if (dist < min_distance) {
-      min_distance = dist;
-      min_index = i;
+    if (a.length <= 32) {
+      return this.#myers_32(a, b);
     }
+    return this.#myers_x(a, b);
   }
-  return arr[min_index];
-};
-function createLevenshteinStringMatcher() {
-  return {
-    getClosestMatch(target, candidates) {
-      return closest(target, candidates);
+  #closest(str, arr) {
+    let min_distance = Infinity;
+    let min_index = 0;
+    for (let i = 0; i < arr.length; i++) {
+      const dist = this.#distance(str, arr[i]);
+      if (dist < min_distance) {
+        min_distance = dist;
+        min_index = i;
+      }
     }
-  };
+    return arr[min_index];
+  }
+  getClosestMatch(target, candidates) {
+    return this.#closest(target, candidates);
+  }
 }
 export {
-  createLevenshteinStringMatcher
+  LevenshteinStringMatcher
 };

package/dist/assets/fonts/infra/local-url-proxy-content-resolver.d.ts

@@ -0,0 +1,4 @@
+import type { UrlProxyContentResolver } from '../definitions.js';
+export declare class LocalUrlProxyContentResolver implements UrlProxyContentResolver {
+    resolve(url: string): string;
+}

package/dist/assets/fonts/infra/local-url-proxy-content-resolver.js

@@ -0,0 +1,14 @@
+import { readFileSync } from "node:fs";
+import { AstroError, AstroErrorData } from "../../../core/errors/index.js";
+class LocalUrlProxyContentResolver {
+  resolve(url) {
+    try {
+      return url + readFileSync(url, "utf-8");
+    } catch (cause) {
+      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause });
+    }
+  }
+}
+export {
+  LocalUrlProxyContentResolver
+};

package/dist/assets/fonts/infra/minifiable-css-renderer.d.ts

@@ -4,6 +4,11 @@ export declare function renderCssVariable(key: string, values: Array<string>, mi
 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;
+export declare class MinifiableCssRenderer implements CssRenderer {
+    #private;
+    constructor({ minify }: {
+        minify: boolean;
+    });
+    generateFontFace(family: string, properties: CssProperties): string;
+    generateCssVariable(key: string, values: Array<string>): string;
+}

package/dist/assets/fonts/infra/minifiable-css-renderer.js

@@ -23,18 +23,20 @@ function handleValueWithSpaces(value) {
   }
   return value;
 }
-function createMinifiableCssRenderer({ minify }) {
-  return {
-    generateFontFace(family, properties) {
-      return renderFontFace(withFamily(family, properties), minify);
-    },
-    generateCssVariable(key, values) {
-      return renderCssVariable(key, values, minify);
-    }
-  };
+class MinifiableCssRenderer {
+  #minify;
+  constructor({ minify }) {
+    this.#minify = minify;
+  }
+  generateFontFace(family, properties) {
+    return renderFontFace(withFamily(family, properties), this.#minify);
+  }
+  generateCssVariable(key, values) {
+    return renderCssVariable(key, values, this.#minify);
+  }
 }
 export {
-  createMinifiableCssRenderer,
+  MinifiableCssRenderer,
   handleValueWithSpaces,
   renderCssVariable,
   renderFontFace,

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

@@ -1,5 +1,10 @@
 import type { RemoteFontProviderModResolver, RemoteFontProviderResolver } from '../definitions.js';
-export declare function createRemoteFontProviderResolver({ root, modResolver, }: {
-    root: URL;
-    modResolver: RemoteFontProviderModResolver;
-}): RemoteFontProviderResolver;
+import type { AstroFontProvider, ResolvedFontProvider } from '../types.js';
+export declare class RealRemoteFontProviderResolver implements RemoteFontProviderResolver {
+    #private;
+    constructor({ root, modResolver, }: {
+        root: URL;
+        modResolver: RemoteFontProviderModResolver;
+    });
+    resolve({ entrypoint, config }: AstroFontProvider): Promise<ResolvedFontProvider>;
+}

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

@@ -1,45 +1,49 @@
 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 }
-    );
+class RealRemoteFontProviderResolver {
+  #root;
+  #modResolver;
+  constructor({
+    root,
+    modResolver
+  }) {
+    this.#root = root;
+    this.#modResolver = modResolver;
   }
-}
-function createRemoteFontProviderResolver({
-  root,
-  modResolver
-}) {
-  return {
-    async resolve({ entrypoint, config }) {
-      const id = resolveEntrypoint(root, entrypoint.toString()).href;
-      const mod = await modResolver.resolve(id);
-      const { provider } = validateMod({
-        mod,
-        entrypoint: id
-      });
-      return { config, provider };
+  #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 resolve({ entrypoint, config }) {
+    const id = resolveEntrypoint(this.#root, entrypoint.toString()).href;
+    const mod = await this.#modResolver.resolve(id);
+    const { provider } = this.#validateMod({
+      mod,
+      entrypoint: id
+    });
+    return { config, provider };
+  }
 }
 export {
-  createRemoteFontProviderResolver
+  RealRemoteFontProviderResolver
 };

package/dist/assets/fonts/infra/remote-url-proxy-content-resolver.d.ts

@@ -0,0 +1,4 @@
+import type { UrlProxyContentResolver } from '../definitions.js';
+export declare class RemoteUrlProxyContentResolver implements UrlProxyContentResolver {
+    resolve(url: string): string;
+}

package/dist/assets/fonts/infra/remote-url-proxy-content-resolver.js

@@ -0,0 +1,9 @@
+class RemoteUrlProxyContentResolver {
+  // Passthrough, the remote provider URL is enough
+  resolve(url) {
+    return url;
+  }
+}
+export {
+  RemoteUrlProxyContentResolver
+};

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

@@ -1,5 +1,9 @@
 import type { LocalProviderUrlResolver } from '../definitions.js';
-export declare function createRequireLocalProviderUrlResolver({ root, intercept, }: {
-    root: URL;
-    intercept?: (path: string) => void;
-}): LocalProviderUrlResolver;
+export declare class RequireLocalProviderUrlResolver implements LocalProviderUrlResolver {
+    #private;
+    constructor({ root, intercept, }: {
+        root: URL;
+        intercept?: ((path: string) => void) | undefined;
+    });
+    resolve(input: string): string;
+}