@hyperframes/core 0.9.12 → 0.9.14

package/dist/fonts/deterministicFonts.d.ts

@@ -142,6 +142,7 @@ export interface InjectDeterministicFontFacesOptions {
      * planning; tests may lower delays and timeouts without replacing timers.
      */
     fontFetchRetryPolicy?: Partial<FontFetchRetryPolicy>;
+    projectFontFamilies?: readonly string[];
     /**
      * When `true` (default for local renders), fonts that aren't resolved by
      * the bundled alias map or Google Fonts are located on the local filesystem,
@@ -150,5 +151,6 @@ export interface InjectDeterministicFontFacesOptions {
      * to contain the same fonts as the authoring machine.
      */
     allowSystemFontCapture?: boolean;
+    systemFontsByInnerName?: boolean;
 }
 export declare function injectDeterministicFontFaces(html: string, options?: InjectDeterministicFontFacesOptions): Promise<string>;

package/dist/fonts/deterministicFonts.js

@@ -2,7 +2,9 @@ import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { fontShorthandFamilies } from "@hyperframes/parsers/composition";
 import { FONT_ALIAS_MAP, resolveAliasDisplayName } from "./aliases.js";
+import { extractSfntFace } from "./sfntNames.js";
 import { locateSystemFontVariants, SYSTEM_FONT_SIZE_LIMIT } from "./systemFontLocator.js";
 import { parseHTML } from "linkedom";
 import postcss from "postcss";
@@ -214,30 +216,6 @@ function collectCssCustomProperties(css, customProperties) {
         customProperties.set(decl.prop, decl.value);
     });
 }
