@aglyn/shared-ui-theme 1.0.0-beta.221 → 1.0.0-beta.222

package/README.md

@@ -18,6 +18,7 @@ From the root entry:
 - **MUI module augmentation.** Importing the package extends MUI's types with the palette additions these themes use (`tertiary`, `surface`, `tint`), extra typography variants such as `displayXl`, and the matching component `color` overrides. It also re-exports a selection of MUI types and helpers (`Theme`, `ThemeOptions`, `SxProps`, `darkScrollbar`, `visuallyHidden`).
 - **Default themes.** `consoleThemeLight` / `consoleThemeDark` / `consoleThemeCssVar` / `getConsoleTheme(mode)` and `tenantThemeLight` / `tenantThemeDark`, with their `ThemeOptions` (`consoleOptions`, `tenantOptions` and the dark variants). `siteFallbackTheme(host, scheme)` and `siteBaseOptions(host, scheme)` pick between them for a host.
 - **Host theme.** A `HostTheme` (the type lives in `@aglyn/shared-data-types`) is a site's theme customization as plain data. `hostThemeToThemeOptions(theme, scheme)` converts it to `ThemeOptions`; `sanitizeHostTheme`, `mergeThemeOptions`, `hasHostTheme` and `getGoogleFontsUrl` support it. `HostThemeProvider` renders children under it, taking `theme`, a required `fallback` theme or `[light, dark]` pair, `baseOptions`, and `initialMode` / `initialDeviceMode` so a server render can choose the scheme before hydration.
+- **Self-hosted fonts.** `util/self-hosted-fonts` reads a Google Fonts CSS2 stylesheet into `@font-face` rules (`parseGoogleFontFaces`), writes them back with every file on the site's own `/api/fonts` route (`selfHostedFontFaceCss`), and picks the one or two faces worth preloading (`selfHostedFontPreloads`). The tenant fetches and serves; this half is pure.
 - **Light/dark mode.** `createWithThemeProvider({ theme })` returns a higher-order component that provides the theme and mode state; `useThemeMode()` reads and toggles it. The choice is stored in the `theme-color-mode` cookie (`COOKIE_THEME_KEY`).
 - **Emotion.** `createEmotionCache`, `CacheProvider`, `createLayeredEmotionCache`, `createWithEmotionClientCache`, and the constants `EMOTION_CACHE_KEY`, `APP_EMOTION_CACHE_OPTIONS`, `MUI_CSS_LAYER_NAME`.
 - **Contrast.** `contrastRatio`, `relativeLuminance`, `meetsContrast`, `accessibleShade`, `accentTextColor`, `accentFillColor`, `auditPaletteContrast`, with `AA_TEXT_CONTRAST` (4.5) and `AA_NON_TEXT_CONTRAST` (3).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aglyn/shared-ui-theme",
