@turntrout/subfont 1.7.0 → 1.8.0

package/lib/subsetGeneration.js

@@ -1,352 +1,355 @@
-const fs = require('fs/promises');
-const pathModule = require('path');
-const crypto = require('crypto');
-const { getVariationAxisBounds } = require('./variationAxes');
-const collectFeatureGlyphIds = require('./collectFeatureGlyphIds');
-const subsetFontWithGlyphs = require('./subsetFontWithGlyphs');
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._SubsetDiskCache = void 0;
+exports.getSubsetPromiseId = getSubsetPromiseId;
+exports.getSubsetsForFontUsage = getSubsetsForFontUsage;
+exports._subsetCacheKey = subsetCacheKey;
+const fs = __importStar(require("fs/promises"));
+const pathModule = require("path");
+const crypto = __importStar(require("crypto"));
+const variationAxes_1 = require("./variationAxes");
+const collectFeatureGlyphIds = require("./collectFeatureGlyphIds");
+const subsetFontWithGlyphs = require("./subsetFontWithGlyphs");
+const codepointMaps_1 = require("./codepointMaps");
 // 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';
-
+const SUBSET_CACHE_VERSION = '4';
 // Cache the SHA-256 hash state after feeding SUBSET_CACHE_VERSION + fontBuffer.
 // For a font with 2 target formats this halves the hashing work on large buffers.
 // Uses WeakMap so entries are garbage-collected when the buffer is released.
 const fontBufferHashPrefixes = new WeakMap();
 function getFontBufferHashPrefix(fontBuffer) {
-  if (!fontBufferHashPrefixes.has(fontBuffer)) {
-    const hash = crypto.createHash('sha256');
-    hash.update(SUBSET_CACHE_VERSION);
-    hash.update(fontBuffer);
-    fontBufferHashPrefixes.set(fontBuffer, hash);
-  }
-  return fontBufferHashPrefixes.get(fontBuffer);
+    let cached = fontBufferHashPrefixes.get(fontBuffer);
+    if (!cached) {
+        cached = crypto.createHash('sha256');
+        cached.update(SUBSET_CACHE_VERSION);
+        cached.update(fontBuffer);
+        fontBufferHashPrefixes.set(fontBuffer, cached);
+    }
+    return cached;
 }
-
-function subsetCacheKey(
-  fontBuffer,
-  text,
-  targetFormat,
-  variationAxes,
-  featureGlyphIds
-) {
-  // Clone the pre-computed prefix (version + font buffer) and append
-  // the remaining fields. hash.copy() is O(1) — just copies the
-  // internal digest state, avoiding re-hashing the entire font buffer.
-  const hash = getFontBufferHashPrefix(fontBuffer).copy();
-  hash.update(text);
-  hash.update(targetFormat);
-  if (variationAxes) hash.update(JSON.stringify(variationAxes));
-  if (featureGlyphIds) hash.update(JSON.stringify(featureGlyphIds));
-  return hash.digest('hex');
+function subsetCacheKey(fontBuffer, text, targetFormat, variationAxes, featureGlyphIds, extraOptions = undefined) {
+    // Clone the pre-computed prefix (version + font buffer) and append
+    // the remaining fields. hash.copy() is O(1) — just copies the
+    // internal digest state, avoiding re-hashing the entire font buffer.
+    const hash = getFontBufferHashPrefix(fontBuffer).copy();
+    hash.update(text);
+    hash.update(targetFormat);
+    if (variationAxes)
+        hash.update(JSON.stringify(variationAxes));
+    if (featureGlyphIds)
+        hash.update(JSON.stringify(featureGlyphIds));
+    if (extraOptions)
+        hash.update(JSON.stringify(extraOptions));
+    return hash.digest('hex');
 }
-
 class SubsetDiskCache {
-  constructor(cacheDir, console) {
-    this._cacheDir = cacheDir;
-    this._console = console;
-    this._ensured = false;
-    this._warnedWrite = false;
-  }
-
-  async _ensureDir() {
-    if (!this._ensured) {
-      // Only attempt once — persistent failures (bad path, permissions)
-      // are far more common than transient ones, and retrying just
-      // produces repeated warnings.
-      this._ensured = true;
-      try {
-        await fs.mkdir(this._cacheDir, { recursive: true });
-      } catch (err) {
-        if (this._console) {
-          this._console.warn(
-            `subfont: cache directory ${this._cacheDir} could not be created: ${err.message}`
-          );
+    _cacheDir;
+    _console;
+    _ensured;
+    _warnedWrite;
+    constructor(cacheDir, console) {
+        this._cacheDir = cacheDir;
+        this._console = console ?? null;
+        this._ensured = false;
+        this._warnedWrite = false;
+    }
+    async _ensureDir() {
+        if (!this._ensured) {
+            // Only attempt once — persistent failures (bad path, permissions)
+            // are far more common than transient ones, and retrying just
+            // produces repeated warnings.
+            this._ensured = true;
+            try {
+                await fs.mkdir(this._cacheDir, { recursive: true });
+            }
+            catch (err) {
+                if (this._console) {
+                    this._console.warn(`subfont: cache directory ${this._cacheDir} could not be created: ${err.message}`);
+                }
+            }
         }
-      }
     }
-  }
-
-  async get(key) {
-    const filePath = pathModule.join(this._cacheDir, key);
-    try {
-      return await fs.readFile(filePath);
-    } catch {
-      return undefined;
+    async get(key) {
+        const filePath = pathModule.join(this._cacheDir, key);
+        try {
+            return await fs.readFile(filePath);
+        }
+        catch {
+            return undefined;
+        }
     }
-  }
-
-  async set(key, buffer) {
-    await this._ensureDir();
-    const filePath = pathModule.join(this._cacheDir, key);
-    try {
-      await fs.writeFile(filePath, buffer);
-    } catch (err) {
-      // If the directory was removed after init, retry once
-      if (err.code === 'ENOENT') {
+    async set(key, buffer) {
+        await this._ensureDir();
+        const filePath = pathModule.join(this._cacheDir, key);
         try {
-          await fs.mkdir(this._cacheDir, { recursive: true });
-          await fs.writeFile(filePath, buffer);
-          return;
-        } catch {
-          // Fall through to warning below
+            await fs.writeFile(filePath, buffer);
+        }
+        catch (err) {
+            const errno = err;
+            // If the directory was removed after init, retry once
+            if (errno.code === 'ENOENT') {
+                try {
+                    await fs.mkdir(this._cacheDir, { recursive: true });
+                    await fs.writeFile(filePath, buffer);
+                    return;
+                }
+                catch {
+                    // Fall through to warning below
+                }
+            }
+            if (this._warnedWrite)
+                return;
+            this._warnedWrite = true;
+            if (this._console) {
+                this._console.warn(`subfont: failed to write cache entry ${key}: ${errno.message}`);
+            }
         }
-      }
-      if (this._warnedWrite) return;
-      this._warnedWrite = true;
-      if (this._console) {
-        this._console.warn(
-          `subfont: failed to write cache entry ${key}: ${err.message}`
-        );
-      }
     }
-  }
 }
-
+exports._SubsetDiskCache = SubsetDiskCache;
 function getSubsetPromiseId(fontUsage, format, variationAxes = null) {
-  return [
-    fontUsage.text,
-    fontUsage.fontUrl,
-    format,
-    JSON.stringify(variationAxes),
-  ].join('\x1d');
+    return [
+        fontUsage.text,
+        fontUsage.fontUrl,
+        format,
+        JSON.stringify(variationAxes),
+    ].join('\x1d');
 }
-
-async function getSubsetsForFontUsage(
-  assetGraph,
-  htmlOrSvgAssetTextsWithProps,
-  formats,
-  seenAxisValuesByFontUrlAndAxisName,
-  cacheDir = null,
-  console = null,
-  debug = false
-) {
-  const diskCache = cacheDir ? new SubsetDiskCache(cacheDir, console) : null;
-  const cacheStats = diskCache ? { hits: 0, misses: 0 } : null;
-
-  // Collect one canonical fontUsage per font URL
-  const canonicalFontUsageByUrl = new Map();
-  for (const item of htmlOrSvgAssetTextsWithProps) {
-    for (const fontUsage of item.fontUsages) {
-      if (
-        fontUsage.fontUrl &&
-        !canonicalFontUsageByUrl.has(fontUsage.fontUrl)
-      ) {
-        canonicalFontUsageByUrl.set(fontUsage.fontUrl, fontUsage);
-      }
-    }
-  }
-
-  const allFontUrls = [...canonicalFontUsageByUrl.keys()];
-
-  // Load font assets
-  await assetGraph.populate({
-    followRelations: {
-      to: { url: { $or: allFontUrls } },
-    },
-  });
-
-  const fontAssetsByUrl = new Map();
-  const originalFontBuffers = new Map();
-  for (const fontUrl of allFontUrls) {
-    const fontAsset = assetGraph.findAssets({
-      url: fontUrl,
-      isLoaded: true,
-    })[0];
-    if (fontAsset) {
-      fontAssetsByUrl.set(fontUrl, fontAsset);
-      originalFontBuffers.set(fontUrl, fontAsset.rawSrc);
-    }
-  }
-
-  // Compute variation axis bounds for all fonts in parallel
-  const fontUrlsWithAssets = allFontUrls.filter((url) =>
-    fontAssetsByUrl.has(url)
-  );
-  const boundsResults = await Promise.all(
-    fontUrlsWithAssets.map((fontUrl) =>
-      getVariationAxisBounds(
-        fontAssetsByUrl,
-        fontUrl,
-        seenAxisValuesByFontUrlAndAxisName
-      )
-    )
-  );
-  const variationAxisBoundsCache = new Map();
-  for (let i = 0; i < fontUrlsWithAssets.length; i++) {
-    variationAxisBoundsCache.set(fontUrlsWithAssets[i], boundsResults[i]);
-  }
-
-  const subsetPromiseMap = new Map();
-  const subsetInfoByFontUrl = new Map();
-
-  // Process fonts concurrently — each font's feature glyph collection
-  // and subset queuing run in parallel, so fonts without feature settings
-  // don't wait behind fonts that need collectFeatureGlyphIds.
-  await Promise.all(
-    [...canonicalFontUsageByUrl].map(async ([fontUrl, fontUsage]) => {
-      const fontBuffer = originalFontBuffers.get(fontUrl);
-      if (!fontBuffer) return;
-      const text = fontUsage.text;
-
-      const bounds = variationAxisBoundsCache.get(fontUrl);
-      const subsetInfo = bounds
-        ? {
-            variationAxes: bounds.variationAxes,
-            fullyInstanced: bounds.fullyInstanced,
-            numAxesPinned: bounds.numAxesPinned,
-            numAxesReduced: bounds.numAxesReduced,
-          }
-        : {
-            variationAxes: undefined,
-            fullyInstanced: false,
-            numAxesPinned: 0,
-            numAxesReduced: 0,
-          };
-      subsetInfoByFontUrl.set(fontUrl, subsetInfo);
-
-      let featureGlyphIds;
-      if (fontUsage.hasFontFeatureSettings && fontBuffer) {
-        try {
-          featureGlyphIds = await collectFeatureGlyphIds(
-            fontBuffer,
-            text,
-            fontUsage.fontFeatureTags
-          );
-        } catch (err) {
-          // Feature glyph collection failed — continue without feature
-          // glyphs rather than blocking all fonts (Promise.all would
-          // reject entirely if this propagated).
-          err.asset = err.asset || fontAssetsByUrl.get(fontUrl);
-          assetGraph.warn(err);
+async function getSubsetsForFontUsage(assetGraph, htmlOrSvgAssetTextsWithProps, formats, seenAxisValuesByFontUrlAndAxisName, cacheDir = null, console = null, debug = false) {
+    const diskCache = cacheDir ? new SubsetDiskCache(cacheDir, console) : null;
+    const cacheStats = diskCache ? { hits: 0, misses: 0 } : null;
+    // Collect one canonical fontUsage per font URL
+    const canonicalFontUsageByUrl = new Map();
+    for (const item of htmlOrSvgAssetTextsWithProps) {
+        for (const fontUsage of item.fontUsages) {
+            if (fontUsage.fontUrl &&
+                !canonicalFontUsageByUrl.has(fontUsage.fontUrl)) {
+                canonicalFontUsageByUrl.set(fontUsage.fontUrl, fontUsage);
+            }
         }
-      }
-
-      for (const targetFormat of formats) {
-        const promiseId = getSubsetPromiseId(
-          fontUsage,
-          targetFormat,
-          subsetInfo.variationAxes
-        );
-
-        if (!subsetPromiseMap.has(promiseId)) {
-          const cacheKey = diskCache
-            ? subsetCacheKey(
-                fontBuffer,
-                text,
-                targetFormat,
-                subsetInfo.variationAxes,
-                featureGlyphIds
-              )
-            : null;
-          const cachedResult = diskCache ? await diskCache.get(cacheKey) : null;
-
-          if (cachedResult) {
-            if (cacheStats) cacheStats.hits++;
-            subsetPromiseMap.set(promiseId, Promise.resolve(cachedResult));
-          } else {
-            if (cacheStats) cacheStats.misses++;
-            const subsetCall = subsetFontWithGlyphs(fontBuffer, text, {
-              targetFormat,
-              glyphIds: featureGlyphIds,
-              variationAxes: subsetInfo.variationAxes,
-            });
-
-            subsetPromiseMap.set(
-              promiseId,
-              subsetCall
-                .then(async (result) => {
-                  if (diskCache && result) {
-                    // Fire-and-forget: cache writes are best-effort.
-                    // Errors are handled inside set(); the catch is a
-                    // safety net against unhandled rejections.
-                    diskCache.set(cacheKey, result).catch(() => {});
-                  }
-                  return result;
-                })
-                .catch((err) => {
-                  err.asset = err.asset || fontAssetsByUrl.get(fontUrl);
-                  assetGraph.warn(err);
-                  return null;
-                })
-            );
-          }
+    }
+    const allFontUrls = [...canonicalFontUsageByUrl.keys()];
+    // Load font assets
+    await assetGraph.populate({
+        followRelations: {
+            to: { url: { $or: allFontUrls } },
+        },
+    });
+    const fontAssetsByUrl = new Map();
+    const originalFontBuffers = new Map();
+    for (const fontUrl of allFontUrls) {
+        const fontAsset = assetGraph.findAssets({
+            url: fontUrl,
+            isLoaded: true,
+        })[0];
+        if (fontAsset) {
+            fontAssetsByUrl.set(fontUrl, fontAsset);
+            originalFontBuffers.set(fontUrl, fontAsset.rawSrc);
         }
-      }
-    })
-  );
-
-  // Await all subset promises
-  const resolvedSubsets = new Map(
-    await Promise.all(
-      [...subsetPromiseMap].map(async ([key, promise]) => [key, await promise])
-    )
-  );
-
-  if (cacheStats && debug && console) {
-    const total = cacheStats.hits + cacheStats.misses;
-    const pct = total > 0 ? Math.round((cacheStats.hits * 100) / total) : 0;
-    console.log(
-      `[subfont timing]   subset disk cache: ${cacheStats.hits} hit${cacheStats.hits === 1 ? '' : 's'}, ${cacheStats.misses} miss${cacheStats.misses === 1 ? '' : 'es'} (${pct}% hit rate)`
-    );
-  }
-
-  // Assign subset results to canonical font usages
-  for (const [, fontUsage] of canonicalFontUsageByUrl) {
-    const info = subsetInfoByFontUrl.get(fontUsage.fontUrl);
-    for (const targetFormat of formats) {
-      const promiseId = getSubsetPromiseId(
-        fontUsage,
-        targetFormat,
-        info.variationAxes
-      );
-      const subsetBuffer = resolvedSubsets.get(promiseId);
-      if (subsetBuffer) {
-        if (!fontUsage.subsets) {
-          fontUsage.subsets = {};
+    }
+    // Compute variation axis bounds for all fonts in parallel
+    const fontUrlsWithAssets = allFontUrls.filter((url) => fontAssetsByUrl.has(url));
+    const boundsResults = await Promise.all(fontUrlsWithAssets.map((fontUrl) => (0, variationAxes_1.getVariationAxisBounds)(fontAssetsByUrl, fontUrl, seenAxisValuesByFontUrlAndAxisName)));
+    const variationAxisBoundsCache = new Map();
+    for (let i = 0; i < fontUrlsWithAssets.length; i++) {
+        variationAxisBoundsCache.set(fontUrlsWithAssets[i], boundsResults[i]);
+    }
+    const subsetPromiseMap = new Map();
+    const subsetInfoByFontUrl = new Map();
+    // Process fonts concurrently — each font's feature glyph collection
+    // and subset queuing run in parallel, so fonts without feature settings
+    // don't wait behind fonts that need collectFeatureGlyphIds.
+    await Promise.all([...canonicalFontUsageByUrl].map(async ([fontUrl, fontUsage]) => {
+        const fontBuffer = originalFontBuffers.get(fontUrl);
+        if (!fontBuffer)
+            return;
+        const text = fontUsage.text;
+        const bounds = variationAxisBoundsCache.get(fontUrl);
+        const subsetInfo = bounds
+            ? {
+                variationAxes: bounds.variationAxes,
+                fullyInstanced: bounds.fullyInstanced,
+                numAxesPinned: bounds.numAxesPinned,
+                numAxesReduced: bounds.numAxesReduced,
+            }
+            : {
+                variationAxes: undefined,
+                fullyInstanced: false,
+                numAxesPinned: 0,
+                numAxesReduced: 0,
+            };
+        subsetInfoByFontUrl.set(fontUrl, subsetInfo);
+        let featureGlyphIds;
+        if (fontUsage.hasFontFeatureSettings) {
+            try {
+                featureGlyphIds = await collectFeatureGlyphIds(fontBuffer, text, fontUsage.fontFeatureTags);
+            }
+            catch (rawErr) {
+                // Feature glyph collection failed — continue without feature
+                // glyphs rather than blocking all fonts (Promise.all would
+                // reject entirely if this propagated).
+                const err = rawErr instanceof Error
+                    ? rawErr
+                    : new Error(String(rawErr));
+                err.asset =
+                    err.asset || fontAssetsByUrl.get(fontUrl);
+                assetGraph.warn(err);
+            }
         }
-        fontUsage.subsets[targetFormat] = subsetBuffer;
-        const size = subsetBuffer.length;
-        if (
-          !fontUsage.smallestSubsetSize ||
-          size < fontUsage.smallestSubsetSize
-        ) {
-          fontUsage.smallestSubsetSize = size;
-          fontUsage.smallestSubsetFormat = targetFormat;
-          fontUsage.variationAxes = info.variationAxes;
-          fontUsage.fullyInstanced = info.fullyInstanced;
-          fontUsage.numAxesPinned = info.numAxesPinned;
-          fontUsage.numAxesReduced = info.numAxesReduced;
+        // Per-fontUsage decisions — same across all target formats.
+        // False positives (keeping a table the page doesn't need) cost a few
+        // hundred bytes; false negatives (dropping a needed table) break
+        // rendering, so the heuristics err on the side of keeping.
+        const extraOptions = {
+            dropMathTable: !(0, codepointMaps_1.pageNeedsMathTable)(text),
+            dropColorTables: !(0, codepointMaps_1.pageNeedsColorTables)(text),
+            scriptTags: (0, codepointMaps_1.scriptsForText)(text),
+        };
+        // Targeted feature retention when we can fully enumerate the
+        // CSS-requested feature tags. If the page declares feature settings
+        // but the tags couldn't be extracted (e.g. resolution through CSS
+        // custom-property var() chains is incomplete), fall back to retain-
+        // all so we don't drop features the page actually uses.
+        const featureTags = fontUsage.hasFontFeatureSettings && !fontUsage.fontFeatureTags
+            ? undefined
+            : fontUsage.fontFeatureTags
+                ? [...fontUsage.fontFeatureTags]
+                : [];
+        for (const targetFormat of formats) {
+            const promiseId = getSubsetPromiseId(fontUsage, targetFormat, subsetInfo.variationAxes);
+            if (!subsetPromiseMap.has(promiseId)) {
+                const cacheKey = diskCache
+                    ? subsetCacheKey(fontBuffer, text, targetFormat, subsetInfo.variationAxes, featureGlyphIds, extraOptions)
+                    : null;
+                const cachedResult = diskCache && cacheKey ? await diskCache.get(cacheKey) : null;
+                if (cachedResult) {
+                    if (cacheStats)
+                        cacheStats.hits++;
+                    subsetPromiseMap.set(promiseId, Promise.resolve(cachedResult));
+                }
+                else {
+                    if (cacheStats)
+                        cacheStats.misses++;
+                    const subsetCall = subsetFontWithGlyphs(fontBuffer, text, {
+                        targetFormat,
+                        glyphIds: featureGlyphIds,
+                        variationAxes: subsetInfo.variationAxes,
+                        featureTags,
+                        ...extraOptions,
+                    });
+                    subsetPromiseMap.set(promiseId, subsetCall
+                        .then(async (result) => {
+                        if (diskCache && result && cacheKey) {
+                            // Fire-and-forget: cache writes are best-effort.
+                            // Errors are handled inside set(); the catch is a
+                            // safety net against unhandled rejections.
+                            diskCache.set(cacheKey, result).catch(() => { });
+                        }
+                        return result;
+                    })
+                        .catch((rawErr) => {
+                        const err = rawErr instanceof Error
+                            ? rawErr
+                            : new Error(String(rawErr));
+                        err.asset =
+                            err.asset ||
+                                fontAssetsByUrl.get(fontUrl);
+                        assetGraph.warn(err);
+                        return null;
+                    }));
+                }
+            }
         }
-      }
+    }));
+    // Await all subset promises
+    const resolvedSubsets = new Map(await Promise.all([...subsetPromiseMap].map(async ([key, promise]) => [key, await promise])));
+    if (cacheStats && debug && console) {
+        const total = cacheStats.hits + cacheStats.misses;
+        const pct = total > 0 ? Math.round((cacheStats.hits * 100) / total) : 0;
+        console.log(`[subfont timing]   subset disk cache: ${cacheStats.hits} hit${cacheStats.hits === 1 ? '' : 's'}, ${cacheStats.misses} miss${cacheStats.misses === 1 ? '' : 'es'} (${pct}% hit rate)`);
     }
-  }
-
-  // Propagate subsets to non-canonical font usages
-  for (const item of htmlOrSvgAssetTextsWithProps) {
-    for (const fontUsage of item.fontUsages) {
-      if (!fontUsage.fontUrl) continue;
-      const canonical = canonicalFontUsageByUrl.get(fontUsage.fontUrl);
-      if (canonical && canonical !== fontUsage && canonical.subsets) {
+    // Assign subset results to canonical font usages
+    for (const [, fontUsage] of canonicalFontUsageByUrl) {
         const info = subsetInfoByFontUrl.get(fontUsage.fontUrl);
-        fontUsage.subsets = canonical.subsets;
-        fontUsage.smallestSubsetSize = canonical.smallestSubsetSize;
-        fontUsage.smallestSubsetFormat = canonical.smallestSubsetFormat;
-        fontUsage.variationAxes = info.variationAxes;
-        fontUsage.fullyInstanced = info.fullyInstanced;
-        fontUsage.numAxesPinned = info.numAxesPinned;
-        fontUsage.numAxesReduced = info.numAxesReduced;
-      }
+        if (!info)
+            continue;
+        for (const targetFormat of formats) {
+            const promiseId = getSubsetPromiseId(fontUsage, targetFormat, info.variationAxes);
+            const subsetBuffer = resolvedSubsets.get(promiseId);
+            if (subsetBuffer) {
+                if (!fontUsage.subsets) {
+                    fontUsage.subsets = {};
+                }
+                fontUsage.subsets[targetFormat] = subsetBuffer;
+                const size = subsetBuffer.length;
+                if (!fontUsage.smallestSubsetSize ||
+                    size < fontUsage.smallestSubsetSize) {
+                    fontUsage.smallestSubsetSize = size;
+                    fontUsage.smallestSubsetFormat = targetFormat;
+                    fontUsage.variationAxes = info.variationAxes;
+                    fontUsage.fullyInstanced = info.fullyInstanced;
+                    fontUsage.numAxesPinned = info.numAxesPinned;
+                    fontUsage.numAxesReduced = info.numAxesReduced;
+                }
+            }
+        }
+    }
+    // Propagate subsets to non-canonical font usages
+    for (const item of htmlOrSvgAssetTextsWithProps) {
+        for (const fontUsage of item.fontUsages) {
+            if (!fontUsage.fontUrl)
+                continue;
+            const canonical = canonicalFontUsageByUrl.get(fontUsage.fontUrl);
+            if (canonical && canonical !== fontUsage && canonical.subsets) {
+                const info = subsetInfoByFontUrl.get(fontUsage.fontUrl);
+                if (!info)
+                    continue;
+                // Shallow-copy so per-page mutation of one fontUsage's subsets
+                // doesn't leak into the canonical entry or other pages.
+                fontUsage.subsets = { ...canonical.subsets };
+                fontUsage.smallestSubsetSize = canonical.smallestSubsetSize;
+                fontUsage.smallestSubsetFormat = canonical.smallestSubsetFormat;
+                fontUsage.variationAxes = info.variationAxes;
+                fontUsage.fullyInstanced = info.fullyInstanced;
+                fontUsage.numAxesPinned = info.numAxesPinned;
+                fontUsage.numAxesReduced = info.numAxesReduced;
+            }
+        }
     }
-  }
-
-  return fontAssetsByUrl;
+    return fontAssetsByUrl;
 }
-
-module.exports = {
-  getSubsetPromiseId,
-  getSubsetsForFontUsage,
-  // Exported for testing
-  _subsetCacheKey: subsetCacheKey,
-  _SubsetDiskCache: SubsetDiskCache,
-};
+//# sourceMappingURL=subsetGeneration.js.map