-const FONT_SIZE_KEYWORD = /^(?:xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large|smaller|larger)$/i;
-const FONT_SIZE_TOKEN = /^(?:\d*\.?\d+[a-z%]+|(?:calc|min|max|clamp|var)\(.*\))(?:\/\S+)?$/i;
-function maskParens(value) {
-    let depth = 0;
-    return value.replace(/[\s\S]/g, (char) => {
-        if (char === "(")
-            depth += 1;
-        const inside = depth > 0;
-        if (char === ")")
-            depth -= 1;
-        return inside ? "_" : char;
-    });
-}
-function fontShorthandFamilies(value) {
-    for (const { 0: masked, index } of maskParens(value).matchAll(/\S+/g)) {
-        const end = index + masked.length;
-        const token = value.slice(index, end);
-        const size = token.split("/")[0] ?? "";
-        if (FONT_SIZE_KEYWORD.test(size) || FONT_SIZE_TOKEN.test(token)) {
-            return value.slice(end).trim();
-        }
-    }
-    return "";
-}
 function* iterateCssRootFontFamilyDeclarations(root) {
     const declarations = [];
     root.walkDecls((decl) => {
@@ -656,16 +634,17 @@ async function googleFamilyFaceRules(lookupFamily, emitFamily, optional, options
     return googleFaces.map((face) => buildFontFaceRule(emitFamily, face.dataUri, face.weight, face.style, face.unicodeRange));
 }
 // Path 3: locate font on the local filesystem, compress, and embed.
-async function systemFamilyFaceRules(lookupFamily, emitFamily, log) {
-    const variants = locateSystemFontVariants(lookupFamily);
+async function systemFamilyFaceRules(lookupFamily, emitFamily, log, byInnerName) {
+    const variants = locateSystemFontVariants(lookupFamily, { byInnerName });
     if (variants.length === 0)
         return null;
     const rules = [];
     let totalBytes = 0;
     for (const variant of variants) {
-        const fontBuffer = readFileSync(variant.path);
+        const single = variant.face === undefined ? null : extractSfntFace(variant.path, variant.face);
+        const fontBuffer = single?.bytes ?? readFileSync(variant.path);
         totalBytes += fontBuffer.length;
-        const dataUri = await fontToDataUri(fontBuffer, variant.format);
+        const dataUri = await fontToDataUri(fontBuffer, single?.format ?? variant.format);
         rules.push(buildFontFaceRule(emitFamily, dataUri, variant.weight, variant.style));
     }
     if (totalBytes > SYSTEM_FONT_SIZE_LIMIT) {
@@ -685,7 +664,7 @@ async function resolveFamilyFaceRules(normalizedFamily, lookupFamily, emitFamily
     }
     return ((await googleFamilyFaceRules(lookupFamily, emitFamily, optional, options, fontText)) ??
         (options.allowSystemFontCapture && !pageNamedThisFile(lookupFamily, options)
-            ? await systemFamilyFaceRules(lookupFamily, emitFamily, options.log)
+            ? await systemFamilyFaceRules(lookupFamily, emitFamily, options.log, options.systemFontsByInnerName)
             : null));
 }
 // css2 repeats `family=Name:axes`; the legacy css API packs `family=Name:400|Other`.
@@ -817,6 +796,14 @@ function findDeclaredFamilyAlias(authoredFamily, declaredFamilies) {
     }
     return match;
 }
+// Design exports name a family by class, `font-<Family>-<weight>`; serve all <Family> faces under that name.
+const WEIGHTED_CLASS_FAMILY = /^font-(.+)-[1-9]00$/i;
+async function resolveWeightedClassFamily(authoredFamily, optional, options, fontText) {
+    const family = WEIGHTED_CLASS_FAMILY.exec(authoredFamily)?.[1];
+    if (!family)
+        return null;
+    return resolveFamilyFaceRules(normalizeFamilyName(family), family, authoredFamily, optional, options, fontText);
+}
 // Emits under the authored name instead of rewriting usages, as FONT_ALIASES does,
 // so script-assigned and var()-indirected usages match too.
 async function resolveDeclaredFamilyAlias(authoredFamily, declaredFamilies, optional, options, fontText) {
@@ -853,7 +840,8 @@ async function buildFontFaceCss(requestedFamilies, options, declaredFamilies, fo
         options.diag.beginFamily(!optional);
         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));
+            (await resolveDeclaredFamilyAlias(originalCaseFamily, declaredFamilies(), optional, options, fontText)) ??
+            (await resolveWeightedClassFamily(originalCaseFamily, optional, options, fontText));
         options.diag.endFamily(Boolean(familyRules));
         if (familyRules) {
             rules.push(...familyRules);
@@ -1534,6 +1522,7 @@ export async function injectDeterministicFontFaces(html, options = {}) {
         failClosedFontFetch,
         fetchImpl,
         allowSystemFontCapture,
+        systemFontsByInnerName: options.systemFontsByInnerName === true,
         abortSignal: options.abortSignal,
         retryPolicy,
         retryDeadlineMs: Date.now() + retryPolicy.maxElapsedMs,
@@ -1541,6 +1530,8 @@ export async function injectDeterministicFontFaces(html, options = {}) {
         diag,
     };
     const existingFaces = extractExistingFontFaces(html);
+    for (const family of options.projectFontFamilies ?? [])
+        existingFaces.add(normalizeFamilyName(family));
     const requestedFamilies = extractRequestedFontFamilies(html);
     const pendingFamilies = new Map();
     for (const [normalizedFamily, requested] of requestedFamilies) {

package/dist/fonts/sfntFixture.d.ts

@@ -0,0 +1,14 @@
+/** Points the locator's per-user font folder, on every platform, at an empty folder and returns it. */
+export declare function fixtureFontDir(): string;
+interface FaceSpec {
+    families: string[];
+    weight?: number;
+    italic?: boolean;
+    flavor?: "ttf" | "otf";
+}
+export declare function makeSfnt(spec: FaceSpec): Buffer;
+export declare function makeTtc(specs: FaceSpec[]): {
+    file: Buffer;
+    offsets: number[];
+};
+export {};

package/dist/fonts/sfntFixture.js

@@ -0,0 +1,103 @@
+// Builds small font files in memory so tests need no binary fixtures.
+import { mkdirSync, mkdtempSync } from "node:fs";
+import { afterAll } from "vitest";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** Points the locator's per-user font folder, on every platform, at an empty folder and returns it. */
+export function fixtureFontDir() {
+    const home = mkdtempSync(join(tmpdir(), "hf-home-"));
+    const set = {
+        HOME: home,
+        USERPROFILE: home,
+        WINDIR: join(home, "Win"),
+        LOCALAPPDATA: join(home, "Local"),
+    };
+    const before = Object.fromEntries(Object.keys(set).map((k) => [k, process.env[k]]));
+    Object.assign(process.env, set);
+    afterAll(() => {
+        for (const [k, v] of Object.entries(before)) {
+            if (v === undefined)
+                delete process.env[k];
+            else
+                process.env[k] = v;
+        }
+    });
+    const dir = process.platform === "win32"
+        ? join(home, "Local", "Microsoft", "Windows", "Fonts")
+        : process.platform === "darwin"
+            ? join(home, "Library", "Fonts")
+            : join(home, ".fonts");
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function nameTable(families) {
+    const strings = families.map((f) => Buffer.from(f, "utf16le").swap16());
+    const header = Buffer.alloc(6 + families.length * 12);
+    header.writeUInt16BE(0, 0);
+    header.writeUInt16BE(families.length, 2);
+    header.writeUInt16BE(header.length, 4);
+    let at = 0;
+    strings.forEach((s, i) => {
+        const r = 6 + i * 12;
+        header.writeUInt16BE(3, r);
+        header.writeUInt16BE(1, r + 2);
+        header.writeUInt16BE(0x409, r + 4);
+        header.writeUInt16BE(i === 0 ? 1 : 16, r + 6);
+        header.writeUInt16BE(s.length, r + 8);
+        header.writeUInt16BE(at, r + 10);
+        at += s.length;
+    });
+    return Buffer.concat([header, ...strings]);
+}
+function os2Table(weight, italic) {
+    const t = Buffer.alloc(78);
+    t.writeUInt16BE(weight, 4);
+    t.writeUInt16BE(italic ? 1 : 0, 62);
+    return t;
+}
+/** One face: its tables laid out from `base`, so a collection can place it anywhere in the file. */
+function face(spec, base) {
+    const tables = [
+        ["OS/2", os2Table(spec.weight ?? 400, spec.italic ?? false)],
+        ["glyf", Buffer.from("glyph-data-" + spec.families[0])],
+        ["name", nameTable(spec.families)],
+    ];
+    const head = Buffer.alloc(12 + tables.length * 16);
+    head.write(spec.flavor === "otf" ? "OTTO" : "\0\x01\0\0", 0, "latin1");
+    head.writeUInt16BE(tables.length, 4);
+    let at = base + head.length;
+    const body = [];
+    tables.forEach(([tag, data], i) => {
+        const r = 12 + i * 16;
+        head.write(tag, r, "latin1");
+        head.writeUInt32BE(0, r + 4);
+        head.writeUInt32BE(at, r + 8);
+        head.writeUInt32BE(data.length, r + 12);
+        const padded = Buffer.alloc((data.length + 3) & ~3);
+        data.copy(padded);
+        body.push(padded);
+        at += padded.length;
+    });
+    return { head, body: Buffer.concat(body) };
+}
+export function makeSfnt(spec) {
+    const { head, body } = face(spec, 0);
+    return Buffer.concat([head, body]);
+}
+export function makeTtc(specs) {
+    let at = 12 + specs.length * 4;
+    const offsets = [];
+    const parts = [];
+    for (const spec of specs) {
+        const { head, body } = face(spec, at);
+        offsets.push(at);
+        parts.push(head, body);
+        at += head.length + body.length;
+    }
+    const header = Buffer.alloc(12 + specs.length * 4);
+    header.write("ttcf", 0, "latin1");
+    header.writeUInt32BE(0x00010000, 4);
+    header.writeUInt32BE(specs.length, 8);
+    offsets.forEach((o, i) => header.writeUInt32BE(o, 12 + i * 4));
+    return { file: Buffer.concat([header, ...parts]), offsets };
+}

package/dist/fonts/sfntNames.d.ts

@@ -0,0 +1,14 @@
+/** One face of a font file: where it starts and the family names written inside it. */
+export interface SfntFace {
+    offset: number;
+    families: string[];
+    weight: string;
+    style: "normal" | "italic";
+}
+/** Every face of a font file, with the family names inside it; a collection (.ttc) yields one per member. */
+export declare function readSfntFaces(path: string): SfntFace[];
+/** One face of a font file as a standalone font, which a browser can load; a collection cannot be loaded whole. */
+export declare function extractSfntFace(path: string, faceOffset: number): {
+    bytes: Buffer;
+    format: "ttf" | "otf";
+};

package/dist/fonts/sfntNames.js

@@ -0,0 +1,115 @@
+import { closeSync, openSync, readFileSync, readSync } from "node:fs";
+const NAME_FAMILY_IDS = new Set([1, 16, 21]);
+const MAX_FACES = 64;
+function readAt(fd, position, length) {
+    const buf = Buffer.alloc(length);
+    const read = readSync(fd, buf, 0, length, position);
+    return read === length ? buf : buf.subarray(0, read);
+}
+function tableDirectory(fd, faceOffset) {
+    const header = readAt(fd, faceOffset, 12);
+    const count = header.length === 12 ? header.readUInt16BE(4) : 0;
+    const dir = readAt(fd, faceOffset + 12, count * 16);
+    const tables = new Map();
+    for (let i = 0; i + 16 <= dir.length; i += 16) {
+        tables.set(dir.toString("latin1", i, i + 4), {
+            offset: dir.readUInt32BE(i + 8),
+            length: dir.readUInt32BE(i + 12),
+        });
+    }
+    return tables;
+}
+function familiesIn(name) {
+    if (name.length < 6)
+        return [];
+    const count = name.readUInt16BE(2);
+    const strings = name.readUInt16BE(4);
+    const found = new Set();
+    for (let i = 0; i < count && 6 + i * 12 + 12 <= name.length; i++) {
+        const at = 6 + i * 12;
+        const platform = name.readUInt16BE(at);
+        const nameId = name.readUInt16BE(at + 6);
+        if (!NAME_FAMILY_IDS.has(nameId))
+            continue;
+        const length = name.readUInt16BE(at + 8);
+        const raw = name.subarray(strings + name.readUInt16BE(at + 10), strings + name.readUInt16BE(at + 10) + length);
+        // Windows (3) and Unicode (0) names are UTF-16BE; Macintosh (1) names are single-byte.
+        const text = platform === 1 ? raw.toString("latin1") : Buffer.from(raw).swap16().toString("utf16le");
+        if (text.trim())
+            found.add(text.trim());
+    }
+    return [...found];
+}
+function readFace(fd, offset) {
+    const tables = tableDirectory(fd, offset);
+    const nameTable = tables.get("name");
+    if (!nameTable)
+        return null;
+    const families = familiesIn(readAt(fd, nameTable.offset, Math.min(nameTable.length, 1 << 20)));
+    const os2Table = tables.get("OS/2");
+    const os2 = os2Table
+        ? readAt(fd, os2Table.offset, Math.min(os2Table.length, 64))
+        : Buffer.alloc(0);
+    const weightClass = os2.length >= 6 ? os2.readUInt16BE(4) : 400;
+    const italic = os2.length >= 64 && (os2.readUInt16BE(62) & 1) === 1;
+    return {
+        offset,
+        families,
+        weight: String(weightClass >= 100 && weightClass <= 900 ? weightClass : 400),
+        style: italic ? "italic" : "normal",
+    };
+}
+/** Every face of a font file, with the family names inside it; a collection (.ttc) yields one per member. */
+export function readSfntFaces(path) {
+    let fd;
+    try {
+        fd = openSync(path, "r");
+        const head = readAt(fd, 0, 12);
+        if (head.length < 12)
+            return [];
+        const collection = head.toString("latin1", 0, 4) === "ttcf";
+        const table = collection ? readAt(fd, 12, Math.min(head.readUInt32BE(8), MAX_FACES) * 4) : head;
+        const offsets = collection
+            ? Array.from({ length: Math.floor(table.length / 4) }, (_, i) => table.readUInt32BE(i * 4))
+            : [0];
+        return offsets.map((offset) => readFace(fd, offset)).filter((f) => f !== null);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+/** One face of a font file as a standalone font, which a browser can load; a collection cannot be loaded whole. */
+export function extractSfntFace(path, faceOffset) {
+    const file = readFileSync(path);
+    const count = file.readUInt16BE(faceOffset + 4);
+    const records = Array.from({ length: count }, (_, i) => {
+        const at = faceOffset + 12 + i * 16;
+        return {
+            tag: file.subarray(at, at + 4),
+            checksum: file.readUInt32BE(at + 4),
+            data: file.subarray(file.readUInt32BE(at + 8), file.readUInt32BE(at + 8) + file.readUInt32BE(at + 12)),
+        };
+    });
+    const dirEnd = 12 + count * 16;
+    const parts = [Buffer.alloc(dirEnd)];
+    let next = dirEnd;
+    const out = parts[0];
+    file.copy(out, 0, faceOffset, faceOffset + 12);
+    records.forEach((record, i) => {
+        const at = 12 + i * 16;
+        record.tag.copy(out, at);
+        out.writeUInt32BE(record.checksum, at + 4);
+        out.writeUInt32BE(next, at + 8);
+        out.writeUInt32BE(record.data.length, at + 12);
+        const padded = Buffer.alloc((record.data.length + 3) & ~3);
+        record.data.copy(padded);
+        parts.push(padded);
+        next += padded.length;
+    });
+    const bytes = Buffer.concat(parts);
+    return { bytes, format: bytes.toString("latin1", 0, 4) === "OTTO" ? "otf" : "ttf" };
+}

package/dist/fonts/systemFontLocator.d.ts

@@ -17,11 +17,14 @@ export interface FontFileEntry {
  * path, filename, and derived family name. Shared by the font listing route
  * and the per-family locator to avoid duplicating the directory scan loop.
  */
-export declare function collectFontFileEntries(dir: string, depth?: number): FontFileEntry[];
+export declare function collectFontFileEntries(dir: string, depth?: number, maxDepth?: number): FontFileEntry[];
 export declare function locateSystemFont(family: string): LocatedFont | null;
 export interface LocatedFontVariant extends LocatedFont {
     weight: string;
     style: "normal" | "italic";
+    face?: number;
 }
-export declare function locateSystemFontVariants(family: string): LocatedFontVariant[];
+export declare function locateSystemFontVariants(family: string, options?: {
+    byInnerName?: boolean;
+}): LocatedFontVariant[];
 export declare function clearSystemFontCache(): void;

package/dist/fonts/systemFontLocator.js

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import { existsSync, lstatSync, readdirSync, realpathSync } from "node:fs";
 import { homedir, platform } from "node:os";
 import { join, resolve } from "node:path";
+import { readSfntFaces } from "./sfntNames.js";
 export const SYSTEM_FONT_SIZE_LIMIT = 5 * 1024 * 1024;
 const FC_MATCH_TIMEOUT_MS = 3000;
 export const FONT_EXT_RE = /\.(otf|ttf|ttc|woff2?)$/i;
@@ -124,6 +125,7 @@ export function fontDirectories() {
             "/Library/Fonts",
             "/System/Library/Fonts",
             "/System/Library/Fonts/Supplemental",
+            "/System/Library/AssetsV2",
         ];
     }
     if (platform() === "win32") {
@@ -144,15 +146,15 @@ export function fontDirectories() {
  * path, filename, and derived family name. Shared by the font listing route
  * and the per-family locator to avoid duplicating the directory scan loop.
  */
-export function collectFontFileEntries(dir, depth = 0) {
-    if (!existsSync(dir) || depth > 2)
+export function collectFontFileEntries(dir, depth = 0, maxDepth = 2) {
+    if (!existsSync(dir) || depth > maxDepth)
         return [];
     const entries = [];
     try {
         for (const entry of readdirSync(dir, { withFileTypes: true })) {
             const fullPath = join(dir, entry.name);
             if (entry.isDirectory()) {
-                entries.push(...collectFontFileEntries(fullPath, depth + 1));
+                entries.push(...collectFontFileEntries(fullPath, depth + 1, maxDepth));
                 continue;
             }
             if (!FONT_EXT_RE.test(entry.name))
@@ -262,7 +264,7 @@ function inferWeightAndStyle(fileName) {
     }
     return { weight: "400", style };
 }
-export function locateSystemFontVariants(family) {
+export function locateSystemFontVariants(family, options = {}) {
     const normalized = normalizeName(family);
     if (!normalized)
         return [];
@@ -275,8 +277,47 @@ export function locateSystemFontVariants(family) {
         const { weight, style } = inferWeightAndStyle(c.path);
         variants.push({ path: c.path, format: c.format, weight, style });
     }
+    if (variants.length === 0 && options.byInnerName) {
+        return regularAndBold(dedupeVariants(variantsByInnerName(normalized)));
+    }
     return dedupeVariants(variants);
 }
+const INNER_NAME_MAX_DEPTH = 4;
+let innerNameIndex = null;
+function innerNameVariants(entry) {
+    const ext = entry.fileName.match(FONT_EXT_RE)?.[1]?.toLowerCase() ?? "";
+    if (ext !== "ttf" && ext !== "otf" && ext !== "ttc")
+        return [];
+    const collection = ext === "ttc";
+    return readSfntFaces(entry.path).flatMap((face) => face.families.map((family) => [
+        normalizeName(family),
+        {
+            path: entry.path,
+            format: collection ? "ttc" : extensionToFormat(ext),
+            weight: face.weight,
+            style: face.style,
+            ...(collection && { face: face.offset }),
+        },
+    ]));
+}
+function buildInnerNameIndex() {
+    const index = new Map();
+    const entries = fontDirectories().flatMap((dir) => collectFontFileEntries(dir, 0, INNER_NAME_MAX_DEPTH));
+    for (const [family, variant] of entries.flatMap(innerNameVariants)) {
+        index.set(family, [...(index.get(family) ?? []), variant]);
+    }
+    return index;
+}
+function regularAndBold(variants) {
+    const nearest = (target) => variants.reduce((best, v) => !best || Math.abs(Number(v.weight) - target) < Math.abs(Number(best.weight) - target)
+        ? v
+        : best, undefined);
+    return [...new Set([nearest(400), nearest(700)])].filter((v) => !!v);
+}
+function variantsByInnerName(normalized) {
+    innerNameIndex ??= buildInnerNameIndex();
+    return innerNameIndex.get(normalized) ?? [];
+}
 function dedupeVariants(variants) {
     const seen = new Map();
     for (const v of variants) {
@@ -288,5 +329,6 @@ function dedupeVariants(variants) {
 }
 export function clearSystemFontCache() {
     cache.clear();
+    innerNameIndex = null;
     allowedDirsCache = null;
 }