@turntrout/subfont 1.6.0 → 1.7.0

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/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/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));

package/lib/subfont.js

@@ -370,22 +370,63 @@ module.exports = async function subfont(
 
   const reportingPhase = trackPhase('output reporting');
   if (debug) {
-    const compactFontInfo = fontInfo.map(({ fontUsages, ...rest }) => ({
-      ...rest,
-      fontUsages: fontUsages.map(({ codepoints, texts, ...fu }) => ({
-        ...fu,
-        codepoints: codepoints
-          ? {
-              original: `[${codepoints.original.length} codepoints]`,
-              used: `[${codepoints.used.length} codepoints]`,
-              unused: `[${codepoints.unused.length} codepoints]`,
-              page: `[${codepoints.page.length} codepoints]`,
-            }
-          : undefined,
-        texts: texts ? `[${texts.length} entries]` : undefined,
-      })),
-    }));
-    log(util.inspect(compactFontInfo, false, 99));
+    // One entry per unique (fontUrl, props) variant. A variable-font URL can
+    // back multiple variants, so fontUrl alone is too coarse. Codepoint unions
+    // and subset sizes are per-font, so the remaining per-page variation
+    // worth surfacing is just which pages reference the variant.
+    const SAMPLE_PAGES = 5;
+    const byVariant = new Map();
+    for (const { assetFileName, fontUsages } of fontInfo) {
+      for (const fu of fontUsages) {
+        const p = fu.props || {};
+        const key = [
+          fu.fontUrl || '[inline]',
+          p['font-family'],
+          p['font-weight'],
+          p['font-style'],
+          p['font-stretch'],
+        ].join('\0');
+        let entry = byVariant.get(key);
+        if (!entry) {
+          entry = {
+            fontUrl: fu.fontUrl,
+            props: fu.props,
+            preload: fu.preload,
+            fullyInstanced: fu.fullyInstanced,
+            numAxesPinned: fu.numAxesPinned,
+            numAxesReduced: fu.numAxesReduced,
+            smallestOriginalFormat: fu.smallestOriginalFormat,
+            smallestSubsetFormat: fu.smallestSubsetFormat,
+            smallestOriginalSize: fu.smallestOriginalSize,
+            smallestSubsetSize: fu.smallestSubsetSize,
+            codepoints: fu.codepoints
+              ? {
+                  original: fu.codepoints.original.length,
+                  used: fu.codepoints.used.length,
+                  unused: fu.codepoints.unused.length,
+                }
+              : undefined,
+            pageCount: 0,
+            samplePages: [],
+          };
+          byVariant.set(key, entry);
+        }
+        entry.pageCount += 1;
+        if (entry.samplePages.length < SAMPLE_PAGES) {
+          entry.samplePages.push(assetFileName);
+        }
+      }
+    }
+    for (const entry of byVariant.values()) {
+      const remaining = entry.pageCount - entry.samplePages.length;
+      if (remaining > 0) {
+        entry.samplePages.push(`...and ${remaining} more`);
+      }
+    }
+    log(
+      `Font variants (aggregated across ${fontInfo.length} page${fontInfo.length === 1 ? '' : 's'}):`
+    );
+    log(util.inspect([...byVariant.values()], false, 99));
   }
 
   let totalSavings = sumSizesBefore - sumSizesAfter;

package/lib/subsetFontWithGlyphs.js

@@ -2,6 +2,7 @@ const os = require('os');
 const { readFile } = require('fs').promises;
 const fontverter = require('fontverter');
 const { toSfnt } = require('./sfntCache');
+const { convert: convertInWorker } = require('./fontConverter');
 
 // hb_subset_sets_t enum values — https://github.com/harfbuzz/harfbuzz/blob/main/src/hb-subset.h
 const HB_SUBSET_SETS_GLYPH_INDEX = 0;
@@ -51,6 +52,7 @@ async function initPool() {
 
 // Waiters queue: callers waiting for an idle WASM instance.
 const _waiters = [];
+const ACQUIRE_TIMEOUT_MS = 120_000;
 
 async function acquireInstance() {
   await initPool();
@@ -60,7 +62,23 @@ async function acquireInstance() {
     return idle;
   }
   // All instances busy — wait for one to be released.
-  return new Promise((resolve) => _waiters.push(resolve));
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      const idx = _waiters.indexOf(entry);
+      if (idx !== -1) _waiters.splice(idx, 1);
+      reject(
+        new Error(
+          `Timed out waiting for a WASM subsetting instance after ${ACQUIRE_TIMEOUT_MS}ms`
+        )
+      );
+    }, ACQUIRE_TIMEOUT_MS);
+    timer.unref();
+    const entry = (inst) => {
+      clearTimeout(timer);
+      resolve(inst);
+    };
+    _waiters.push(entry);
+  });
 }
 
 function releaseInstance(inst) {
@@ -71,16 +89,11 @@ function releaseInstance(inst) {
   }
 }
 
