@turntrout/subfont 1.0.0 → 1.0.1

package/LICENSE.md

@@ -1,4 +1,5 @@
 Copyright 2017 Peter Brandt Müller
+Copyright 2024-2026 Alexander Turner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -2,16 +2,7 @@
 
 [![Build Status](https://github.com/alexander-turner/subfont/actions/workflows/ci.yml/badge.svg)](https://github.com/alexander-turner/subfont/actions/workflows/ci.yml)
 
-A faster fork of [subfont](https://github.com/Munter/subfont) that subsets web fonts to only the characters used on your pages. Adds parallel tracing, disk caching, woff2-only output, and always-on variable font instancing.
-
-## Performance
-
-On [TurnTrout.com](https://github.com/alexander-turner/TurnTrout.com) (382 pages, 20+ font variants), switching to this fork cut font subsetting from **111 minutes to 28 minutes**:
-
-|                                                                                      |    Version     | Duration |
-| -----------------------------------------------------------------------------------: | :------------: | :------- |
-| [Before](https://github.com/alexander-turner/TurnTrout.com/actions/runs/23470135763) | Munter/subfont | 111 min  |
-|  [After](https://github.com/alexander-turner/TurnTrout.com/actions/runs/23518006824) |   This fork    | 28 min   |
+A faster fork of [subfont](https://github.com/Munter/subfont) that subsets web fonts to only the characters used on your pages. Adds parallel tracing, disk caching, woff2-only output, and always-on variable font instancing. On [`turntrout.com`](https://github.com/alexander-turner/TurnTrout.com) (382 pages, 20+ font variants), switching to this fork cut font subsetting from [111 minutes](https://github.com/alexander-turner/TurnTrout.com/actions/runs/23470135763) to [28 minutes](https://github.com/alexander-turner/TurnTrout.com/actions/runs/23518006824).
 
 ## Install
 

package/lib/FontTracerPool.js

@@ -149,6 +149,16 @@ class FontTracerPool {
   }
 
   async destroy() {
+    // Reject any tasks still waiting in the queue
+    for (const task of this._pendingTasks) {
+      const cb = this._taskCallbacks.get(task.message.taskId);
+      if (cb) {
+        this._taskCallbacks.delete(task.message.taskId);
+        cb.reject(new Error('Worker pool destroyed'));
+      }
+    }
+    this._pendingTasks = [];
+
     await Promise.all(this._workers.map((w) => w.terminate()));
     this._workers = [];
     this._idle = [];

package/lib/HeadlessBrowser.js

@@ -1,9 +1,9 @@
 const urlTools = require('urltools');
 const puppeteer = require('puppeteer-core');
 const pathModule = require('path');
+const os = require('os');
 const {
   install,
-  uninstall,
   Browser,
   detectBrowserPlatform,
   Cache,
@@ -19,7 +19,10 @@ async function transferResults(jsHandle) {
   return results;
 }
 
-async function downloadOrLocatePreferredBrowserRevision(extraArgs = []) {
+async function downloadOrLocatePreferredBrowserRevision(
+  extraArgs = [],
+  log = console
+) {
   if (process.env.PUPPETEER_EXECUTABLE_PATH) {
     return puppeteer.launch({
       executablePath: process.env.PUPPETEER_EXECUTABLE_PATH,
@@ -37,7 +40,7 @@ async function downloadOrLocatePreferredBrowserRevision(extraArgs = []) {
   } else {
     // Check the default puppeteer cache (~/.cache/puppeteer) before downloading
     const defaultCacheDir = pathModule.join(
-      require('os').homedir(),
+      os.homedir(),
       '.cache',
       'puppeteer'
     );
@@ -49,7 +52,7 @@ async function downloadOrLocatePreferredBrowserRevision(extraArgs = []) {
     if (defaultChromeEntry) {
       executablePath = defaultChromeEntry.executablePath;
     } else {
-      console.log('Downloading Chrome');
+      log.log('Downloading Chrome');
       const result = await install({
         browser: Browser.CHROME,
         buildId: 'stable',
@@ -57,27 +60,6 @@ async function downloadOrLocatePreferredBrowserRevision(extraArgs = []) {
         platform,
       });
       executablePath = result.executablePath;
-
-      // Clean up older Chrome versions that may have accumulated from
-      // previous runs with different stable buildIds.
-      const allInstalled = cache.getInstalledBrowsers();
-      for (const entry of allInstalled) {
-        if (
-          entry.browser === Browser.CHROME &&
-          entry.executablePath !== executablePath
-        ) {
-          try {
-            await uninstall({
-              browser: entry.browser,
-              buildId: entry.buildId,
-              cacheDir,
-            });
-            console.log(`Removed old Chrome ${entry.buildId}`);
-          } catch {
-            // Ignore cleanup errors — the old version may be in use or locked
-          }
-        }
-      }
     }
   }
   return puppeteer.launch({
@@ -92,13 +74,19 @@ class HeadlessBrowser {
     this._chromeArgs = chromeArgs;
   }
 
-  _ensureBrowserDownloaded() {}
-
   _launchBrowserMemoized() {
-    // Make sure we only download and launch one browser per HeadlessBrowser instance
-    return (this._launchPromise =
-      this._launchPromise ||
-      downloadOrLocatePreferredBrowserRevision(this._chromeArgs));
+    // Make sure we only download and launch one browser per HeadlessBrowser instance.
+    // Clear the cached promise on failure so a subsequent call can retry.
+    if (!this._launchPromise) {
+      this._launchPromise = downloadOrLocatePreferredBrowserRevision(
+        this._chromeArgs,
+        this.console
+      ).catch((err) => {
+        this._launchPromise = undefined;
+        throw err;
+      });
+    }
+    return this._launchPromise;
   }
 
   async tracePage(htmlAsset) {

package/lib/collectFeatureGlyphIds.js

@@ -1,8 +1,5 @@
 const { toSfnt } = require('./sfntCache');
 
-// Standard OpenType GSUB feature tags that can substitute glyphs.
-// We intersect with the font's actual GSUB features to avoid
-// unnecessary shaping calls.
 const GSUB_FEATURE_TAGS = new Set([
   'aalt',
   'c2sc',
@@ -47,19 +44,6 @@ const GSUB_FEATURE_TAGS = new Set([
   'zero',
 ]);
 
-/**
- * Collect glyph IDs produced by GSUB features for the given text.
- *
- * Uses harfbuzzjs face.getTableFeatureTags('GSUB') to enumerate the
- * font's actual GSUB features, then only tests those that are in our
- * known substitution set. Collects ALL output glyph IDs from each
- * shaping result (not just the first), to handle ligatures and
- * multi-glyph substitutions.
- *
- * @param {Buffer} fontBuffer - The original font data
- * @param {string} text - The text whose characters to check
- * @returns {Promise<number[]>} Array of alternate glyph IDs
- */
 const enqueueWasm = require('./wasmQueue');
 
 async function collectFeatureGlyphIdsImpl(fontBuffer, text) {
@@ -71,8 +55,6 @@ async function collectFeatureGlyphIdsImpl(fontBuffer, text) {
   const font = harfbuzzJs.createFont(face);
 
   try {
-    // Use harfbuzzjs to enumerate GSUB features directly from the font,
-    // then intersect with our known substitution tags
     const fontFeatures = new Set(face.getTableFeatureTags('GSUB'));
     const featuresToTest = [...fontFeatures].filter((tag) =>
       GSUB_FEATURE_TAGS.has(tag)
@@ -80,14 +62,11 @@ async function collectFeatureGlyphIdsImpl(fontBuffer, text) {
 
     if (featuresToTest.length === 0) return [];
 
-    // Build a single string of unique non-whitespace characters.
-    // Shaping the full string once per feature is O(features) HarfBuzz
-    // calls instead of O(chars × features) with per-character shaping.
+    // Shape the full string once per feature: O(features) calls, not O(chars × features).
     const uniqueChars = [...new Set(text)].filter((ch) => ch.trim() !== '');
     if (uniqueChars.length === 0) return [];
     const testText = uniqueChars.join('');
 
-    // Get base glyph IDs (no features)
     const baseBuf = harfbuzzJs.createBuffer();
     let baseGids;
     try {
@@ -103,7 +82,6 @@ async function collectFeatureGlyphIdsImpl(fontBuffer, text) {
 
     const altGlyphIds = new Set();
 
-    // Shape the full text with each feature and collect alternate glyph IDs
     for (const feat of featuresToTest) {
       const buf = harfbuzzJs.createBuffer();
       try {

package/lib/collectTextsByPage.js

@@ -19,18 +19,9 @@ const {
   uniqueCharsFromArray,
 } = require('./fontFaceHelpers');
 
-// Inline stylesheets matching this regex contain font-related CSS and
-// must be included in the fast-path grouping key. Non-matching inline
-// CSS (e.g., layout-only critical CSS) is excluded so pages that differ
-// only in non-font inline styles still share a single fontTracer run.
 const fontRelevantCssRegex =
   /font-family|font-weight|font-style|font-stretch|font-display|@font-face|font-variation|font-feature/i;
 
-// Detect inline style attributes with font-related properties.
-// Used to exclude pages from fast-path when inline styles could affect
-// font-tracer output (since the stylesheet cache key doesn't cover them).
-// Matches style="..." containing font-family, font-weight, font-style,
-// font-stretch, or the font shorthand (font:).
 // The \s before style ensures we don't match data-style or similar.
 const inlineFontStyleRegex =
   /(?:^|\s)style\s*=\s*["'][^"']*\b(?:font-family|font-weight|font-style|font-stretch|font\s*:)/i;
@@ -38,10 +29,12 @@ function hasInlineFontStyles(html) {
   return inlineFontStyleRegex.test(html);
 }
 
-// Relation types followed when traversing from HTML to CSS for @font-face gathering
 const fontFaceTraversalTypes = new Set(['HtmlStyle', 'SvgStyle', 'CssImport']);
 
-// CSS properties that trigger OpenType feature glyph collection
+// Minimum number of pages that justifies spawning a worker pool (below this
+// the overhead of worker thread startup exceeds the parallelism benefit).
+const MIN_PAGES_FOR_WORKER_POOL = 4;
+
 const featureSettingsProps = new Set([
   'font-feature-settings',
   'font-variant-alternates',
@@ -102,8 +95,7 @@ const initialValueByProp = {
   'font-stretch': allInitialValues['font-stretch'],
 };
 
-// Null byte delimiter — CSS property values cannot contain \0,
-// so this is collision-safe and cheaper than JSON.stringify in hot loops.
+// Null byte delimiter is collision-safe — CSS property values cannot contain \0.
 function fontPropsKey(family, weight, style, stretch) {
   return `${family}\0${weight}\0${style}\0${stretch}`;
 }
@@ -230,10 +222,6 @@ function getOrComputeGlobalFontUsages(
 
   const snappedGlobalEntries = cached.snappedEntries;
 
-  // Build all indices in a single pass over snappedGlobalEntries:
-  // - pageTextIndex: Map<htmlOrSvgAsset, Map<fontUrl, string[]>> for pageText
-  // - entriesByFontUrl: Map<fontUrl, entry[]> for building templates
-  // - textAndPropsToFontUrl: Map<textAndProps, fontUrl> for preload (inverted index)
   const pageTextIndex = new Map();
   const entriesByFontUrl = new Map();
   const textAndPropsToFontUrl = new Map();
@@ -241,7 +229,6 @@ function getOrComputeGlobalFontUsages(
   for (const entry of snappedGlobalEntries) {
     if (!entry.fontUrl) continue;
 
-    // pageTextIndex: group texts by (asset, fontUrl)
     const asset = entry.textAndProps.htmlOrSvgAsset;
     let assetMap = pageTextIndex.get(asset);
     if (!assetMap) {
@@ -255,7 +242,6 @@ function getOrComputeGlobalFontUsages(
     }
     texts.push(entry.textAndProps.text);
 
-    // entriesByFontUrl: group entries by fontUrl
     let arr = entriesByFontUrl.get(entry.fontUrl);
     if (!arr) {
       arr = [];
@@ -263,14 +249,8 @@ function getOrComputeGlobalFontUsages(
     }
     arr.push(entry);
 
-    // Inverted preload index: textAndProps -> fontUrl
-    // In the per-page loop we iterate the page's small textByProps and
-    // look up which fontUrls they map to, making preload O(|pageTextByProps|).
     textAndPropsToFontUrl.set(entry.textAndProps, entry.fontUrl);
   }
-
-  // Also collect subfont-text / text param contributions per fontUrl
-  // These are the same for every page sharing this declarations key
   const extraTextsByFontUrl = new Map();
   for (const fontFaceDeclaration of accumulatedFontFaceDeclarations) {
     const {
@@ -349,7 +329,6 @@ function getOrComputeGlobalFontUsages(
 
     const props =
       fontEntries.length > 0 ? { ...fontEntries[0].props } : { ...extra.props };
-    // Pre-join the extra texts (subfont-text / text param) for pageText computation
     const extraTextsStr = extra ? extra.texts.join('') : '';
 
     fontUsageTemplates.push({
@@ -450,7 +429,6 @@ async function collectTextsByPage(
         }
       }
     })(htmlOrSvgAsset, false);
-    // Key parts are structured id:media:ns strings — simple join is safe
     return keyParts.join('\x1d');
   }
 
@@ -640,7 +618,9 @@ async function collectTextsByPage(
     );
 
   // Use worker pool for parallel fontTracer when there are enough pages
-  const useWorkerPool = !headlessBrowser && pagesNeedingFullTrace.length >= 4;
+  const useWorkerPool =
+    !headlessBrowser &&
+    pagesNeedingFullTrace.length >= MIN_PAGES_FOR_WORKER_POOL;
 
   const tracingStart = Date.now();
   try {

package/lib/getCssRulesByProperty.js

@@ -84,35 +84,36 @@ function getCssRulesByProperty(properties, cssSource, existingPredicates) {
     }
   }
 
+  function pushRulePerSelector(node, prop, value) {
+    getSpecificity(node.parent.selector).forEach((specificityObject) => {
+      const isStyleAttribute = specificityObject.selector === 'bogusselector';
+      (rulesByProperty[prop] = rulesByProperty[prop] || []).push({
+        predicates: getCurrentPredicates(),
+        namespaceURI: defaultNamespaceURI,
+        selector: isStyleAttribute
+          ? undefined
+          : specificityObject.selector.trim(),
+        specificityArray: isStyleAttribute
+          ? [1, 0, 0, 0]
+          : specificityObject.specificityArray,
+        prop,
+        value,
+        important: !!node.important,
+      });
+    });
+  }
+
   (function visit(node) {
     // Check for selector. We might be in an at-rule like @font-face
     if (node.type === 'decl' && node.parent.selector) {
       const isCustomProperty = /^--/.test(node.prop);
       const propName = isCustomProperty ? node.prop : node.prop.toLowerCase(); // Custom properties ARE case sensitive
       if (isCustomProperty || properties.includes(propName)) {
-        // Split up combined selectors as they might have different specificity
-        getSpecificity(node.parent.selector).forEach((specificityObject) => {
-          const isStyleAttribute =
-            specificityObject.selector === 'bogusselector';
-          (rulesByProperty[propName] = rulesByProperty[propName] || []).push({
-            predicates: getCurrentPredicates(),
-            namespaceURI: defaultNamespaceURI,
-            selector: isStyleAttribute
-              ? undefined
-              : specificityObject.selector.trim(),
-            specificityArray: isStyleAttribute
-              ? [1, 0, 0, 0]
-              : specificityObject.specificityArray,
-            prop: propName,
-            value: node.value,
-            important: !!node.important,
-          });
-        });
+        pushRulePerSelector(node, propName, node.value);
       } else if (
         propName === 'list-style' &&
         properties.includes('list-style-type')
       ) {
-        // Shorthand — use postcss-value-parser to properly handle quoted strings
         let listStyleType;
         for (const valueNode of postcssValueParser(node.value).nodes) {
           if (valueNode.type === 'string') {
@@ -126,84 +127,31 @@ function getCssRulesByProperty(properties, cssSource, existingPredicates) {
         }
 
         if (typeof listStyleType !== 'undefined') {
-          // Split up combined selectors as they might have different specificity
-          getSpecificity(node.parent.selector).forEach((specificityObject) => {
-            const isStyleAttribute =
-              specificityObject.selector === 'bogusselector';
-
-            rulesByProperty['list-style-type'].push({
-              predicates: getCurrentPredicates(),
-              namespaceURI: defaultNamespaceURI,
-              selector: isStyleAttribute
-                ? undefined
-                : specificityObject.selector.trim(),
-              specificityArray: isStyleAttribute
-                ? [1, 0, 0, 0]
-                : specificityObject.specificityArray,
-              prop: 'list-style-type',
-              value: listStyleType,
-              important: !!node.important,
-            });
-          });
+          pushRulePerSelector(node, 'list-style-type', listStyleType);
         }
       } else if (propName === 'animation') {
-        // Shorthand
         const parsedAnimation = parseAnimationShorthand.parseSingle(
           node.value
         ).value;
 
         if (properties.includes('animation-name')) {
-          // Split up combined selectors as they might have different specificity
-          getSpecificity(node.parent.selector).forEach((specificityObject) => {
-            const isStyleAttribute =
-              specificityObject.selector === 'bogusselector';
-
-            rulesByProperty['animation-name'].push({
-              predicates: getCurrentPredicates(),
-              namespaceURI: defaultNamespaceURI,
-              selector: isStyleAttribute
-                ? undefined
-                : specificityObject.selector.trim(),
-              specificityArray: isStyleAttribute
-                ? [1, 0, 0, 0]
-                : specificityObject.specificityArray,
-              prop: 'animation-name',
-              value: parsedAnimation.name,
-              important: !!node.important,
-            });
-          });
+          pushRulePerSelector(node, 'animation-name', parsedAnimation.name);
         }
         if (properties.includes('animation-timing-function')) {
-          // Split up combined selectors as they might have different specificity
-          getSpecificity(node.parent.selector).forEach((specificityObject) => {
-            const isStyleAttribute =
-              specificityObject.selector === 'bogusselector';
-
-            rulesByProperty['animation-timing-function'].push({
-              predicates: getCurrentPredicates(),
-              namespaceURI: defaultNamespaceURI,
-              selector: isStyleAttribute
-                ? undefined
-                : specificityObject.selector.trim(),
-              specificityArray: isStyleAttribute
-                ? [1, 0, 0, 0]
-                : specificityObject.specificityArray,
-              prop: 'animation-timing-function',
-              value: parseAnimationShorthand.serialize({
-                name: '',
-                timingFunction: parsedAnimation.timingFunction,
-              }),
-              important: !!node.important,
-            });
-          });
+          pushRulePerSelector(
+            node,
+            'animation-timing-function',
+            parseAnimationShorthand.serialize({
+              name: '',
+              timingFunction: parsedAnimation.timingFunction,
+            })
+          );
         }
       } else if (propName === 'transition') {
-        // Shorthand — use postcss-value-parser to correctly split on commas
-        // (regex split breaks on commas inside cubic-bezier() etc.)
+        // Use postcss-value-parser — regex split breaks on commas inside cubic-bezier() etc.
         const transitionProperties = [];
         const transitionDurations = [];
         const parsed = postcssValueParser(node.value);
-        // Split top-level nodes by dividers (commas)
         let currentItem = [];
         for (const valueNode of parsed.nodes) {
           if (valueNode.type === 'div' && valueNode.value === ',') {
@@ -218,7 +166,6 @@ function getCssRulesByProperty(properties, cssSource, existingPredicates) {
             currentItem.push(postcssValueParser.stringify(valueNode));
           }
         }
-        // Handle last item
         if (currentItem.length > 0) {
           transitionProperties.push(currentItem[0]);
         }
@@ -226,27 +173,32 @@ function getCssRulesByProperty(properties, cssSource, existingPredicates) {
           transitionDurations.push(currentItem[1]);
         }
 
-        // Split up combined selectors as they might have different specificity
-        getSpecificity(node.parent.selector).forEach((specificityObject) => {
-          const isStyleAttribute =
-            specificityObject.selector === 'bogusselector';
-          if (properties.includes('transition-property')) {
-            rulesByProperty['transition-property'].push({
-              predicates: getCurrentPredicates(),
-              namespaceURI: defaultNamespaceURI,
-              selector: isStyleAttribute
-                ? undefined
-                : specificityObject.selector.trim(),
-              specificityArray: isStyleAttribute
-                ? [1, 0, 0, 0]
-                : specificityObject.specificityArray,
-              prop: 'transition-property',
-              value: transitionProperties.join(', '),
-              important: !!node.important,
-            });
-          }
-          if (properties.includes('transition-duration')) {
-            rulesByProperty['transition-duration'].push({
+        if (properties.includes('transition-property')) {
+          pushRulePerSelector(
+            node,
+            'transition-property',
+            transitionProperties.join(', ')
+          );
+        }
+        if (properties.includes('transition-duration')) {
+          pushRulePerSelector(
+            node,
+            'transition-duration',
+            transitionDurations.join(', ')
+          );
+        }
+      } else if (propName === 'font') {
+        const fontLonghands = [
+          'font-family',
+          'font-weight',
+          'font-size',
+          'font-style',
+        ].filter((prop) => properties.includes(prop));
+        if (fontLonghands.length > 0) {
+          getSpecificity(node.parent.selector).forEach((specificityObject) => {
+            const isStyleAttribute =
+              specificityObject.selector === 'bogusselector';
+            const entry = {
               predicates: getCurrentPredicates(),
               namespaceURI: defaultNamespaceURI,
               selector: isStyleAttribute
@@ -255,41 +207,15 @@ function getCssRulesByProperty(properties, cssSource, existingPredicates) {
               specificityArray: isStyleAttribute
                 ? [1, 0, 0, 0]
                 : specificityObject.specificityArray,
-              prop: 'transition-duration',
-              value: transitionDurations.join(', '),
+              prop: 'font',
+              value: node.value,
               important: !!node.important,
-            });
-          }
-        });
-      } else if (propName === 'font') {
-        getSpecificity(node.parent.selector).forEach((specificityObject) => {
-          const isStyleAttribute =
-            specificityObject.selector === 'bogusselector';
-          const value = {
-            predicates: getCurrentPredicates(),
-            namespaceURI: defaultNamespaceURI,
-            selector: isStyleAttribute
-              ? undefined
-              : specificityObject.selector.trim(),
-            specificityArray: isStyleAttribute
-              ? [1, 0, 0, 0]
-              : specificityObject.specificityArray,
-            prop: 'font',
-            value: node.value,
-            important: !!node.important,
-          };
-
-          for (const prop of [
-            'font-family',
-            'font-weight',
-            'font-size',
-            'font-style',
-          ]) {
-            if (properties.includes(prop)) {
-              rulesByProperty[prop].push(value);
+            };
+            for (const prop of fontLonghands) {
+              rulesByProperty[prop].push(entry);
             }
-          }
-        });
+          });
+        }
       }
     } else if (
       node.type === 'atrule' &&

package/lib/injectSubsetDefinitions.js

@@ -5,14 +5,14 @@ function injectSubsetDefinitions(cssValue, webfontNameMap, replaceOriginal) {
     Object.values(webfontNameMap).map((name) => name.toLowerCase())
   );
   const rootNode = postcssValueParser(cssValue);
-  let isPreceededByWords = false;
+  let isPrecededByWords = false;
   for (const [i, node] of rootNode.nodes.entries()) {
     let possibleFontFamily;
     let lastFontFamilyTokenIndex = i;
     if (node.type === 'string') {
       possibleFontFamily = node.value;
     } else if (node.type === 'word' || node.type === 'space') {
-      if (!isPreceededByWords) {
+      if (!isPrecededByWords) {
         const wordSequence = [];
         for (let j = i; j < rootNode.nodes.length; j += 1) {
           if (rootNode.nodes[j].type === 'word') {
@@ -24,9 +24,9 @@ function injectSubsetDefinitions(cssValue, webfontNameMap, replaceOriginal) {
         }
         possibleFontFamily = wordSequence.join(' ');
       }
-      isPreceededByWords = true;
+      isPrecededByWords = true;
     } else {
-      isPreceededByWords = false;
+      isPrecededByWords = false;
     }
     if (possibleFontFamily) {
       const possibleFontFamilyLowerCase = possibleFontFamily.toLowerCase();

package/lib/parseCommandLineOptions.js

@@ -11,19 +11,16 @@ module.exports = function parseCommandLineOptions(argv) {
       describe:
         'Path to your web root (will be deduced from your input files if not specified)',
       type: 'string',
-      demand: false,
     })
     .options('canonical-root', {
       describe:
         'URI root where the site will be deployed. Must be either an absolute, a protocol-relative, or a root-relative url',
       type: 'string',
-      demand: false,
     })
     .options('output', {
       alias: 'o',
       describe: 'Directory where results should be written to',
       type: 'string',
-      demand: false,
     })
     .options('text', {
       describe:
@@ -112,7 +109,6 @@ module.exports = function parseCommandLineOptions(argv) {
       describe:
         'Maximum number of worker threads for parallel font tracing. Defaults to the number of CPU cores (max 8)',
       type: 'number',
-      demand: false,
     })
     .options('source-maps', {
       describe: 'Preserve CSS source maps through subfont processing',

package/lib/sfntCache.js

@@ -1,8 +1,5 @@
 const fontverter = require('fontverter');
 
-// Cache sfnt conversions by source buffer to avoid redundant work
-// when the same font is processed by collectFeatureGlyphIds and
-// subsetFontWithGlyphs.
 const sfntPromiseByBuffer = new WeakMap();
 
 function toSfnt(buffer) {