-  "version": "1.0.0-beta.221",
+  "version": "1.0.0-beta.222",
   "license": "Apache-2.0",
   "homepage": "https://aglyn.com",
   "repository": {
@@ -25,9 +25,9 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@aglyn/shared-data-types": "1.0.0-beta.221",
-    "@aglyn/shared-util-tools": "1.0.0-beta.221",
-    "@aglyn/shared-util-vendor": "1.0.0-beta.221",
+    "@aglyn/shared-data-types": "1.0.0-beta.222",
+    "@aglyn/shared-util-tools": "1.0.0-beta.222",
+    "@aglyn/shared-util-vendor": "1.0.0-beta.222",
     "@emotion/cache": "^11.14.0",
     "@emotion/react": "11.14.0",
     "@swc/helpers": "0.5.23",

package/src/lib/util/self-hosted-fonts.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { HostTheme } from '@aglyn/shared-data-types';
+/**
+ * A theme's Google fonts, served from the site's own origin (AGL-3485).
+ *
+ * A published page loaded its theme font as a `<link rel="stylesheet">` to
+ * `fonts.googleapis.com`: a render-blocking request to a third origin, then a
+ * second connection to `fonts.gstatic.com` for the files it names — about
+ * 800 ms before first paint on the page Lighthouse measured. Nothing about a
+ * theme font needs either round trip at view time. The stylesheet is a short
+ * list of `@font-face` rules that changes only when the theme does, and the
+ * files are versioned in their own paths (`/s/inter/v18/…woff2`), so neither
+ * changes under a URL.
+ *
+ * So the server fetches the stylesheet once, keeps the rules, and inlines them
+ * in the page with each `src` pointing at {@link SELF_HOSTED_FONT_ROUTE} on the
+ * site's own origin, which serves the file with a year-long `immutable`
+ * policy. The one or two faces the first screen paints with are preloaded.
+ * Nothing on the page asks Google for anything, which also means a visitor's
+ * address is no longer handed to Google by every page view.
+ *
+ * This module is the pure half: reading Google's stylesheet, writing the
+ * rules back, and choosing the faces to preload. The fetching and the file
+ * route live with the tenant (`libs/tenant/runtime/.../self-hosted-fonts.ts`).
+ *
+ * The rules are REBUILT from validated fields rather than echoed, so the
+ * inlined CSS can only ever contain a family name the theme chose, a style, a
+ * weight, a unicode range and a path on our own route.
+ */
+/** Where a site serves its theme's font files from. */
+export declare const SELF_HOSTED_FONT_ROUTE = "/api/fonts";
+/** The origin Google serves font files from. */
+export declare const GOOGLE_FONT_FILE_ORIGIN = "https://fonts.gstatic.com";
+/** One `@font-face` rule from Google's stylesheet. */
+export interface GoogleFontFace {
+    family: string;
+    style: 'normal' | 'italic';
+    /** A weight (`400`) or, for a variable font, a range (`100 900`). */
+    weight: string;
+    /** Google's subset comment above the rule (`latin`, `latin-ext`, …). */
+    subset?: string;
+    /** The file's path below `/s/` on Google's origin. */
+    path: string;
+    unicodeRange?: string;
+}
+/** Whether a path is one {@link SELF_HOSTED_FONT_ROUTE} will serve. */
+export declare function isSelfHostedFontPath(path: string): boolean;
+/** The site-relative URL a face's file is served from. */
+export declare function selfHostedFontUrl(path: string): string;
+/** Google's own URL for a self-hosted path. */
+export declare function googleFontFileUrl(path: string): string;
+/**
+ * Reads the `@font-face` rules out of a Google Fonts CSS2 stylesheet fetched
+ * with a browser that accepts WOFF2. A rule that is not exactly the shape
+ * Google writes — a missing field, a file off Google's origin, a path the
+ * route would refuse — is dropped, never repaired.
+ */
+export declare function parseGoogleFontFaces(css: string): GoogleFontFace[];
+/**
+ * The faces as `@font-face` rules on the site's own route, every one
+ * `font-display: swap` so text paints in the fallback while a file loads.
+ *
+ * Every subset Google declared is kept, each with its `unicode-range`: a
+ * browser downloads a subset only when the page uses a character in it, so
+ * the Cyrillic file costs an English page nothing, and a Polish or Greek page
+ * keeps its typeface. Only the Latin faces are preloaded.
+ */
+export declare function selfHostedFontFaceCss(faces: readonly GoogleFontFace[]): string;
+/**
+ * The paths of the one or two faces the first screen paints with: the body
+ * text's face, and the headline's when it is a different file. Those are the
+ * fonts the largest text on the page — usually the LCP element — waits for,
+ * so they are worth starting with the document; every other face is fetched
+ * when the page first uses it.
+ *
+ * The body face is the theme's `fontFamily` (else the first Google font it
+ * loads) at `body1`'s weight, 400 by default; the headline face is `h1`'s
+ * family and weight, 700 by default. A variable font serves every weight
+ * from one file, which is then preloaded once.
+ */
+export declare function selfHostedFontPreloads(theme: Pick<HostTheme, 'fonts' | 'typography'> | undefined, faces: readonly GoogleFontFace[]): string[];

package/src/lib/util/self-hosted-fonts.js

@@ -0,0 +1,169 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * A theme's Google fonts, served from the site's own origin (AGL-3485).
+ *
+ * A published page loaded its theme font as a `<link rel="stylesheet">` to
+ * `fonts.googleapis.com`: a render-blocking request to a third origin, then a
+ * second connection to `fonts.gstatic.com` for the files it names — about
+ * 800 ms before first paint on the page Lighthouse measured. Nothing about a
+ * theme font needs either round trip at view time. The stylesheet is a short
+ * list of `@font-face` rules that changes only when the theme does, and the
+ * files are versioned in their own paths (`/s/inter/v18/…woff2`), so neither
+ * changes under a URL.
+ *
+ * So the server fetches the stylesheet once, keeps the rules, and inlines them
+ * in the page with each `src` pointing at {@link SELF_HOSTED_FONT_ROUTE} on the
+ * site's own origin, which serves the file with a year-long `immutable`
+ * policy. The one or two faces the first screen paints with are preloaded.
+ * Nothing on the page asks Google for anything, which also means a visitor's
+ * address is no longer handed to Google by every page view.
+ *
+ * This module is the pure half: reading Google's stylesheet, writing the
+ * rules back, and choosing the faces to preload. The fetching and the file
+ * route live with the tenant (`libs/tenant/runtime/.../self-hosted-fonts.ts`).
+ *
+ * The rules are REBUILT from validated fields rather than echoed, so the
+ * inlined CSS can only ever contain a family name the theme chose, a style, a
+ * weight, a unicode range and a path on our own route.
+ */ /** Where a site serves its theme's font files from. */ export const SELF_HOSTED_FONT_ROUTE = '/api/fonts';
+/** The origin Google serves font files from. */ export const GOOGLE_FONT_FILE_ORIGIN = 'https://fonts.gstatic.com';
+/**
+ * A font file's path on {@link GOOGLE_FONT_FILE_ORIGIN} below `/s/`, as the
+ * route accepts it: `{family}/v{n}/{file}.woff2`. Anything else is refused,
+ * so the route can never be used to fetch an arbitrary URL.
+ */ const FONT_FILE_PATH = /^[a-z0-9]+\/v\d{1,4}\/[A-Za-z0-9_-]{1,200}\.woff2$/;
+/** Whether a path is one {@link SELF_HOSTED_FONT_ROUTE} will serve. */ export function isSelfHostedFontPath(path) {
+    return FONT_FILE_PATH.test(path);
+}
+/** The site-relative URL a face's file is served from. */ export function selfHostedFontUrl(path) {
+    return `${SELF_HOSTED_FONT_ROUTE}/${path}`;
+}
+/** Google's own URL for a self-hosted path. */ export function googleFontFileUrl(path) {
+    return `${GOOGLE_FONT_FILE_ORIGIN}/s/${path}`;
+}
+const FACE_BLOCK = /(?:\/\*\s*([a-z0-9-]+)\s*\*\/\s*)?@font-face\s*\{([^}]*)\}/g;
+const FAMILY = /font-family:\s*'([^']{1,80})'/;
+const STYLE = /font-style:\s*(normal|italic)/;
+const WEIGHT = /font-weight:\s*(\d{3}(?:\s+\d{3})?)/;
+const SRC = /src:\s*url\((https:\/\/fonts\.gstatic\.com\/s\/[^)\s]+)\)\s*format\('woff2'\)/;
+const RANGE = /unicode-range:\s*([U+0-9A-Fa-f?,\s-]{1,4000});/;
+/**
+ * Reads the `@font-face` rules out of a Google Fonts CSS2 stylesheet fetched
+ * with a browser that accepts WOFF2. A rule that is not exactly the shape
+ * Google writes — a missing field, a file off Google's origin, a path the
+ * route would refuse — is dropped, never repaired.
+ */ export function parseGoogleFontFaces(css) {
+    const faces = [];
+    for (const match of css.matchAll(FACE_BLOCK)){
+        var _FAMILY_exec, _STYLE_exec, _WEIGHT_exec, _SRC_exec, _RANGE_exec_, _RANGE_exec;
+        const [, subset, body] = match;
+        const family = (_FAMILY_exec = FAMILY.exec(body)) == null ? void 0 : _FAMILY_exec[1];
+        const style = (_STYLE_exec = STYLE.exec(body)) == null ? void 0 : _STYLE_exec[1];
+        const weight = (_WEIGHT_exec = WEIGHT.exec(body)) == null ? void 0 : _WEIGHT_exec[1];
+        const url = (_SRC_exec = SRC.exec(body)) == null ? void 0 : _SRC_exec[1];
+        if (!family || !style || !weight || !url) continue;
+        const path = url.slice(`${GOOGLE_FONT_FILE_ORIGIN}/s/`.length);
+        if (!isSelfHostedFontPath(path)) continue;
+        const unicodeRange = (_RANGE_exec = RANGE.exec(body)) == null ? void 0 : (_RANGE_exec_ = _RANGE_exec[1]) == null ? void 0 : _RANGE_exec_.trim();
+        faces.push(_extends({
+            family,
+            style,
+            weight: weight.replace(/\s+/g, ' ')
+        }, subset ? {
+            subset
+        } : {}, {
+            path
+        }, unicodeRange ? {
+            unicodeRange
+        } : {}));
+    }
+    return faces;
+}
+/** A family name as it may appear quoted in CSS. */ function cssFamily(family) {
+    return `'${family.replace(/['\\\n\r]/g, '')}'`;
+}
+/**
+ * The faces as `@font-face` rules on the site's own route, every one
+ * `font-display: swap` so text paints in the fallback while a file loads.
+ *
+ * Every subset Google declared is kept, each with its `unicode-range`: a
+ * browser downloads a subset only when the page uses a character in it, so
+ * the Cyrillic file costs an English page nothing, and a Polish or Greek page
+ * keeps its typeface. Only the Latin faces are preloaded.
+ */ export function selfHostedFontFaceCss(faces) {
+    return faces.map((face)=>[
+            '@font-face{',
+            `font-family:${cssFamily(face.family)};`,
+            `font-style:${face.style};`,
+            `font-weight:${face.weight};`,
+            'font-display:swap;',
+            `src:url(${selfHostedFontUrl(face.path)}) format('woff2');`,
+            face.unicodeRange ? `unicode-range:${face.unicodeRange};` : '',
+            '}'
+        ].join('')).join('');
+}
+/** The first family named in a CSS `font-family` stack. */ function firstFamily(stack) {
+    var _stack_split_;
+    if (typeof stack !== 'string') return undefined;
+    const first = (_stack_split_ = stack.split(',')[0]) == null ? void 0 : _stack_split_.trim().replace(/^['"]|['"]$/g, '');
+    return first || undefined;
+}
+/** How far a face is from a wanted weight; 0 when its range covers it. */ function weightDistance(face, wanted) {
+    const [low, high = low] = face.weight.split(' ').map(Number);
+    if (wanted >= low && wanted <= high) return 0;
+    return Math.min(Math.abs(wanted - low), Math.abs(wanted - high));
+}
+/** The Latin, upright face of `family` closest to `weight`. */ function latinFace(faces, family, weight) {
+    if (!family) return undefined;
+    const wanted = family.toLowerCase();
+    const candidates = faces.filter((face)=>face.family.toLowerCase() === wanted && face.style === 'normal' && (face.subset === undefined || face.subset === 'latin'));
+    return candidates.sort((a, b)=>weightDistance(a, weight) - weightDistance(b, weight))[0];
+}
+/**
+ * The paths of the one or two faces the first screen paints with: the body
+ * text's face, and the headline's when it is a different file. Those are the
+ * fonts the largest text on the page — usually the LCP element — waits for,
+ * so they are worth starting with the document; every other face is fetched
+ * when the page first uses it.
+ *
+ * The body face is the theme's `fontFamily` (else the first Google font it
+ * loads) at `body1`'s weight, 400 by default; the headline face is `h1`'s
+ * family and weight, 700 by default. A variable font serves every weight
+ * from one file, which is then preloaded once.
+ */ export function selfHostedFontPreloads(theme, faces) {
+    var _firstFamily, _ref, _firstFamily1, _ref1;
+    var _theme_fonts_find, _theme_fonts, _variants_body1, _variants_h1, _variants_h11;
+    const typography = theme == null ? void 0 : theme.typography;
+    const variants = typography == null ? void 0 : typography.variants;
+    const fallback = theme == null ? void 0 : (_theme_fonts = theme.fonts) == null ? void 0 : (_theme_fonts_find = _theme_fonts.find((font)=>{
+        var _font_source;
+        return ((_font_source = font.source) != null ? _font_source : 'google') === 'google';
+    })) == null ? void 0 : _theme_fonts_find.family;
+    const bodyFamily = (_firstFamily = firstFamily(typography == null ? void 0 : typography.fontFamily)) != null ? _firstFamily : fallback;
+    const body = latinFace(faces, bodyFamily, (_ref = variants == null ? void 0 : (_variants_body1 = variants.body1) == null ? void 0 : _variants_body1.fontWeight) != null ? _ref : 400);
+    const heading = latinFace(faces, (_firstFamily1 = firstFamily(variants == null ? void 0 : (_variants_h1 = variants.h1) == null ? void 0 : _variants_h1.fontFamily)) != null ? _firstFamily1 : bodyFamily, (_ref1 = variants == null ? void 0 : (_variants_h11 = variants.h1) == null ? void 0 : _variants_h11.fontWeight) != null ? _ref1 : 700);
+    const paths = [
+        body,
+        heading
+    ].filter((face)=>Boolean(face)).map((face)=>selfHostedFontUrl(face.path));
+    return [
+        ...new Set(paths)
+    ];
+}
+
+//# sourceMappingURL=self-hosted-fonts.js.map

package/src/lib/util/self-hosted-fonts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/shared/ui/theme/src/lib/util/self-hosted-fonts.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { HostTheme } from '@aglyn/shared-data-types'\n\n/**\n * A theme's Google fonts, served from the site's own origin (AGL-3485).\n *\n * A published page loaded its theme font as a `<link rel=\"stylesheet\">` to\n * `fonts.googleapis.com`: a render-blocking request to a third origin, then a\n * second connection to `fonts.gstatic.com` for the files it names — about\n * 800 ms before first paint on the page Lighthouse measured. Nothing about a\n * theme font needs either round trip at view time. The stylesheet is a short\n * list of `@font-face` rules that changes only when the theme does, and the\n * files are versioned in their own paths (`/s/inter/v18/…woff2`), so neither\n * changes under a URL.\n *\n * So the server fetches the stylesheet once, keeps the rules, and inlines them\n * in the page with each `src` pointing at {@link SELF_HOSTED_FONT_ROUTE} on the\n * site's own origin, which serves the file with a year-long `immutable`\n * policy. The one or two faces the first screen paints with are preloaded.\n * Nothing on the page asks Google for anything, which also means a visitor's\n * address is no longer handed to Google by every page view.\n *\n * This module is the pure half: reading Google's stylesheet, writing the\n * rules back, and choosing the faces to preload. The fetching and the file\n * route live with the tenant (`libs/tenant/runtime/.../self-hosted-fonts.ts`).\n *\n * The rules are REBUILT from validated fields rather than echoed, so the\n * inlined CSS can only ever contain a family name the theme chose, a style, a\n * weight, a unicode range and a path on our own route.\n */\n\n/** Where a site serves its theme's font files from. */\nexport const SELF_HOSTED_FONT_ROUTE = '/api/fonts'\n\n/** The origin Google serves font files from. */\nexport const GOOGLE_FONT_FILE_ORIGIN = 'https://fonts.gstatic.com'\n\n/**\n * A font file's path on {@link GOOGLE_FONT_FILE_ORIGIN} below `/s/`, as the\n * route accepts it: `{family}/v{n}/{file}.woff2`. Anything else is refused,\n * so the route can never be used to fetch an arbitrary URL.\n */\nconst FONT_FILE_PATH = /^[a-z0-9]+\\/v\\d{1,4}\\/[A-Za-z0-9_-]{1,200}\\.woff2$/\n\n/** One `@font-face` rule from Google's stylesheet. */\nexport interface GoogleFontFace {\n  family: string\n  style: 'normal' | 'italic'\n  /** A weight (`400`) or, for a variable font, a range (`100 900`). */\n  weight: string\n  /** Google's subset comment above the rule (`latin`, `latin-ext`, …). */\n  subset?: string\n  /** The file's path below `/s/` on Google's origin. */\n  path: string\n  unicodeRange?: string\n}\n\n/** Whether a path is one {@link SELF_HOSTED_FONT_ROUTE} will serve. */\nexport function isSelfHostedFontPath(path: string): boolean {\n  return FONT_FILE_PATH.test(path)\n}\n\n/** The site-relative URL a face's file is served from. */\nexport function selfHostedFontUrl(path: string): string {\n  return `${SELF_HOSTED_FONT_ROUTE}/${path}`\n}\n\n/** Google's own URL for a self-hosted path. */\nexport function googleFontFileUrl(path: string): string {\n  return `${GOOGLE_FONT_FILE_ORIGIN}/s/${path}`\n}\n\nconst FACE_BLOCK = /(?:\\/\\*\\s*([a-z0-9-]+)\\s*\\*\\/\\s*)?@font-face\\s*\\{([^}]*)\\}/g\nconst FAMILY = /font-family:\\s*'([^']{1,80})'/\nconst STYLE = /font-style:\\s*(normal|italic)/\nconst WEIGHT = /font-weight:\\s*(\\d{3}(?:\\s+\\d{3})?)/\nconst SRC = /src:\\s*url\\((https:\\/\\/fonts\\.gstatic\\.com\\/s\\/[^)\\s]+)\\)\\s*format\\('woff2'\\)/\nconst RANGE = /unicode-range:\\s*([U+0-9A-Fa-f?,\\s-]{1,4000});/\n\n/**\n * Reads the `@font-face` rules out of a Google Fonts CSS2 stylesheet fetched\n * with a browser that accepts WOFF2. A rule that is not exactly the shape\n * Google writes — a missing field, a file off Google's origin, a path the\n * route would refuse — is dropped, never repaired.\n */\nexport function parseGoogleFontFaces(css: string): GoogleFontFace[] {\n  const faces: GoogleFontFace[] = []\n  for (const match of css.matchAll(FACE_BLOCK)) {\n    const [, subset, body] = match\n    const family = FAMILY.exec(body)?.[1]\n    const style = STYLE.exec(body)?.[1] as GoogleFontFace['style'] | undefined\n    const weight = WEIGHT.exec(body)?.[1]\n    const url = SRC.exec(body)?.[1]\n    if (!family || !style || !weight || !url) continue\n    const path = url.slice(`${GOOGLE_FONT_FILE_ORIGIN}/s/`.length)\n    if (!isSelfHostedFontPath(path)) continue\n    const unicodeRange = RANGE.exec(body)?.[1]?.trim()\n    faces.push({\n      family,\n      style,\n      weight: weight.replace(/\\s+/g, ' '),\n      ...(subset ? { subset } : {}),\n      path,\n      ...(unicodeRange ? { unicodeRange } : {}),\n    })\n  }\n  return faces\n}\n\n/** A family name as it may appear quoted in CSS. */\nfunction cssFamily(family: string): string {\n  return `'${family.replace(/['\\\\\\n\\r]/g, '')}'`\n}\n\n/**\n * The faces as `@font-face` rules on the site's own route, every one\n * `font-display: swap` so text paints in the fallback while a file loads.\n *\n * Every subset Google declared is kept, each with its `unicode-range`: a\n * browser downloads a subset only when the page uses a character in it, so\n * the Cyrillic file costs an English page nothing, and a Polish or Greek page\n * keeps its typeface. Only the Latin faces are preloaded.\n */\nexport function selfHostedFontFaceCss(faces: readonly GoogleFontFace[]): string {\n  return faces\n    .map((face) =>\n      [\n        '@font-face{',\n        `font-family:${cssFamily(face.family)};`,\n        `font-style:${face.style};`,\n        `font-weight:${face.weight};`,\n        'font-display:swap;',\n        `src:url(${selfHostedFontUrl(face.path)}) format('woff2');`,\n        face.unicodeRange ? `unicode-range:${face.unicodeRange};` : '',\n        '}',\n      ].join(''),\n    )\n    .join('')\n}\n\n/** The first family named in a CSS `font-family` stack. */\nfunction firstFamily(stack: unknown): string | undefined {\n  if (typeof stack !== 'string') return undefined\n  const first = stack.split(',')[0]?.trim().replace(/^['\"]|['\"]$/g, '')\n  return first || undefined\n}\n\n/** How far a face is from a wanted weight; 0 when its range covers it. */\nfunction weightDistance(face: GoogleFontFace, wanted: number): number {\n  const [low, high = low] = face.weight.split(' ').map(Number)\n  if (wanted >= low && wanted <= high) return 0\n  return Math.min(Math.abs(wanted - low), Math.abs(wanted - high))\n}\n\n/** The Latin, upright face of `family` closest to `weight`. */\nfunction latinFace(\n  faces: readonly GoogleFontFace[],\n  family: string | undefined,\n  weight: number,\n): GoogleFontFace | undefined {\n  if (!family) return undefined\n  const wanted = family.toLowerCase()\n  const candidates = faces.filter(\n    (face) =>\n      face.family.toLowerCase() === wanted &&\n      face.style === 'normal' &&\n      (face.subset === undefined || face.subset === 'latin'),\n  )\n  return candidates.sort(\n    (a, b) => weightDistance(a, weight) - weightDistance(b, weight),\n  )[0]\n}\n\n/**\n * The paths of the one or two faces the first screen paints with: the body\n * text's face, and the headline's when it is a different file. Those are the\n * fonts the largest text on the page — usually the LCP element — waits for,\n * so they are worth starting with the document; every other face is fetched\n * when the page first uses it.\n *\n * The body face is the theme's `fontFamily` (else the first Google font it\n * loads) at `body1`'s weight, 400 by default; the headline face is `h1`'s\n * family and weight, 700 by default. A variable font serves every weight\n * from one file, which is then preloaded once.\n */\nexport function selfHostedFontPreloads(\n  theme: Pick<HostTheme, 'fonts' | 'typography'> | undefined,\n  faces: readonly GoogleFontFace[],\n): string[] {\n  const typography = theme?.typography\n  const variants = typography?.variants\n  const fallback = theme?.fonts?.find(\n    (font) => (font.source ?? 'google') === 'google',\n  )?.family\n  const bodyFamily = firstFamily(typography?.fontFamily) ?? fallback\n  const body = latinFace(faces, bodyFamily, variants?.body1?.fontWeight ?? 400)\n  const heading = latinFace(\n    faces,\n    firstFamily(variants?.h1?.fontFamily) ?? bodyFamily,\n    variants?.h1?.fontWeight ?? 700,\n  )\n  const paths = [body, heading]\n    .filter((face): face is GoogleFontFace => Boolean(face))\n    .map((face) => selfHostedFontUrl(face.path))\n  return [...new Set(paths)]\n}\n"],"names":["SELF_HOSTED_FONT_ROUTE","GOOGLE_FONT_FILE_ORIGIN","FONT_FILE_PATH","isSelfHostedFontPath","path","test","selfHostedFontUrl","googleFontFileUrl","FACE_BLOCK","FAMILY","STYLE","WEIGHT","SRC","RANGE","parseGoogleFontFaces","css","faces","match","matchAll","subset","body","family","exec","style","weight","url","slice","length","unicodeRange","trim","push","replace","cssFamily","selfHostedFontFaceCss","map","face","join","firstFamily","stack","undefined","first","split","weightDistance","wanted","low","high","Number","Math","min","abs","latinFace","toLowerCase","candidates","filter","sort","a","b","selfHostedFontPreloads","theme","variants","typography","fallback","fonts","find","font","source","bodyFamily","fontFamily","body1","fontWeight","heading","h1","paths","Boolean","Set"],"mappings":"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"}