-// Serialize fontverter.convert calls — the wawoff2 module (used internally by
-// fontverter for WOFF2 compression) has a shared WASM instance whose memory
-// is corrupted by concurrent calls.  Only woff2 paths need this; woff and
-// truetype conversions use separate synchronous/JS libraries that are safe
-// to call in parallel.
-const convertLimiter = require('p-limit')(1);
-
-function usesWawoff2(buffer) {
-  return buffer.length >= 4 && buffer.toString('ascii', 0, 4) === 'wOF2';
-}
+// woff2 encode/decode uses wawoff2's WASM module, which has a shared
+// instance that corrupts memory under concurrent use.  Instead of
+// serializing to p-limit(1) in the main thread, we route woff2
+// operations through fontConverterPool — each worker thread loads its
+// own wawoff2 instance, enabling safe parallel compression.
 
 // Re-create on every call — WASM memory.buffer is detached when memory grows,
 // so a cached Uint8Array would silently read/write stale data.
@@ -88,9 +101,11 @@ function getHeapu8(exports) {
   return new Uint8Array(exports.memory.buffer);
 }
 
+// >>> 0 keeps the accumulator unsigned; without it, tags whose first byte
+// exceeds 0x7F would overflow into negative i32 territory after << 24.
 function HB_TAG(str) {
   return str.split('').reduce(function (a, ch) {
-    return (a << 8) + ch.charCodeAt(0);
+    return ((a << 8) >>> 0) + ch.charCodeAt(0);
   }, 0);
 }
 
@@ -238,11 +253,8 @@ async function subsetFontWithGlyphs(
 ) {
   // Reuse cached sfnt conversion when available (same buffer may have
   // been converted by getFontInfo or collectFeatureGlyphIds already).
-  // Serialize through convertLimiter when the source is woff2 — toSfnt
-  // would call wawoff2.decompress which isn't concurrency-safe.
-  const ttf = usesWawoff2(originalFont)
-    ? await convertLimiter(() => toSfnt(originalFont))
-    : await toSfnt(originalFont);
+  // sfntCache routes woff2 decompression through the worker pool.
+  const ttf = await toSfnt(originalFont);
 
   const inst = await acquireInstance();
   const { exports } = inst;
@@ -287,12 +299,11 @@ async function subsetFontWithGlyphs(
     released = true;
     releaseInstance(inst);
 
-    // Only serialize through convertLimiter when targeting woff2 —
-    // woff and truetype conversions don't use wawoff2.
+    // Route woff2 compression to a worker thread (each spawns its own
+    // wawoff2 WASM instance).  Non-woff2 formats use JS-based converters
+    // that are safe to call concurrently in the main thread.
     return targetFormat === 'woff2'
-      ? convertLimiter(() =>
-          fontverter.convert(subsetFont, targetFormat, 'truetype')
-        )
+      ? convertInWorker(subsetFont, targetFormat, 'truetype')
       : fontverter.convert(subsetFont, targetFormat, 'truetype');
   } finally {
     if (!released) releaseInstance(inst);