@turntrout/subfont 1.0.1 → 1.0.3

package/lib/collectTextsByPage.js

@@ -352,6 +352,202 @@ function getOrComputeGlobalFontUsages(
   cached.preloadIndex = textAndPropsToFontUrl;
 }
 
+// Extract font tracing (worker pool + sequential) to reduce
+// cyclomatic complexity of collectTextsByPage.
+async function tracePages(
+  pagesNeedingFullTrace,
+  { headlessBrowser, concurrency, console, memoizedGetCssRulesByProperty }
+) {
+  const useWorkerPool =
+    !headlessBrowser &&
+    pagesNeedingFullTrace.length >= MIN_PAGES_FOR_WORKER_POOL;
+
+  if (useWorkerPool) {
+    const maxWorkers =
+      concurrency > 0 ? concurrency : Math.min(os.cpus().length, 8);
+    const numWorkers = Math.min(maxWorkers, pagesNeedingFullTrace.length);
+    const pool = new FontTracerPool(numWorkers);
+    await pool.init();
+
+    try {
+      const totalPages = pagesNeedingFullTrace.length;
+      const showProgress = totalPages >= 10 && console;
+      let tracedCount = 0;
+      const tracePromises = pagesNeedingFullTrace.map(async (pd) => {
+        try {
+          pd.textByProps = await pool.trace(
+            pd.htmlOrSvgAsset.text || '',
+            pd.stylesheetsWithPredicates
+          );
+        } catch (err) {
+          if (console) {
+            console.warn(
+              `Worker fontTracer failed for ${pd.htmlOrSvgAsset.url}, falling back to main thread: ${err.message}`
+            );
+          }
+          pd.textByProps = fontTracer(pd.htmlOrSvgAsset.parseTree, {
+            stylesheetsWithPredicates: pd.stylesheetsWithPredicates,
+            getCssRulesByProperty: memoizedGetCssRulesByProperty,
+            asset: pd.htmlOrSvgAsset,
+          });
+        }
+        tracedCount++;
+        if (showProgress && tracedCount % 10 === 0) {
+          console.log(`  Tracing fonts: ${tracedCount}/${totalPages} pages...`);
+        }
+      });
+      await Promise.all(tracePromises);
+      await pool.destroy();
+    } catch (err) {
+      await pool.destroy();
+      throw err;
+    }
+  } else if (pagesNeedingFullTrace.length > 0) {
+    const totalPages = pagesNeedingFullTrace.length;
+    const showProgress = totalPages >= 10 && console;
+    for (let pi = 0; pi < totalPages; pi++) {
+      const pd = pagesNeedingFullTrace[pi];
+      pd.textByProps = fontTracer(pd.htmlOrSvgAsset.parseTree, {
+        stylesheetsWithPredicates: pd.stylesheetsWithPredicates,
+        getCssRulesByProperty: memoizedGetCssRulesByProperty,
+        asset: pd.htmlOrSvgAsset,
+      });
+      if (headlessBrowser) {
+        pd.textByProps.push(
+          ...(await headlessBrowser.tracePage(pd.htmlOrSvgAsset))
+        );
+      }
+      if (showProgress && (pi + 1) % 10 === 0) {
+        console.log(`  Tracing fonts: ${pi + 1}/${totalPages} pages...`);
+      }
+    }
+  }
+}
+
+// Extract fast-path text extraction to reduce collectTextsByPage complexity.
+// Pages sharing the same CSS configuration reuse the representative's
+// props and only extract visible text content.
+function processFastPathPages(
+  fastPathPages,
+  { memoizedGetCssRulesByProperty, console, debug, subTimings }
+) {
+  if (fastPathPages.length === 0) return;
+
+  const fastPathStart = Date.now();
+
+  const repDataCache = new Map();
+  function getRepData(representativePd) {
+    if (repDataCache.has(representativePd)) {
+      return repDataCache.get(representativePd);
+    }
+    const repTextByProps = representativePd.textByProps;
+
+    const uniquePropsMap = new Map();
+    const textPerPropsKey = new Map();
+    const seenVariantKeys = new Set();
+    for (const entry of repTextByProps) {
+      const family = entry.props['font-family'] || '';
+      const propsKey = fontPropsKey(
+        family,
+        entry.props['font-weight'] || '',
+        entry.props['font-style'] || '',
+        entry.props['font-stretch'] || ''
+      );
+      if (!uniquePropsMap.has(propsKey)) {
+        uniquePropsMap.set(propsKey, entry.props);
+        textPerPropsKey.set(propsKey, []);
+      }
+      textPerPropsKey.get(propsKey).push(entry.text);
+      if (family) {
+        const weight = entry.props['font-weight'] || 'normal';
+        const style = entry.props['font-style'] || 'normal';
+        const stretch = entry.props['font-stretch'] || 'normal';
+        for (const fam of cssFontParser.parseFontFamily(family)) {
+          seenVariantKeys.add(
+            fontPropsKey(fam.toLowerCase(), weight, style, stretch)
+          );
+        }
+      }
+    }
+    const data = { uniquePropsMap, textPerPropsKey, seenVariantKeys };
+    repDataCache.set(representativePd, data);
+    return data;
+  }
+
+  let fastPathFallbacks = 0;
+  for (const pd of fastPathPages) {
+    if (hasInlineFontStyles(pd.htmlOrSvgAsset.text || '')) {
+      fastPathFallbacks++;
+      pd.textByProps = fontTracer(pd.htmlOrSvgAsset.parseTree, {
+        stylesheetsWithPredicates: pd.stylesheetsWithPredicates,
+        getCssRulesByProperty: memoizedGetCssRulesByProperty,
+        asset: pd.htmlOrSvgAsset,
+      });
+      continue;
+    }
+
+    const { uniquePropsMap, textPerPropsKey, seenVariantKeys } = getRepData(
+      pd.representativePd
+    );
+
+    // Check if any @font-face variants are unseen by the representative.
+    // Only copy Maps when extensions are actually needed.
+    let effectivePropsMap = uniquePropsMap;
+    let effectiveTextPerPropsKey = textPerPropsKey;
+    for (const decl of pd.accumulatedFontFaceDeclarations) {
+      const family = decl['font-family'];
+      if (!family) continue;
+      const weight = decl['font-weight'] || 'normal';
+      const style = decl['font-style'] || 'normal';
+      const stretch = decl['font-stretch'] || 'normal';
+      const variantKey = fontPropsKey(
+        family.toLowerCase(),
+        weight,
+        style,
+        stretch
+      );
+      if (!seenVariantKeys.has(variantKey)) {
+        // Lazy-copy on first unseen variant
+        if (effectivePropsMap === uniquePropsMap) {
+          effectivePropsMap = new Map(uniquePropsMap);
+          effectiveTextPerPropsKey = new Map(textPerPropsKey);
+        }
+        const propsKey = fontPropsKey(
+          stringifyFontFamily(family),
+          weight,
+          style,
+          stretch
+        );
+        if (!effectivePropsMap.has(propsKey)) {
+          effectivePropsMap.set(propsKey, {
+            'font-family': stringifyFontFamily(family),
+            'font-weight': weight,
+            'font-style': style,
+            'font-stretch': stretch,
+          });
+          effectiveTextPerPropsKey.set(propsKey, []);
+        }
+      }
+    }
+
+    const pageText = extractVisibleText(pd.htmlOrSvgAsset.text || '');
+
+    pd.textByProps = [];
+    for (const [propsKey, props] of effectivePropsMap) {
+      const repTexts = effectiveTextPerPropsKey.get(propsKey) || [];
+      pd.textByProps.push({
+        text: pageText + repTexts.join(''),
+        props: { ...props },
+      });
+    }
+  }
+  subTimings['Fast-path extraction'] = Date.now() - fastPathStart;
+  if (debug && console)
+    console.log(
+      `[subfont timing] Fast-path text extraction (${fastPathPages.length} pages, ${fastPathFallbacks} fell back to full trace): ${subTimings['Fast-path extraction']}ms`
+    );
+}
+
 async function collectTextsByPage(
   assetGraph,
   htmlOrSvgAssets,
@@ -454,39 +650,30 @@ async function collectTextsByPage(
 
         if (asset.type === 'Css' && asset.isLoaded) {
           const seenNodes = new Set();
-
           const fontRelations = asset.outgoingRelations.filter(
             (relation) => relation.type === 'CssFontFaceSrc'
           );
 
           for (const fontRelation of fontRelations) {
             const node = fontRelation.node;
-
-            if (!seenNodes.has(node)) {
-              seenNodes.add(node);
-
-              const fontFaceDeclaration = {
-                relations: fontRelations.filter((r) => r.node === node),
-                ...initialValueByProp,
-              };
-
-              node.walkDecls((declaration) => {
-                const propName = declaration.prop.toLowerCase();
-                if (propName === 'font-family') {
-                  fontFaceDeclaration[propName] = cssFontParser.parseFontFamily(
-                    declaration.value
-                  )[0];
-                } else {
-                  fontFaceDeclaration[propName] = declaration.value;
-                }
-              });
-              // Disregard incomplete @font-face declarations (must contain font-family and src per spec):
-              if (
-                fontFaceDeclaration['font-family'] &&
-                fontFaceDeclaration.src
-              ) {
-                accumulatedFontFaceDeclarations.push(fontFaceDeclaration);
-              }
+            if (seenNodes.has(node)) continue;
+            seenNodes.add(node);
+
+            const fontFaceDeclaration = {
+              relations: fontRelations.filter((r) => r.node === node),
+              ...initialValueByProp,
+            };
+
+            node.walkDecls((declaration) => {
+              const propName = declaration.prop.toLowerCase();
+              fontFaceDeclaration[propName] =
+                propName === 'font-family'
+                  ? cssFontParser.parseFontFamily(declaration.value)[0]
+                  : declaration.value;
+            });
+            // Disregard incomplete @font-face declarations (must contain font-family and src per spec):
+            if (fontFaceDeclaration['font-family'] && fontFaceDeclaration.src) {
+              accumulatedFontFaceDeclarations.push(fontFaceDeclaration);
             }
           }
         }
@@ -507,24 +694,19 @@ async function collectTextsByPage(
     // Group @font-face declarations that share family/style/weight but have
     // different unicode-range values. Each group's members cover a disjoint
     // subset of the Unicode space (common for CJK / large character-set fonts).
-    if (accumulatedFontFaceDeclarations.length > 0) {
-      const comboGroups = new Map();
-      for (const fontFace of accumulatedFontFaceDeclarations) {
-        const comboKey = `${fontFace['font-family']}/${fontFace['font-style']}/${fontFace['font-weight']}`;
-        if (!comboGroups.has(comboKey)) {
-          comboGroups.set(comboKey, []);
-        }
-        comboGroups.get(comboKey).push(fontFace);
-      }
-      for (const [comboKey, group] of comboGroups) {
-        if (group.length > 1) {
-          const withoutRange = group.filter((d) => !d['unicode-range']);
-          if (withoutRange.length > 0) {
-            throw new Error(
-              `Multiple @font-face with the same font-family/font-style/font-weight combo but missing unicode-range on ${withoutRange.length} of ${group.length} declarations: ${comboKey}`
-            );
-          }
-        }
+    const comboGroups = new Map();
+    for (const fontFace of accumulatedFontFaceDeclarations) {
+      const comboKey = `${fontFace['font-family']}/${fontFace['font-style']}/${fontFace['font-weight']}`;
+      if (!comboGroups.has(comboKey)) comboGroups.set(comboKey, []);
+      comboGroups.get(comboKey).push(fontFace);
+    }
+    for (const [comboKey, group] of comboGroups) {
+      if (group.length <= 1) continue;
+      const withoutRange = group.filter((d) => !d['unicode-range']);
+      if (withoutRange.length > 0) {
+        throw new Error(
+          `Multiple @font-face with the same font-family/font-style/font-weight combo but missing unicode-range on ${withoutRange.length} of ${group.length} declarations: ${comboKey}`
+        );
       }
     }
 
@@ -617,75 +799,14 @@ async function collectTextsByPage(
       `[subfont timing] CSS groups: ${pagesByStylesheetKey.size} unique, ${pagesNeedingFullTrace.length} to trace, ${fastPathPages.length} fast-path`
     );
 
-  // Use worker pool for parallel fontTracer when there are enough pages
-  const useWorkerPool =
-    !headlessBrowser &&
-    pagesNeedingFullTrace.length >= MIN_PAGES_FOR_WORKER_POOL;
-
   const tracingStart = Date.now();
   try {
-    if (useWorkerPool) {
-      const maxWorkers =
-        concurrency > 0 ? concurrency : Math.min(os.cpus().length, 8);
-      const numWorkers = Math.min(maxWorkers, pagesNeedingFullTrace.length);
-      const pool = new FontTracerPool(numWorkers);
-      await pool.init();
-
-      try {
-        const totalPages = pagesNeedingFullTrace.length;
-        const showProgress = totalPages >= 10 && console;
-        let tracedCount = 0;
-        const tracePromises = pagesNeedingFullTrace.map(async (pd) => {
-          try {
-            pd.textByProps = await pool.trace(
-              pd.htmlOrSvgAsset.text || '',
-              pd.stylesheetsWithPredicates
-            );
-          } catch (err) {
-            if (console) {
-              console.warn(
-                `Worker fontTracer failed for ${pd.htmlOrSvgAsset.url}, falling back to main thread: ${err.message}`
-              );
-            }
-            pd.textByProps = fontTracer(pd.htmlOrSvgAsset.parseTree, {
-              stylesheetsWithPredicates: pd.stylesheetsWithPredicates,
-              getCssRulesByProperty: memoizedGetCssRulesByProperty,
-              asset: pd.htmlOrSvgAsset,
-            });
-          }
-          tracedCount++;
-          if (showProgress && tracedCount % 10 === 0) {
-            console.log(
-              `  Tracing fonts: ${tracedCount}/${totalPages} pages...`
-            );
-          }
-        });
-        await Promise.all(tracePromises);
-        await pool.destroy();
-      } catch (err) {
-        await pool.destroy();
-        throw err;
-      }
-    } else if (pagesNeedingFullTrace.length > 0) {
-      const totalPages = pagesNeedingFullTrace.length;
-      const showProgress = totalPages >= 10 && console;
-      for (let pi = 0; pi < totalPages; pi++) {
-        const pd = pagesNeedingFullTrace[pi];
-        pd.textByProps = fontTracer(pd.htmlOrSvgAsset.parseTree, {
-          stylesheetsWithPredicates: pd.stylesheetsWithPredicates,
-          getCssRulesByProperty: memoizedGetCssRulesByProperty,
-          asset: pd.htmlOrSvgAsset,
-        });
-        if (headlessBrowser) {
-          pd.textByProps.push(
-            ...(await headlessBrowser.tracePage(pd.htmlOrSvgAsset))
-          );
-        }
-        if (showProgress && (pi + 1) % 10 === 0) {
-          console.log(`  Tracing fonts: ${pi + 1}/${totalPages} pages...`);
-        }
-      }
-    }
+    await tracePages(pagesNeedingFullTrace, {
+      headlessBrowser,
+      concurrency,
+      console,
+      memoizedGetCssRulesByProperty,
+    });
 
     subTimings['Full tracing'] = Date.now() - tracingStart;
     if (debug && console)
@@ -693,123 +814,12 @@ async function collectTextsByPage(
         `[subfont timing] Full tracing (${pagesNeedingFullTrace.length} pages): ${subTimings['Full tracing']}ms`
       );
 
-    // Fast-path: for pages sharing CSS with a traced representative,
-    // reuse the representative's props and extract only the text content.
-    if (fastPathPages.length > 0) {
-      const fastPathStart = Date.now();
-
-      const repDataCache = new Map();
-      function getRepData(representativePd) {
-        if (repDataCache.has(representativePd)) {
-          return repDataCache.get(representativePd);
-        }
-        const repTextByProps = representativePd.textByProps;
-
-        const uniquePropsMap = new Map();
-        const textPerPropsKey = new Map();
-        const seenVariantKeys = new Set();
-        for (const entry of repTextByProps) {
-          const family = entry.props['font-family'] || '';
-          const propsKey = fontPropsKey(
-            family,
-            entry.props['font-weight'] || '',
-            entry.props['font-style'] || '',
-            entry.props['font-stretch'] || ''
-          );
-          if (!uniquePropsMap.has(propsKey)) {
-            uniquePropsMap.set(propsKey, entry.props);
-            textPerPropsKey.set(propsKey, []);
-          }
-          textPerPropsKey.get(propsKey).push(entry.text);
-          if (family) {
-            const weight = entry.props['font-weight'] || 'normal';
-            const style = entry.props['font-style'] || 'normal';
-            const stretch = entry.props['font-stretch'] || 'normal';
-            for (const fam of cssFontParser.parseFontFamily(family)) {
-              seenVariantKeys.add(
-                fontPropsKey(fam.toLowerCase(), weight, style, stretch)
-              );
-            }
-          }
-        }
-        const data = { uniquePropsMap, textPerPropsKey, seenVariantKeys };
-        repDataCache.set(representativePd, data);
-        return data;
-      }
-
-      let fastPathFallbacks = 0;
-      for (const pd of fastPathPages) {
-        if (hasInlineFontStyles(pd.htmlOrSvgAsset.text || '')) {
-          fastPathFallbacks++;
-          pd.textByProps = fontTracer(pd.htmlOrSvgAsset.parseTree, {
-            stylesheetsWithPredicates: pd.stylesheetsWithPredicates,
-            getCssRulesByProperty: memoizedGetCssRulesByProperty,
-            asset: pd.htmlOrSvgAsset,
-          });
-          continue;
-        }
-
-        const { uniquePropsMap, textPerPropsKey, seenVariantKeys } = getRepData(
-          pd.representativePd
-        );
-
-        // Check if any @font-face variants are unseen by the representative.
-        // Only copy Maps when extensions are actually needed.
-        let effectivePropsMap = uniquePropsMap;
-        let effectiveTextPerPropsKey = textPerPropsKey;
-        for (const decl of pd.accumulatedFontFaceDeclarations) {
-          const family = decl['font-family'];
-          if (!family) continue;
-          const weight = decl['font-weight'] || 'normal';
-          const style = decl['font-style'] || 'normal';
-          const stretch = decl['font-stretch'] || 'normal';
-          const variantKey = fontPropsKey(
-            family.toLowerCase(),
-            weight,
-            style,
-            stretch
-          );
-          if (!seenVariantKeys.has(variantKey)) {
-            // Lazy-copy on first unseen variant
-            if (effectivePropsMap === uniquePropsMap) {
-              effectivePropsMap = new Map(uniquePropsMap);
-              effectiveTextPerPropsKey = new Map(textPerPropsKey);
-            }
-            const propsKey = fontPropsKey(
-              stringifyFontFamily(family),
-              weight,
-              style,
-              stretch
-            );
-            if (!effectivePropsMap.has(propsKey)) {
-              effectivePropsMap.set(propsKey, {
-                'font-family': stringifyFontFamily(family),
-                'font-weight': weight,
-                'font-style': style,
-                'font-stretch': stretch,
-              });
-              effectiveTextPerPropsKey.set(propsKey, []);
-            }
-          }
-        }
-
-        const pageText = extractVisibleText(pd.htmlOrSvgAsset.text || '');
-
-        pd.textByProps = [];
-        for (const [propsKey, props] of effectivePropsMap) {
-          const repTexts = effectiveTextPerPropsKey.get(propsKey) || [];
-          pd.textByProps.push({
-            text: pageText + repTexts.join(''),
-            props: { ...props },
-          });
-        }
-      }
-      subTimings['Fast-path extraction'] = Date.now() - fastPathStart;
-      if (debug && console)
-        console.log(
-          `[subfont timing] Fast-path text extraction (${fastPathPages.length} pages, ${fastPathFallbacks} fell back to full trace): ${subTimings['Fast-path extraction']}ms`
-        );
-    }
+    processFastPathPages(fastPathPages, {
+      memoizedGetCssRulesByProperty,
+      console,
+      debug,
+      subTimings,
+    });
 
     const assembleStart = Date.now();
     for (const pd of pageData) {

package/lib/getCssRulesByProperty.js

@@ -24,15 +24,49 @@ const counterRendererNames = new Set([
 ]);
 
 function unwrapNamespace(str) {
-  if (/^"/.test(str)) {
+  if (/^["']/.test(str)) {
     return unquote(str);
   } else if (/^url\(.*\)$/i.test(str)) {
-    return unquote(str.replace(/^url\((.*)\)$/, '$1'));
+    return unquote(str.replace(/^url\((.*)\)$/i, '$1'));
   } else {
     throw new Error(`Cannot parse CSS namespace: ${str}`);
   }
 }
 
+// Build a collision-free fingerprint for a CSS rule entry. Null bytes (\0)
+// delimit fields because they cannot appear in CSS property values.
+function ruleFingerprint(rule) {
+  const predicateEntries = Object.keys(rule.predicates)
+    .sort()
+    .map((k) => `${k}=${rule.predicates[k]}`);
+  return [
+    rule.selector,
+    rule.value,
+    rule.prop,
+    rule.important,
+    (rule.specificityArray || []).join(','),
+    rule.namespaceURI,
+    predicateEntries.join('&'),
+  ].join('\0');
+}
+
+// Remove fully-duplicate rule entries (same selector, value, specificity,
+// predicates, namespace, and importance) within each property.
+function deduplicateRules(rulesByProperty) {
+  for (const key of Object.keys(rulesByProperty)) {
+    if (key === 'counterStyles' || key === 'keyframes') continue;
+    const rules = rulesByProperty[key];
+    if (rules.length <= 1) continue;
+    const seen = new Set();
+    rulesByProperty[key] = rules.filter((rule) => {
+      const fp = ruleFingerprint(rule);
+      if (seen.has(fp)) return false;
+      seen.add(fp);
+      return true;
+    });
+  }
+}
+
 function getCssRulesByProperty(properties, cssSource, existingPredicates) {
   if (!Array.isArray(properties)) {
     throw new Error('properties argument must be an array');
@@ -44,13 +78,21 @@ function getCssRulesByProperty(properties, cssSource, existingPredicates) {
 
   const parseTree = postcss.parse(cssSource);
   let defaultNamespaceURI;
+  const namespacePrefixes = new Map();
+  // Parse @namespace rules: either a default namespace or a prefixed one.
+  // Spec: https://developer.mozilla.org/en-US/docs/Web/CSS/@namespace
+  // Grammar: @namespace <prefix>? [<string> | url(<uri>)]
   parseTree.walkAtRules('namespace', (rule) => {
-    const fragments = rule.params.split(/\s+/);
-    if (fragments.length === 1) {
-      defaultNamespaceURI = unwrapNamespace(rule.params);
+    const match = rule.params.match(
+      /^(?<prefix>\w+)\s+(?<uri>.+)$|^(?<defaultUri>.+)$/
+    );
+    if (!match) return;
+    const { prefix, uri, defaultUri } = match.groups;
+    if (prefix) {
+      namespacePrefixes.set(prefix, unwrapNamespace(uri));
+    } else {
+      defaultNamespaceURI = unwrapNamespace(defaultUri);
     }
-    // FIXME: Support registering namespace prefixes (fragments.length === 2):
-    // https://developer.mozilla.org/en-US/docs/Web/CSS/@namespace
   });
   const rulesByProperty = {
     counterStyles: [],
@@ -61,6 +103,33 @@ function getCssRulesByProperty(properties, cssSource, existingPredicates) {
     rulesByProperty[property] = [];
   }
 
+  // Resolve the namespace URI for a selector by examining its subject
+  // (the rightmost compound selector) for a namespace prefix like svg|text.
+  function resolveNamespaceURI(selector) {
+    if (namespacePrefixes.size === 0) {
+      return defaultNamespaceURI;
+    }
+    // Find the subject (rightmost simple selector before pseudo-elements).
+    // Split on combinators: whitespace, >, +, ~
+    const compoundSelectors = selector.split(/\s*[>+~]\s*|\s+/);
+    const subject = compoundSelectors[compoundSelectors.length - 1];
+    // Check for namespace prefix: prefix|element, *|element, or |element
+    const nsMatch = subject.match(/^(?<nsPrefix>\*|\w*)\|/);
+    if (!nsMatch) {
+      return defaultNamespaceURI;
+    }
+    const prefix = nsMatch.groups.nsPrefix;
+    if (prefix === '*') {
+      // *|element matches any namespace — no namespace filter
+      return undefined;
+    }
+    if (prefix === '') {
+      // |element means no namespace (elements not in any namespace)
+      return '';
+    }
+    return namespacePrefixes.get(prefix) || defaultNamespaceURI;
+  }
+
   const specificityCache = new Map();
   function getSpecificity(selector) {
     let cached = specificityCache.get(selector);
@@ -87,12 +156,15 @@ function getCssRulesByProperty(properties, cssSource, existingPredicates) {
   function pushRulePerSelector(node, prop, value) {
     getSpecificity(node.parent.selector).forEach((specificityObject) => {
       const isStyleAttribute = specificityObject.selector === 'bogusselector';
+      const selectorStr = isStyleAttribute
+        ? undefined
+        : specificityObject.selector.trim();
       (rulesByProperty[prop] = rulesByProperty[prop] || []).push({
         predicates: getCurrentPredicates(),
-        namespaceURI: defaultNamespaceURI,
-        selector: isStyleAttribute
-          ? undefined
-          : specificityObject.selector.trim(),
+        namespaceURI: isStyleAttribute
+          ? defaultNamespaceURI
+          : resolveNamespaceURI(selectorStr),
+        selector: selectorStr,
         specificityArray: isStyleAttribute
           ? [1, 0, 0, 0]
           : specificityObject.specificityArray,
@@ -198,12 +270,15 @@ function getCssRulesByProperty(properties, cssSource, existingPredicates) {
           getSpecificity(node.parent.selector).forEach((specificityObject) => {
             const isStyleAttribute =
               specificityObject.selector === 'bogusselector';
+            const fontSelector = isStyleAttribute
+              ? undefined
+              : specificityObject.selector.trim();
             const entry = {
               predicates: getCurrentPredicates(),
-              namespaceURI: defaultNamespaceURI,
-              selector: isStyleAttribute
-                ? undefined
-                : specificityObject.selector.trim(),
+              namespaceURI: isStyleAttribute
+                ? defaultNamespaceURI
+                : resolveNamespaceURI(fontSelector),
+              selector: fontSelector,
               specificityArray: isStyleAttribute
                 ? [1, 0, 0, 0]
                 : specificityObject.specificityArray,
@@ -261,7 +336,7 @@ function getCssRulesByProperty(properties, cssSource, existingPredicates) {
     }
   })(parseTree);
 
-  // TODO: Collapse into a single object for duplicate values?
+  deduplicateRules(rulesByProperty);
 
   return rulesByProperty;
 }