@fanboynz/network-scanner 2.0.45 → 2.0.47

package/lib/adblock.js

@@ -62,6 +62,7 @@ function parseAdblockRules(filePath, options = {}) {
     domainMap: new Map(),          // ||domain.com^ - Exact domains for O(1) lookup
     domainRules: [],               // ||*.domain.com^ - Wildcard domains (fallback)
     thirdPartyRules: [],           // ||domain.com^$third-party
+    firstPartyRules: [],
     pathRules: [],                 // /ads/*
     scriptRules: [],               // .js$script
     regexRules: [],                // /regex/
@@ -73,6 +74,7 @@ function parseAdblockRules(filePath, options = {}) {
       domain: 0,
       domainMapEntries: 0,         // Exact domain matches in Map
       thirdParty: 0,
+      firstParty: 0,
       path: 0,
       script: 0,
       regex: 0,
@@ -137,6 +139,9 @@ function parseAdblockRules(filePath, options = {}) {
       if (parsedRule.isThirdParty) {
         rules.thirdPartyRules.push(parsedRule);
         rules.stats.thirdParty++;
+      } else if (parsedRule.isFirstParty) {
+        rules.firstPartyRules.push(parsedRule);
+        rules.stats.firstParty++;
       } else if (parsedRule.isDomain) {
         // Store exact domains in Map for O(1) lookup, wildcards in array
         if (parsedRule.domain && !parsedRule.domain.includes('*')) {
@@ -170,6 +175,7 @@ function parseAdblockRules(filePath, options = {}) {
     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(`  - First-party rules: ${rules.stats.firstParty}`);
     console.log(`  - Path rules: ${rules.stats.path}`);
     console.log(`  - Script rules: ${rules.stats.script}`);
     console.log(`  - Regex rules: ${rules.stats.regex}`);
@@ -193,7 +199,10 @@ function parseRule(rule, isWhitelist) {
     isWhitelist,
     isDomain: false,
     isThirdParty: false,
+    isFirstParty: false,
     isScript: false,
+    resourceTypes: null,       // Array of allowed resource types, null = all types
+    excludedResourceTypes: null, // Array of excluded resource types ($~script, $~image)
     isRegex: false,
     domainRestrictions: null,  // { include: ['site.com'], exclude: ['~site.com'] }
     pattern: '',
@@ -233,10 +242,47 @@ function parseRule(rule, isWhitelist) {
       parsed.isThirdParty = true;
     }
     
-    // Check for script option
-    if (parsed.options['script']) {
-      parsed.isScript = true;
+    // Check for first-party option ($first-party, $1p, $~third-party)
+    if (parsed.options['first-party'] || parsed.options['1p'] || parsed.options['~third-party']) {
+      parsed.isFirstParty = true;
     }
+
+    // Parse resource type options
+    const TYPE_MAP = {
+      'script': 'script',
+      'stylesheet': 'stylesheet',
+      'css': 'stylesheet',
+      'image': 'image',
+      'xmlhttprequest': 'xhr',
+      'xhr': 'xhr',
+      'font': 'font',
+      'media': 'media',
+      'websocket': 'websocket',
+      'subdocument': 'subdocument',
+      'document': 'document',
+      'ping': 'ping',
+      'other': 'other'
+    };
+    
+    const matchedTypes = Object.keys(parsed.options)
+      .filter(key => TYPE_MAP[key])
+      .map(key => TYPE_MAP[key]);
+  
+    const excludedTypes = Object.keys(parsed.options)
+      .filter(key => key.startsWith('~') && TYPE_MAP[key.substring(1)])
+      .map(key => TYPE_MAP[key.substring(1)]);
+
+    if (matchedTypes.length > 0) {
+      parsed.resourceTypes = matchedTypes;
+      if (parsed.options['script']) {
+        parsed.isScript = true;
+      }
+    }
+
+    if (excludedTypes.length > 0) {
+      parsed.excludedResourceTypes = excludedTypes;
+    }
+
     // Parse domain option: $domain=site1.com|site2.com|~excluded.com
     if (parsed.options['domain']) {
       const domainList = parsed.options['domain'];
@@ -261,15 +307,6 @@ function parseRule(rule, isWhitelist) {
         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(', ')}`);
-        }
-      }
   }
  }
 
@@ -284,7 +321,8 @@ function parseRule(rule, isWhitelist) {
   else if (pattern.startsWith('/') && pattern.endsWith('/')) {
     parsed.isRegex = true;
     const regexPattern = pattern.substring(1, pattern.length - 1);
-    parsed.matcher = new RegExp(regexPattern, 'i');
+    const regex = new RegExp(regexPattern, 'i');
+    parsed.matcher = (url) => regex.test(url);
   }
   // Path/wildcard rules: /ads/* or ad.js
   else {
@@ -378,10 +416,10 @@ function createMatcher(rules, options = {}) {
           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) 
+        // OPTIMIZATION #1: Only calculate third-party status if we have rules that need it
+        const hasPartyRules = rules.thirdPartyRules.length > 0 || rules.firstPartyRules.length > 0;
+        const isThirdParty = (sourceUrl && hasPartyRules)
+          ? isThirdPartyRequest(url, sourceUrl)
           : false;
         
         // OPTIMIZATION #2: Calculate hostname parts once and reuse (avoid duplicate split operations)
@@ -513,6 +551,24 @@ function createMatcher(rules, options = {}) {
           }
         }
 
+        // Check first-party rules
+        if (!isThirdParty) {
+          const firstPartyLen = rules.firstPartyRules.length;
+          for (let i = 0; i < firstPartyLen; i++) {
+            const rule = rules.firstPartyRules[i];
+            if (matchesRule(rule, url, hostname, isThirdParty, resourceType, sourceDomain)) {
+              if (enableLogging) {
+                console.log(`[Adblock] Blocked first-party: ${url} (${rule.raw})`);
+              }
+              return {
+                blocked: true,
+                rule: rule.raw,
+                reason: 'first_party_rule'
+              };
+            }
+          }
+        }
+
         // Check script rules
         if (resourceType === 'script' || url.endsWith('.js')) {
           const scriptRulesLen = rules.scriptRules.length;  // V8: Cache length
@@ -675,6 +731,14 @@ function matchesDomainRestrictions(rule, sourceDomain) {
   return true;
 }
 
+// Module-level constant for resource type normalization (hot path)
+const RESOURCE_TYPE_ALIASES = {
+  'script': 'script', 'stylesheet': 'stylesheet', 'image': 'image',
+  'xhr': 'xhr', 'fetch': 'xhr', 'font': 'font', 'media': 'media',
+  'websocket': 'websocket', 'subdocument': 'subdocument',
+  'document': 'document', 'ping': 'ping', 'other': 'other'
+};
+
 /**
  * Check if rule matches the given URL
  * @param {Object} rule - Parsed rule object
@@ -685,6 +749,7 @@ function matchesDomainRestrictions(rule, sourceDomain) {
  * @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)) {
@@ -695,11 +760,34 @@ function matchesRule(rule, url, hostname, isThirdParty, resourceType, sourceDoma
     return false;
   }
 
-  // Check script option
-  if (rule.isScript && resourceType !== 'script' && !url.endsWith('.js')) {
+  // Check first-party option
+  if (rule.isFirstParty && isThirdParty) {
     return false;
   }
 
+  // Check resource type restrictions
+  if (rule.resourceTypes) {
+    if (!resourceType) {
+      // No resource type info available — allow match for safety
+    } else {
+      // Normalize Puppeteer resource types to match our type names
+      const normalizedType = RESOURCE_TYPE_ALIASES[resourceType] || resourceType;
+      if (!rule.resourceTypes.includes(normalizedType)) {
+        return false;
+      }
+    }
+  }
+
+  // Check negated resource type restrictions ($~script, $~image, etc.)
+  if (rule.excludedResourceTypes) {
+    if (resourceType) {
+      const normalizedType = RESOURCE_TYPE_ALIASES[resourceType] || resourceType;
+      if (rule.excludedResourceTypes.includes(normalizedType)) {
+        return false;
+      }
+    }
+  }
+
   // Apply matcher function
   if (rule.isDomain) {
     return rule.matcher(url, hostname);

package/lib/cdp.js

@@ -425,7 +425,5 @@ async function createEnhancedCDPSession(page, currentUrl, options = {}) {
 module.exports = {
   createCDPSession,
   createPageWithTimeout,
-  setRequestInterceptionWithTimeout,
-  validateCDPConfig,
-  createEnhancedCDPSession
+  setRequestInterceptionWithTimeout
 };

package/lib/clear_sitedata.js

@@ -345,6 +345,5 @@ async function clearSiteDataEnhanced(page, currentUrl, forceDebug) {
 module.exports = {
   clearSiteData,
   clearSiteDataViaCDP,
-  clearSiteDataViaPage,
-  clearSiteDataEnhanced
+  clearSiteDataViaPage
 };

package/lib/grep.js

@@ -88,6 +88,7 @@ async function grepContent(content, searchPatterns, options = {}) {
   }
 
   let tempFile = null;
+  let tempDir = null;
   
   try {
     // Create temporary directory and file with content

package/lib/interaction.js

@@ -373,7 +373,6 @@ async function humanLikeMouseMove(page, fromX, fromY, toX, toY, options = {}) {
 
     // Add slight curve to movement (more human-like)
     if (curve > 0 && i > 0 && i < actualSteps) {
-      const midpoint = actualSteps / 2;
       const curveIntensity = Math.sin((i / actualSteps) * Math.PI) * curve * distance * MOUSE_MOVEMENT.CURVE_INTENSITY_RATIO;
       const perpX = -(toY - fromY) / distance;
       const perpY = (toX - fromX) / distance;
@@ -449,7 +448,7 @@ async function simulateScrolling(page, options = {}) {
       // Smooth scrolling by breaking into smaller increments
       for (let j = 0; j < smoothness; j++) {
         await page.mouse.wheel({ deltaY: scrollDelta / smoothness });
-        await new Promise(resolve => setTimeout(resolve, SCROLLING.SMOOTH_INCREMENT_DELAY));
+        await fastTimeout(SCROLLING.SMOOTH_INCREMENT_DELAY);
       }
       
       if (i < amount - 1) {
@@ -549,7 +548,7 @@ async function interactWithElements(page, options = {}) {
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       try {
         // Find visible, clickable elements
-        const elements = await page.evaluate((selectors, avoidWords) => {
+        const elements = await page.evaluate((selectors, avoidWords, textPreviewLen) => {
           const clickableElements = [];
           
           selectors.forEach(selector => {
@@ -571,7 +570,7 @@ async function interactWithElements(page, options = {}) {
                     y: rect.top + rect.height / 2,
                     width: rect.width,
                     height: rect.height,
-                    text: text.substring(0, ELEMENT_INTERACTION.TEXT_PREVIEW_LENGTH)
+                    text: text.substring(0, textPreviewLen)
                   });
                 }
               }
@@ -579,7 +578,7 @@ async function interactWithElements(page, options = {}) {
           });
           
           return clickableElements;
-        }, elementTypes, avoidDestructive ? ['delete', 'remove', 'submit', 'buy', 'purchase', 'order'] : []);
+        }, elementTypes, avoidDestructive ? ['delete', 'remove', 'submit', 'buy', 'purchase', 'order'] : [], ELEMENT_INTERACTION.TEXT_PREVIEW_LENGTH);
 
         if (elements.length > 0) {
           // Choose a random element to interact with
@@ -590,12 +589,12 @@ async function interactWithElements(page, options = {}) {
           await humanLikeMouseMove(page, currentPos.x, currentPos.y, element.x, element.y);
           
           // Brief pause before clicking
-          await fastTimeout(TIMING.CLICK_PAUSE_MIN + Math.random() * TIMING.CLICK_PAUSE_MAX);
+          await fastTimeout(TIMING.CLICK_PAUSE_MIN + Math.random() * (TIMING.CLICK_PAUSE_MAX - TIMING.CLICK_PAUSE_MIN));
           
           await page.mouse.click(element.x, element.y);
           
           // Brief pause after clicking
-          await fastTimeout(TIMING.POST_CLICK_MIN + Math.random() * TIMING.POST_CLICK_MAX);
+          await fastTimeout(TIMING.POST_CLICK_MIN + Math.random() * (TIMING.POST_CLICK_MAX - TIMING.POST_CLICK_MIN));
         }
       } catch (elementErr) {
         // Continue to next attempt if this one fails
@@ -673,9 +672,9 @@ async function simulateTyping(page, text, options = {}) {
       if (mistakes && Math.random() < mistakeRate) {
         const wrongChar = String.fromCharCode(97 + Math.floor(Math.random() * 26));
         await page.keyboard.type(wrongChar);
-        await fastTimeout(TIMING.MISTAKE_PAUSE_MIN + Math.random() * TIMING.MISTAKE_PAUSE_MAX);
+        await fastTimeout(TIMING.MISTAKE_PAUSE_MIN + Math.random() * (TIMING.MISTAKE_PAUSE_MAX - TIMING.MISTAKE_PAUSE_MIN));
         await page.keyboard.press('Backspace');
-        await fastTimeout(TIMING.BACKSPACE_DELAY_MIN + Math.random() * TIMING.BACKSPACE_DELAY_MAX);
+        await fastTimeout(TIMING.BACKSPACE_DELAY_MIN + Math.random() * (TIMING.BACKSPACE_DELAY_MAX - TIMING.BACKSPACE_DELAY_MIN));
       }
       
       await page.keyboard.type(char);
@@ -818,6 +817,7 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
         }
         return;
       }
+      await bodyExists.dispose();
     } catch (bodyCheckErr) {
       if (forceDebug) {
         console.log(`[interaction] Page not ready for interaction on ${currentUrl} (waited ${Math.min(Math.max((options.siteTimeout || 20000) / 8, 2000), 5000)}ms): ${bodyCheckErr.message}`);
@@ -922,6 +922,7 @@ async function performPageInteraction(page, currentUrl, options = {}, forceDebug
       const bodyElement = await page.$('body');
       if (bodyElement) {
         await page.hover('body');
+        await bodyElement.dispose();
       }
     } catch (hoverErr) {
       // Silently handle hover failures - not critical

package/nwss.js

@@ -1790,10 +1790,6 @@ function setupFrameHandling(page, forceDebug) {
         }
       });
       
-      page.on('response', (response) => {
-        // Response handler - removed incorrect error logging
-      });
-
       // Apply flowProxy timeouts if detection is enabled
       if (flowproxyDetection) {
         const flowproxyTimeouts = getFlowProxyTimeouts(siteConfig);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fanboynz/network-scanner",
-  "version": "2.0.45",
+  "version": "2.0.47",
   "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": {