hyperframes 0.8.84 → 0.8.86

package/dist/fontLocalizeCli.js

@@ -94979,96 +94979,234 @@ function partitionWeightRuns(faces, coveredWeights) {
   for (const face of unsortable) runs.push([face]);
   return runs;
 }
-async function buildFontFaceCss(requestedFamilies, options, fontText) {
+async function bundledFamilyFaceRules(canonical, normalizedFamily, emitFamily, optional, options, fontText) {
+  const rules = [];
+  const coveredWeights = /* @__PURE__ */ new Set();
+  const bundledRules = [];
+  for (const face of canonical.faces) {
+    const style = face.style || "normal";
+    const src = fontDataUri(canonical.packageName, face.weight, style);
+    bundledRules.push(
+      buildFontFaceRule(emitFamily, src, face.weight, style, BUNDLED_SUBSET_UNICODE_RANGE)
+    );
+    coveredWeights.add(coverageKey(face.weight, style));
+  }
+  const canonicalFamily = resolveAliasDisplayName(normalizedFamily);
+  const googleFaces = canonicalFamily ? await fetchFamilyFaces(canonicalFamily, optional, options, fontText) : [];
+  const supplementary = googleFaces.filter(
+    (face) => !coveredWeights.has(coverageKey(face.weight, face.style)) || !isBundledSubsetRange(face.unicodeRange)
+  );
+  const runs = groupFacesBySource(supplementary).flatMap(
+    (group) => partitionWeightRuns(group, coveredWeights)
+  );
+  const firstAppearance = (run) => Math.min(...run.map((face) => supplementary.indexOf(face)));
+  for (const run of [...runs].sort((a, b) => firstAppearance(a) - firstAppearance(b))) {
+    const first = run[0];
+    const last = run[run.length - 1];
+    if (!first || !last) continue;
+    const weight = run.length > 1 ? `${first.weight} ${last.weight}` : first.weight;
+    rules.push(
+      buildFontFaceRule(emitFamily, first.dataUri, weight, first.style, first.unicodeRange)
+    );
+  }
+  rules.push(...bundledRules);
+  return rules;
+}
+async function googleFamilyFaceRules(lookupFamily, emitFamily, optional, options, fontText) {
+  const googleFaces = await fetchFamilyFaces(lookupFamily, optional, options, fontText);
+  if (googleFaces.length === 0) return null;
+  return googleFaces.map(
+    (face) => buildFontFaceRule(emitFamily, face.dataUri, face.weight, face.style, face.unicodeRange)
+  );
+}
+async function systemFamilyFaceRules(lookupFamily, emitFamily) {
+  const variants = locateSystemFontVariants(lookupFamily);
+  if (variants.length === 0) return null;
+  const rules = [];
+  let totalBytes = 0;
+  for (const variant of variants) {
+    const fontBuffer = readFileSync12(variant.path);
+    totalBytes += fontBuffer.length;
+    const dataUri = await fontToDataUri(fontBuffer, variant.format);
+    rules.push(buildFontFaceRule(emitFamily, dataUri, variant.weight, variant.style));
+  }
+  if (totalBytes > SYSTEM_FONT_SIZE_LIMIT) {
+    defaultLogger.warn(
+      `[Compiler] System font "${lookupFamily}" is large (${(totalBytes / 1024 / 1024).toFixed(1)} MB total across ${variants.length} variant(s)) \u2014 embedding anyway. Consider font subsetting for production.`
+    );
+  }
+  defaultLogger.info(
+    `[Compiler] Embedded system font "${lookupFamily}" \u2014 ${variants.length} variant(s), ${(totalBytes / 1024).toFixed(0)} KB total`
+  );
+  return rules;
+}
+async function resolveFamilyFaceRules(normalizedFamily, lookupFamily, emitFamily, optional, options, fontText) {
+  const canonicalKey = FONT_ALIASES[normalizedFamily];
+  if (canonicalKey) {
+    const canonical = CANONICAL_FONTS[canonicalKey];
+    if (!canonical) return [];
+    return bundledFamilyFaceRules(
+      canonical,
+      normalizedFamily,
+      emitFamily,
+      optional,
+      options,
+      fontText
+    );
+  }
+  return await googleFamilyFaceRules(lookupFamily, emitFamily, optional, options, fontText) ?? (options.allowSystemFontCapture && !pageNamedThisFile(lookupFamily, options) ? await systemFamilyFaceRules(lookupFamily, emitFamily) : null);
+}
+function googleFontsUrlFamilies(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl.trim(), "https://document.invalid/");
+  } catch {
+    return [];
+  }
+  if (url.hostname !== "fonts.googleapis.com") return [];
+  if (url.pathname !== "/css" && url.pathname !== "/css2") return [];
+  return url.searchParams.getAll("family").flatMap((value) => value.split("|")).map((entry) => (entry.split(":", 1)[0] ?? "").trim()).filter((family) => family.length > 0);
+}
+function importRuleUrl(params) {
+  const trimmed = params.trim();
+  if (trimmed.toLowerCase().startsWith("url(")) {
+    const close = trimmed.indexOf(")");
+    if (close < 0 || !isUnconditionalMedia(trimmed.slice(close + 1))) return null;
+    return trimmed.slice(4, close).trim().replace(/^['"]/, "").replace(/['"]$/, "");
+  }
+  const quote = trimmed[0];
+  if (quote !== '"' && quote !== "'") return null;
+  const end = trimmed.indexOf(quote, 1);
+  return end > 0 && isUnconditionalMedia(trimmed.slice(end + 1)) ? trimmed.slice(1, end) : null;
+}
+function fontFaceRuleFamily(rule) {
+  let family;
+  rule.walkDecls((decl) => {
+    if (decl.prop.toLowerCase() === "font-family") family = parseFontFamilyValue(decl.value)[0];
+  });
+  return family;
+}
+function isUnconditionalMedia(media) {
+  const normalized2 = (media ?? "").trim().toLowerCase();
+  return normalized2 === "" || normalized2 === "all";
+}
+function isUnconditionalStylesheet(element) {
+  const type = (element.getAttribute("type") ?? "").trim().toLowerCase();
+  return isUnconditionalMedia(element.getAttribute("media")) && (type === "" || type === "text/css") && !(element.getAttribute("title") ?? "").trim() && !element.hasAttribute("disabled");
+}
+function declareStyleFontFamilies(styleEl, register) {
+  if (!isUnconditionalStylesheet(styleEl)) return;
+  const root = parseCssRoot(styleEl.textContent ?? "");
+  if (!root) return;
+  root.walkAtRules((atRule) => {
+    if (atRule.parent?.type !== "root") return;
+    const name = atRule.name.toLowerCase();
+    if (name === "import") {
+      const url = importRuleUrl(atRule.params);
+      if (url) for (const family2 of googleFontsUrlFamilies(url)) register(family2);
+      return;
+    }
+    if (name !== "font-face") return;
+    const family = fontFaceRuleFamily(atRule);
+    if (family) register(family, atRule);
+  });
+}
+function declareLinkedFontFamilies(link, register) {
+  const rel = (link.getAttribute("rel") ?? "").toLowerCase().split(/\s+/);
+  if (!rel.includes("stylesheet") || rel.includes("alternate") || !isUnconditionalStylesheet(link))
+    return;
+  for (const family of googleFontsUrlFamilies(link.getAttribute("href") ?? "")) register(family);
+}
+function collectDeclaredFontFamilies(html) {
+  const { document: document2 } = parseHTML(html);
+  const declared = /* @__PURE__ */ new Map();
+  const register = (family, fontFaceRule) => {
+    const key2 = normalizeFamilyName(family);
+    if (!key2 || GENERIC_FAMILIES2.has(key2)) return;
+    let entry = declared.get(key2);
+    if (!entry) {
+      entry = { family, fontFaceRules: [] };
+      declared.set(key2, entry);
+    }
+    if (fontFaceRule) entry.fontFaceRules.push(fontFaceRule);
+  };
+  for (const styleEl of Array.from(document2.querySelectorAll("style"))) {
+    declareStyleFontFamilies(styleEl, register);
+  }
+  for (const link of Array.from(document2.querySelectorAll("link[href]"))) {
+    declareLinkedFontFamilies(link, register);
+  }
+  return declared;
+}
+function familySpellingKey(family) {
+  return family.toLowerCase().replace(/[\s_+-]+/g, "");
+}
+function findDeclaredFamilyAlias(authoredFamily, declaredFamilies) {
+  if (declaredFamilies.has(normalizeFamilyName(authoredFamily))) return null;
+  const key2 = familySpellingKey(authoredFamily);
+  if (!key2) return null;
+  let match = null;
+  for (const entry of declaredFamilies.values()) {
+    if (familySpellingKey(entry.family) !== key2) continue;
+    if (match) return null;
+    match = entry;
+  }
+  return match;
+}
+async function resolveDeclaredFamilyAlias(authoredFamily, declaredFamilies, optional, options, fontText) {
+  const declared = findDeclaredFamilyAlias(authoredFamily, declaredFamilies);
+  if (!declared) return null;
+  let rules;
+  if (declared.fontFaceRules.length > 0) {
+    rules = declared.fontFaceRules.map((rule) => {
+      const renamed = rule.clone();
+      renamed.walkDecls((decl) => {
+        if (decl.prop.toLowerCase() === "font-family") decl.value = `"${authoredFamily}"`;
+      });
+      return renamed.toString();
+    });
+  } else {
+    rules = await resolveFamilyFaceRules(
+      normalizeFamilyName(declared.family),
+      declared.family,
+      authoredFamily,
+      optional,
+      options,
+      fontText
+    );
+  }
+  if (!rules) return null;
+  defaultLogger.warn(
+    `[Compiler] font-family "${authoredFamily}" is not a known family; resolved it to "${declared.family}", which this document declares. Correct the authored font-family to "${declared.family}".`
+  );
+  return rules;
+}
+async function buildFontFaceCss(requestedFamilies, options, declaredFamilies, fontText) {
   const rules = [];
   const unresolved = [];
   const requiredFirst = [...requestedFamilies].sort(
     ([, a], [, b]) => Number(a.optional) - Number(b.optional)
   );
   for (const [normalizedFamily, { family: originalCaseFamily, optional }] of requiredFirst) {
-    const canonicalKey = FONT_ALIASES[normalizedFamily];
-    if (canonicalKey) {
-      const canonical = CANONICAL_FONTS[canonicalKey];
-      if (!canonical) continue;
-      const coveredWeights = /* @__PURE__ */ new Set();
-      const bundledRules = [];
-      for (const face of canonical.faces) {
-        const style = face.style || "normal";
-        const src = fontDataUri(canonical.packageName, face.weight, style);
-        bundledRules.push(
-          buildFontFaceRule(
-            originalCaseFamily,
-            src,
-            face.weight,
-            style,
-            BUNDLED_SUBSET_UNICODE_RANGE
-          )
-        );
-        coveredWeights.add(coverageKey(face.weight, style));
-      }
-      const canonicalFamily = resolveAliasDisplayName(normalizedFamily);
-      const googleFaces2 = canonicalFamily ? await fetchFamilyFaces(canonicalFamily, optional, options, fontText) : [];
-      const supplementary = googleFaces2.filter(
-        (face) => !coveredWeights.has(coverageKey(face.weight, face.style)) || !isBundledSubsetRange(face.unicodeRange)
-      );
-      const runs = groupFacesBySource(supplementary).flatMap(
-        (group) => partitionWeightRuns(group, coveredWeights)
-      );
-      const firstAppearance = (run) => Math.min(...run.map((face) => supplementary.indexOf(face)));
-      for (const run of [...runs].sort((a, b) => firstAppearance(a) - firstAppearance(b))) {
-        const first = run[0];
-        const last = run[run.length - 1];
-        if (!first || !last) continue;
-        const weight = run.length > 1 ? `${first.weight} ${last.weight}` : first.weight;
-        rules.push(
-          buildFontFaceRule(
-            originalCaseFamily,
-            first.dataUri,
-            weight,
-            first.style,
-            first.unicodeRange
-          )
-        );
-      }
-      rules.push(...bundledRules);
-      continue;
-    }
-    const googleFaces = await fetchFamilyFaces(originalCaseFamily, optional, options, fontText);
-    if (googleFaces.length > 0) {
-      for (const face of googleFaces) {
-        rules.push(
-          buildFontFaceRule(
-            originalCaseFamily,
-            face.dataUri,
-            face.weight,
-            face.style,
-            face.unicodeRange
-          )
-        );
-      }
+    const familyRules = await resolveFamilyFaceRules(
+      normalizedFamily,
+      originalCaseFamily,
+      originalCaseFamily,
+      optional,
+      options,
+      fontText
+    ) ?? // Last, so a family that already resolves keeps exactly the faces it had.
+    await resolveDeclaredFamilyAlias(
+      originalCaseFamily,
+      declaredFamilies(),
+      optional,
+      options,
+      fontText
+    );
+    if (familyRules) {
+      rules.push(...familyRules);
       continue;
     }
-    if (options.allowSystemFontCapture && !pageNamedThisFile(originalCaseFamily, options)) {
-      const variants = locateSystemFontVariants(originalCaseFamily);
-      if (variants.length > 0) {
-        let totalBytes = 0;
-        for (const variant of variants) {
-          const fontBuffer = readFileSync12(variant.path);
-          totalBytes += fontBuffer.length;
-          const dataUri = await fontToDataUri(fontBuffer, variant.format);
-          rules.push(buildFontFaceRule(originalCaseFamily, dataUri, variant.weight, variant.style));
-        }
-        if (totalBytes > SYSTEM_FONT_SIZE_LIMIT) {
-          defaultLogger.warn(
-            `[Compiler] System font "${originalCaseFamily}" is large (${(totalBytes / 1024 / 1024).toFixed(1)} MB total across ${variants.length} variant(s)) \u2014 embedding anyway. Consider font subsetting for production.`
-          );
-        }
-        defaultLogger.info(
-          `[Compiler] Embedded system font "${originalCaseFamily}" \u2014 ${variants.length} variant(s), ${(totalBytes / 1024).toFixed(0)} KB total`
-        );
-        continue;
-      }
-    }
     unresolved.push(originalCaseFamily);
   }
   return {
@@ -95142,13 +95280,16 @@ var FontFetchError = class extends Error {
   familyName;
   url;
   cause;
-  constructor(familyName, url, message, cause, code = FONT_FETCH_FAILED) {
+  /** Unlike `message`, holds no URLs: safe for callers that must not echo resolver output. */
+  unresolvedFamilies;
+  constructor(familyName, url, message, cause, code = FONT_FETCH_FAILED, unresolvedFamilies = []) {
     super(message);
     this.name = "FontFetchError";
     this.code = code;
     this.familyName = familyName;
     this.url = url;
     this.cause = cause;
+    this.unresolvedFamilies = unresolvedFamilies;
   }
 };
 var FontFetchUnavailableError = class extends FontFetchError {
@@ -95571,9 +95712,11 @@ async function injectDeterministicFontFaces(html, options = {}) {
   if (pendingFamilies.size === 0) {
     return html;
   }
+  let declaredFamilies;
   const { css, unresolved } = await buildFontFaceCss(
     pendingFamilies,
     fetchOptions,
+    () => declaredFamilies ??= collectDeclaredFontFamilies(html),
     extractGoogleFontsText(html)
   );
   const required = unresolved.filter(
@@ -95583,7 +95726,10 @@ async function injectDeterministicFontFaces(html, options = {}) {
     throw new FontFetchError(
       required.join(", "),
       "",
-      `[Compiler] Unresolved fonts in fail-closed mode: ${required.join(", ")}. Distributed renders require all fonts to be resolvable.`
+      `[Compiler] Unresolved fonts in fail-closed mode: ${required.join(", ")}. Distributed renders require all fonts to be resolvable.`,
+      void 0,
+      FONT_FETCH_FAILED,
+      unresolved
     );
   }
   if (!css) {
@@ -105085,6 +105231,29 @@ function safeErrorName(error) {
   const name = error instanceof Error ? error.name : "UnknownError";
   return /^[A-Za-z][A-Za-z0-9]*$/.test(name) ? name : "Error";
 }
+var MAX_REPORTED_FAMILIES = 8;
+var MAX_FAMILY_NAME_LENGTH = 64;
+function unresolvedFamilyList(error) {
+  if (!(error instanceof Error) || !("unresolvedFamilies" in error)) return [];
+  const families = error.unresolvedFamilies;
+  return Array.isArray(families) ? families : [];
+}
+function safeFamilyName(family) {
+  if (typeof family !== "string" || /[:/?#&=%@\\]/.test(family)) return null;
+  const safe = family.replace(/[^A-Za-z0-9 _-]+/g, " ").replace(/\s+/g, " ").trim().slice(0, MAX_FAMILY_NAME_LENGTH).trim();
+  return safe || null;
+}
+function unresolvedFamiliesSuffix(error) {
+  const families = unresolvedFamilyList(error);
+  if (families.length === 0) return "";
+  const printable = families.map(safeFamilyName).filter((name) => name !== null);
+  const distinct = [...new Set(printable)];
+  const shown = distinct.slice(0, MAX_REPORTED_FAMILIES);
+  const hidden = families.length - printable.length + (distinct.length - shown.length);
+  const listed = shown.map((name) => `"${name}"`).join(", ");
+  const more = hidden > 0 ? `${listed ? " " : ""}(+${hidden} more)` : "";
+  return `: unresolved font families: ${listed}${more}`;
+}
 async function runFontLocalize(io, localize) {
   const html = await io.readInput();
   if (!html.trim()) {
@@ -105100,15 +105269,17 @@ async function runFontLocalize(io, localize) {
     io.writeOutput(localized);
     return 0;
   } catch (error) {
-    io.writeError(`font localization failed (${safeErrorName(error)})
-`);
+    io.writeError(
+      `font localization failed (${safeErrorName(error)})${unresolvedFamiliesSuffix(error)}
+`
+    );
     return 1;
   }
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.84" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.84" : "0.0.0-dev";
+var VERSION = true ? "0.8.86" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.86" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {