@turntrout/subfont 1.5.1 → 1.7.0

package/lib/concurrencyLimit.js

@@ -5,7 +5,9 @@ const WORKER_MEMORY_BYTES = 50 * 1024 * 1024; // 50 MB
 
 function getMaxConcurrency() {
   const byMemory = Math.floor(os.freemem() / WORKER_MEMORY_BYTES);
-  const byCpu = os.cpus().length * 4;
+  // Font tracing is CPU-bound (not I/O), so match the pool size to the
+  // core count directly — no multiplier.
+  const byCpu = os.cpus().length;
   return Math.max(1, Math.min(byMemory, byCpu));
 }
 

package/lib/escapeJsStringLiteral.js

@@ -0,0 +1,13 @@
+// Escape a value for safe inclusion in any JS string context (single-quoted,
+// double-quoted, or template literal). Uses JSON.stringify for robust escaping
+// of backslashes, quotes, newlines, U+2028, U+2029, etc.
+// The < escape prevents </script> from closing an inline script tag.
+function escapeJsStringLiteral(str) {
+  return JSON.stringify(str)
+    .slice(1, -1)
+    .replace(/'/g, "\\'")
+    .replace(/`/g, '\\x60')
+    .replace(/</g, '\\x3c');
+}
+
+module.exports = escapeJsStringLiteral;

package/lib/extractVisibleText.js

@@ -81,8 +81,12 @@ const namedEntities = {
 const entityRe = /&(?:#x([0-9a-fA-F]+)|#(\d+)|([a-zA-Z]+));/g;
 function decodeEntities(str) {
   return str.replace(entityRe, (match, hex, dec, name) => {
-    if (hex) return String.fromCodePoint(parseInt(hex, 16));
-    if (dec) return String.fromCodePoint(parseInt(dec, 10));
+    try {
+      if (hex) return String.fromCodePoint(parseInt(hex, 16));
+      if (dec) return String.fromCodePoint(parseInt(dec, 10));
+    } catch {
+      return match;
+    }
     if (name && namedEntities[name.toLowerCase()] !== undefined) {
       return namedEntities[name.toLowerCase()];
     }

package/lib/fontConverter.js

@@ -0,0 +1,25 @@
+const pathModule = require('path');
+const { Worker } = require('worker_threads');
+
+const workerPath = pathModule.join(__dirname, 'fontConverterWorker.js');
+
+function convert(buffer, targetFormat, sourceFormat) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(workerPath);
+    worker.on('message', (msg) => {
+      worker.terminate();
+      if (msg.type === 'result') {
+        resolve(Buffer.from(msg.buffer));
+      } else {
+        reject(new Error(msg.error));
+      }
+    });
+    worker.on('error', (err) => {
+      worker.terminate();
+      reject(err);
+    });
+    worker.postMessage({ buffer, targetFormat, sourceFormat });
+  });
+}
+
+module.exports = { convert };

package/lib/fontConverterWorker.js

@@ -0,0 +1,16 @@
+const { parentPort } = require('worker_threads');
+const fontverter = require('fontverter');
+
+parentPort.on('message', async (msg) => {
+  try {
+    const buffer = Buffer.from(msg.buffer);
+    const result = await fontverter.convert(
+      buffer,
+      msg.targetFormat,
+      msg.sourceFormat
+    );
+    parentPort.postMessage({ type: 'result', buffer: result });
+  } catch (err) {
+    parentPort.postMessage({ type: 'error', error: err.message });
+  }
+});

package/lib/fontFaceHelpers.js

@@ -75,15 +75,27 @@ function getFontFaceDeclarationText(node, relations) {
 
 const fontOrder = ['woff2', 'woff', 'truetype'];
 
-function getFontFaceForFontUsage(fontUsage) {
-  const subsets = fontOrder
-    .filter((format) => fontUsage.subsets[format])
+// Cache base64-encoded data URIs keyed by the underlying Buffer. Subset
+// buffers are shared across pages (propagated from the canonical fontUsage),
+// so without this every page re-encodes the same multi-hundred-KB buffer.
+const subsetDataUrlCache = new WeakMap();
+function getSubsetDataUrls(subsetsObj) {
+  let cached = subsetDataUrlCache.get(subsetsObj);
+  if (cached) return cached;
+  cached = fontOrder
+    .filter((format) => subsetsObj[format])
     .map((format) => ({
       format,
-      url: `data:${contentTypeByFontFormat[format]};base64,${fontUsage.subsets[
+      url: `data:${contentTypeByFontFormat[format]};base64,${subsetsObj[
         format
       ].toString('base64')}`,
     }));
+  subsetDataUrlCache.set(subsetsObj, cached);
+  return cached;
+}
+
+function getFontFaceForFontUsage(fontUsage) {
+  const subsets = getSubsetDataUrls(fontUsage.subsets);
 
   const resultString = ['@font-face {'];
 

package/lib/fontFeatureHelpers.js

@@ -0,0 +1,249 @@
+const cssFontParser = require('css-font-parser');
+
+const featureSettingsProps = new Set([
+  'font-feature-settings',
+  'font-variant-alternates',
+  'font-variant-caps',
+  'font-variant-east-asian',
+  'font-variant-ligatures',
+  'font-variant-numeric',
+  'font-variant-position',
+]);
+
+// Map font-variant-* CSS values to their corresponding OpenType feature tags.
+const fontVariantToOTTags = {
+  'font-variant-ligatures': {
+    'common-ligatures': ['liga', 'clig'],
+    'no-common-ligatures': ['liga', 'clig'],
+    'discretionary-ligatures': ['dlig'],
+    'no-discretionary-ligatures': ['dlig'],
+    'historical-ligatures': ['hlig'],
+    'no-historical-ligatures': ['hlig'],
+    contextual: ['calt'],
+    'no-contextual': ['calt'],
+  },
+  'font-variant-caps': {
+    'small-caps': ['smcp'],
+    'all-small-caps': ['smcp', 'c2sc'],
+    'petite-caps': ['pcap'],
+    'all-petite-caps': ['pcap', 'c2pc'],
+    unicase: ['unic'],
+    'titling-caps': ['titl'],
+  },
+  'font-variant-numeric': {
+    'lining-nums': ['lnum'],
+    'oldstyle-nums': ['onum'],
+    'proportional-nums': ['pnum'],
+    'tabular-nums': ['tnum'],
+    'diagonal-fractions': ['frac'],
+    'stacked-fractions': ['afrc'],
+    ordinal: ['ordn'],
+    'slashed-zero': ['zero'],
+  },
+  'font-variant-position': {
+    sub: ['subs'],
+    super: ['sups'],
+  },
+  'font-variant-east-asian': {
+    jis78: ['jp78'],
+    jis83: ['jp83'],
+    jis90: ['jp90'],
+    jis04: ['jp04'],
+    simplified: ['smpl'],
+    traditional: ['trad'],
+    'proportional-width': ['pwid'],
+    'full-width': ['fwid'],
+    ruby: ['ruby'],
+  },
+};
+
+// Extract OpenType feature tags referenced by a CSS declaration.
+function extractFeatureTagsFromDecl(prop, value) {
+  const tags = new Set();
+  const propLower = prop.toLowerCase();
+
+  if (propLower === 'font-feature-settings') {
+    // Parse quoted 4-letter tags: "liga" 1, 'dlig', etc.
+    const re = /["']([a-zA-Z0-9]{4})["']/g;
+    let m;
+    while ((m = re.exec(value)) !== null) {
+      tags.add(m[1]);
+    }
+    return tags;
+  }
+
+  if (propLower === 'font-variant-alternates') {
+    const v = value.toLowerCase();
+    if (v.includes('historical-forms')) tags.add('hist');
+    if (/stylistic\s*\(/.test(v)) tags.add('salt');
+    if (/swash\s*\(/.test(v)) tags.add('swsh');
+    if (/ornaments\s*\(/.test(v)) tags.add('ornm');
+    if (/annotation\s*\(/.test(v)) tags.add('nalt');
+    if (/styleset\s*\(/.test(v)) {
+      for (let i = 1; i <= 20; i++) {
+        tags.add(`ss${String(i).padStart(2, '0')}`);
+      }
+    }
+    if (/character-variant\s*\(/.test(v)) {
+      for (let i = 1; i <= 99; i++) {
+        tags.add(`cv${String(i).padStart(2, '0')}`);
+      }
+    }
+    return tags;
+  }
+
+  const mapping = fontVariantToOTTags[propLower];
+  if (mapping) {
+    // Split into tokens for exact keyword matching — substring matching
+    // would falsely trigger e.g. "sub" inside "super".
+    const tokens = new Set(value.toLowerCase().split(/\s+/));
+    for (const [keyword, otTags] of Object.entries(mapping)) {
+      if (tokens.has(keyword)) {
+        for (const t of otTags) tags.add(t);
+      }
+    }
+  }
+  return tags;
+}
+
+// Collect feature tags from all feature-related declarations in a CSS rule.
+function ruleFeatureTags(rule) {
+  const tags = new Set();
+  let hasFeatureDecl = false;
+  for (const node of rule.nodes) {
+    if (
+      node.type === 'decl' &&
+      featureSettingsProps.has(node.prop.toLowerCase())
+    ) {
+      hasFeatureDecl = true;
+      for (const t of extractFeatureTagsFromDecl(node.prop, node.value)) {
+        tags.add(t);
+      }
+    }
+  }
+  return hasFeatureDecl ? tags : null;
+}
+
+function ruleFontFamily(rule) {
+  for (let i = rule.nodes.length - 1; i >= 0; i--) {
+    const node = rule.nodes[i];
+    if (node.type === 'decl' && node.prop.toLowerCase() === 'font-family') {
+      return node.value;
+    }
+  }
+  return null;
+}
+
+// Add all items from `tags` into the Set stored at `key` in `map`,
+// creating the Set if it doesn't exist yet.
+function addTagsToMapEntry(map, key, tags) {
+  let s = map.get(key);
+  if (!s) {
+    s = new Set();
+    map.set(key, s);
+  }
+  for (const t of tags) s.add(t);
+}
+
+// Record the OT tags from a single CSS rule into featureTagsByFamily,
+// keyed by font-family (or '*' when no font-family is specified).
+function recordRuleFeatureTags(rule, featureTagsByFamily) {
+  const tags = ruleFeatureTags(rule);
+  if (!tags) return null;
+
+  const fontFamily = ruleFontFamily(rule);
+  if (!fontFamily) {
+    if (featureTagsByFamily) addTagsToMapEntry(featureTagsByFamily, '*', tags);
+    return true; // signals "all families"
+  }
+
+  const families = cssFontParser.parseFontFamily(fontFamily);
+  if (featureTagsByFamily) {
+    for (const family of families) {
+      addTagsToMapEntry(featureTagsByFamily, family.toLowerCase(), tags);
+    }
+  }
+  return families;
+}
+
+// Determine which font-families use font-feature-settings or font-variant-*.
+// Returns null (none detected), a Set of lowercase family names, or true (all).
+// Also populates featureTagsByFamily with the OT tags per family (lowercase).
+function findFontFamiliesWithFeatureSettings(
+  stylesheetsWithPredicates,
+  featureTagsByFamily
+) {
+  let result = null;
+  for (const { asset } of stylesheetsWithPredicates) {
+    if (!asset || !asset.parseTree) continue;
+    asset.parseTree.walkRules((rule) => {
+      if (result === true && !featureTagsByFamily) return;
+
+      const recorded = recordRuleFeatureTags(rule, featureTagsByFamily);
+      if (!recorded) return;
+
+      if (recorded === true) {
+        result = true;
+      } else if (result !== true) {
+        if (!result) result = new Set();
+        for (const family of recorded) {
+          result.add(family.toLowerCase());
+        }
+      }
+    });
+    if (result === true && !featureTagsByFamily) break;
+  }
+  return result;
+}
+
+// Determine whether a template's font families use feature settings, and
+// collect the corresponding OT feature tags from featureTagsByFamily.
+function resolveFeatureSettings(
+  fontFamilies,
+  fontFamiliesWithFeatureSettings,
+  featureTagsByFamily
+) {
+  let hasFontFeatureSettings = false;
+  if (fontFamiliesWithFeatureSettings === true) {
+    hasFontFeatureSettings = true;
+  } else if (fontFamiliesWithFeatureSettings instanceof Set) {
+    for (const f of fontFamilies) {
+      if (fontFamiliesWithFeatureSettings.has(f.toLowerCase())) {
+        hasFontFeatureSettings = true;
+        break;
+      }
+    }
+  }
+
+  let fontFeatureTags;
+  if (hasFontFeatureSettings && featureTagsByFamily) {
+    const tags = new Set();
+    const globalTags = featureTagsByFamily.get('*');
+    if (globalTags) {
+      for (const t of globalTags) tags.add(t);
+    }
+    for (const f of fontFamilies) {
+      const familyTags = featureTagsByFamily.get(f.toLowerCase());
+      if (familyTags) {
+        for (const t of familyTags) tags.add(t);
+      }
+    }
+    if (tags.size > 0) {
+      fontFeatureTags = [...tags];
+    }
+  }
+
+  return { hasFontFeatureSettings, fontFeatureTags };
+}
+
+module.exports = {
+  featureSettingsProps,
+  fontVariantToOTTags,
+  extractFeatureTagsFromDecl,
+  ruleFeatureTags,
+  ruleFontFamily,
+  addTagsToMapEntry,
+  recordRuleFeatureTags,
+  findFontFamiliesWithFeatureSettings,
+  resolveFeatureSettings,
+};

package/lib/fontTracerWorker.js

@@ -48,16 +48,6 @@ parentPort.on('message', (msg) => {
       const textByProps = fontTracer(document, {
         stylesheetsWithPredicates,
         getCssRulesByProperty: memoizedGetCssRulesByProperty,
-        propsToReturn: [
-          'font-family',
-          'font-style',
-          'font-weight',
-          'font-variant',
-          'font-stretch',
-          'font-variation-settings',
-          'animation-timing-function',
-          'font-size',
-        ],
       });
 
       // Strip any non-serializable data from results

package/lib/gatherStylesheetsWithPredicates.js

@@ -3,18 +3,17 @@ module.exports = function gatherStylesheetsWithPredicates(
   htmlAsset,
   relationIndex
 ) {
-  const assetStack = [];
+  const visiting = new Set();
   const incomingMedia = [];
   const conditionalCommentConditionStack = [];
   const result = [];
   (function traverse(asset, isWithinNotIeConditionalComment, isWithinNoscript) {
-    if (assetStack.includes(asset)) {
-      // Cycle detected
+    if (visiting.has(asset)) {
       return;
     } else if (!asset.isLoaded) {
       return;
     }
-    assetStack.push(asset);
+    visiting.add(asset);
     // Use pre-built index if available, otherwise fall back to findRelations
     const relations = relationIndex
       ? relationIndex.get(asset) || []
@@ -60,7 +59,7 @@ module.exports = function gatherStylesheetsWithPredicates(
         }
       }
     }
-    assetStack.pop();
+    visiting.delete(asset);
     if (asset.type === 'Css') {
       const predicates = {};
       for (const incomingMedium of incomingMedia) {

package/lib/normalizeFontPropertyValue.js

@@ -34,7 +34,7 @@ function isValidWeight(weight) {
 function normalizeFontPropertyValue(propName, value) {
   const propNameLowerCase = propName.toLowerCase();
   if (value === undefined) {
-    return initialValueByProp[propName];
+    return initialValueByProp[propNameLowerCase];
   }
   if (propNameLowerCase === 'font-family') {
     return unquote(value);

package/lib/progress.js

@@ -0,0 +1,101 @@
+// Helpers for surfacing phase progress to the console.
+//
+// Two audiences:
+//   1. Non-debug users want brief, always-visible signal that the tool
+//      isn't hung on large runs (banner + periodic page counts + done).
+//   2. Debug users want to pinpoint *which* phase is stuck when output
+//      goes silent. Paired "→ starting" / "← finished in Nms" markers
+//      around each slow phase mean the last line printed is always the
+//      currently-running phase.
+
+// Pick a progress step that gives roughly 10 updates across the run,
+// clamped to [1, 10]. For a 500-page run this prints every 50; for 30,
+// every 3. Avoids long silent stretches on large runs and per-page spam
+// on small ones.
+function progressStep(total) {
+  return Math.max(1, Math.min(10, Math.ceil(total / 10)));
+}
+
+// Reporter for a phase that iterates `total` items.
+//   banner(msg): optional one-line header printed immediately.
+//   tick(): call once per completed item; returns the running count.
+//   done(): prints "<label>: <total>/<total> pages done." footer.
+// All methods no-op when disabled (missing console or below minTotal).
+function createPageProgress({ total, console, label, minTotal = 5 }) {
+  const enabled = Boolean(console) && total >= minTotal;
+  const step = progressStep(total);
+  let count = 0;
+  return {
+    enabled,
+    banner(msg) {
+      if (enabled) console.log(msg);
+    },
+    tick() {
+      count++;
+      if (enabled && count % step === 0 && count < total) {
+        console.log(`  ${label}: ${count}/${total} pages...`);
+      }
+      return count;
+    },
+    done() {
+      if (enabled) {
+        console.log(`  ${label}: ${total}/${total} pages done.`);
+      }
+    },
+  };
+}
+
+// Per-page debug line emitted right after a page finishes tracing.
+// When a run hangs, the last-printed page identifies which page stalled.
+function logTracedPage(console, debug, index, total, asset, startMs) {
+  if (!debug || !console) return;
+  console.log(
+    `[subfont timing]   traced [${index}/${total}] ${asset.urlOrDescription} in ${Date.now() - startMs}ms`
+  );
+}
+
+// Start/end markers for a debug phase. The "→ label..." line is printed
+// *before* the work begins, so if the work hangs the user sees exactly
+// which phase is in flight. The returned end() logs elapsed ms and
+// returns the duration so callers can still populate a timings map.
+//
+//   const phase = logPhaseStart(console, debug, 'getSubsetsForFontUsage');
+//   await getSubsetsForFontUsage(...);
+//   timings.x = phase.end();
+function logPhaseStart(console, debug, label) {
+  if (!debug || !console) {
+    const start = Date.now();
+    return {
+      end() {
+        return Date.now() - start;
+      },
+    };
+  }
+  const start = Date.now();
+  console.log(`[subfont timing] → ${label}...`);
+  return {
+    end(extraInfo) {
+      const ms = Date.now() - start;
+      const suffix = extraInfo ? ` (${extraInfo})` : '';
+      console.log(`[subfont timing] ← ${label}: ${ms}ms${suffix}`);
+      return ms;
+    },
+  };
+}
+
+// Bind a (console, debug) pair once at the top of a function, then use
+// the returned tracker to open phases with a single short call:
+//
+//   const trackPhase = makePhaseTracker(console, debug);
+//   const p = trackPhase('codepoint generation');
+//   ...work...
+//   timings.x = p.end();
+function makePhaseTracker(console, debug) {
+  return (label) => logPhaseStart(console, debug, label);
+}
+
+module.exports = {
+  createPageProgress,
+  logTracedPage,
+  makePhaseTracker,
+};

package/lib/sfntCache.js

@@ -1,4 +1,5 @@
 const fontverter = require('fontverter');
+const { convert } = require('./fontConverter');
 
 const sfntPromiseByBuffer = new WeakMap();
 
@@ -9,13 +10,15 @@ function toSfnt(buffer) {
   let promise;
   try {
     const format = fontverter.detectFormat(buffer);
-    promise =
-      format === 'sfnt'
-        ? Promise.resolve(buffer)
-        : fontverter.convert(buffer, 'sfnt');
-  } catch (err) {
-    // Unrecognized format — don't cache so retries work
-    return fontverter.convert(buffer, 'sfnt');
+    if (format === 'sfnt') {
+      promise = Promise.resolve(buffer);
+    } else if (format === 'woff2') {
+      promise = convert(buffer, 'sfnt');
+    } else {
+      promise = fontverter.convert(buffer, 'sfnt');
+    }
+  } catch {
+    promise = convert(buffer, 'sfnt');
   }
   // Evict on rejection so retries with the same buffer aren't stuck
   promise.catch(() => sfntPromiseByBuffer.delete(buffer));