fontfetch 0.6.0

package/dist/cli.js

@@ -0,0 +1,927 @@
+#!/usr/bin/env node
+
+// src/pull.ts
+import fs from "fs/promises";
+import path2 from "path";
+
+// src/utils.ts
+import path from "path";
+var FONT_EXT_RE = /\.(woff2|woff|ttf|otf|eot)(\?[^"')\s]*)?$/i;
+var UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36";
+async function fetchText(url, headers = {}) {
+  const res = await fetch(url, { headers: { "User-Agent": UA, ...headers } });
+  if (!res.ok) throw new Error(`GET ${url} \u2192 ${res.status}`);
+  return await res.text();
+}
+async function fetchBuffer(url, headers = {}) {
+  const res = await fetch(url, { headers: { "User-Agent": UA, ...headers } });
+  if (!res.ok) throw new Error(`GET ${url} \u2192 ${res.status}`);
+  return Buffer.from(await res.arrayBuffer());
+}
+function abs(u, base) {
+  try {
+    return new URL(u, base).toString();
+  } catch {
+    return null;
+  }
+}
+function siteSlug(url) {
+  return new URL(url).hostname.replace(/^www\./, "").replace(/[^a-zA-Z0-9.-]/g, "_");
+}
+function safeFilename(url) {
+  const u = new URL(url);
+  const base = path.basename(u.pathname) || "font";
+  return base.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+var log = {
+  info: (msg) => console.log(msg),
+  warn: (msg) => console.warn(msg),
+  err: (msg) => console.error(msg)
+};
+
+// src/parse.ts
+function extractStylesheetLinks(html, baseUrl) {
+  const out = [];
+  const linkRe = /<link\b[^>]*rel=["']?stylesheet["']?[^>]*>/gi;
+  for (const m of html.matchAll(linkRe)) {
+    const href = /href=["']([^"']+)["']/i.exec(m[0])?.[1];
+    if (href) {
+      const u = abs(href, baseUrl);
+      if (u) out.push(u);
+    }
+  }
+  return out;
+}
+function extractInlineStyles(html) {
+  const out = [];
+  const styleRe = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+  for (const m of html.matchAll(styleRe)) out.push(m[1]);
+  return out;
+}
+function parseFontFace(body, baseUrl) {
+  const getProp = (prop) => {
+    const m = new RegExp(`${prop}\\s*:\\s*([^;]+)`, "i").exec(body);
+    return m ? m[1].trim() : null;
+  };
+  const family = (getProp("font-family") || "").replace(/^['"]|['"]$/g, "");
+  const weight = getProp("font-weight") || "400";
+  const style = getProp("font-style") || "normal";
+  const display = getProp("font-display");
+  const unicodeRange = getProp("unicode-range");
+  const srcRaw = getProp("src") || "";
+  const sources = [];
+  const srcRe = /url\(\s*['"]?([^'")]+)['"]?\s*\)(?:\s*format\(\s*['"]?([^'")]+)['"]?\s*\))?/gi;
+  for (const m of srcRaw.matchAll(srcRe)) {
+    const raw = m[1];
+    if (raw.startsWith("data:")) continue;
+    if (!FONT_EXT_RE.test(raw)) continue;
+    const absUrl = abs(raw, baseUrl);
+    if (!absUrl) continue;
+    sources.push({ url: absUrl, format: m[2] || null });
+  }
+  if (!family || sources.length === 0) return null;
+  return { family, weight, style, display, unicodeRange, sources };
+}
+function extractFontFaces(css, baseUrl) {
+  const out = [];
+  const faceRe = /@font-face\s*\{([^}]*)\}/gi;
+  for (const m of css.matchAll(faceRe)) {
+    const parsed = parseFontFace(m[1], baseUrl);
+    if (parsed) out.push(parsed);
+  }
+  return out;
+}
+
+// src/emit.ts
+function buildFontsCss(faces) {
+  const lines = [
+    "/* Auto-generated by fontfetch */",
+    "/* Drop this folder into your project and link this CSS file. */",
+    ""
+  ];
+  for (const f of faces) {
+    lines.push("@font-face {");
+    lines.push(`  font-family: '${f.family}';`);
+    lines.push(`  font-style: ${f.style};`);
+    lines.push(`  font-weight: ${f.weight};`);
+    if (f.display) lines.push(`  font-display: ${f.display};`);
+    const srcParts = f.sources.map((s) => {
+      const local = `url('./files/${s.localFile}')`;
+      return s.format ? `${local} format('${s.format}')` : local;
+    });
+    lines.push(`  src: ${srcParts.join(", ")};`);
+    if (f.unicodeRange) lines.push(`  unicode-range: ${f.unicodeRange};`);
+    lines.push("}");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildFontsJson(faces, orphans = []) {
+  return JSON.stringify(
+    {
+      faces: faces.map((f) => ({
+        family: f.family,
+        weight: f.weight,
+        style: f.style,
+        display: f.display,
+        unicodeRange: f.unicodeRange,
+        files: f.sources.map((s) => ({ file: `files/${s.localFile}`, format: s.format }))
+      })),
+      orphan_files: orphans.map((o) => ({ file: `files/${o.file}`, url: o.url }))
+    },
+    null,
+    2
+  );
+}
+function buildReadme(host, faces, totalFiles, orphans = []) {
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const f of faces) {
+    if (!byFamily.has(f.family)) byFamily.set(f.family, []);
+    byFamily.get(f.family).push(f);
+  }
+  const lines = [
+    `# Fonts from ${host}`,
+    "",
+    `Downloaded ${totalFiles} font file(s) across ${faces.length} @font-face declaration(s).`,
+    "",
+    "## Usage",
+    "",
+    "1. Copy this whole folder into your project (e.g. `public/fonts/` or `src/assets/fonts/`).",
+    '2. Include `fonts.css` in your app (import it, or `<link rel="stylesheet" href="...">`).',
+    "3. Reference the families below by `font-family` in your CSS.",
+    "",
+    "## Families",
+    ""
+  ];
+  for (const [family, list] of byFamily) {
+    lines.push(`### ${family}`);
+    lines.push("");
+    const variants = /* @__PURE__ */ new Map();
+    for (const f of list) {
+      const key = `${f.weight} / ${f.style}`;
+      variants.set(key, (variants.get(key) || 0) + 1);
+    }
+    for (const [key, n] of variants) {
+      lines.push(`- ${key}${n > 1 ? `  _(${n} subset files)_` : ""}`);
+    }
+    lines.push("");
+  }
+  if (orphans.length > 0) {
+    lines.push("## Orphan files");
+    lines.push("");
+    lines.push(`These ${orphans.length} font file(s) were observed loading in the browser but came from a cross-origin stylesheet whose @font-face rules couldn't be read directly (common for Adobe Typekit and similar services). The files are downloaded into \`files/\` but **not referenced in \`fonts.css\`** \u2014 there's no family/weight/style metadata to construct a rule from.`);
+    lines.push("");
+    lines.push("To use them, inspect the live site's DevTools to find the matching @font-face declarations, then add them to your CSS pointing at the local files.");
+    lines.push("");
+    for (const o of orphans) {
+      lines.push(`- \`files/${o.file}\` \u2190 ${o.url}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Notes");
+  lines.push("");
+  lines.push("- Multiple files per weight/style usually means the source split the font by `unicode-range` (Latin, Latin-Ext, Cyrillic, etc.). The browser only loads the subsets it needs \u2014 keep them all.");
+  lines.push("- For local design exploration. Verify licensing before shipping to production.");
+  lines.push("");
+  return lines.join("\n");
+}
+function buildLicenseReview(host, classified, summary) {
+  const lines = [
+    `# License review for ${host}`,
+    "",
+    "> Heuristic-only. Not legal advice. Verify before shipping.",
+    "",
+    "## Summary",
+    "",
+    `- \u2705 **${summary.open} open** \u2014 safe to self-host`,
+    `- \u26A0\uFE0F **${summary.commercial} commercial** \u2014 do not ship without a license`,
+    `- \u2753 **${summary.unknown} unknown** \u2014 manual review needed`,
+    ""
+  ];
+  const sections = [
+    { status: "open", title: "## \u2705 Open / self-hostable" },
+    {
+      status: "commercial",
+      title: "## \u26A0\uFE0F Commercial \u2014 do not ship without a license",
+      note: "These came from a commercial foundry CDN. Bundling them into a production app without a paid license violates the foundry EULA."
+    },
+    {
+      status: "unknown",
+      title: "## \u2753 Unknown \u2014 manual review",
+      note: "Couldn't match against known CDN signatures or the known-open family list. Check the foundry, search Google Fonts for a free alternative, or inspect the site's CSS to confirm."
+    }
+  ];
+  for (const section of sections) {
+    const items = classified.filter((c) => c.classification.status === section.status);
+    if (items.length === 0) continue;
+    lines.push(section.title);
+    lines.push("");
+    if (section.note) {
+      lines.push(`_${section.note}_`);
+      lines.push("");
+    }
+    const byFamily = /* @__PURE__ */ new Map();
+    for (const it of items) {
+      const list = byFamily.get(it.face.family) ?? [];
+      list.push(it);
+      byFamily.set(it.face.family, list);
+    }
+    for (const [family, list] of byFamily) {
+      lines.push(`### ${family}`);
+      lines.push("");
+      lines.push(`- ${list[0].classification.reason}`);
+      const fileList = list.flatMap(
+        (it) => it.face.sources.map((s) => s.localFile).filter((f) => Boolean(f)).map((f) => `files/${f} (${it.face.weight}/${it.face.style})`)
+      );
+      const unique = [...new Set(fileList)];
+      if (unique.length > 0) {
+        lines.push("- Files:");
+        for (const f of unique) lines.push(`  - \`${f}\``);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/license-data.ts
+var OPEN_HOSTS = [
+  { host: "fonts.gstatic.com", label: "Google Fonts CDN" },
+  { host: "fonts.googleapis.com", label: "Google Fonts API" },
+  { host: "cdn.jsdelivr.net/npm/@fontsource/", label: "Fontsource (mostly OFL)" },
+  { host: "rsms.me/inter", label: "Inter \u2014 OFL (by Rasmus Andersson)" },
+  { host: "cdn.jsdelivr.net/gh/google/fonts", label: "Google Fonts GitHub mirror" }
+];
+var COMMERCIAL_HOSTS = [
+  { host: "use.typekit.net", label: "Adobe Fonts (Typekit)" },
+  { host: "fonts.adobe.com", label: "Adobe Fonts" },
+  { host: "p.typekit.net", label: "Adobe Fonts (Typekit)" },
+  { host: "fast.fonts.net", label: "Monotype (fonts.com)" },
+  { host: "cloud.typenetwork.com", label: "Type Network" },
+  { host: "cloud.typography.com", label: "Hoefler & Co (Cloud.typography)" },
+  { host: "use.fontawesome.com", label: "Font Awesome (commercial tiers)" },
+  { host: "fontstand.com", label: "Fontstand" }
+];
+var KNOWN_OPEN_FAMILIES = [
+  // Top sans
+  "Inter",
+  "Inter Display",
+  "Inter Tight",
+  "Roboto",
+  "Roboto Condensed",
+  "Roboto Flex",
+  "Open Sans",
+  "Lato",
+  "Montserrat",
+  "Poppins",
+  "Oswald",
+  "Raleway",
+  "Nunito",
+  "Nunito Sans",
+  "Ubuntu",
+  "PT Sans",
+  "Source Sans Pro",
+  "Source Sans 3",
+  "Mulish",
+  "Karla",
+  "Work Sans",
+  "Quicksand",
+  "DM Sans",
+  "Manrope",
+  "Outfit",
+  "Space Grotesk",
+  "Plus Jakarta Sans",
+  "Public Sans",
+  "Hind",
+  "Cabin",
+  "Atkinson Hyperlegible",
+  // Geist (Vercel + Basement Studio, OFL)
+  "Geist",
+  "Geist Mono",
+  "Geist Sans",
+  // Mono
+  "JetBrains Mono",
+  "Fira Code",
+  "Fira Mono",
+  "Source Code Pro",
+  "IBM Plex Mono",
+  "Space Mono",
+  "DM Mono",
+  "Roboto Mono",
+  // Serif
+  "Playfair Display",
+  "Merriweather",
+  "Noto Serif",
+  "Noto Sans",
+  "EB Garamond",
+  "Lora",
+  "Bitter",
+  "Cardo",
+  "Cormorant",
+  "Crimson Text",
+  "PT Serif",
+  "DM Serif Display",
+  "DM Serif Text",
+  // IBM Plex (Apache 2.0)
+  "IBM Plex Sans",
+  "IBM Plex Serif",
+  // Fira (OFL)
+  "Fira Sans",
+  // Display / handwritten
+  "Lobster",
+  "Pacifico",
+  "Sacramento",
+  "Dancing Script",
+  "Caveat",
+  "Indie Flower",
+  "Patrick Hand",
+  "Comic Neue",
+  "Architects Daughter"
+];
+
+// src/license.ts
+var NORMALIZED_OPEN_FAMILIES = new Set(KNOWN_OPEN_FAMILIES.map((f) => f.trim().toLowerCase()));
+function classifyFace(face) {
+  for (const src of face.sources) {
+    for (const sig of COMMERCIAL_HOSTS) {
+      if (src.url.includes(sig.host)) {
+        return { status: "commercial", reason: `Served from ${sig.label}` };
+      }
+    }
+  }
+  for (const src of face.sources) {
+    for (const sig of OPEN_HOSTS) {
+      if (src.url.includes(sig.host)) {
+        return { status: "open", reason: `Served from ${sig.label}` };
+      }
+    }
+  }
+  const fam = (face.family || "").trim().toLowerCase();
+  if (NORMALIZED_OPEN_FAMILIES.has(fam)) {
+    return { status: "open", reason: `'${face.family}' is on the SIL OFL / Google Fonts catalog` };
+  }
+  return { status: "unknown", reason: "No matching CDN or known-family signature" };
+}
+function classifyFaces(faces) {
+  return faces.map((face) => ({ face, classification: classifyFace(face) }));
+}
+function summarize(classified) {
+  let open = 0;
+  let commercial = 0;
+  let unknown = 0;
+  for (const c of classified) {
+    if (c.classification.status === "open") open++;
+    else if (c.classification.status === "commercial") commercial++;
+    else unknown++;
+  }
+  const total = classified.length;
+  return {
+    open,
+    commercial,
+    unknown,
+    total,
+    allCommercial: total > 0 && commercial === total
+  };
+}
+
+// src/headless.ts
+var INSTALL_HINT = `
+Playwright is required for --headless mode. To install:
+
+  npm install playwright
+  npx playwright install chromium
+
+Or skip --headless to use the static parser.
+`.trim();
+async function fetchHeadless(url, timeoutMs = 3e4) {
+  let chromium;
+  try {
+    ({ chromium } = await import("playwright"));
+  } catch {
+    throw new Error(INSTALL_HINT);
+  }
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: true });
+  } catch (e) {
+    const msg = e.message;
+    if (/Executable doesn't exist|browserType\.launch/i.test(msg)) {
+      throw new Error(
+        `Playwright is installed but Chromium isn't. Run:
+  npx playwright install chromium
+
+(${msg})`
+      );
+    }
+    throw e;
+  }
+  try {
+    const context = await browser.newContext({ userAgent: UA });
+    const page = await context.newPage();
+    const networkFontUrls = /* @__PURE__ */ new Set();
+    page.on("response", (response) => {
+      const u = response.url();
+      const ct = (response.headers()["content-type"] || "").toLowerCase();
+      const isFontByExt = /\.(woff2|woff|ttf|otf|eot)(\?|$)/i.test(u);
+      const isFontByType = ct.startsWith("font/") || ct === "application/font-woff" || ct === "application/font-woff2";
+      if ((isFontByExt || isFontByType) && response.status() < 400) {
+        networkFontUrls.add(u);
+      }
+    });
+    await page.goto(url, { waitUntil: "networkidle", timeout: timeoutMs });
+    await page.evaluate(() => document.fonts.ready);
+    const cssText = await page.evaluate(() => {
+      const out = [];
+      for (const sheet of Array.from(document.styleSheets)) {
+        try {
+          const rules = sheet.cssRules;
+          if (!rules) continue;
+          for (const rule of Array.from(rules)) {
+            if (rule.type === CSSRule.FONT_FACE_RULE) {
+              out.push(rule.cssText);
+            }
+          }
+        } catch {
+        }
+      }
+      return out.join("\n");
+    });
+    return {
+      cssSources: cssText ? [{ text: cssText, base: url }] : [],
+      networkFontUrls: [...networkFontUrls]
+    };
+  } finally {
+    await browser.close();
+  }
+}
+
+// src/emitters/util.ts
+function familyToIdent(family) {
+  const cleaned = family.replace(/[^A-Za-z0-9 ]+/g, " ").trim();
+  if (!cleaned) return "font";
+  const parts = cleaned.split(/\s+/);
+  const first = parts[0][0].toLowerCase() + parts[0].slice(1);
+  const rest = parts.slice(1).map((p) => p[0].toUpperCase() + p.slice(1));
+  return [first, ...rest].join("");
+}
+function familyToKebab(family) {
+  return family.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function tailwindBucket(family) {
+  const f = family.toLowerCase();
+  if (/(mono|code|console|courier|consolas)/.test(f)) return "mono";
+  if (/sans/.test(f)) return "sans";
+  if (/(serif|garamond|caslon|baskerville|times|georgia|plantijn|tiempos)/.test(f)) return "serif";
+  return "sans";
+}
+function groupByFamily(faces) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of faces) {
+    const existing = out.get(f.family);
+    if (existing) existing.push(f);
+    else out.set(f.family, [f]);
+  }
+  return out;
+}
+function pickPrimaryFile(face) {
+  if (face.sources.length === 0) return null;
+  const woff2 = face.sources.find((s) => s.format === "woff2");
+  const chosen = woff2 ?? face.sources[0];
+  if (!chosen.localFile) return null;
+  return { file: chosen.localFile, format: chosen.format };
+}
+
+// src/emitters/next.ts
+var nextEmitter = (faces, ctx) => {
+  const byFamily = groupByFamily(faces);
+  if (byFamily.size === 0) return null;
+  const lines = [
+    "/* Auto-generated by fontfetch (`--emit next`). */",
+    "/* Copy this folder into your Next.js project and import these exports. */",
+    "/* Example: `<html className={`${interFont.variable} ${geistMono.variable}`}>` */",
+    "",
+    "import localFont from 'next/font/local';",
+    ""
+  ];
+  for (const [family, list] of byFamily) {
+    const ident = familyToIdent(family);
+    const cssVar = `--font-${familyToKebab(family)}`;
+    const sources = list.map((f) => pickPrimaryFile(f)).filter((s) => s !== null);
+    if (sources.length === 0) continue;
+    lines.push(`export const ${ident} = localFont({`);
+    lines.push("  src: [");
+    list.forEach((f, i) => {
+      const src = pickPrimaryFile(f);
+      if (!src) return;
+      const weight = f.weight || "400";
+      const style = f.style || "normal";
+      lines.push(
+        `    { path: './${ctx.filesDir}/${src.file}', weight: '${weight}', style: '${style}' },` + (i === list.length - 1 ? "" : "")
+      );
+    });
+    lines.push("  ],");
+    lines.push(`  variable: '${cssVar}',`);
+    lines.push("  display: 'swap',");
+    lines.push("});");
+    lines.push("");
+  }
+  return { filename: "next.fonts.ts", content: lines.join("\n") };
+};
+
+// src/emitters/tailwind.ts
+var tailwindEmitter = (faces, ctx) => {
+  void ctx;
+  const byFamily = groupByFamily(faces);
+  if (byFamily.size === 0) return null;
+  const buckets = { sans: [], serif: [], mono: [] };
+  const aliases = [];
+  for (const family of byFamily.keys()) {
+    const cssVar = `--font-${familyToKebab(family)}`;
+    const bucket = tailwindBucket(family);
+    buckets[bucket].push(`var(${cssVar})`);
+    aliases.push({ alias: familyToIdent(family), family, cssVar });
+  }
+  const fallback = {
+    sans: "'system-ui', 'sans-serif'",
+    serif: "'Georgia', 'serif'",
+    mono: "'ui-monospace', 'monospace'"
+  };
+  const lines = [
+    "/* Auto-generated by fontfetch (`--emit tailwind`). */",
+    "/* Merge `fonts` into your tailwind.config.ts -> theme.extend.fontFamily. */",
+    "/* Pair with the Next.js setup from `--emit next` for CSS variables. */",
+    "",
+    "import type { Config } from 'tailwindcss';",
+    "",
+    "type FontFamilyConfig = NonNullable<NonNullable<Config['theme']>['extend']>['fontFamily'];",
+    "",
+    "export const fonts: FontFamilyConfig = {"
+  ];
+  for (const bucket of ["sans", "serif", "mono"]) {
+    const vars = buckets[bucket];
+    if (vars.length === 0) continue;
+    const stack = [...vars.map((v) => `'${v}'`), fallback[bucket]].join(", ");
+    lines.push(`  ${bucket}: [${stack}],`);
+  }
+  for (const { alias, family, cssVar } of aliases) {
+    lines.push(`  '${alias}': ['var(${cssVar})', /* ${family} */],`);
+  }
+  lines.push("};");
+  lines.push("");
+  lines.push("export default fonts;");
+  return { filename: "tailwind.fonts.ts", content: lines.join("\n") };
+};
+
+// src/emitters/vite.ts
+var viteEmitter = (faces, ctx) => {
+  const byFamily = groupByFamily(faces);
+  if (byFamily.size === 0) return null;
+  const lines = [
+    "# Vite integration",
+    "",
+    "The generated `fonts.css` is already a drop-in `@font-face` stylesheet \u2014 no Vite-specific plugin needed.",
+    "",
+    "## Steps",
+    "",
+    "1. Copy this folder into your project, e.g. `src/assets/fonts/<site>/`",
+    "2. Import the stylesheet from your entry file:",
+    "",
+    "   ```ts",
+    "   // src/main.ts (or src/main.tsx, etc.)",
+    `   import './assets/fonts/<site>/fonts.css';`,
+    "   ```",
+    "",
+    "3. Reference the families in your CSS or Tailwind config:",
+    ""
+  ];
+  for (const family of byFamily.keys()) {
+    lines.push(`   - \`font-family: '${family}';\``);
+  }
+  lines.push("");
+  lines.push("## Notes");
+  lines.push("");
+  lines.push("- Vite emits the font files as-is during build; they go through `vite-plugin-static-copy` or your asset pipeline automatically when imported via `url()` in the CSS.");
+  lines.push(`- File paths in \`fonts.css\` are relative (\`./${ctx.filesDir}/...\`), so the import works from anywhere you place this folder.`);
+  lines.push("");
+  return { filename: "vite.fonts.md", content: lines.join("\n") };
+};
+
+// src/emitters/types.ts
+var EMIT_TARGETS = ["css", "next", "tailwind", "vite"];
+function isEmitTarget(s) {
+  return EMIT_TARGETS.includes(s);
+}
+
+// src/emitters/index.ts
+var EMITTERS = {
+  next: nextEmitter,
+  tailwind: tailwindEmitter,
+  vite: viteEmitter
+};
+
+// src/provenance.ts
+var RULES = [
+  {
+    bucket: "google",
+    patterns: ["fonts.gstatic.com", "fonts.googleapis.com", "cdn.jsdelivr.net/gh/google/fonts"]
+  },
+  {
+    bucket: "adobe-typekit",
+    patterns: ["use.typekit.net", "p.typekit.net", "fonts.adobe.com"]
+  },
+  {
+    bucket: "commercial",
+    patterns: [
+      "fast.fonts.net",
+      "cloud.typography.com",
+      "cloud.typenetwork.com",
+      "use.fontawesome.com",
+      "fontstand.com"
+    ]
+  },
+  {
+    bucket: "open-cdn",
+    patterns: ["cdn.jsdelivr.net/npm/@fontsource/", "rsms.me"]
+  }
+];
+function strip(host) {
+  return host.replace(/^www\./i, "").toLowerCase();
+}
+function sameOrigin(urlHost, pageHost) {
+  const a = strip(urlHost);
+  const b = strip(pageHost);
+  if (a === b) return true;
+  return a.endsWith("." + b) || b.endsWith("." + a);
+}
+function bucketForUrl(url, pageHost) {
+  for (const rule of RULES) {
+    for (const pattern of rule.patterns) {
+      if (url.includes(pattern)) return rule.bucket;
+    }
+  }
+  try {
+    const u = new URL(url);
+    if (sameOrigin(u.hostname, pageHost)) return "self-hosted";
+  } catch {
+  }
+  return "self-hosted";
+}
+
+// src/pull.ts
+async function pull({
+  url,
+  baseDir,
+  headless = false,
+  emit = [],
+  force = false
+}) {
+  const host = siteSlug(url);
+  const outDir = path2.join(path2.resolve(baseDir), host);
+  const filesDir = path2.join(outDir, "files");
+  await fs.mkdir(filesDir, { recursive: true });
+  log.info(`\u2192 Fetching page: ${url}`);
+  const html = await fetchText(url);
+  const cssLinks = extractStylesheetLinks(html, url);
+  const inlineCss = extractInlineStyles(html);
+  log.info(`  ${cssLinks.length} external stylesheet(s), ${inlineCss.length} inline <style> block(s)`);
+  const cssSources = inlineCss.map((t) => ({ text: t, base: url }));
+  for (const link of cssLinks) {
+    try {
+      log.info(`\u2192 Fetching CSS: ${link}`);
+      cssSources.push({ text: await fetchText(link, { Referer: url }), base: link });
+    } catch (e) {
+      log.warn(`  ! Failed: ${e.message}`);
+    }
+  }
+  let networkFontUrls = [];
+  if (headless) {
+    log.info("\u2192 Running headless mode (Playwright)...");
+    try {
+      const result = await fetchHeadless(url);
+      cssSources.push(...result.cssSources);
+      networkFontUrls = result.networkFontUrls;
+      log.info(`  + ${result.cssSources.length} stylesheet block(s) from headless`);
+      if (networkFontUrls.length > 0) {
+        log.info(`  + ${networkFontUrls.length} font URL(s) observed in network`);
+      }
+    } catch (e) {
+      log.warn(`  ! Headless mode failed: ${e.message}`);
+      log.warn("  Continuing with static results.");
+    }
+  }
+  const allFaces = cssSources.flatMap(({ text, base }) => extractFontFaces(text, base));
+  const seen = /* @__PURE__ */ new Set();
+  const faces = allFaces.filter((f) => {
+    const sig = `${f.family}|${f.weight}|${f.style}|${f.sources.map((s) => s.url).sort().join(",")}`;
+    if (seen.has(sig)) return false;
+    seen.add(sig);
+    return true;
+  });
+  const preloadRe = /<link\b[^>]*rel=["']?preload["']?[^>]*as=["']?font["']?[^>]*>/gi;
+  const extraUrls = [];
+  for (const m of html.matchAll(preloadRe)) {
+    const href = /href=["']([^"']+)["']/i.exec(m[0])?.[1];
+    if (href) {
+      const u = abs(href, url);
+      if (u && FONT_EXT_RE.test(u)) extraUrls.push(u);
+    }
+  }
+  const pageHost = new URL(url).hostname;
+  const urlToLocal = /* @__PURE__ */ new Map();
+  const usedNames = /* @__PURE__ */ new Set();
+  const claim = (u) => {
+    if (urlToLocal.has(u)) return urlToLocal.get(u);
+    const bucket = bucketForUrl(u, pageHost);
+    let name = safeFilename(u);
+    const candidate = `${bucket}/${name}`;
+    if (usedNames.has(candidate)) {
+      const h = new URL(u).hostname.replace(/[^a-z0-9]/gi, "_");
+      name = `${h}__${name}`;
+    }
+    const final = `${bucket}/${name}`;
+    usedNames.add(final);
+    urlToLocal.set(u, final);
+    return final;
+  };
+  for (const f of faces) {
+    for (const s of f.sources) s.localFile = claim(s.url);
+  }
+  for (const u of extraUrls) claim(u);
+  const faceUrls = /* @__PURE__ */ new Set();
+  for (const f of faces) for (const s of f.sources) faceUrls.add(s.url);
+  const orphans = [];
+  for (const u of networkFontUrls) {
+    if (faceUrls.has(u)) continue;
+    if (urlToLocal.has(u)) continue;
+    const file = claim(u);
+    orphans.push({ url: u, file });
+  }
+  if (orphans.length > 0) {
+    log.info(`\u2192 ${orphans.length} orphan file(s) (cross-origin, no @font-face metadata available)`);
+  }
+  log.info(`\u2192 Found ${faces.length} @font-face declaration(s), ${urlToLocal.size} unique file(s)`);
+  if (urlToLocal.size === 0) {
+    log.info("  (Nothing to download. Site may load fonts via JS, or block automated requests. Try --headless.)");
+    return { outDir, faces, orphans: [], downloaded: 0, total: 0 };
+  }
+  const classified = classifyFaces(faces);
+  const licenseSummary = summarize(classified);
+  log.info(
+    `\u2192 License review: ${licenseSummary.open} open / ${licenseSummary.commercial} commercial / ${licenseSummary.unknown} unknown`
+  );
+  if (licenseSummary.allCommercial && !force) {
+    await fs.writeFile(
+      path2.join(outDir, "LICENSE_REVIEW.md"),
+      buildLicenseReview(host, classified, licenseSummary)
+    );
+    log.warn("");
+    log.warn(`\u2717 All ${licenseSummary.commercial} detected font(s) are served from known commercial CDNs.`);
+    log.warn("  Downloading and shipping these without a license violates foundry EULAs.");
+    log.warn(`  Wrote ${path2.join(outDir, "LICENSE_REVIEW.md")} with the breakdown.`);
+    log.warn("  To download anyway (e.g. for a local mockup you have rights to), re-run with --force.");
+    log.warn("");
+    return { outDir, faces, orphans: [], downloaded: 0, total: urlToLocal.size };
+  }
+  let downloaded = 0;
+  const createdBuckets = /* @__PURE__ */ new Set();
+  for (const [fontUrl, name] of urlToLocal) {
+    const dest = path2.join(filesDir, name);
+    const bucketDir = path2.dirname(dest);
+    if (!createdBuckets.has(bucketDir)) {
+      await fs.mkdir(bucketDir, { recursive: true });
+      createdBuckets.add(bucketDir);
+    }
+    try {
+      const buf = await fetchBuffer(fontUrl, { Referer: url });
+      await fs.writeFile(dest, buf);
+      log.info(`  \u2713 ${name}  (${buf.length.toLocaleString()} bytes)`);
+      downloaded++;
+    } catch (e) {
+      log.warn(`  \u2717 ${name} \u2014 ${e.message}`);
+    }
+  }
+  await fs.writeFile(path2.join(outDir, "fonts.css"), buildFontsCss(faces));
+  await fs.writeFile(path2.join(outDir, "fonts.json"), buildFontsJson(faces, orphans));
+  await fs.writeFile(path2.join(outDir, "README.md"), buildReadme(host, faces, downloaded, orphans));
+  await fs.writeFile(
+    path2.join(outDir, "LICENSE_REVIEW.md"),
+    buildLicenseReview(host, classified, licenseSummary)
+  );
+  for (const target of emit) {
+    const emitter = EMITTERS[target];
+    if (!emitter) continue;
+    const output = emitter(faces, { siteSlug: host, filesDir: "files" });
+    if (!output) continue;
+    await fs.writeFile(path2.join(outDir, output.filename), output.content);
+    log.info(`  + emitted ${output.filename} (--emit ${target})`);
+  }
+  return { outDir, faces, orphans, downloaded, total: urlToLocal.size };
+}
+
+// src/cli.ts
+var VERSION = "0.6.0";
+function printHelp() {
+  log.info(`fontfetch ${VERSION}
+
+Usage:
+  fontfetch <url> [outDir] [flags]
+
+Arguments:
+  <url>             Page to download fonts from (https://example.com)
+  [outDir]          Directory to write output into (default: ./downloaded-fonts)
+
+Flags:
+  --headless        Use Playwright to also capture JS-loaded fonts (SPAs,
+                    late-injected @font-face rules). Requires:
+                      npm install playwright
+                      npx playwright install chromium
+  --emit <targets>  Comma-separated framework targets to emit alongside the
+                    default fonts.css. One or more of: ${EMIT_TARGETS.join(", ")}
+                    Examples:
+                      --emit next            Next.js next/font/local file
+                      --emit tailwind        Tailwind fontFamily snippet
+                      --emit next,tailwind   Both (pair for CSS variables)
+                      --emit vite            Vite integration guide
+  --force           Download even if every detected font is served from a
+                    known commercial-foundry CDN. Default behaviour is to
+                    abort early and emit only LICENSE_REVIEW.md.
+  -h, --help        Show this help
+  -v, --version     Print version
+
+Examples:
+  fontfetch https://stripe.com
+  fontfetch https://stripe.com ./fonts
+  fontfetch https://linear.app --headless
+  fontfetch https://vercel.com --emit next,tailwind
+  npx fontfetch https://stripe.com
+
+Output (per site):
+  <outDir>/<hostname>/
+    files/          Raw font files (woff2/woff/ttf/otf/eot)
+    fonts.css       Ready-to-use @font-face block with local URLs
+    fonts.json      Manifest grouped by family/weight/style
+    README.md       Human-readable summary
+
+For local design exploration. You're responsible for licensing the fonts you use.
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args.includes("-h") || args.includes("--help")) {
+    printHelp();
+    process.exit(args.length === 0 ? 1 : 0);
+  }
+  if (args.includes("-v") || args.includes("--version")) {
+    log.info(VERSION);
+    process.exit(0);
+  }
+  const headless = args.includes("--headless");
+  const force = args.includes("--force");
+  let emit = [];
+  const emitIdx = args.findIndex((a) => a === "--emit" || a.startsWith("--emit="));
+  if (emitIdx !== -1) {
+    const raw = args[emitIdx] === "--emit" ? args[emitIdx + 1] : args[emitIdx].slice("--emit=".length);
+    if (!raw) {
+      log.err(`--emit requires a value. One or more of: ${EMIT_TARGETS.join(", ")}`);
+      process.exit(1);
+    }
+    const requested = raw.split(",").map((s) => s.trim()).filter(Boolean);
+    for (const r of requested) {
+      if (!isEmitTarget(r)) {
+        log.err(`Unknown --emit target: '${r}'. Valid: ${EMIT_TARGETS.join(", ")}`);
+        process.exit(1);
+      }
+      if (r !== "css") emit.push(r);
+    }
+  }
+  const reservedFlags = /* @__PURE__ */ new Set(["--headless", "--emit", "--force"]);
+  const positional = args.filter((a, i) => {
+    if (a.startsWith("--")) return false;
+    if (i > 0 && args[i - 1] === "--emit") return false;
+    if (reservedFlags.has(a)) return false;
+    return true;
+  });
+  const [url, outDir = "./downloaded-fonts"] = positional;
+  if (!url) {
+    log.err("Missing <url> argument. Run with --help for usage.");
+    process.exit(1);
+  }
+  try {
+    new URL(url);
+  } catch {
+    log.err(`Invalid URL: ${url}`);
+    process.exit(1);
+  }
+  const result = await pull({ url, baseDir: outDir, headless, emit, force });
+  log.info("");
+  if (result.total === 0) {
+    log.info("No fonts found.");
+    process.exit(0);
+  }
+  log.info(`Done. ${result.downloaded}/${result.total} files saved to ${result.outDir}`);
+}
+main().catch((e) => {
+  log.err(String(e));
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map