@turntrout/subfont 1.1.0 → 1.2.0

package/CLAUDE.md

@@ -34,7 +34,7 @@ pnpm run check-coverage  # Verify coverage thresholds
 - Built on **assetgraph** for HTML/CSS asset graph traversal
 - Uses **puppeteer-core** for headless browser font tracing
 - **font-tracer** traces which fonts are used on each page
-- **subset-font** / **harfbuzzjs** for WOFF2 subsetting
+- **harfbuzzjs** for WOFF2 subsetting (via direct WASM calls in `lib/subsetFontWithGlyphs.js`)
 - `lib/subsetFonts.js` — Main orchestration logic
 - `lib/FontTracerPool.js` — Manages puppeteer browser pool for parallel tracing
 

package/README.md

@@ -4,6 +4,25 @@
 
 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).
 
+### Aggressive woff2 subsetting
+
+subfont produces dramatically smaller font files by stripping data that browsers never use:
+
+| Optimization                | Technique                                                                          |
+| --------------------------- | ---------------------------------------------------------------------------------- |
+| Hinting removal             | Strips TrueType hinting instructions (browsers auto-hint)                          |
+| Name table pruning          | Keeps only the 4 IDs browsers read (family, subfamily, full name, PostScript name) |
+| Table stripping             | Drops DSIG, LTSH, VDMX, hdmx, gasp, PCLT                                           |
+| CSS-aware feature filtering | Only collects alternate glyphs for OpenType features actually used in your CSS     |
+
+On the [`turntrout.com/design`](https://turntrout.com/design) page, a typical font subset (OpenSans, woff2) is **48-68% smaller** than a naive subset of the same glyphs:
+
+| Text sample       | Naive subset | subfont | Savings |
+| ----------------- | ------------ | ------- | ------- |
+| Heading (short)   | 2,604 B      | 824 B   | **68%** |
+| Paragraph         | 4,052 B      | 1,840 B | **55%** |
+| Full page charset | 5,268 B      | 2,716 B | **48%** |
+
 ## Install
 
 ```

package/lib/collectFeatureGlyphIds.js

@@ -1,22 +1,40 @@
 const { toSfnt } = require('./sfntCache');
 
+// GSUB feature tags that can produce alternate glyphs.  Used as the
+// fallback set when CSS doesn't specify which features are in use.
+// Keep in sync with fontVariantToOTTags in collectTextsByPage.js.
 const GSUB_FEATURE_TAGS = new Set([
   'aalt',
+  'afrc',
+  'c2pc',
   'c2sc',
   'calt',
   'clig',
   'dlig',
   'dnom',
   'frac',
+  'fwid',
+  'hist',
+  'hlig',
+  'jp04',
+  'jp78',
+  'jp83',
+  'jp90',
   'liga',
   'lnum',
+  'nalt',
   'numr',
   'onum',
   'ordn',
+  'ornm',
+  'pcap',
   'pnum',
+  'pwid',
+  'ruby',
   'salt',
   'sinf',
   'smcp',
+  'smpl',
   'ss01',
   'ss02',
   'ss03',
@@ -40,13 +58,16 @@ const GSUB_FEATURE_TAGS = new Set([
   'subs',
   'sups',
   'swsh',
+  'titl',
   'tnum',
+  'trad',
+  'unic',
   'zero',
 ]);
 
 const enqueueWasm = require('./wasmQueue');
 
-async function collectFeatureGlyphIdsImpl(fontBuffer, text) {
+async function collectFeatureGlyphIdsImpl(fontBuffer, text, cssFeatureTags) {
   const harfbuzzJs = await require('harfbuzzjs');
   const sfnt = await toSfnt(fontBuffer);
 
@@ -56,8 +77,16 @@ async function collectFeatureGlyphIdsImpl(fontBuffer, text) {
 
   try {
     const fontFeatures = new Set(face.getTableFeatureTags('GSUB'));
+
+    // When CSS specifies which features are used, only test those.
+    // Otherwise fall back to the full set of supported GSUB features.
+    const allowedTags =
+      cssFeatureTags && cssFeatureTags.length > 0
+        ? new Set(cssFeatureTags)
+        : GSUB_FEATURE_TAGS;
+
     const featuresToTest = [...fontFeatures].filter((tag) =>
-      GSUB_FEATURE_TAGS.has(tag)
+      allowedTags.has(tag)
     );
 
     if (featuresToTest.length === 0) return [];
@@ -108,8 +137,10 @@ async function collectFeatureGlyphIdsImpl(fontBuffer, text) {
   }
 }
 
-function collectFeatureGlyphIds(fontBuffer, text) {
-  return enqueueWasm(() => collectFeatureGlyphIdsImpl(fontBuffer, text));
+function collectFeatureGlyphIds(fontBuffer, text, cssFeatureTags) {
+  return enqueueWasm(() =>
+    collectFeatureGlyphIdsImpl(fontBuffer, text, cssFeatureTags)
+  );
 }
 
 module.exports = collectFeatureGlyphIds;

package/lib/collectTextsByPage.js

@@ -45,11 +45,118 @@ const featureSettingsProps = new Set([
   'font-variant-position',
 ]);
 
-function ruleUsesFeatureSettings(rule) {
-  return rule.nodes.some(
-    (node) =>
-      node.type === 'decl' && featureSettingsProps.has(node.prop.toLowerCase())
-  );
+// 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) {
@@ -62,32 +169,108 @@ function ruleFontFamily(rule) {
   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).
-function findFontFamiliesWithFeatureSettings(stylesheetsWithPredicates) {
+// 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) return;
-      if (!ruleUsesFeatureSettings(rule)) return;
+      if (result === true && !featureTagsByFamily) return;
 
-      const fontFamily = ruleFontFamily(rule);
-      if (!fontFamily) {
-        // No font-family in this rule — conservatively assume all fonts
+      const recorded = recordRuleFeatureTags(rule, featureTagsByFamily);
+      if (!recorded) return;
+
+      if (recorded === true) {
         result = true;
-        return;
-      }
-      if (!result) result = new Set();
-      for (const family of cssFontParser.parseFontFamily(fontFamily)) {
-        result.add(family.toLowerCase());
+      } else {
+        if (!result) result = new Set();
+        for (const family of recorded) {
+          result.add(family.toLowerCase());
+        }
       }
     });
-    if (result === true) break;
+    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 };
+}
+
 const allInitialValues = require('./initialValueByProp');
 const initialValueByProp = {
   'font-style': allInitialValues['font-style'],
@@ -708,14 +891,17 @@ async function collectTextsByPage(
       }
     }
 
+    const featureTagsByFamily = new Map();
     const fontFamiliesWithFeatureSettings = findFontFamiliesWithFeatureSettings(
-      stylesheetsWithPredicates
+      stylesheetsWithPredicates,
+      featureTagsByFamily
     );
 
     const result = {
       accumulatedFontFaceDeclarations,
       stylesheetsWithPredicates,
       fontFamiliesWithFeatureSettings,
+      featureTagsByFamily,
       fastPathKey: buildStylesheetKey(htmlOrSvgAsset, true),
     };
     stylesheetResultCache.set(key, result);
@@ -739,6 +925,7 @@ async function collectTextsByPage(
       accumulatedFontFaceDeclarations,
       stylesheetsWithPredicates,
       fontFamiliesWithFeatureSettings,
+      featureTagsByFamily,
       fastPathKey,
     } = getOrComputeStylesheetResults(htmlOrSvgAsset);
     fontFaceDeclarationsByHtmlOrSvgAsset.set(
@@ -755,6 +942,7 @@ async function collectTextsByPage(
       accumulatedFontFaceDeclarations,
       stylesheetsWithPredicates,
       fontFamiliesWithFeatureSettings,
+      featureTagsByFamily,
       stylesheetCacheKey: fastPathKey,
     });
   }
@@ -833,6 +1021,7 @@ async function collectTextsByPage(
         textByProps: pd.textByProps,
         accumulatedFontFaceDeclarations: pd.accumulatedFontFaceDeclarations,
         fontFamiliesWithFeatureSettings: pd.fontFamiliesWithFeatureSettings,
+        featureTagsByFamily: pd.featureTagsByFamily,
       });
     }
 
@@ -872,6 +1061,7 @@ async function collectTextsByPage(
       textByProps,
       accumulatedFontFaceDeclarations,
       fontFamiliesWithFeatureSettings,
+      featureTagsByFamily,
     } = htmlOrSvgAssetTextsWithPropsEntry;
 
     // Get or compute the snapped global entries for this declarations set
@@ -932,17 +1122,12 @@ async function collectTextsByPage(
           uniqueCharsCache.set(pageTextStr, pageTextUnique);
         }
 
-        let hasFontFeatureSettings = false;
-        if (fontFamiliesWithFeatureSettings === true) {
-          hasFontFeatureSettings = true;
-        } else if (fontFamiliesWithFeatureSettings instanceof Set) {
-          for (const f of template.fontFamilies) {
-            if (fontFamiliesWithFeatureSettings.has(f.toLowerCase())) {
-              hasFontFeatureSettings = true;
-              break;
-            }
-          }
-        }
+        const { hasFontFeatureSettings, fontFeatureTags } =
+          resolveFeatureSettings(
+            template.fontFamilies,
+            fontFamiliesWithFeatureSettings,
+            featureTagsByFamily
+          );
 
         return {
           smallestOriginalSize: template.smallestOriginalSize,
@@ -959,6 +1144,7 @@ async function collectTextsByPage(
           fontVariationSettings: template.fontVariationSettings,
           preload: preloadFontUrls.has(template.fontUrl),
           hasFontFeatureSettings,
+          fontFeatureTags,
         };
       }
     );
@@ -1003,3 +1189,7 @@ async function collectTextsByPage(
 }
 
 module.exports = collectTextsByPage;
+
+// Exported for testing only
+module.exports._extractFeatureTagsFromDecl = extractFeatureTagsFromDecl;
+module.exports._resolveFeatureSettings = resolveFeatureSettings;

package/lib/subsetFontWithGlyphs.js

@@ -4,9 +4,16 @@ const { toSfnt } = require('./sfntCache');
 
 // hb_subset_sets_t enum values — https://github.com/harfbuzz/harfbuzz/blob/main/src/hb-subset.h
 const HB_SUBSET_SETS_GLYPH_INDEX = 0;
+const HB_SUBSET_SETS_DROP_TABLE_TAG = 5;
 const HB_SUBSET_SETS_LAYOUT_FEATURE_TAG = 6;
+const HB_SUBSET_SETS_NAME_ID = 4;
 
-// subset-font doesn't expose a glyphIds option, so we call harfbuzz directly.
+// hb_subset_flags_t
+const HB_SUBSET_FLAGS_NO_HINTING = 0x00000001;
+
+// All font subsetting goes through harfbuzz directly so we can apply
+// web-specific optimizations (no hinting, minimal name table, table
+// stripping) and support explicit glyph-ID inclusion.
 let _wasmExports;
 let _loadPromise;
 async function loadHarfbuzz() {
@@ -62,6 +69,15 @@ function setAxisRange(exports, input, face, axisName, value) {
   }
 }
 
+// Tables unnecessary for web rendering — safe to drop unconditionally.
+// gasp is only meaningful when hinting is present (which we strip above).
+const DROP_TABLE_TAGS = ['DSIG', 'LTSH', 'VDMX', 'hdmx', 'gasp', 'PCLT'];
+
+// Name IDs needed for web fonts: family (1), subfamily (2), full name (4),
+// PostScript name (6).  Copyright (0), unique ID (3), version (5), and
+// everything above 6 are display/license metadata that browsers never read.
+const KEEP_NAME_IDS = [1, 2, 4, 6];
+
 function configureSubsetInput(
   exports,
   input,
@@ -70,6 +86,7 @@ function configureSubsetInput(
   glyphIds,
   variationAxes
 ) {
+  // --- Retain all layout features ---
   const layoutFeatures = exports.hb_subset_input_set(
     input,
     HB_SUBSET_SETS_LAYOUT_FEATURE_TAG
@@ -77,11 +94,33 @@ function configureSubsetInput(
   exports.hb_set_clear(layoutFeatures);
   exports.hb_set_invert(layoutFeatures);
 
+  // --- Strip hinting instructions (ignored by modern browsers) ---
+  const flags = exports.hb_subset_input_get_flags(input);
+  exports.hb_subset_input_set_flags(input, flags | HB_SUBSET_FLAGS_NO_HINTING);
+
+  // --- Keep only essential name table entries ---
+  const nameIdSet = exports.hb_subset_input_set(input, HB_SUBSET_SETS_NAME_ID);
+  exports.hb_set_clear(nameIdSet);
+  for (const id of KEEP_NAME_IDS) {
+    exports.hb_set_add(nameIdSet, id);
+  }
+
+  // --- Drop tables not needed for web rendering ---
+  const dropTableSet = exports.hb_subset_input_set(
+    input,
+    HB_SUBSET_SETS_DROP_TABLE_TAG
+  );
+  for (const tag of DROP_TABLE_TAGS) {
+    exports.hb_set_add(dropTableSet, HB_TAG(tag));
+  }
+
+  // --- Add unicode codepoints ---
   const inputUnicodes = exports.hb_subset_input_unicode_set(input);
   for (const c of text) {
     exports.hb_set_add(inputUnicodes, c.codePointAt(0));
   }
 
+  // --- Add explicit glyph IDs (from feature glyph collection) ---
   if (glyphIds && glyphIds.length > 0) {
     const glyphSet = exports.hb_subset_input_set(
       input,
@@ -92,6 +131,7 @@ function configureSubsetInput(
     }
   }
 
+  // --- Pin/reduce variation axes ---
   if (variationAxes) {
     for (const [axisName, value] of Object.entries(variationAxes)) {
       if (typeof value === 'number') {

package/lib/subsetFonts.js

@@ -607,7 +607,9 @@ async function subsetFonts(
         ({ fontUsages, htmlOrSvgAsset }) => ({
           assetFileName: htmlOrSvgAsset.nonInlineAncestor.urlOrDescription,
           fontUsages: fontUsages.map((fontUsage) =>
-            (({ hasFontFeatureSettings, ...rest }) => rest)(fontUsage)
+            (({ hasFontFeatureSettings, fontFeatureTags, ...rest }) => rest)(
+              fontUsage
+            )
           ),
         })
       ),
@@ -1256,7 +1258,8 @@ async function subsetFonts(
       ({ fontUsages, htmlOrSvgAsset }) => ({
         assetFileName: htmlOrSvgAsset.nonInlineAncestor.urlOrDescription,
         fontUsages: fontUsages.map((fontUsage) =>
-          (({ subsets, hasFontFeatureSettings, ...rest }) => rest)(fontUsage)
+          (({ subsets, hasFontFeatureSettings, fontFeatureTags, ...rest }) =>
+            rest)(fontUsage)
         ),
       })
     ),

package/lib/subsetGeneration.js

@@ -1,11 +1,14 @@
 const fs = require('fs/promises');
 const pathModule = require('path');
 const crypto = require('crypto');
-const subsetFont = require('subset-font');
 const { getVariationAxisBounds } = require('./variationAxes');
 const collectFeatureGlyphIds = require('./collectFeatureGlyphIds');
 const subsetFontWithGlyphs = require('./subsetFontWithGlyphs');
 
+// Bump when subsetting behaviour changes to invalidate stale disk-cache
+// entries (e.g. after adding hinting removal or table stripping).
+const SUBSET_CACHE_VERSION = '2';
+
 function subsetCacheKey(
   fontBuffer,
   text,
@@ -14,6 +17,7 @@ function subsetCacheKey(
   featureGlyphIds
 ) {
   const hash = crypto.createHash('sha256');
+  hash.update(SUBSET_CACHE_VERSION);
   hash.update(fontBuffer);
   hash.update(text);
   hash.update(targetFormat);
@@ -182,7 +186,11 @@ async function getSubsetsForFontUsage(
 
     let featureGlyphIds;
     if (fontUsage.hasFontFeatureSettings && fontBuffer) {
-      featureGlyphIds = await collectFeatureGlyphIds(fontBuffer, text);
+      featureGlyphIds = await collectFeatureGlyphIds(
+        fontBuffer,
+        text,
+        fontUsage.fontFeatureTags
+      );
     }
 
     for (const targetFormat of formats) {
@@ -207,17 +215,11 @@ async function getSubsetsForFontUsage(
         if (cachedResult) {
           subsetPromiseMap.set(promiseId, Promise.resolve(cachedResult));
         } else {
-          const subsetCall =
-            featureGlyphIds && featureGlyphIds.length > 0
-              ? subsetFontWithGlyphs(fontBuffer, text, {
-                  targetFormat,
-                  glyphIds: featureGlyphIds,
-                  variationAxes: subsetInfo.variationAxes,
-                })
-              : subsetFont(fontBuffer, text, {
-                  targetFormat,
-                  variationAxes: subsetInfo.variationAxes,
-                });
+          const subsetCall = subsetFontWithGlyphs(fontBuffer, text, {
+            targetFormat,
+            glyphIds: featureGlyphIds,
+            variationAxes: subsetInfo.variationAxes,
+          });
 
           subsetPromiseMap.set(
             promiseId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turntrout/subfont",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Automatically subset web fonts to only the characters used on your pages. Fork of Munter/subfont with modern defaults.",
   "engines": {
     "node": ">=18.0.0"
@@ -64,7 +64,6 @@
     "pretty-bytes": "^5.1.0",
     "puppeteer-core": "^24.39.1",
     "specificity": "^0.4.1",
-    "subset-font": "^2.3.0",
     "urltools": "^0.4.1",
     "yargs": "^17.7.2"
   },