@koda-sl/baker-cli 0.472.0 → 0.473.0

package/dist/chunk-QFEZKCQL.js

@@ -0,0 +1,494 @@
+import {
+  DEFAULT_SUBSETS,
+  FONT_PROVIDERS,
+  checkFontRequests,
+  fontFileName,
+  fontsourceCatalogue,
+  fontsourceFamilies,
+  googleFontRequests,
+  missingFontFiles,
+  planFontAdoption,
+  renderFontFaceCss,
+  resolveBrandFaces,
+  resolveFetchStyles,
+  resolveFetchSubsets,
+  resolveFetchWeights,
+  selfHostedStyles,
+  selfHostedSubsets,
+  selfHostedWeights,
+  stripFontFaceBlocks,
+  suggestFamilies,
+  unresolvedBrandFamilies,
+  upsertFontFaceCss
+} from "./chunk-7PTOGEUN.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-IWLWY2UD.js";
+
+// src/commands/brand/fonts.ts
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { defineCommand } from "citty";
+var GLOBAL_CSS = path.join("src", "styles", "global.css");
+var FONTS_DIR = path.join("src", "brand", "fonts");
+var DEFAULT_SUBSETS_LABEL = DEFAULT_SUBSETS.join(",");
+var BROWSER_UA = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120.0 Safari/537.36";
+registerSchema({
+  command: "brand.fonts.check",
+  description: "Start here when a brand's fonts are 'confirmed' but nobody verified it. Fails if any --font-* family in src/styles/global.css has nothing loading it (no @font-face, no Google import) \u2014 the silent fallback that also fails the client's verify \u2014 then asks Google Fonts what it ACTUALLY serves for every family/weight the stylesheet requests.",
+  args: {}
+});
+registerSchema({
+  command: "brand.fonts.adopt",
+  description: "Move brand faces a page already self-hosts into src/styles/global.css, so every page loads them rather than only the page that declared them. Use when `check` reports a family as not loaded but its files are already in src/brand/fonts/. Never downloads: re-fetching would hand that page a different build of the same face.",
+  args: {}
+});
+registerSchema({
+  command: "brand.fonts.fetch",
+  description: "Download a font into src/brand/fonts/ so the brand stops depending on a third party at page load, and write its @font-face into src/styles/global.css above @theme. Resolves against Google Fonts first, then Fontsource \u2014 which carries ~2000 open-licence families Google does not, so a name Google 400s is often still fetchable. Idempotent: re-running replaces that family's faces rather than stacking duplicates.",
+  args: {
+    family: { type: "string", description: 'Font family, e.g. "DM Sans"', required: true },
+    weights: {
+      type: "string",
+      description: "Comma-separated weights (default: the weights global.css already requests or self-hosts, else 400)",
+      required: false
+    },
+    subsets: {
+      type: "string",
+      description: `Comma-separated unicode subsets (default: the subsets global.css already self-hosts, else ${DEFAULT_SUBSETS_LABEL})`,
+      required: false
+    },
+    italic: {
+      type: "boolean",
+      description: "Also self-host the family's italic faces. On automatically when global.css already loads one, so a re-fetch never strands it.",
+      required: false
+    }
+  }
+});
+function fail(code, message, fix) {
+  writeJson({ ok: false, error: { code, message, ...fix ? { fix } : {} } });
+  process.exit(2);
+}
+var REQUEST_TIMEOUT_MS = 15e3;
+async function fetchJson(url) {
+  const res = await fetch(url, {
+    headers: { "User-Agent": BROWSER_UA },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (res.status === 404) return null;
+  if (!res.ok) throw new Error(`Fontsource answered ${res.status}`);
+  return await res.json();
+}
+async function lookupGoogleCss(url) {
+  try {
+    const res = await fetch(url, {
+      headers: { "User-Agent": BROWSER_UA },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+    });
+    if (res.ok) return { status: "served", css: await res.text() };
+    return { status: res.status === 400 ? "absent" : "unreachable" };
+  } catch {
+    return { status: "unreachable" };
+  }
+}
+var fetchGoogleCss = async (url) => {
+  const got = await lookupGoogleCss(url);
+  return got.status === "served" ? got.css : null;
+};
+var WIRING_HINT = {
+  written: (family) => `Wrote the @font-face for "${family}" into ${GLOBAL_CSS}, above @theme. Remove "${family}" from the Google @import if one is still there, so the page stops fetching it at load.`,
+  // Told apart from "no stylesheet" on purpose: they used to share one hint, so
+  // an idempotent re-run instructed the agent to paste a block that was already
+  // in the file, and doing as it was told duplicated the face.
+  "already-wired": (family) => `${GLOBAL_CSS} already loads exactly these faces for "${family}" \u2014 nothing to change.`,
+  "no-stylesheet": () => `No ${GLOBAL_CSS} to write to \u2014 paste the \`fontFace\` block above the @theme block once the stylesheet exists, or the files just downloaded will never load.`
+};
+var PROVIDER_DEPS = { lookupGoogleCss, fetchJson };
+var PROVIDER_LABEL = { google: "Google Fonts", fontsource: "Fontsource" };
+function italicHints(family, wantedStyles, availableStyles, downloadedStyles, provider) {
+  const wanted = wantedStyles.includes("italic");
+  const available = availableStyles.includes("italic");
+  if (wanted && !downloadedStyles.includes("italic")) {
+    return [
+      `NO ITALIC: ${PROVIDER_LABEL[provider]} does not ship an italic for "${family}", so none was written. Drop italic from src/brand/BRAND.md, or the browser will slant the upright face instead.`
+    ];
+  }
+  if (!wanted && available) {
+    return [
+      `${PROVIDER_LABEL[provider]} also ships an italic for "${family}", which was NOT downloaded. If the brand uses italic anywhere, re-run with \`--italic\` \u2014 otherwise the browser slants the upright face, which is not the same shapes.`
+    ];
+  }
+  return [];
+}
+function fetchHints({
+  family,
+  downloadedWeights,
+  downloadedStyles,
+  incomplete,
+  wiring,
+  provider,
+  wantedStyles,
+  availableStyles
+}) {
+  return [
+    WIRING_HINT[wiring](family),
+    ...italicHints(family, wantedStyles, availableStyles, downloadedStyles, provider),
+    `Record the exact weights (${downloadedWeights.join(", ")}) in src/brand/tokens.json and BRAND.md \u2014 a weight tokens.json lists but nothing loads renders as a synthesized fallback, and verify warns about it.`,
+    ...incomplete.length > 0 ? [
+      // The remedy is provider-specific: only a Google family has an @import
+      // to fall back on, and telling an agent to keep one for a Fontsource
+      // family sends it to write an import Google will 400.
+      provider === "google" ? `PARTIAL: ${incomplete.join(", ")} did not download and is NOT in the \`fontFace\` block. Re-run \`baker brand fonts fetch "${family}" --weights ${incomplete.join(",")}\` \u2014 a Google @import cannot cover those weights, because the build drops it before the page loads.` : `PARTIAL: ${incomplete.join(", ")} did not download and is NOT in the \`fontFace\` block. ${PROVIDER_LABEL[provider]} does not serve them, so re-run \`baker brand fonts fetch "${family}" --weights ${downloadedWeights.join(",")}\` and record only those weights in src/brand/BRAND.md.`
+    ] : [],
+    `Licensing: ${PROVIDER_LABEL[provider]} carries open-licensed families, which are safe to self-host. A client's own commercial face is not \u2014 confirm before re-hosting one.`
+  ];
+}
+async function wireFontFaceIntoStylesheet(css, family, fontFace) {
+  if (!css) return "no-stylesheet";
+  const wired = upsertFontFaceCss(css, family, fontFace);
+  if (wired === css) return "already-wired";
+  await writeFile(path.resolve(process.cwd(), GLOBAL_CSS), wired);
+  return "written";
+}
+function failResolution(family, weights, outcome) {
+  if (outcome.reason === "unreachable") {
+    return fail(
+      "CATALOGUE_UNREACHABLE",
+      `Could not reach ${PROVIDER_LABEL[outcome.provider]} to ask about "${family}".`,
+      {
+        action: "Run the same command again.",
+        explanation: `${PROVIDER_LABEL[outcome.provider]} did not answer, which is not the same as not having the family \u2014 so nothing was concluded from it. Guessing either way would self-host the wrong build, or report a real family as missing.`,
+        provider: outcome.provider
+      }
+    );
+  }
+  if (outcome.reason === "ambiguous-subsets") {
+    return fail(
+      "SUBSET_AMBIGUOUS",
+      `${PROVIDER_LABEL[outcome.provider]} serves "${family}" in several subsets but reports no unicode-range to tell them apart.`,
+      {
+        action: `Retry with a single --subsets value, e.g. --subsets ${outcome.available[0] ?? "latin"}.`,
+        explanation: "Two @font-face rules with the same family, style and weight and no unicode-range both claim every character, so the last one silently wins and the other file is downloaded and never read.",
+        available: outcome.available
+      }
+    );
+  }
+  if (outcome.reason === "subset") {
+    return fail("SUBSET_NOT_SERVED", `${PROVIDER_LABEL[outcome.provider]} has "${family}", but not in that subset.`, {
+      action: `Retry with --subsets set to one it serves: ${outcome.available.join(",")}.`,
+      explanation: "A family is split into unicode subsets and not every family ships every one. The weights you asked for are fine \u2014 only the subset is wrong.",
+      available: outcome.available
+    });
+  }
+  if (outcome.reason === "weight") {
+    return fail(
+      "FONT_NOT_SERVED",
+      `${PROVIDER_LABEL[outcome.provider]} has "${family}", but not at weight ${weights.join("/")}.`,
+      {
+        action: `Retry with --weights set to one of these: ${outcome.available.join(",")}.`,
+        explanation: "The family exists; the weight you asked for is not one it ships.",
+        served: outcome.available
+      }
+    );
+  }
+  return failUnknownFamily(family);
+}
+async function failUnknownFamily(family) {
+  const didYouMean = suggestFamilies(family, await fontsourceCatalogue(PROVIDER_DEPS));
+  return fail("FONT_NOT_SERVED", `No font catalogue carries a family called "${family}".`, {
+    action: didYouMean.length ? `Did you mean one of these? ${didYouMean.join(", ")}. Retry with the exact name, and update the --font-* token in ${GLOBAL_CSS} to match whichever you pick.` : `Check the exact spelling, then retry. If it is a commercial typeface, add the file to ${FONTS_DIR} and write the @font-face by hand \u2014 it cannot be downloaded.`,
+    explanation: `Tried ${FONT_PROVIDERS.join(" then ")}. Family names are case- and space-sensitive in every catalogue.`,
+    tried: [...FONT_PROVIDERS],
+    ...didYouMean.length ? { didYouMean } : {}
+  });
+}
+async function listFontFiles() {
+  try {
+    const entries = await readdir(path.resolve(process.cwd(), FONTS_DIR), { withFileTypes: true });
+    return entries.filter((e) => e.isFile()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function readGlobalCss() {
+  try {
+    return await readFile(path.resolve(process.cwd(), GLOBAL_CSS), "utf8");
+  } catch {
+    return "";
+  }
+}
+async function unresolvedAction(css, unresolved) {
+  const { plans } = planFontAdoption(await astroSources(), unresolved);
+  if (plans.length > 0) {
+    const names = plans.map((p) => `"${p.family}"`).join(", ");
+    return `Run \`baker brand fonts adopt\` \u2014 ${names} is already self-hosted by ${plans[0]?.files.join(", ")}, so it only needs moving into ${GLOBAL_CSS} to load on every page. Don't fetch it: that downloads a different build of the same face.`;
+  }
+  const viaFontsource = [...fontsourceFamilies(css)];
+  const stranded = unresolved.filter((family) => viaFontsource.includes(family.toLowerCase()));
+  if (stranded.length > 0) {
+    return `Run \`baker brand fonts fetch "${stranded[0]}"\` to self-host it. Its only provider is an @fontsource import, and that package does not survive a workspace sync \u2014 the import is left pointing at nothing, which fails the build before the font check even runs.`;
+  }
+  return `Run \`baker brand fonts fetch "${unresolved[0]}"\` to self-host it, which writes the @font-face for you. For a face no catalogue carries, add an @font-face pointing at a file in ${FONTS_DIR}.`;
+}
+var fontsCheckCommand = defineCommand({
+  meta: {
+    name: "check",
+    description: "Verify the brand's fonts really exist. First: every --font-* family in src/styles/global.css must be provided by a local @font-face, or it renders as a fallback on every page \u2014 a Google @import does not provide one here, the build drops it before the page loads. Then, for families still requested from Google, ask Google what it actually serves \u2014 a weight nobody serves is silently synthesized."
+  },
+  async run() {
+    const css = await readGlobalCss();
+    const requests = googleFontRequests(css);
+    const unresolved = unresolvedBrandFamilies(css);
+    if (unresolved.length > 0) {
+      fail("FONT_NOT_LOADED", `Nothing loads ${unresolved.map((f) => `"${f}"`).join(", ")} in ${GLOBAL_CSS}.`, {
+        action: await unresolvedAction(css, unresolved),
+        explanation: "The family is declared as a brand font but no @font-face provides it, so every page silently renders a fallback. A Google @import does not count: Astro merges component CSS ahead of global.css into one inlined <style>, so the import lands after rules and the browser drops it \u2014 measured on a live client site. The client's verify fails on this too.",
+        unresolved
+      });
+    }
+    if (requests.length === 0) {
+      writeJson({
+        ok: true,
+        data: { families: [], selfHosted: true },
+        hints: [
+          `No Google Fonts requested in ${GLOBAL_CSS}, and every brand face is provided by an @font-face \u2014 nothing to verify against Google.`
+        ]
+      });
+      return;
+    }
+    const families = await checkFontRequests(requests, fetchGoogleCss);
+    const broken = families.filter((f) => f.missing.length > 0);
+    if (broken.length > 0) {
+      const summary = broken.map(
+        (f) => f.cause === "unknown-family" ? `${f.family} (no such family on Google Fonts \u2014 check the exact spelling)` : `${f.family} ${f.missing.join("/")} (served: ${f.served.join("/") || "none"})`
+      ).join("; ");
+      fail("FONT_NOT_SERVED", `Google Fonts does not serve: ${summary}`, {
+        action: `Correct the family name or weight in ${GLOBAL_CSS} and src/brand/BRAND.md, picking from the \`served\` weights below.`,
+        explanation: "A requested weight Google does not serve is silently synthesized by the browser, so the page looks subtly wrong with nothing failing.",
+        // The per-family breakdown is the point of the command, so it ships on
+        // the failure path too — otherwise the only remedy is re-running the
+        // command that just failed. Healthy families are included so a
+        // multi-family brand shows what NOT to touch.
+        families
+      });
+    }
+    writeJson({
+      ok: true,
+      data: { families },
+      hints: [
+        "Every requested family and weight is really served by Google.",
+        `To stop depending on Google at page load, run \`baker brand fonts fetch "<family>"\` to self-host into ${FONTS_DIR}.`
+      ]
+    });
+  }
+});
+var fontsFetchCommand = defineCommand({
+  meta: {
+    name: "fetch",
+    description: "Download a font from Google Fonts or Fontsource into src/brand/fonts/ and write its @font-face into src/styles/global.css above @theme, so the family actually loads. Use when a brand font should be self-hosted rather than requested from a third party on every page load."
+  },
+  args: {
+    family: { type: "positional", required: true, description: 'Font family, e.g. "DM Sans"' },
+    weights: {
+      type: "string",
+      description: "Comma-separated weights (default: the weights global.css already requests or self-hosts, else 400)"
+    },
+    subsets: {
+      type: "string",
+      description: `Comma-separated unicode subsets (default: the subsets global.css already self-hosts, else ${DEFAULT_SUBSETS_LABEL})`
+    },
+    italic: {
+      type: "boolean",
+      description: "Also self-host the family's italic faces (default: on when global.css already loads one, off otherwise)"
+    }
+  },
+  async run({ args }) {
+    const family = String(args.family).trim();
+    if (!family) fail("INVALID_FAMILY", 'Pass a font family, e.g. `baker brand fonts fetch "DM Sans"`.');
+    const css = await readGlobalCss();
+    const declared = googleFontRequests(css).find((r) => r.family.toLowerCase() === family.toLowerCase());
+    const provided = declared?.weights.length ? declared.weights : selfHostedWeights(css, family);
+    const weights = resolveFetchWeights(args.weights, provided);
+    if (weights.length === 0) {
+      fail("INVALID_WEIGHTS", `"${args.weights}" has no usable weight \u2014 pass whole hundreds, e.g. --weights 400,700.`);
+    }
+    const wanted = new Set(resolveFetchSubsets(args.subsets, selfHostedSubsets(css, family)));
+    const styles = resolveFetchStyles(args.italic, selfHostedStyles(css, family));
+    const resolved = await resolveBrandFaces(family, weights, [...wanted], PROVIDER_DEPS, styles);
+    if (!resolved.ok) return failResolution(family, weights, resolved);
+    const faces = resolved.faces;
+    const fontsDir = path.resolve(process.cwd(), FONTS_DIR);
+    await mkdir(fontsDir, { recursive: true });
+    const downloaded = [];
+    for (const face of faces) {
+      const res = await fetch(face.url, {
+        headers: { "User-Agent": BROWSER_UA },
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+      });
+      if (!res.ok) continue;
+      await writeFile(path.join(fontsDir, fontFileName(face)), Buffer.from(await res.arrayBuffer()));
+      downloaded.push(face);
+    }
+    const written = downloaded.map(fontFileName);
+    if (written.length === 0) {
+      fail("DOWNLOAD_FAILED", `Could not download any file for "${family}".`, {
+        action: "Retry; if it keeps failing, keep the Google @import and note it in BRAND.md.",
+        explanation: "The font stylesheet resolved but the font files themselves did not download."
+      });
+    }
+    const fontFace = renderFontFaceCss(downloaded);
+    const downloadedWeights = [...new Set(downloaded.map((f) => f.weight))].sort((a, b) => a - b);
+    const downloadedStyles = [...new Set(downloaded.map((f) => f.style))].sort();
+    const incomplete = weights.filter((w) => !downloadedWeights.includes(w));
+    const wiring = await wireFontFaceIntoStylesheet(css, family, fontFace);
+    writeJson({
+      ok: true,
+      data: {
+        family,
+        provider: resolved.provider,
+        weights: downloadedWeights,
+        styles: downloadedStyles,
+        files: written,
+        fontFace,
+        stylesheet: wiring
+      },
+      hints: fetchHints({
+        family,
+        downloadedWeights,
+        downloadedStyles,
+        incomplete,
+        wiring,
+        provider: resolved.provider,
+        wantedStyles: styles,
+        availableStyles: resolved.availableStyles
+      })
+    });
+  }
+});
+async function astroSources() {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir("src", { recursive: true, withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".astro")) continue;
+    const file = path.posix.join(entry.parentPath ?? "src", entry.name);
+    try {
+      out.push({ path: file, source: await readFile(file, "utf8") });
+    } catch {
+    }
+  }
+  return out;
+}
+var fontsAdoptCommand = defineCommand({
+  meta: {
+    name: "adopt",
+    description: "Move brand faces a page already self-hosts into src/styles/global.css, so every page loads them instead of just that one. Use when `check` reports a family as not loaded but the font files are already in src/brand/fonts/ \u2014 downloading it again would hand that page a different build of the same face."
+  },
+  async run() {
+    const css = await readGlobalCss();
+    if (!css) fail("NO_STYLESHEET", `There is no ${GLOBAL_CSS} to adopt faces into.`);
+    const unresolved = unresolvedBrandFamilies(css);
+    if (unresolved.length === 0) {
+      writeJson({
+        ok: true,
+        data: { adopted: [], conflicts: [] },
+        hints: [`Every --font-* family in ${GLOBAL_CSS} is already loaded by it \u2014 nothing to adopt.`]
+      });
+      return;
+    }
+    const { plans, conflicts } = planFontAdoption(await astroSources(), unresolved);
+    const available = new Set(await listFontFiles());
+    const adopted = [];
+    const skipped = [];
+    let next = css;
+    for (const plan of plans) {
+      const missing = missingFontFiles(plan.urls, available);
+      if (missing.length > 0) {
+        skipped.push({ family: plan.family, reason: `${missing.join(", ")} is not in ${FONTS_DIR}` });
+        continue;
+      }
+      next = upsertFontFaceCss(next, plan.family, plan.blocks.join("\n"));
+      adopted.push({
+        family: plan.family,
+        files: plan.files,
+        weights: plan.blocks.map((b) => b.match(/font-weight\s*:\s*([^;]+)/i)?.[1]?.trim() ?? "400")
+      });
+    }
+    if (adopted.length === 0) {
+      if (conflicts.length > 0) {
+        fail(
+          "ADOPTION_CONFLICT",
+          `${conflicts.map((c) => `"${c.family}" is declared differently in ${c.files.join(" and ")}`).join("; ")}.`,
+          {
+            action: "Make the declarations match \u2014 same weights, same files \u2014 then re-run. Pick the one whose page renders correctly.",
+            explanation: "One global scope holds one mapping per family, so adopting would silently repaint whichever page lost.",
+            conflicts
+          }
+        );
+      }
+      if (skipped.length > 0) {
+        fail("FONT_FILE_MISSING", `${skipped.map((s) => `${s.family} \u2014 ${s.reason}`).join("; ")}.`, {
+          action: `Add the missing file to ${FONTS_DIR}, or fix the src: url() in the page that declares it, then re-run.`,
+          explanation: "The page declares the face but points at a file that is not in the repo, so the rule renders as a fallback. Moving it into the stylesheet would spread that fallback to every page.",
+          skipped
+        });
+      }
+      fail("NOTHING_TO_ADOPT", `No page declares a face for ${unresolved.map((f) => `"${f}"`).join(", ")}.`, {
+        action: `Self-host it instead: \`baker brand fonts fetch "${unresolved[0]}"\`.`,
+        explanation: "Adopting only moves faces the repo already ships; it never downloads one."
+      });
+    }
+    await writeFile(path.resolve(process.cwd(), GLOBAL_CSS), next);
+    for (const plan of plans.filter((p) => adopted.some((a) => a.family === p.family))) {
+      for (const file of plan.files) {
+        const source = await readFile(file, "utf8");
+        await writeFile(file, stripFontFaceBlocks(source, plan.family));
+      }
+    }
+    writeJson({
+      ok: true,
+      data: { adopted, conflicts, skipped },
+      hints: [
+        `Moved ${adopted.map((a) => `"${a.family}" (${a.weights.join("/")})`).join(", ")} into ${GLOBAL_CSS} and removed the page copies, so every page loads them \u2014 not just the one that declared them.`,
+        ...conflicts.length > 0 ? [
+          `CONFLICT: ${conflicts.map((c) => `"${c.family}" is declared differently in ${c.files.join(" and ")}`).join("; ")}. One global scope can hold only one mapping, so pick which files the family should use and make the declarations match before re-running.`
+        ] : [],
+        ...skipped.length > 0 ? [`SKIPPED: ${skipped.map((s) => `${s.family} \u2014 ${s.reason}`).join("; ")}.`] : [],
+        `Run \`baker brand fonts check\` to confirm nothing is left unresolved.`
+      ]
+    });
+  }
+});
+var fontsCommand = defineCommand({
+  meta: {
+    name: "fonts",
+    description: `Verify and self-host the brand's typefaces.
+
+Start here: \`baker brand fonts check\` \u2014 confirms the fonts the brand claims really load.
+
+Subcommands:
+  baker brand fonts check           \u2014 fail if any --font-* family has nothing loading it, then ask Google what it actually serves for the ones global.css requests
+  baker brand fonts fetch <family>  \u2014 download a family into src/brand/fonts/ and wire its @font-face into src/styles/global.css
+  baker brand fonts adopt           \u2014 move faces a page already self-hosts into global.css, so every page loads them. Try this BEFORE fetch when the font files are already in src/brand/fonts/`
+  },
+  subCommands: {
+    check: fontsCheckCommand,
+    fetch: fontsFetchCommand,
+    adopt: fontsAdoptCommand
+  }
+});
+
+export {
+  fetchJson,
+  lookupGoogleCss,
+  fontsCheckCommand,
+  fontsFetchCommand,
+  fontsAdoptCommand,
+  fontsCommand
+};
+//# sourceMappingURL=chunk-QFEZKCQL.js.map