@turntrout/subfont 1.7.1 → 1.8.0

package/lib/variationAxes.js

@@ -1,173 +1,143 @@
-const getFontInfo = require('./getFontInfo');
-const parseFontVariationSettings = require('./parseFontVariationSettings');
-
-const standardVariationAxes = new Set(['wght', 'wdth', 'ital', 'slnt', 'opsz']);
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderNumberRange = renderNumberRange;
+exports.getVariationAxisUsage = getVariationAxisUsage;
+exports.getVariationAxisBounds = getVariationAxisBounds;
+const getFontInfo = require("./getFontInfo");
+const parseFontVariationSettings = require("./parseFontVariationSettings");
 // CSS oblique without an explicit <angle> defaults to 14deg. The OpenType slnt
 // axis uses the opposite sign convention (positive = counter-clockwise), so
 // CSS maps oblique to slnt -14.
 const DEFAULT_OBLIQUE_SLNT = -14;
-
-// When no opsz values are determined from font-variation-settings, the axis is
-// pinned to its default value rather than preserving the full range, which can
-// significantly bloat variable font subsets.
-const ignoredVariationAxes = new Set();
-
 function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
+    return Math.min(Math.max(value, min), max);
 }
-
 function renderNumberRange(min, max) {
-  if (min === max) {
-    return String(min);
-  } else {
-    return `${min}-${max}`;
-  }
-}
-
-function getVariationAxisUsage(
-  htmlOrSvgAssetTextsWithProps,
-  parseFontWeightRange,
-  parseFontStretchRange
-) {
-  const seenAxisValuesByFontUrlAndAxisName = new Map();
-
-  function noteUsedValue(fontUrl, axisName, axisValue) {
-    let seenAxes = seenAxisValuesByFontUrlAndAxisName.get(fontUrl);
-    if (!seenAxes) {
-      seenAxes = new Map();
-      seenAxisValuesByFontUrlAndAxisName.set(fontUrl, seenAxes);
+    if (min === max) {
+        return String(min);
     }
-    if (seenAxes.has(axisName)) {
-      seenAxes.get(axisName).add(axisValue);
-    } else {
-      seenAxes.set(axisName, new Set([axisValue]));
+    else {
+        return `${min}-${max}`;
     }
-  }
-
-  // Since fontUsages are built from shared templates, all pages produce
-  // the same fontStyles/fontWeights/etc. for a given fontUrl. Process
-  // each unique fontUrl only once to avoid num_pages × redundant iterations.
-  const seenFontUrls = new Set();
-  for (const { fontUsages } of htmlOrSvgAssetTextsWithProps) {
-    for (const {
-      fontUrl,
-      fontStyles,
-      fontWeights,
-      fontStretches,
-      fontVariationSettings,
-      props,
-    } of fontUsages) {
-      if (seenFontUrls.has(fontUrl)) continue;
-      seenFontUrls.add(fontUrl);
-      if (fontStyles.has('italic')) {
-        noteUsedValue(fontUrl, 'ital', 1);
-      }
-      // If any font-style value except italic is seen (including normal or oblique)
-      // we're also utilizing value 0:
-      if (fontStyles.size > (fontStyles.has('italic') ? 1 : 0)) {
-        noteUsedValue(fontUrl, 'ital', 0);
-      }
-      if (fontStyles.has('oblique')) {
-        // https://www.w3.org/TR/css-fonts-4/#font-style-prop
-        // oblique <angle>?
-        //   [...] The lack of an <angle> represents 14deg.
-        // And also:
-        //   Note: the OpenType slnt axis is defined with a positive angle meaning a counter-clockwise slant, the opposite direction to CSS.
-        // The CSS implementation will take this into account when using variations to produce oblique faces.
-        noteUsedValue(fontUrl, 'slnt', DEFAULT_OBLIQUE_SLNT);
-      }
-      // If any font-style value except oblique is seen (including normal or italic)
-      // we're also utilizing value 0:
-      if (fontStyles.size > (fontStyles.has('oblique') ? 1 : 0)) {
-        noteUsedValue(fontUrl, 'slnt', 0);
-      }
-
-      const minMaxFontWeight = parseFontWeightRange(props['font-weight']);
-      for (const fontWeight of fontWeights) {
-        noteUsedValue(fontUrl, 'wght', clamp(fontWeight, ...minMaxFontWeight));
-      }
-
-      const minMaxFontStretch = parseFontStretchRange(props['font-stretch']);
-      for (const fontStretch of fontStretches) {
-        noteUsedValue(
-          fontUrl,
-          'wdth',
-          clamp(fontStretch, ...minMaxFontStretch)
-        );
-      }
-
-      for (const fontVariationSettingsValue of fontVariationSettings) {
-        for (const [axisName, axisValue] of parseFontVariationSettings(
-          fontVariationSettingsValue
-        )) {
-          noteUsedValue(fontUrl, axisName, axisValue);
+}
+function getVariationAxisUsage(htmlOrSvgAssetTextsWithProps, parseFontWeightRange, parseFontStretchRange) {
+    const seenAxisValuesByFontUrlAndAxisName = new Map();
+    function noteUsedValue(fontUrl, axisName, axisValue) {
+        let seenAxes = seenAxisValuesByFontUrlAndAxisName.get(fontUrl);
+        if (!seenAxes) {
+            seenAxes = new Map();
+            seenAxisValuesByFontUrlAndAxisName.set(fontUrl, seenAxes);
+        }
+        const existing = seenAxes.get(axisName);
+        if (existing) {
+            existing.add(axisValue);
+        }
+        else {
+            seenAxes.set(axisName, new Set([axisValue]));
         }
-      }
     }
-  }
-
-  return { seenAxisValuesByFontUrlAndAxisName };
+    // Since fontUsages are built from shared templates, all pages produce
+    // the same fontStyles/fontWeights/etc. for a given fontUrl. Process
+    // each unique fontUrl only once to avoid num_pages × redundant iterations.
+    const seenFontUrls = new Set();
+    for (const { fontUsages } of htmlOrSvgAssetTextsWithProps) {
+        for (const { fontUrl, fontStyles, fontWeights, fontStretches, fontVariationSettings, props, } of fontUsages) {
+            if (seenFontUrls.has(fontUrl))
+                continue;
+            seenFontUrls.add(fontUrl);
+            if (fontStyles.has('italic')) {
+                noteUsedValue(fontUrl, 'ital', 1);
+            }
+            // If any font-style value except italic is seen (including normal or oblique)
+            // we're also utilizing value 0:
+            if (fontStyles.size > (fontStyles.has('italic') ? 1 : 0)) {
+                noteUsedValue(fontUrl, 'ital', 0);
+            }
+            if (fontStyles.has('oblique')) {
+                noteUsedValue(fontUrl, 'slnt', DEFAULT_OBLIQUE_SLNT);
+            }
+            // If any font-style value except oblique is seen (including normal or italic)
+            // we're also utilizing value 0:
+            if (fontStyles.size > (fontStyles.has('oblique') ? 1 : 0)) {
+                noteUsedValue(fontUrl, 'slnt', 0);
+            }
+            const minMaxFontWeight = parseFontWeightRange(props['font-weight']);
+            for (const fontWeight of fontWeights) {
+                noteUsedValue(fontUrl, 'wght', clamp(fontWeight, ...minMaxFontWeight));
+            }
+            const minMaxFontStretch = parseFontStretchRange(props['font-stretch']);
+            for (const fontStretch of fontStretches) {
+                noteUsedValue(fontUrl, 'wdth', clamp(fontStretch, ...minMaxFontStretch));
+            }
+            for (const fontVariationSettingsValue of fontVariationSettings) {
+                for (const [axisName, axisValue] of parseFontVariationSettings(fontVariationSettingsValue)) {
+                    noteUsedValue(fontUrl, axisName, axisValue);
+                }
+            }
+        }
+    }
+    return { seenAxisValuesByFontUrlAndAxisName };
 }
-
-async function getVariationAxisBounds(
-  fontAssetsByUrl,
-  fontUrl,
-  seenAxisValuesByFontUrlAndAxisName
-) {
-  let fontInfo;
-  try {
-    fontInfo = await getFontInfo(fontAssetsByUrl.get(fontUrl).rawSrc);
-  } catch {
-    // Invalid font -- skip instancing, return safe defaults
-    return {
-      fullyInstanced: false,
-      numAxesPinned: 0,
-      numAxesReduced: 0,
-      variationAxes: {},
-    };
-  }
-
-  const variationAxes = {};
-  let fullyInstanced = true;
-  let numAxesPinned = 0;
-  let numAxesReduced = 0;
-  const fontVariationEntries = Object.entries(fontInfo.variationAxes);
-  const seenAxisValuesByAxisName =
-    seenAxisValuesByFontUrlAndAxisName.get(fontUrl);
-  if (fontVariationEntries.length > 0 && seenAxisValuesByAxisName) {
-    for (const [
-      axisName,
-      { min, max, default: defaultValue },
-    ] of fontVariationEntries) {
-      let seenAxisValues = seenAxisValuesByAxisName.get(axisName);
-      if (!seenAxisValues && !ignoredVariationAxes.has(axisName)) {
-        seenAxisValues = new Set([defaultValue]);
-      }
-      if (seenAxisValues && seenAxisValues.size === 1) {
-        variationAxes[axisName] = clamp([...seenAxisValues][0], min, max);
-        numAxesPinned += 1;
-      } else if (seenAxisValues) {
-        const minSeenValue = Math.min(...seenAxisValues);
-        const maxSeenValue = Math.max(...seenAxisValues);
-        variationAxes[axisName] = {
-          min: Math.max(minSeenValue, min),
-          max: Math.min(maxSeenValue, max),
+async function getVariationAxisBounds(fontAssetsByUrl, fontUrl, seenAxisValuesByFontUrlAndAxisName) {
+    let fontInfo;
+    try {
+        const asset = fontAssetsByUrl.get(fontUrl);
+        if (!asset) {
+            return {
+                fullyInstanced: false,
+                numAxesPinned: 0,
+                numAxesReduced: 0,
+                variationAxes: {},
+            };
+        }
+        fontInfo = await getFontInfo(asset.rawSrc);
+    }
+    catch {
+        // Invalid font -- skip instancing, return safe defaults
+        return {
+            fullyInstanced: false,
+            numAxesPinned: 0,
+            numAxesReduced: 0,
+            variationAxes: {},
         };
-        fullyInstanced = false;
-        if (minSeenValue > min || maxSeenValue < max) {
-          numAxesReduced += 1;
+    }
+    const variationAxes = {};
+    let fullyInstanced = true;
+    let numAxesPinned = 0;
+    let numAxesReduced = 0;
+    const fontVariationEntries = Object.entries(fontInfo.variationAxes);
+    const seenAxisValuesByAxisName = seenAxisValuesByFontUrlAndAxisName.get(fontUrl);
+    if (fontVariationEntries.length > 0 && seenAxisValuesByAxisName) {
+        for (const [axisName, { min, max, default: defaultValue },] of fontVariationEntries) {
+            let seenAxisValues = seenAxisValuesByAxisName.get(axisName);
+            if (!seenAxisValues) {
+                seenAxisValues = new Set([defaultValue]);
+            }
+            if (seenAxisValues.size === 1) {
+                const [only] = seenAxisValues;
+                variationAxes[axisName] = clamp(only, min, max);
+                numAxesPinned += 1;
+            }
+            else {
+                let minSeenValue = Infinity;
+                let maxSeenValue = -Infinity;
+                for (const v of seenAxisValues) {
+                    if (v < minSeenValue)
+                        minSeenValue = v;
+                    if (v > maxSeenValue)
+                        maxSeenValue = v;
+                }
+                variationAxes[axisName] = {
+                    min: Math.max(minSeenValue, min),
+                    max: Math.min(maxSeenValue, max),
+                };
+                fullyInstanced = false;
+                if (minSeenValue > min || maxSeenValue < max) {
+                    numAxesReduced += 1;
+                }
+            }
         }
-      }
     }
-  }
-  return { fullyInstanced, numAxesPinned, numAxesReduced, variationAxes };
+    return { fullyInstanced, numAxesPinned, numAxesReduced, variationAxes };
 }
-
-module.exports = {
-  standardVariationAxes,
-  ignoredVariationAxes,
-  renderNumberRange,
-  getVariationAxisUsage,
-  getVariationAxisBounds,
-};
+//# sourceMappingURL=variationAxes.js.map

package/lib/variationAxes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variationAxes.js","sourceRoot":"","sources":["../src/variationAxes.ts"],"names":[],"mappings":"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"}

package/lib/warnAboutMissingGlyphs.d.ts

@@ -0,0 +1,43 @@
+interface AtRuleLike {
+    some(predicate: (node: {
+        prop?: string;
+    }) => boolean): boolean;
+    append(decl: {
+        prop: string;
+        value: string;
+    }): void;
+}
+interface FontFaceRelationLike {
+    from: {
+        markDirty(): void;
+    };
+    node: AtRuleLike;
+}
+interface FontFaceDeclaration {
+    'font-family'?: string;
+    relations: FontFaceRelationLike[];
+}
+interface FontUsageLike {
+    subsets?: Record<string, Buffer | Uint8Array>;
+    pageText: string;
+    fontFamilies: Set<string>;
+    codepoints: {
+        original: number[];
+    };
+    props: Record<string, string>;
+}
+interface AssetTextEntry {
+    htmlOrSvgAsset: {
+        text: string;
+        urlOrDescription: string;
+    };
+    fontUsages: FontUsageLike[];
+    accumulatedFontFaceDeclarations: FontFaceDeclaration[];
+}
+interface AssetGraphLike {
+    warn(err: Error): void;
+    info(err: Error): void;
+}
+declare function warnAboutMissingGlyphs(htmlOrSvgAssetTextsWithProps: AssetTextEntry[], assetGraph: AssetGraphLike): Promise<void>;
+export = warnAboutMissingGlyphs;
+//# sourceMappingURL=warnAboutMissingGlyphs.d.ts.map

package/lib/warnAboutMissingGlyphs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warnAboutMissingGlyphs.d.ts","sourceRoot":"","sources":["../src/warnAboutMissingGlyphs.ts"],"names":[],"mappings":"AAIA,UAAU,UAAU;IAClB,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,GAAG,OAAO,CAAC;IAC/D,MAAM,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACrD;AAED,UAAU,oBAAoB;IAC5B,IAAI,EAAE;QAAE,SAAS,IAAI,IAAI,CAAA;KAAE,CAAC;IAG5B,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,UAAU,mBAAmB;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,oBAAoB,EAAE,CAAC;CACnC;AAED,UAAU,aAAa;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,UAAU,EAAE;QAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED,UAAU,cAAc;IACtB,cAAc,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3D,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,+BAA+B,EAAE,mBAAmB,EAAE,CAAC;CACxD;AAED,UAAU,cAAc;IACtB,IAAI,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,CAAC;IACvB,IAAI,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,CAAC;CACxB;AAED,iBAAe,sBAAsB,CACnC,4BAA4B,EAAE,cAAc,EAAE,EAC9C,UAAU,EAAE,cAAc,GACzB,OAAO,CAAC,IAAI,CAAC,CAoLf;AAED,SAAS,sBAAsB,CAAC"}

package/lib/warnAboutMissingGlyphs.js

@@ -1,155 +1,147 @@
-const LinesAndColumns = require('lines-and-columns').default;
-const getFontInfo = require('./getFontInfo');
-const unicodeRange = require('./unicodeRange');
-
-async function warnAboutMissingGlyphs(
-  htmlOrSvgAssetTextsWithProps,
-  assetGraph
-) {
-  const missingGlyphsErrors = [];
-
-  // Collect all unique subset buffers and parse them concurrently.
-  // getFontInfo internally serializes harfbuzzjs WASM calls, so
-  // Promise.all just queues them up rather than running in parallel.
-  const uniqueSubsetBuffers = new Map();
-  for (const { fontUsages } of htmlOrSvgAssetTextsWithProps) {
-    for (const fontUsage of fontUsages) {
-      if (!fontUsage.subsets) continue;
-      const subsetBuffer = Object.values(fontUsage.subsets)[0];
-      if (!uniqueSubsetBuffers.has(subsetBuffer)) {
-        uniqueSubsetBuffers.set(
-          subsetBuffer,
-          getFontInfo(subsetBuffer)
-            .then((info) => new Set(info.characterSet))
-            .catch((err) => {
-              assetGraph.warn(err);
-              return null;
-            })
-        );
-      }
-    }
-  }
-  const subsetCharSetCache = new Map();
-  await Promise.all(
-    [...uniqueSubsetBuffers.entries()].map(async ([buffer, promise]) => {
-      subsetCharSetCache.set(buffer, await promise);
-    })
-  );
-
-  for (const {
-    htmlOrSvgAsset,
-    fontUsages,
-    accumulatedFontFaceDeclarations,
-  } of htmlOrSvgAssetTextsWithProps) {
-    let linesAndColumns;
-    // Dedupe scans for the same missing char across different fontUsages on
-    // this page. On KaTeX-heavy pages the same symbol is often missing in
-    // several font-families, and each scan is an O(N) walk of the HTML text.
-    const charLookupCache = new Map();
-    const lookupChar = (char) => {
-      let cached = charLookupCache.get(char);
-      if (cached) return cached;
-      let firstLocation;
-      let occurrences = 0;
-      if (char.length > 0) {
-        const sourceText = htmlOrSvgAsset.text;
-        let searchIdx = 0;
-        while (true) {
-          const charIdx = sourceText.indexOf(char, searchIdx);
-          if (charIdx === -1) break;
-          occurrences++;
-          if (occurrences === 1) {
-            if (!linesAndColumns) {
-              linesAndColumns = new LinesAndColumns(sourceText);
+"use strict";
+const lines_and_columns_1 = require("lines-and-columns");
+const getFontInfo = require("./getFontInfo");
+const unicodeRange = require("./unicodeRange");
+async function warnAboutMissingGlyphs(htmlOrSvgAssetTextsWithProps, assetGraph) {
+    const missingGlyphsErrors = [];
+    // Collect all unique subset buffers and parse them concurrently.
+    // getFontInfo internally serializes harfbuzzjs WASM calls, so
+    // Promise.all just queues them up rather than running in parallel.
+    const uniqueSubsetBuffers = new Map();
+    for (const { fontUsages } of htmlOrSvgAssetTextsWithProps) {
+        for (const fontUsage of fontUsages) {
+            if (!fontUsage.subsets)
+                continue;
+            const subsetBuffer = Object.values(fontUsage.subsets)[0];
+            if (!uniqueSubsetBuffers.has(subsetBuffer)) {
+                uniqueSubsetBuffers.set(subsetBuffer, getFontInfo(subsetBuffer)
+                    .then((info) => new Set(info.characterSet))
+                    // eslint-disable-next-line no-restricted-syntax
+                    .catch((rawErr) => {
+                    assetGraph.warn(rawErr);
+                    return null;
+                }));
             }
-            const position = linesAndColumns.locationForIndex(charIdx);
-            firstLocation = `${htmlOrSvgAsset.urlOrDescription}:${
-              position.line + 1
-            }:${position.column + 1}`;
-          }
-          searchIdx = charIdx + char.length;
-        }
-      }
-      if (!firstLocation) {
-        firstLocation = `${htmlOrSvgAsset.urlOrDescription} (generated content)`;
-      }
-      cached = { firstLocation, occurrences };
-      charLookupCache.set(char, cached);
-      return cached;
-    };
-    for (const fontUsage of fontUsages) {
-      if (!fontUsage.subsets) continue;
-      const subsetBuffer = Object.values(fontUsage.subsets)[0];
-      const characterSetLookup = subsetCharSetCache.get(subsetBuffer);
-      if (!characterSetLookup) continue; // getFontInfo failed on subset; already warned
-
-      let missedAny = false;
-      for (const char of fontUsage.pageText) {
-        // Turns out that browsers don't mind that these are missing:
-        if (char === '\t' || char === '\n') {
-          continue;
-        }
-
-        const codePoint = char.codePointAt(0);
-
-        const isMissing = !characterSetLookup.has(codePoint);
-
-        if (isMissing) {
-          // Report only the first location plus a count of remaining
-          // occurrences. A character like U+200B can appear thousands of
-          // times on a page and per-occurrence lines drown the log.
-          const { firstLocation, occurrences } = lookupChar(char);
-
-          missingGlyphsErrors.push({
-            codePoint,
-            char,
-            htmlOrSvgAsset,
-            fontUsage,
-            location: firstLocation,
-            occurrences,
-          });
-          missedAny = true;
         }
-      }
-      if (missedAny) {
-        const fontFaces = accumulatedFontFaceDeclarations.filter((fontFace) =>
-          fontUsage.fontFamilies.has(fontFace['font-family'])
-        );
-        for (const fontFace of fontFaces) {
-          const cssFontFaceSrc = fontFace.relations[0];
-          const fontFaceDeclaration = cssFontFaceSrc.node;
-          if (
-            !fontFaceDeclaration.some((node) => node.prop === 'unicode-range')
-          ) {
-            fontFaceDeclaration.append({
-              prop: 'unicode-range',
-              value: unicodeRange(fontUsage.codepoints.original),
-            });
-            cssFontFaceSrc.from.markDirty();
-          }
+    }
+    const subsetCharSetCache = new Map();
+    await Promise.all([...uniqueSubsetBuffers.entries()].map(async ([buffer, promise]) => {
+        subsetCharSetCache.set(buffer, await promise);
+    }));
+    // Codepoint unions per @font-face declaration, keyed by the at-rule node.
+    // Built across all fontUsages on a page, then flushed in a single append
+    // per @font-face so multiple fontUsages sharing a family don't lose data.
+    const unicodeRangeAccumulator = new Map();
+    for (const { htmlOrSvgAsset, fontUsages, accumulatedFontFaceDeclarations, } of htmlOrSvgAssetTextsWithProps) {
+        let linesAndColumns;
+        // Dedupe scans for the same missing char across different fontUsages on
+        // this page. On KaTeX-heavy pages the same symbol is often missing in
+        // several font-families, and each scan is an O(N) walk of the HTML text.
+        const charLookupCache = new Map();
+        const lookupChar = (char) => {
+            const cachedHit = charLookupCache.get(char);
+            if (cachedHit)
+                return cachedHit;
+            let firstLocation;
+            let occurrences = 0;
+            if (char.length > 0) {
+                const sourceText = htmlOrSvgAsset.text;
+                let searchIdx = 0;
+                while (true) {
+                    const charIdx = sourceText.indexOf(char, searchIdx);
+                    if (charIdx === -1)
+                        break;
+                    occurrences++;
+                    if (occurrences === 1) {
+                        if (!linesAndColumns) {
+                            linesAndColumns = new lines_and_columns_1.LinesAndColumns(sourceText);
+                        }
+                        const position = linesAndColumns.locationForIndex(charIdx);
+                        firstLocation = `${htmlOrSvgAsset.urlOrDescription}:${position.line + 1}:${position.column + 1}`;
+                    }
+                    searchIdx = charIdx + char.length;
+                }
+            }
+            if (!firstLocation) {
+                firstLocation = `${htmlOrSvgAsset.urlOrDescription} (generated content)`;
+            }
+            const result = { firstLocation, occurrences };
+            charLookupCache.set(char, result);
+            return result;
+        };
+        for (const fontUsage of fontUsages) {
+            if (!fontUsage.subsets)
+                continue;
+            const subsetBuffer = Object.values(fontUsage.subsets)[0];
+            const characterSetLookup = subsetCharSetCache.get(subsetBuffer);
+            if (!characterSetLookup)
+                continue; // getFontInfo failed on subset; already warned
+            let missedAny = false;
+            for (const char of fontUsage.pageText) {
+                // Turns out that browsers don't mind that these are missing:
+                if (char === '\t' || char === '\n') {
+                    continue;
+                }
+                const codePoint = char.codePointAt(0);
+                if (codePoint === undefined)
+                    continue;
+                const isMissing = !characterSetLookup.has(codePoint);
+                if (isMissing) {
+                    // Report only the first location plus a count of remaining
+                    // occurrences. A character like U+200B can appear thousands of
+                    // times on a page and per-occurrence lines drown the log.
+                    const { firstLocation, occurrences } = lookupChar(char);
+                    missingGlyphsErrors.push({
+                        codePoint,
+                        char,
+                        htmlOrSvgAsset,
+                        fontUsage,
+                        location: firstLocation,
+                        occurrences,
+                    });
+                    missedAny = true;
+                }
+            }
+            if (missedAny) {
+                for (const fontFace of accumulatedFontFaceDeclarations) {
+                    const family = fontFace['font-family'];
+                    if (!family || !fontUsage.fontFamilies.has(family))
+                        continue;
+                    const relation = fontFace.relations[0];
+                    const node = relation.node;
+                    if (node.some((decl) => decl.prop === 'unicode-range'))
+                        continue;
+                    let entry = unicodeRangeAccumulator.get(node);
+                    if (!entry) {
+                        entry = { relation, codepoints: new Set() };
+                        unicodeRangeAccumulator.set(node, entry);
+                    }
+                    for (const cp of fontUsage.codepoints.original) {
+                        entry.codepoints.add(cp);
+                    }
+                }
+            }
         }
-      }
     }
-  }
-
-  if (missingGlyphsErrors.length) {
-    const errorLog = missingGlyphsErrors.map(
-      ({ char, fontUsage, location, occurrences }) => {
-        const extra = occurrences > 1 ? ` (+${occurrences - 1} more)` : '';
-        return `- \\u{${char.codePointAt(0).toString(16)}} (${char}) in font-family '${
-          fontUsage.props['font-family']
-        }' (${fontUsage.props['font-weight']}/${
-          fontUsage.props['font-style']
-        }) at ${location}${extra}`;
-      }
-    );
-
-    const message = `Missing glyph fallback detected.
+    // Flush accumulated unicode-range declarations: one append per @font-face,
+    // covering every fontUsage that mapped to it.
+    for (const { relation, codepoints } of unicodeRangeAccumulator.values()) {
+        relation.node.append({
+            prop: 'unicode-range',
+            value: unicodeRange([...codepoints]),
+        });
+        relation.from.markDirty();
+    }
+    if (missingGlyphsErrors.length) {
+        const errorLog = missingGlyphsErrors.map(({ char, fontUsage, location, occurrences }) => {
+            const extra = occurrences > 1 ? ` (+${occurrences - 1} more)` : '';
+            return `- \\u{${char.codePointAt(0).toString(16)}} (${char}) in font-family '${fontUsage.props['font-family']}' (${fontUsage.props['font-weight']}/${fontUsage.props['font-style']}) at ${location}${extra}`;
+        });
+        const message = `Missing glyph fallback detected.
 When your primary webfont doesn't contain the glyphs you use, browsers that don't support unicode-range will load your fallback fonts, which will be a potential waste of bandwidth.
 These glyphs are used on your site, but they don't exist in the font you applied to them:`;
-
-    assetGraph.info(new Error(`${message}\n${errorLog.join('\n')}`));
-  }
+        assetGraph.info(new Error(`${message}\n${errorLog.join('\n')}`));
+    }
 }
-
 module.exports = warnAboutMissingGlyphs;
+//# sourceMappingURL=warnAboutMissingGlyphs.js.map