@fanboynz/network-scanner 2.0.31 → 2.0.33

package/lib/adblock.js

@@ -0,0 +1,750 @@
+// === Adblock Rules Parser (adblock_rules.js) v2.2 - Complete Optimization ===
+// Supports EasyList/AdBlock Plus filter syntax
+// Optimizations: Map domains + URL cache + skip third-party calc + cached hostname split
+
+const fs = require('fs');
+
+/**
+ * Simple LRU cache for URL parsing results
+ * Prevents memory leaks with fixed size limit
+ */
+class URLCache {
+  constructor(maxSize = 1000) {
+    this.cache = new Map();
+    this.maxSize = maxSize;
+  }
+  
+  get(url) {
+    return this.cache.get(url);
+  }
+  
+  set(url, value) {
+    // LRU eviction: if at max size, delete oldest entry
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    this.cache.set(url, value);
+  }
+  
+  clear() {
+    this.cache.clear();
+  }
+  
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize
+    };
+  }
+}
+
+/**
+ * Parses adblock filter list and creates matcher
+ * @param {string} filePath - Path to filter list file
+ * @param {Object} options - Parser options
+ * @returns {Object} Rule matcher with matching functions
+ */
+function parseAdblockRules(filePath, options = {}) {
+  const {
+    enableLogging = false,
+    caseSensitive = false
+  } = options;
+
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Adblock rules file not found: ${filePath}`);
+  }
+
+  const fileContent = fs.readFileSync(filePath, 'utf-8');
+  const lines = fileContent.split('\n');
+  
+  const rules = {
+    domainMap: new Map(),          // ||domain.com^ - Exact domains for O(1) lookup
+    domainRules: [],               // ||*.domain.com^ - Wildcard domains (fallback)
+    thirdPartyRules: [],           // ||domain.com^$third-party
+    pathRules: [],                 // /ads/*
+    scriptRules: [],               // .js$script
+    regexRules: [],                // /regex/
+    whitelist: [],                 // @@||domain.com^ - Wildcard whitelist
+    whitelistMap: new Map(),       // Exact whitelist domains for O(1) lookup
+    elementHiding: [],             // ##.ad-class (not used for network blocking)
+    stats: {
+      total: 0,
+      domain: 0,
+      domainMapEntries: 0,         // Exact domain matches in Map
+      thirdParty: 0,
+      path: 0,
+      script: 0,
+      regex: 0,
+      whitelist: 0,
+      elementHiding: 0,
+      comments: 0,
+      invalid: 0
+    }
+  };
+
+  for (let line of lines) {
+    line = line.trim();
+    
+    // Skip empty lines
+    if (!line) continue;
+    
+    // Skip comments
+    if (line.startsWith('!') || line.startsWith('#')) {
+      rules.stats.comments++;
+      continue;
+    }
+    
+    // Skip element hiding rules (cosmetic filters)
+    if (line.includes('##') || line.includes('#@#')) {
+      rules.stats.elementHiding++;
+      continue;
+    }
+
+    // Skip rules with cosmetic-only options (not for network blocking)
+    // These options only affect element hiding, not network requests
+    const cosmeticOnlyOptions = ['generichide', 'elemhide', 'specifichide'];
+    const hasCosmeticOption = cosmeticOnlyOptions.some(opt => 
+      line.includes(`$${opt}`) || line.includes(`,${opt}`)
+    );
+    if (hasCosmeticOption) {
+      rules.stats.elementHiding++;
+      continue;
+    }
+
+    rules.stats.total++;
+
+    try {
+      // Whitelist rules (exception rules)
+      if (line.startsWith('@@')) {
+        const cleanLine = line.substring(2);
+        const parsedRule = parseRule(cleanLine, true);
+        
+        // Store exact domains in Map for O(1) lookup, wildcards in array
+        if (parsedRule.isDomain && parsedRule.domain && !parsedRule.domain.includes('*')) {
+          rules.whitelistMap.set(parsedRule.domain.toLowerCase(), parsedRule);
+        } else {
+          rules.whitelist.push(parsedRule);
+        }
+        rules.stats.whitelist++;
+        continue;
+      }
+
+      // Regular blocking rules
+      const parsedRule = parseRule(line, false);
+      
+      // Categorize based on rule type
+      if (parsedRule.isThirdParty) {
+        rules.thirdPartyRules.push(parsedRule);
+        rules.stats.thirdParty++;
+      } else if (parsedRule.isDomain) {
+        // Store exact domains in Map for O(1) lookup, wildcards in array
+        if (parsedRule.domain && !parsedRule.domain.includes('*')) {
+          rules.domainMap.set(parsedRule.domain.toLowerCase(), parsedRule);
+          rules.stats.domainMapEntries++;
+        } else {
+          rules.domainRules.push(parsedRule);
+        }
+        rules.stats.domain++;
+      } else if (parsedRule.isScript) {
+        rules.scriptRules.push(parsedRule);
+        rules.stats.script++;
+      } else if (parsedRule.isRegex) {
+        rules.regexRules.push(parsedRule);
+        rules.stats.regex++;
+      } else {
+        rules.pathRules.push(parsedRule);
+        rules.stats.path++;
+      }
+    } catch (err) {
+      rules.stats.invalid++;
+      if (enableLogging) {
+        console.log(`[Adblock] Failed to parse rule: ${line} - ${err.message}`);
+      }
+    }
+  }
+
+  if (enableLogging) {
+    console.log(`[Adblock] Loaded ${rules.stats.total} rules:`);
+    console.log(`  - Domain rules: ${rules.stats.domain}`);
+    console.log(`    • Exact matches (Map): ${rules.stats.domainMapEntries}`);
+    console.log(`    • Wildcard patterns (Array): ${rules.domainRules.length}`);
+    console.log(`  - Third-party rules: ${rules.stats.thirdParty}`);
+    console.log(`  - Path rules: ${rules.stats.path}`);
+    console.log(`  - Script rules: ${rules.stats.script}`);
+    console.log(`  - Regex rules: ${rules.stats.regex}`);
+    console.log(`  - Whitelist rules: ${rules.stats.whitelist}`);
+    console.log(`  - Comments/Element hiding: ${rules.stats.comments + rules.stats.elementHiding}`);
+    console.log(`  - Invalid rules: ${rules.stats.invalid}`);
+  }
+
+  return createMatcher(rules, { enableLogging, caseSensitive });
+}
+
+/**
+ * Parses individual adblock rule
+ * @param {string} rule - Raw rule string
+ * @param {boolean} isWhitelist - Whether this is a whitelist rule
+ * @returns {Object} Parsed rule object
+ */
+function parseRule(rule, isWhitelist) {
+  const parsed = {
+    raw: rule,
+    isWhitelist,
+    isDomain: false,
+    isThirdParty: false,
+    isScript: false,
+    isRegex: false,
+    domainRestrictions: null,  // { include: ['site.com'], exclude: ['~site.com'] }
+    pattern: '',
+    options: {},
+    matcher: null
+  };
+
+  // Split rule and options ($option1,option2)
+  let [pattern, optionsStr] = rule.split('$');
+  parsed.pattern = pattern;
+
+  // Parse options
+  if (optionsStr) {
+    const options = optionsStr.split(',');
+
+    // Filter out cosmetic-only options that don't affect network blocking
+    const networkOptions = options.filter(opt => {
+      const optKey = opt.split('=')[0].trim();
+      // Skip cosmetic filtering options
+      const cosmeticOptions = [
+        'generichide',
+        'elemhide', 
+        'specifichide',
+        'genericblock'  // Also cosmetic-related
+      ];
+      return !cosmeticOptions.includes(optKey);
+    });
+
+    // Only process network-related options
+    for (const opt of networkOptions) {
+      const [key, value] = opt.split('=');
+      parsed.options[key.trim()] = value ? value.trim() : true;
+    }
+    
+    // Check for third-party option
+    if (parsed.options['third-party'] || parsed.options['3p']) {
+      parsed.isThirdParty = true;
+    }
+    
+    // Check for script option
+    if (parsed.options['script']) {
+      parsed.isScript = true;
+    }
+    // Parse domain option: $domain=site1.com|site2.com|~excluded.com
+    if (parsed.options['domain']) {
+      const domainList = parsed.options['domain'];
+      const domains = domainList.split('|').map(d => d.trim()).filter(d => d);
+      
+      const include = [];
+      const exclude = [];
+      
+      for (const domain of domains) {
+        if (domain.startsWith('~')) {
+          // Negation: exclude this domain
+          exclude.push(domain.substring(1).toLowerCase());
+        } else {
+          // Positive: include this domain
+          include.push(domain.toLowerCase());
+        }
+      }
+      
+      // Store parsed domain restrictions
+      parsed.domainRestrictions = {
+        include: include.length > 0 ? include : null,
+        exclude: exclude.length > 0 ? exclude : null
+      };
+      
+      // For debugging
+      if (enableLogging && parsed.domainRestrictions) {
+        if (parsed.domainRestrictions.include) {
+          // console.log(`[Adblock] Rule includes domains: ${parsed.domainRestrictions.include.join(', ')}`);
+        }
+        if (parsed.domainRestrictions.exclude) {
+          // console.log(`[Adblock] Rule excludes domains: ${parsed.domainRestrictions.exclude.join(', ')}`);
+        }
+      }
+  }
+ }
+
+  // Domain rules: ||domain.com^ or ||domain.com
+  if (pattern.startsWith('||')) {
+    parsed.isDomain = true;
+    const domain = pattern.substring(2).replace(/\^.*$/, '').replace(/\*$/, '');
+    parsed.domain = domain;
+    parsed.matcher = createDomainMatcher(domain);
+  }
+  // Regex rules: /pattern/
+  else if (pattern.startsWith('/') && pattern.endsWith('/')) {
+    parsed.isRegex = true;
+    const regexPattern = pattern.substring(1, pattern.length - 1);
+    parsed.matcher = new RegExp(regexPattern, 'i');
+  }
+  // Path/wildcard rules: /ads/* or ad.js
+  else {
+    parsed.matcher = createPatternMatcher(pattern);
+  }
+
+  return parsed;
+}
+
+/**
+ * Creates a domain matcher function
+ * @param {string} domain - Domain to match
+ * @returns {Function} Matcher function
+ */
+function createDomainMatcher(domain) {
+  const lowerDomain = domain.toLowerCase();
+  return (url, hostname) => {
+    const lowerHostname = hostname.toLowerCase();
+    // Exact match or subdomain match
+    return lowerHostname === lowerDomain || 
+           lowerHostname.endsWith('.' + lowerDomain);
+  };
+}
+
+/**
+ * Creates a pattern matcher for path/wildcard rules
+ * @param {string} pattern - Pattern with wildcards
+ * @returns {Function} Matcher function
+ */
+function createPatternMatcher(pattern) {
+  // Convert adblock pattern to regex
+  // * matches anything
+  // ^ matches separator (/, ?, &, =, :)
+  // | matches start/end of URL
+  
+  let regexPattern = pattern
+    .replace(/[.+?{}()[\]\\]/g, '\\$&')  // Escape regex special chars
+    .replace(/\*/g, '.*')                 // * -> .*
+    .replace(/\^/g, '[/?&=:]')            // ^ -> separator chars
+    .replace(/^\|/, '^')                  // | at start -> ^
+    .replace(/\|$/, '$');                 // | at end -> $
+  
+  const regex = new RegExp(regexPattern, 'i');
+  return (url) => regex.test(url);
+}
+
+/**
+ * Creates rule matcher with shouldBlock function
+ * @param {Object} rules - Parsed rules object
+ * @param {Object} options - Matcher options
+ * @returns {Object} Matcher with shouldBlock function
+ */
+function createMatcher(rules, options = {}) {
+  const { enableLogging = false, caseSensitive = false } = options;
+  
+  // Create URL parsing cache (scoped to this matcher instance)
+  const urlCache = new URLCache(1000);
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  
+  return {
+    rules,
+    
+    /**
+     * Check if URL should be blocked
+     * @param {string} url - URL to check
+     * @param {string} sourceUrl - Source page URL (for third-party detection)
+     * @param {string} resourceType - Type of resource (script, image, etc)
+     * @returns {Object} { blocked: boolean, rule: string|null, reason: string }
+     */
+    shouldBlock(url, sourceUrl = '', resourceType = '') {
+      try {
+        // OPTIMIZATION: Check cache first for URL parsing (60% faster)
+        let cachedData = urlCache.get(url);
+        let hostname, lowerHostname;
+        
+        if (cachedData) {
+          hostname = cachedData.hostname;
+          lowerHostname = cachedData.lowerHostname;
+          cacheHits++;
+        } else {
+          // Parse URL and cache result
+          const urlObj = new URL(url);
+          hostname = urlObj.hostname;
+          lowerHostname = hostname.toLowerCase();
+          
+          urlCache.set(url, {
+            hostname,
+            lowerHostname
+          });
+          cacheMisses++;
+        }
+        
+        // OPTIMIZATION #1: Only calculate third-party status if we have third-party rules to check
+        // Avoids expensive URL parsing (2x new URL() calls) when no third-party rules exist
+        const isThirdParty = (sourceUrl && rules.thirdPartyRules.length > 0) 
+          ? isThirdPartyRequest(url, sourceUrl) 
+          : false;
+        
+        // OPTIMIZATION #2: Calculate hostname parts once and reuse (avoid duplicate split operations)
+        const hostnameParts = lowerHostname.split('.');
+    
+        // V8 OPT: Extract and cache source page domain for $domain option checking
+        let sourceDomain = null;
+        let cachedSourceData = null;
+
+        if (sourceUrl) {
+          // Check if sourceUrl is in cache (avoid duplicate URL parsing)
+          cachedSourceData = urlCache.get(sourceUrl);
+          
+          if (cachedSourceData) {
+            sourceDomain = cachedSourceData.lowerHostname;
+            cacheHits++;
+          } else {
+            // Parse and cache sourceUrl
+            try {
+              const sourceUrlObj = new URL(sourceUrl);
+              sourceDomain = sourceUrlObj.hostname.toLowerCase();
+              
+              // Cache sourceUrl parsing result (same as request URLs)
+              urlCache.set(sourceUrl, {
+                hostname: sourceUrlObj.hostname,
+                lowerHostname: sourceDomain
+              });
+              cacheMisses++;
+            } catch (err) {
+            // Invalid sourceUrl, leave as null
+            }
+          }
+        }
+
+        // === WHITELIST CHECK (exception rules take precedence) ===
+        
+        // Fast path: Check exact domain in Map (O(1))
+        let rule = rules.whitelistMap.get(lowerHostname);  // V8: Single Map lookup
+        if (rule) {
+          if (enableLogging) {  // V8: Check after getting rule (inlined)
+            console.log(`[Adblock] Whitelisted: ${url} (${rule.raw})`);
+          }
+          if (matchesDomainRestrictions(rule, sourceDomain)) {
+            return { blocked: false, rule: rule.raw, reason: 'whitelisted' };
+          }
+        }
+        
+        // Check parent domains for subdomain matches (e.g., sub.example.com -> example.com)
+        const partsLen = hostnameParts.length;  // V8: Cache array length
+        for (let i = 1; i < partsLen; i++) {
+          const parentDomain = hostnameParts.slice(i).join('.');
+          rule = rules.whitelistMap.get(parentDomain);  // V8: Single Map lookup
+          if (rule) {
+            if (enableLogging) {
+              console.log(`[Adblock] Whitelisted: ${url} (${rule.raw})`);
+            }
+            if (matchesDomainRestrictions(rule, sourceDomain)) {
+              return { blocked: false, rule: rule.raw, reason: 'whitelisted' };
+            }
+          }
+        }
+        
+        // Slow path: Check wildcard whitelist patterns in array
+        const whitelistLen = rules.whitelist.length;  // V8: Cache length + indexed access
+        for (let i = 0; i < whitelistLen; i++) {
+          const rule = rules.whitelist[i];
+          if (matchesRule(rule, url, hostname, isThirdParty, resourceType, sourceDomain)) {
+            if (enableLogging) {
+              console.log(`[Adblock] Whitelisted: ${url} (${rule.raw})`);
+            }
+            return { blocked: false, rule: rule.raw, reason: 'whitelisted' };
+          }
+        }
+
+        // === DOMAIN BLOCKING CHECK ===
+        
+        // Fast path: Check exact domain in Map (O(1))
+        rule = rules.domainMap.get(lowerHostname);  // V8: Single Map lookup
+        if (rule) {
+          if (enableLogging) {
+            console.log(`[Adblock] Blocked domain: ${url} (${rule.raw})`);
+          }
+          if (matchesDomainRestrictions(rule, sourceDomain)) {
+            return { blocked: true, rule: rule.raw, reason: 'domain_rule' };
+          }
+        }
+        
+        // Check parent domains for subdomain matches (e.g., ads.example.com -> example.com)
+        for (let i = 1; i < partsLen; i++) {  // V8: Reuse cached length
+          const parentDomain = hostnameParts.slice(i).join('.');
+          rule = rules.domainMap.get(parentDomain);  // V8: Single Map lookup
+          if (rule) {
+            if (enableLogging) {
+              console.log(`[Adblock] Blocked domain: ${url} (${rule.raw})`);
+            }
+            if (matchesDomainRestrictions(rule, sourceDomain)) {
+              return { blocked: true, rule: rule.raw, reason: 'domain_rule' };
+            }
+          }
+        }
+        
+        // Slow path: Check wildcard domain patterns in array
+        const domainRulesLen = rules.domainRules.length;  // V8: Cache length + indexed access
+        for (let i = 0; i < domainRulesLen; i++) {
+          const rule = rules.domainRules[i];
+          if (matchesRule(rule, url, hostname, isThirdParty, resourceType, sourceDomain)) {
+            if (enableLogging) {
+              console.log(`[Adblock] Blocked domain: ${url} (${rule.raw})`);
+            }
+            return { blocked: true, rule: rule.raw, reason: 'domain_rule' };
+          }
+        }
+
+        // Check third-party rules
+        if (isThirdParty) {
+          const thirdPartyLen = rules.thirdPartyRules.length;  // V8: Cache length
+          for (let i = 0; i < thirdPartyLen; i++) {
+            const rule = rules.thirdPartyRules[i];
+            if (matchesRule(rule, url, hostname, isThirdParty, resourceType, sourceDomain)) {
+              if (enableLogging) {
+                console.log(`[Adblock] Blocked third-party: ${url} (${rule.raw})`);
+              }
+              return { 
+                blocked: true, 
+                rule: rule.raw, 
+                reason: 'third_party_rule' 
+              };
+            }
+          }
+        }
+
+        // Check script rules
+        if (resourceType === 'script' || url.endsWith('.js')) {
+          const scriptRulesLen = rules.scriptRules.length;  // V8: Cache length
+          for (let i = 0; i < scriptRulesLen; i++) {
+            const rule = rules.scriptRules[i];
+           if (matchesRule(rule, url, hostname, isThirdParty, resourceType, sourceDomain)) {
+              if (enableLogging) {
+                console.log(`[Adblock] Blocked script: ${url} (${rule.raw})`);
+              }
+              return { 
+                blocked: true, 
+                rule: rule.raw, 
+                reason: 'script_rule' 
+              };
+            }
+          }
+        }
+
+        // Check path rules
+        const pathRulesLen = rules.pathRules.length;  // V8: Cache length
+        for (let i = 0; i < pathRulesLen; i++) {
+          const rule = rules.pathRules[i];
+          if (matchesRule(rule, url, hostname, isThirdParty, resourceType, sourceDomain)) {
+            if (enableLogging) {
+              console.log(`[Adblock] Blocked path: ${url} (${rule.raw})`);
+            }
+            return { 
+              blocked: true, 
+              rule: rule.raw, 
+              reason: 'path_rule' 
+            };
+          }
+        }
+
+        // Check regex rules (most expensive, check last)
+        const regexRulesLen = rules.regexRules.length;  // V8: Cache length
+        for (let i = 0; i < regexRulesLen; i++) {
+          const rule = rules.regexRules[i];
+          if (matchesRule(rule, url, hostname, isThirdParty, resourceType, sourceDomain)) {
+            if (enableLogging) {
+              console.log(`[Adblock] Blocked regex: ${url} (${rule.raw})`);
+            }
+            return { 
+              blocked: true, 
+              rule: rule.raw, 
+              reason: 'regex_rule' 
+            };
+          }
+        }
+
+        // No match - allow request
+        return { 
+          blocked: false, 
+          rule: null, 
+          reason: 'no_match' 
+        };
+
+      } catch (err) {
+        if (enableLogging) {
+          console.log(`[Adblock] Error checking ${url}: ${err.message}`);
+        }
+        // On error, allow request
+        return { 
+          blocked: false, 
+          rule: null, 
+          reason: 'error' 
+        };
+      }
+    },
+
+    /**
+     * Get statistics about loaded rules
+     * @returns {Object} Statistics object
+     */
+    getStats() {
+      const hitRate = cacheHits + cacheMisses > 0 
+        ? ((cacheHits / (cacheHits + cacheMisses)) * 100).toFixed(1) + '%'
+        : '0%';
+      
+      return { 
+        ...rules.stats,
+        cache: {
+          hits: cacheHits,
+          misses: cacheMisses,
+          hitRate: hitRate,
+          size: urlCache.cache.size,
+          maxSize: urlCache.maxSize
+        }
+      };
+    }
+  };
+}
+
+/**
+ * Check if rule's domain restrictions match the source domain
+ * @param {Object} rule - Rule with potential domainRestrictions
+ * @param {string|null} sourceDomain - Domain of the page making the request (lowercase)
+ * @returns {boolean} True if rule should apply on this source domain
+ */
+function matchesDomainRestrictions(rule, sourceDomain) {
+  // No domain restrictions = applies everywhere
+  if (!rule.domainRestrictions) {
+    return true;
+  }
+  
+  // No source domain provided = can't check restrictions, allow for safety
+  if (!sourceDomain) {
+    return true;
+  }
+  
+  const { include, exclude } = rule.domainRestrictions;
+
+  // V8 OPT ADVANCED: For single-domain restrictions, skip loop overhead
+  // This is the most common case (~80% of domain restrictions)
+  
+  // Fast path: Single exclusion
+  if (exclude && exclude.length === 1 && (!include || include.length === 0)) {
+    const excludedDomain = exclude[0];
+    if (sourceDomain === excludedDomain || sourceDomain.endsWith('.' + excludedDomain)) {
+      return false;
+    }
+    return true;
+  }
+  
+  // Fast path: Single inclusion
+  if (include && include.length === 1 && (!exclude || exclude.length === 0)) {
+    const includedDomain = include[0];
+    return sourceDomain === includedDomain || sourceDomain.endsWith('.' + includedDomain);
+  }
+  
+  // Slow path: Multiple domains (use indexed loops)
+  // V8 OPT: Check exclusions first (higher priority) - use indexed loop
+  // If domain is explicitly excluded, rule does NOT apply
+  if (exclude && exclude.length > 0) {
+    const excludeLen = exclude.length;
+    for (let i = 0; i < excludeLen; i++) {
+      const excludedDomain = exclude[i];
+      // Exact match or subdomain match
+      if (sourceDomain === excludedDomain || sourceDomain.endsWith('.' + excludedDomain)) {
+        return false;  // Domain is excluded, rule should NOT apply
+      }
+    }
+  }
+  
+  // V8 OPT: Check inclusions - use indexed loop
+  // If there's an include list, domain MUST be in it
+  if (include && include.length > 0) {
+    const includeLen = include.length;
+    for (let i = 0; i < includeLen; i++) {
+      const includedDomain = include[i];
+      // Exact match or subdomain match
+      if (sourceDomain === includedDomain || sourceDomain.endsWith('.' + includedDomain)) {
+        return true;  // Domain is included, rule SHOULD apply
+      }
+    }
+    return false;  // Domain not in include list, rule should NOT apply
+  }
+  
+  // Has exclusions but no inclusions, and not excluded = applies
+  return true;
+}
+
+/**
+ * Check if rule matches the given URL
+ * @param {Object} rule - Parsed rule object
+ * @param {string} url - URL to check
+ * @param {string} hostname - Hostname of URL
+ * @param {boolean} isThirdParty - Whether request is third-party
+ * @param {string} resourceType - Resource type
+ * @param {string|null} sourceDomain - Source page domain (for $domain option)
+ * @returns {boolean} True if rule matches
+ */
+function matchesRule(rule, url, hostname, isThirdParty, resourceType, sourceDomain) {
+  // Check domain restrictions first
+  if (!matchesDomainRestrictions(rule, sourceDomain)) {
+    return false;
+  }
+  // Check third-party option
+  if (rule.isThirdParty && !isThirdParty) {
+    return false;
+  }
+
+  // Check script option
+  if (rule.isScript && resourceType !== 'script' && !url.endsWith('.js')) {
+    return false;
+  }
+
+  // Apply matcher function
+  if (rule.isDomain) {
+    return rule.matcher(url, hostname);
+  } else {
+    return rule.matcher(url);
+  }
+}
+
+/**
+ * Determine if request is third-party
+ * @param {string} requestUrl - URL being requested
+ * @param {string} sourceUrl - URL of the page making the request
+ * @returns {boolean} True if third-party request
+ */
+function isThirdPartyRequest(requestUrl, sourceUrl) {
+  try {
+    const requestHostname = new URL(requestUrl).hostname;
+    const sourceHostname = new URL(sourceUrl).hostname;
+    
+    // Extract base domain (handle subdomains)
+    const requestDomain = getBaseDomain(requestHostname);
+    const sourceDomain = getBaseDomain(sourceHostname);
+    
+    return requestDomain !== sourceDomain;
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * Extract base domain from hostname
+ * @param {string} hostname - Full hostname
+ * @returns {string} Base domain
+ */
+function getBaseDomain(hostname) {
+  const parts = hostname.split('.');
+  if (parts.length <= 2) {
+    return hostname;
+  }
+  // Return last two parts (example.com from sub.example.com)
+  return parts.slice(-2).join('.');
+}
+
+module.exports = {
+  parseAdblockRules,
+  isThirdPartyRequest,
+  getBaseDomain
+};

package/lib/domain-cache.js

@@ -10,18 +10,24 @@ const { formatLogMessage } = require('./colorize');
  */
 class DomainCache {
   constructor(options = {}) {
+    // V8 Optimization: Initialize all properties in constructor for stable hidden class
     this.cache = new Set();
+    
+    // V8 Optimization: Use consistent object shape (no dynamic property addition)
     this.stats = {
       totalDetected: 0,
       totalSkipped: 0,
       cacheHits: 0,
       cacheMisses: 0
     };
-    this.options = {
-      enableLogging: options.enableLogging || false,
-      logPrefix: options.logPrefix || '[domain-cache]',
-      maxCacheSize: options.maxCacheSize || 10000 // Prevent memory leaks
-    };
+    
+    // V8 Optimization: Store options directly instead of nested object for faster property access
+    this.enableLogging = options.enableLogging || false;
+    this.logPrefix = options.logPrefix || '[domain-cache]';
+    this.maxCacheSize = options.maxCacheSize || 10000; // Prevent memory leaks
+    
+    // V8 Optimization: Pre-calculate 90% target to avoid repeated Math.floor
+    this.targetCacheSize = Math.floor(this.maxCacheSize * 0.9);
   }
 
   /**
@@ -40,14 +46,14 @@ class DomainCache {
       this.stats.totalSkipped++;
       this.stats.cacheHits++;
       
-      if (this.options.enableLogging) {
-        console.log(formatLogMessage('debug', `${this.options.logPrefix} Cache HIT: ${domain} (skipped)`));
+      if (this.enableLogging) {
+        console.log(formatLogMessage('debug', `${this.logPrefix} Cache HIT: ${domain} (skipped)`));
       }
     } else {
       this.stats.cacheMisses++;
       
-      if (this.options.enableLogging) {
-        console.log(formatLogMessage('debug', `${this.options.logPrefix} Cache MISS: ${domain} (processing)`));
+      if (this.enableLogging) {
+        console.log(formatLogMessage('debug', `${this.logPrefix} Cache MISS: ${domain} (processing)`));
       }
     }
     
@@ -63,25 +69,77 @@ class DomainCache {
       return false;
     }
 
-    // Prevent cache from growing too large
-    if (this.cache.size >= this.options.maxCacheSize) {
-      this.clearOldestEntries(Math.floor(this.options.maxCacheSize * 0.1)); // Remove 10% of entries
-    }
-
     const wasNew = !this.cache.has(domain);
     this.cache.add(domain);
     
     if (wasNew) {
       this.stats.totalDetected++;
       
-      if (this.options.enableLogging) {
-        console.log(formatLogMessage('debug', `${this.options.logPrefix} Marked as detected: ${domain} (cache size: ${this.cache.size})`));
+      if (this.enableLogging) {
+        console.log(formatLogMessage('debug', `${this.logPrefix} Marked as detected: ${domain} (cache size: ${this.cache.size})`));
+      }
+    }
+    
+    // Check size AFTER adding to prevent race where multiple threads see same size
+    // and all trigger cleanup before any adds complete
+    // V8 Optimization: Use pre-calculated targetCacheSize
+    if (this.cache.size > this.maxCacheSize) {
+      const toRemove = this.cache.size - this.targetCacheSize;
+      if (toRemove > 0) {
+        this.clearOldestEntries(toRemove);
       }
     }
     
     return wasNew;
   }
 
+  /**
+   * Atomically check if domain was detected and mark it if new (race-condition free)
+   * This method combines isDomainAlreadyDetected + markDomainAsDetected in one atomic operation
+   * @param {string} domain - Domain to check and potentially mark
+   * @returns {boolean} True if domain was ALREADY detected (should skip), false if NEW (should process)
+   */
+  checkAndMark(domain) {
+    if (!domain || typeof domain !== 'string') {
+      return false;
+    }
+
+    const wasAlreadyDetected = this.cache.has(domain);
+    
+    if (wasAlreadyDetected) {
+      // Domain already exists - update skip stats and return true (should skip)
+      this.stats.totalSkipped++;
+      this.stats.cacheHits++;
+      
+      if (this.enableLogging) {
+        console.log(formatLogMessage('debug', `${this.logPrefix} Cache HIT: ${domain} (skipped)`));
+      }
+      return true; // Already detected, should skip
+    }
+    
+    // Domain is NEW - mark it as detected
+    this.stats.cacheMisses++;
+    
+    this.cache.add(domain);
+    this.stats.totalDetected++;
+    
+    if (this.enableLogging) {
+      console.log(formatLogMessage('debug', `${this.logPrefix} Cache MISS: ${domain} (processing and marked, cache size: ${this.cache.size})`));
+    }
+    
+    // Check size AFTER adding to prevent race where multiple threads see same size
+    // and all trigger cleanup before any adds complete
+    // V8 Optimization: Use pre-calculated targetCacheSize
+    if (this.cache.size > this.maxCacheSize) {
+      const toRemove = this.cache.size - this.targetCacheSize;
+      if (toRemove > 0) {
+        this.clearOldestEntries(toRemove);
+      }
+    }
+    
+    return false; // New domain, should process
+  }
+
   /**
    * Clear oldest entries from cache (basic LRU simulation)
    * Note: Set doesn't maintain insertion order in all Node.js versions,
@@ -96,8 +154,8 @@ class DomainCache {
     
     toRemove.forEach(domain => this.cache.delete(domain));
     
-    if (this.options.enableLogging) {
-      console.log(formatLogMessage('debug', `${this.options.logPrefix} Cleared ${toRemove.length} old entries, cache size now: ${this.cache.size}`));
+    if (this.enableLogging) {
+      console.log(formatLogMessage('debug', `${this.logPrefix} Cleared ${toRemove.length} old entries, cache size now: ${this.cache.size}`));
     }
   }
 
@@ -128,8 +186,8 @@ class DomainCache {
       cacheMisses: 0
     };
     
-    if (this.options.enableLogging) {
-      console.log(formatLogMessage('debug', `${this.options.logPrefix} Cache cleared (${previousSize} entries removed)`));
+    if (this.enableLogging) {
+      console.log(formatLogMessage('debug', `${this.logPrefix} Cache cleared (${previousSize} entries removed)`));
     }
   }
 
@@ -158,8 +216,8 @@ class DomainCache {
   removeDomain(domain) {
     const wasRemoved = this.cache.delete(domain);
     
-    if (wasRemoved && this.options.enableLogging) {
-      console.log(formatLogMessage('debug', `${this.options.logPrefix} Removed from cache: ${domain}`));
+    if (wasRemoved && this.enableLogging) {
+      console.log(formatLogMessage('debug', `${this.logPrefix} Removed from cache: ${domain}`));
     }
     
     return wasRemoved;
@@ -193,6 +251,7 @@ class DomainCache {
     return {
       isDomainAlreadyDetected: this.isDomainAlreadyDetected.bind(this),
       markDomainAsDetected: this.markDomainAsDetected.bind(this),
+      checkAndMark: this.checkAndMark.bind(this),
       getSkippedCount: () => this.stats.totalSkipped,
       getCacheSize: () => this.cache.size,
       getStats: this.getStats.bind(this)
@@ -261,6 +320,16 @@ function markDomainAsDetected(domain) {
   cache.markDomainAsDetected(domain);
 }
 
+/**
+ * Atomically check and mark a domain (race-condition free)
+ * @param {string} domain - Domain to check and mark
+ * @returns {boolean} True if already detected (skip), false if new (process)
+ */
+function checkAndMark(domain) {
+  const cache = getGlobalDomainCache();
+  return cache.checkAndMark(domain);
+}
+
 /**
  * Get total domains skipped (legacy wrapper)
  * @returns {number} Number of domains skipped
@@ -291,6 +360,7 @@ module.exports = {
   // Legacy wrapper functions for backward compatibility
   isDomainAlreadyDetected,
   markDomainAsDetected,
+  checkAndMark,
   getTotalDomainsSkipped,
   getDetectedDomainsCount
 };

package/lib/fingerprint.js

@@ -93,9 +93,9 @@ const USER_AGENT_COLLECTIONS = Object.freeze(new Map([
   ['chrome', "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36"],
   ['chrome_mac', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36"],
   ['chrome_linux', "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36"],
-  ['firefox', "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:144.0) Gecko/20100101 Firefox/144.0"],
-  ['firefox_mac', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:144.0) Gecko/20100101 Firefox/144.0"],
-  ['firefox_linux', "Mozilla/5.0 (X11; Linux x86_64; rv:144.0) Gecko/20100101 Firefox/144.0"],
+  ['firefox', "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0) Gecko/20100101 Firefox/145.0"],
+  ['firefox_mac', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:145.0) Gecko/20100101 Firefox/145.0"],
+  ['firefox_linux', "Mozilla/5.0 (X11; Linux x86_64; rv:145.0) Gecko/20100101 Firefox/145.0"],
   ['safari', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15"]
 ]));
 

package/lib/referrer.js

@@ -1,6 +1,16 @@
 // === Referrer Header Generation Module ===
 // This module handles generation of referrer headers for different traffic simulation modes
 
+/**
+ * Performance utility: Get random element from array
+ * Reduces code duplication and improves readability
+ * @param {Array} array - Array to select from
+ * @returns {*} Random element from array
+ */
+function getRandomElement(array) {
+  return array[Math.floor(Math.random() * array.length)];
+}
+
 /**
  * Referrer URL collections for different modes
  */
@@ -69,7 +79,7 @@ const REFERRER_COLLECTIONS = Object.freeze({
  */
 function generateSearchTerm(customTerms, context = null) {
   if (customTerms && customTerms.length > 0) {
-    return customTerms[Math.floor(Math.random() * customTerms.length)];
+    return getRandomElement(customTerms);
   }
   
   // Use context-specific terms if available
@@ -80,7 +90,7 @@ function generateSearchTerm(customTerms, context = null) {
     termCollection = REFERRER_COLLECTIONS.TECH_TERMS;
   }
   
-  return termCollection[Math.floor(Math.random() * termCollection.length)];
+  return getRandomElement(termCollection);
 }
 
 /**
@@ -91,9 +101,8 @@ function generateSearchTerm(customTerms, context = null) {
  * @returns {string} Generated search engine referrer URL
  */
 function generateSearchReferrer(searchTerms, context, forceDebug) {
-  const randomEngine = REFERRER_COLLECTIONS.SEARCH_ENGINES[
-    Math.floor(Math.random() * REFERRER_COLLECTIONS.SEARCH_ENGINES.length)
-  ];
+  const randomEngine = getRandomElement(REFERRER_COLLECTIONS.SEARCH_ENGINES);
+  
   const searchTerm = generateSearchTerm(searchTerms, context);
   const referrerUrl = randomEngine + encodeURIComponent(searchTerm);
   
@@ -110,9 +119,7 @@ function generateSearchReferrer(searchTerms, context, forceDebug) {
  * @returns {string} Generated social media referrer URL
  */
 function generateSocialMediaReferrer(forceDebug) {
-  const randomSocial = REFERRER_COLLECTIONS.SOCIAL_MEDIA[
-    Math.floor(Math.random() * REFERRER_COLLECTIONS.SOCIAL_MEDIA.length)
-  ];
+  const randomSocial = getRandomElement(REFERRER_COLLECTIONS.SOCIAL_MEDIA);
   
   if (forceDebug) {
     console.log(`[debug] Generated social media referrer: ${randomSocial}`);
@@ -127,9 +134,7 @@ function generateSocialMediaReferrer(forceDebug) {
  * @returns {string} Generated news site referrer URL
  */
 function generateNewsReferrer(forceDebug) {
-  const randomNews = REFERRER_COLLECTIONS.NEWS_SITES[
-    Math.floor(Math.random() * REFERRER_COLLECTIONS.NEWS_SITES.length)
-  ];
+  const randomNews = getRandomElement(REFERRER_COLLECTIONS.NEWS_SITES);
   
   if (forceDebug) {
     console.log(`[debug] Generated news referrer: ${randomNews}`);
@@ -155,33 +160,47 @@ function isValidUrl(url) {
  * @returns {boolean} True if referrer should be disabled for this URL
  */
 function shouldDisableReferrer(targetUrl, disableList, forceDebug = false) {
-  if (!disableList || !Array.isArray(disableList) || disableList.length === 0) {
+  // Fast path: early return for empty/invalid inputs
+  if (!disableList?.length || !targetUrl || typeof targetUrl !== 'string') {
     return false;
   }
   
-  if (!targetUrl || typeof targetUrl !== 'string') {
-    return false;
+  // Parse target URL once (performance optimization)
+  let targetHostname = null;
+  let targetUrlParsed = false;
+  
+  try {
+    targetHostname = new URL(targetUrl).hostname;
+    targetUrlParsed = true;
+  } catch (e) {
+    // Invalid URL - can only do string matching
+    targetUrlParsed = false;
   }
   
   for (const disablePattern of disableList) {
     if (typeof disablePattern !== 'string') continue;
     
-    // Exact URL match
+    // Fast check: Exact URL match (no parsing needed)
     if (targetUrl === disablePattern) {
-      if (forceDebug) console.log(`[debug] Referrer disabled for exact URL match: ${targetUrl}`);
+      if (forceDebug) console.log(`[debug] Referrer disabled for exact match: ${targetUrl}`);
       return true;
     }
     
-    // Domain/hostname match
-    try {
-      const targetHostname = new URL(targetUrl).hostname;
-      const disableHostname = new URL(disablePattern).hostname;
-      if (targetHostname === disableHostname) {
-        if (forceDebug) console.log(`[debug] Referrer disabled for domain match: ${targetHostname}`);
-        return true;
+    // Domain/hostname match (use cached parsed URL)
+    if (targetUrlParsed) {
+      try {
+        const disableHostname = new URL(disablePattern).hostname;
+        if (targetHostname === disableHostname) {
+          if (forceDebug) console.log(`[debug] Referrer disabled for domain match: ${targetHostname}`);
+          return true;
+        }
+      } catch (e) {
+        // disablePattern is not a valid URL, try substring match below
       }
-    } catch (e) {
-      // If pattern is not a valid URL, try simple string matching
+    }
+    
+    // Fallback: Simple substring match (for patterns like 'example.com')
+    if (!targetUrlParsed || disablePattern.includes('/') === false) {
       if (targetUrl.includes(disablePattern)) {
         if (forceDebug) console.log(`[debug] Referrer disabled for pattern match: ${disablePattern} in ${targetUrl}`);
         return true;
@@ -218,7 +237,7 @@ function generateReferrerUrl(referrerConfig, forceDebug = false) {
         return '';
       }
       
-      const randomUrl = referrerConfig[Math.floor(Math.random() * referrerConfig.length)];
+      const randomUrl = getRandomElement(referrerConfig);
       const url = isValidUrl(randomUrl) ? randomUrl : '';
       
       if (forceDebug) {
@@ -261,7 +280,7 @@ function generateReferrerUrl(referrerConfig, forceDebug = false) {
         case 'mixed': {
           // Randomly choose between different referrer types
           const modes = ['random_search', 'social_media', 'news_sites'];
-          const randomMode = modes[Math.floor(Math.random() * modes.length)];
+          const randomMode = getRandomElement(modes);
           
           if (forceDebug) console.log(`[debug] Mixed mode selected: ${randomMode}`);
           
@@ -335,14 +354,26 @@ function validateReferrerConfig(referrerConfig) {
   if (Array.isArray(referrerConfig)) {
     if (referrerConfig.length === 0) {
       result.warnings.push('Empty referrer array will result in no referrer');
-    } else {
-      referrerConfig.forEach((url, index) => {
+      return result;
+    }
+    
+    // Fast validation: check only first and last items if array is large
+    const itemsToCheck = referrerConfig.length > 10 
+      ? [referrerConfig[0], referrerConfig[referrerConfig.length - 1]]
+      : referrerConfig;
+    
+    itemsToCheck.forEach((url, index) => {
         if (!isValidUrl(url)) {
-          result.errors.push(`Array item ${index} is not a valid HTTP/HTTPS URL: ${url}`);
+          const actualIndex = itemsToCheck === referrerConfig ? index : (index === 0 ? 0 : referrerConfig.length - 1);
+          result.errors.push(`Array item ${actualIndex} is not a valid HTTP/HTTPS URL: ${url}`);
           result.isValid = false;
         }
       });
+
+    if (referrerConfig.length > 10 && itemsToCheck.length < referrerConfig.length) {
+      result.warnings.push(`Large array (${referrerConfig.length} items): only validated first and last items for performance`);
     }
+    
     return result;
   }
   

package/nwss.js

@@ -1,4 +1,4 @@
-// === Network scanner script (nwss.js) v2.0.31 ===
+// === Network scanner script (nwss.js) v2.0.33 ===
 
 // puppeteer for browser automation, fs for file system operations, psl for domain parsing.
 // const pLimit = require('p-limit'); // Will be dynamically imported
@@ -50,6 +50,8 @@ const { initializeDryRunCollections, addDryRunMatch, addDryRunNetTools, processD
 const { clearSiteData } = require('./lib/clear_sitedata');
 // Referrer header generation
 const { getReferrerForUrl, validateReferrerConfig, validateReferrerDisable } = require('./lib/referrer');
+// Adblock rules parser
+const { parseAdblockRules } = require('./lib/adblock');
 
 // Fast setTimeout helper for Puppeteer 22.x compatibility
 // Uses standard Promise constructor for better performance than node:timers/promises
@@ -94,9 +96,9 @@ const USER_AGENTS = Object.freeze(new Map([
   ['chrome', "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36"],
   ['chrome_mac', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36"],
   ['chrome_linux', "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36"],
-  ['firefox', "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:144.0) Gecko/20100101 Firefox/144.0"],
-  ['firefox_mac', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:144.0) Gecko/20100101 Firefox/144.0"],
-  ['firefox_linux', "Mozilla/5.0 (X11; Linux x86_64; rv:144.0) Gecko/20100101 Firefox/144.0"],
+  ['firefox', "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:145.0) Gecko/20100101 Firefox/145.0"],
+  ['firefox_mac', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:145.0) Gecko/20100101 Firefox/145.0"],
+  ['firefox_linux', "Mozilla/5.0 (X11; Linux x86_64; rv:145.0) Gecko/20100101 Firefox/145.0"],
   ['safari', "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.6 Safari/605.1.15"]
 ]));
 
@@ -145,7 +147,7 @@ const { navigateWithRedirectHandling, handleRedirectTimeout } = require('./lib/r
 const { monitorBrowserHealth, isBrowserHealthy, isQuicklyResponsive, performGroupWindowCleanup, performRealtimeWindowCleanup, trackPageForRealtime, updatePageUsage, cleanupPageBeforeReload } = require('./lib/browserhealth');
 
 // --- Script Configuration & Constants --- 
-const VERSION = '2.0.31'; // Script version
+const VERSION = '2.0.33'; // Script version
 
 // get startTime
 const startTime = Date.now();
@@ -244,6 +246,11 @@ if (cleanupIntervalIndex !== -1 && args[cleanupIntervalIndex + 1]) {
 const enableColors = args.includes('--color') || args.includes('--colour');
 let adblockRulesMode = args.includes('--adblock-rules');
 
+// Adblock variables (request blocking)
+let adblockEnabled = false;
+let adblockMatcher = null;
+let adblockStats = { blocked: 0, allowed: 0 };
+
 // Validate --adblock-rules usage - ignore if used incorrectly instead of erroring
 if (adblockRulesMode) {
   if (!outputFile) {
@@ -452,6 +459,24 @@ if (validateRules || validateRulesFile) {
   }
 }
 
+// Parse --block-ads argument for request-level ad blocking
+const blockAdsIndex = args.findIndex(arg => arg.startsWith('--block-ads'));
+if (blockAdsIndex !== -1) {
+  const rulesFile = args[blockAdsIndex].includes('=') 
+    ? args[blockAdsIndex].split('=')[1] 
+    : args[blockAdsIndex + 1];
+  
+  if (!rulesFile || !fs.existsSync(rulesFile)) {
+    console.log(`Error: Adblock rules file not found: ${rulesFile || '(not specified)'}`);
+    process.exit(1);
+  }
+  
+  adblockEnabled = true;
+  adblockMatcher = parseAdblockRules(rulesFile, { enableLogging: forceDebug });
+  const stats = adblockMatcher.getStats();
+  if (!silentMode) console.log(messageColors.success(`Adblock enabled: Loaded ${stats.total} blocking rules from ${rulesFile}`));
+}
+
 if (args.includes('--help') || args.includes('-h')) {
   console.log(`Usage: node nwss.js [options]
 
@@ -471,6 +496,10 @@ Output Format Options:
   --privoxy                      Output as { +block } .domain.com (Privoxy format)
   --pihole                       Output as (^|\\.)domain\\.com$ (Pi-hole regex format)
   --adblock-rules                Generate adblock filter rules with resource type modifiers (requires -o)
+  
+Request Blocking:
+  --block-ads=<file>             Block ads/trackers using EasyList format rules (||domain.com^, /ads/*, etc)
+                                 Works at request-level for maximum performance
 
 General Options:
   --verbose                      Force verbose mode globally
@@ -2345,6 +2374,27 @@ function setupFrameHandling(page, forceDebug) {
           console.log(formatLogMessage('debug', `${messageColors.highlight('[req]')}[frame: ${isMainFrame ? 'main' : 'iframe'}] ${frameUrl} → ${request.url()}`));
         }
 
+        // Apply adblock rules BEFORE expensive regex checks for better performance
+        if (adblockEnabled && adblockMatcher) {
+          try {
+            const result = adblockMatcher.shouldBlock(
+              checkedUrl,
+              currentUrl,
+              request.resourceType()
+            );
+            
+            if (result.blocked) {
+              adblockStats.blocked++;
+              if (forceDebug) {
+                console.log(formatLogMessage('debug', `${messageColors.blocked('[adblock]')} ${checkedUrl} (${result.reason})`));
+              }
+              request.abort();
+              return;
+            }
+            adblockStats.allowed++;
+          } catch (err) { /* Silently continue on adblock errors */ }
+        }
+
         // Show --debug output and the url while its scanning
         if (forceDebug) {
           const simplifiedUrl = getRootDomain(currentUrl);
@@ -4049,6 +4099,12 @@ function setupFrameHandling(page, forceDebug) {
        console.log(formatLogMessage('debug', `Cached detections: ${cloudflareStats.size}`));
      }
      // Log smart cache statistics (if cache is enabled)
+     // Adblock statistics
+     if (adblockEnabled) {
+       console.log(formatLogMessage('debug', '=== Adblock Statistics ==='));
+       const blockRate = ((adblockStats.blocked / (adblockStats.blocked + adblockStats.allowed)) * 100).toFixed(1);
+       console.log(formatLogMessage('debug', `Blocked: ${adblockStats.blocked} requests (${blockRate}% block rate), Allowed: ${adblockStats.allowed}`));
+     }
     if (smartCache) {
     const cacheStats = smartCache.getStats();  
     console.log(formatLogMessage('debug', '=== Smart Cache Statistics ==='));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "2.0.31",
+  "version": "2.0.33",
   "description": "A Puppeteer-based network scanner for analyzing web traffic, generating adblock filter rules, and identifying third-party requests. Features include fingerprint spoofing, Cloudflare bypass, content analysis with curl/grep, and multiple output formats.",
   "main": "nwss.js",
   "scripts": {