jumpy-lion 0.0.42 → 0.0.44

package/dist/fingerprinting/fingerprint-overrides/ua-ch.js

@@ -1,93 +1,193 @@
 /**
- * navigator.userAgentData spoofing
+ * navigator.userAgentData spoofing (UA-CH Client Hints)
  * Generates brand list & bitness matching the chosen platform.
+ *
+ * 2024-2025 Enhanced:
+ * - Consistent platform returns "Windows" for Win32
+ * - Proper getHighEntropyValues() with all Windows-specific fields
+ * - Realistic Chrome version numbers matching userAgent
+ * - Proper prototype chain and native-like appearance
  */
 export const createUAClientHintsSpoofingScript = (platform = 'Win32') => {
     let platformData;
     let platformVersion;
-    if (platform.startsWith('Win')) {
+    let architecture;
+    let bitness;
+    let wow64;
+    if (platform.startsWith('Win') || platform === 'Win32') {
         platformData = 'Windows';
-        platformVersion = '15.0.0';
+        platformVersion = '15.0.0'; // Windows 11
+        architecture = 'x86';
+        bitness = '64';
+        wow64 = false;
     }
     else if (platform.startsWith('Mac')) {
         platformData = 'macOS';
-        platformVersion = '14.0.0';
+        platformVersion = '14.4.0'; // macOS Sonoma
+        architecture = 'arm';
+        bitness = '64';
+        wow64 = false;
     }
     else {
         platformData = 'Linux';
-        platformVersion = '6.2.0';
+        platformVersion = '6.5.0';
+        architecture = 'x86';
+        bitness = '64';
+        wow64 = false;
     }
+    // Use realistic Chrome version (should match userAgent)
+    const chromeVersion = '131';
+    const fullVersion = '131.0.6778.139';
     return `
 (() => {
     'use strict';
     
-    // UA-CH (User-Agent Client Hints) spoofing for 2025
-    const brands = [
-        { brand: "Chromium", version: "125" },
-        { brand: "Google Chrome", version: "125" },
-        { brand: "Not A(Brand", version: "99" }
-    ];
+    // UA-CH (User-Agent Client Hints) spoofing for 2024-2025
+    // CRITICAL: Must match the platform spoofing and userAgent
+    
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    
+    // Brand list in Chrome's format - order matters!
+    const brands = Object.freeze([
+        Object.freeze({ brand: "Google Chrome", version: "${chromeVersion}" }),
+        Object.freeze({ brand: "Chromium", version: "${chromeVersion}" }),
+        Object.freeze({ brand: "Not_A Brand", version: "24" })
+    ]);
+    
+    const fullVersionList = Object.freeze([
+        Object.freeze({ brand: "Google Chrome", version: "${fullVersion}" }),
+        Object.freeze({ brand: "Chromium", version: "${fullVersion}" }),
+        Object.freeze({ brand: "Not_A Brand", version: "24.0.0.0" })
+    ]);
     
     const mobile = false;
     const platformData = "${platformData}";
+    const platformVersion = "${platformVersion}";
+    const architecture = "${architecture}";
+    const bitness = "${bitness}";
+    const wow64 = ${wow64};
     
-    const uaData = {
+    // High entropy values for getHighEntropyValues()
+    const highEntropyValues = {
+        architecture: architecture,
+        bitness: bitness,
         brands: brands,
+        fullVersionList: fullVersionList,
         mobile: mobile,
+        model: "",
         platform: platformData,
+        platformVersion: platformVersion,
+        uaFullVersion: "${fullVersion}",
+        wow64: wow64,
+        formFactor: []
+    };
+    
+    // Create a proper NavigatorUAData-like object
+    const createUAData = () => {
+        const uaData = Object.create(null);
         
-        getHighEntropyValues(hints) {
-            return new Promise((resolve) => {
-                const base = {
-                    architecture: "x86",
-                    bitness: "64",
-                    brands: brands,
-                    mobile: mobile,
-                    model: "",
-                    platform: platformData,
-                    platformVersion: "${platformVersion}",
-                    uaFullVersion: "125.0.6422.4",
-                    fullVersionList: brands.map(b => ({ brand: b.brand, version: "125.0.6422.4" })),
-                    wow64: false
-                };
-                
-                const result = {};
-                hints.forEach(hint => {
-                    if (hint in base) {
-                        result[hint] = base[hint];
-                    }
-                });
-                
-                resolve(result);
-            });
-        },
+        // Define properties to match NavigatorUAData interface
+        Object.defineProperties(uaData, {
+            brands: {
+                get: function() { return brands; },
+                enumerable: true,
+                configurable: false
+            },
+            mobile: {
+                get: function() { return mobile; },
+                enumerable: true,
+                configurable: false
+            },
+            platform: {
+                get: function() { return platformData; },
+                enumerable: true,
+                configurable: false
+            },
+            getHighEntropyValues: {
+                value: function(hints) {
+                    return new Promise((resolve) => {
+                        // Simulate slight async delay like real browser
+                        setTimeout(() => {
+                            const result = {};
+                            
+                            if (!hints || !Array.isArray(hints)) {
+                                resolve(result);
+                                return;
+                            }
+                            
+                            // Return requested hints
+                            for (const hint of hints) {
+                                if (hint in highEntropyValues) {
+                                    result[hint] = highEntropyValues[hint];
+                                }
+                            }
+                            
+                            resolve(result);
+                        }, 1 + Math.random() * 2);
+                    });
+                },
+                writable: false,
+                enumerable: true,
+                configurable: false
+            },
+            toJSON: {
+                value: function() {
+                    return {
+                        brands: brands,
+                        mobile: mobile,
+                        platform: platformData
+                    };
+                },
+                writable: false,
+                enumerable: true,
+                configurable: false
+            }
+        });
         
-        toJSON() {
-            return {
-                brands: brands,
-                mobile: mobile,
-                platform: platformData
-            };
-        }
+        // Make it look like a real NavigatorUAData object
+        Object.defineProperty(uaData, Symbol.toStringTag, {
+            value: 'NavigatorUAData',
+            writable: false,
+            enumerable: false,
+            configurable: true
+        });
+        
+        // Freeze to prevent modification
+        return Object.freeze(uaData);
     };
     
-    // Override navigator.userAgentData
-    Object.defineProperty(navigator, "userAgentData", {
-        get: () => uaData,
-        configurable: false,
-        enumerable: true
-    });
+    const uaData = createUAData();
+    
+    // Register with stealth utils if available
+    if (window.__stealthUtils__) {
+        window.__stealthUtils__.registerNativeFunction(uaData.getHighEntropyValues, 'getHighEntropyValues');
+        window.__stealthUtils__.registerNativeFunction(uaData.toJSON, 'toJSON');
+    }
+    
+    // Override navigator.userAgentData with prototype integrity
+    const overrideUserAgentData = () => {
+        // Use prototype integrity if available
+        if (window.__prototypeIntegrity__) {
+            window.__prototypeIntegrity__.overridePropertyNative(navigator, 'userAgentData', {
+                get: function() { return uaData; },
+                enumerable: true,
+                configurable: false
+            });
+        } else {
+            // Fallback to standard override
+            Object.defineProperty(navigator, 'userAgentData', {
+                get: function() { return uaData; },
+                enumerable: true,
+                configurable: false
+            });
+        }
+    };
     
-    // Also ensure the property exists and is not writable
     try {
-        Object.defineProperty(navigator, "userAgentData", {
-            value: uaData,
-            writable: false,
-            configurable: false,
-            enumerable: true
-        });
+        overrideUserAgentData();
+        console.log(DEBUG_PREFIX, '✓ UA-CH spoofing applied - platform:', platformData);
     } catch (e) {
-        // Property might already be defined
+        console.error('[CDP-FP-ERROR]', 'Failed to apply UA-CH spoofing:', e);
     }
 })();
 `;

package/dist/fingerprinting/fingerprint-overrides/ua-ch.js.map

@@ -1 +1 @@
-{"version":3,"file":"ua-ch.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/ua-ch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,QAAQ,GAAG,OAAO,EAAU,EAAE;IAC5E,IAAI,YAAoB,CAAC;IACzB,IAAI,eAAuB,CAAC;IAE5B,IAAI,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,YAAY,GAAG,SAAS,CAAC;QACzB,eAAe,GAAG,QAAQ,CAAC;IAC/B,CAAC;SAAM,IAAI,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QACpC,YAAY,GAAG,OAAO,CAAC;QACvB,eAAe,GAAG,QAAQ,CAAC;IAC/B,CAAC;SAAM,CAAC;QACJ,YAAY,GAAG,OAAO,CAAC;QACvB,eAAe,GAAG,OAAO,CAAC;IAC9B,CAAC;IAED,OAAO;;;;;;;;;;;;4BAYiB,YAAY;;;;;;;;;;;;;;;;wCAgBA,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CtD,CAAC;AACF,CAAC,CAAC"}
+{"version":3,"file":"ua-ch.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/ua-ch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,QAAQ,GAAG,OAAO,EAAU,EAAE;IAC5E,IAAI,YAAoB,CAAC;IACzB,IAAI,eAAuB,CAAC;IAC5B,IAAI,YAAoB,CAAC;IACzB,IAAI,OAAe,CAAC;IACpB,IAAI,KAAc,CAAC;IAEnB,IAAI,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;QACrD,YAAY,GAAG,SAAS,CAAC;QACzB,eAAe,GAAG,QAAQ,CAAC,CAAC,aAAa;QACzC,YAAY,GAAG,KAAK,CAAC;QACrB,OAAO,GAAG,IAAI,CAAC;QACf,KAAK,GAAG,KAAK,CAAC;IAClB,CAAC;SAAM,IAAI,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QACpC,YAAY,GAAG,OAAO,CAAC;QACvB,eAAe,GAAG,QAAQ,CAAC,CAAC,eAAe;QAC3C,YAAY,GAAG,KAAK,CAAC;QACrB,OAAO,GAAG,IAAI,CAAC;QACf,KAAK,GAAG,KAAK,CAAC;IAClB,CAAC;SAAM,CAAC;QACJ,YAAY,GAAG,OAAO,CAAC;QACvB,eAAe,GAAG,OAAO,CAAC;QAC1B,YAAY,GAAG,KAAK,CAAC;QACrB,OAAO,GAAG,IAAI,CAAC;QACf,KAAK,GAAG,KAAK,CAAC;IAClB,CAAC;IAED,wDAAwD;IACxD,MAAM,aAAa,GAAG,KAAK,CAAC;IAC5B,MAAM,WAAW,GAAG,gBAAgB,CAAC;IAErC,OAAO;;;;;;;;;;;4DAWiD,aAAa;uDAClB,aAAa;;;;;4DAKR,WAAW;uDAChB,WAAW;;;;;4BAKtC,YAAY;+BACT,eAAe;4BAClB,YAAY;uBACjB,OAAO;oBACV,KAAK;;;;;;;;;;;;0BAYC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiHpC,CAAC;AACF,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAAO,MA+S3C,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAAO,MAyf3C,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/utils.js

@@ -24,49 +24,246 @@ export const createStealthUtilsScript = () => {
     // Cache original toString BEFORE any modifications
     const nativeToStringFunctionString = Function.prototype.toString.call(Function.prototype.toString);
     const nativeToStringFunc = Function.prototype.toString;
+    const nativeCall = Function.prototype.call;
+    const nativeApply = Function.prototype.apply;
+    const nativeBind = Function.prototype.bind;
     
     // WeakMap to track which functions should appear native
     const nativeFunctionOverrides = new WeakMap();
     
+    // Track bound functions to their originals
+    const boundFunctionMap = new WeakMap();
+    
+    // Track proxy targets
+    const proxyTargetMap = new WeakMap();
+    
     /**
      * Generate a native-looking function string
+     * Handles various function types for maximum authenticity
      */
-    const makeNativeString = (name = '') => {
-        return \`function \${name}() { [native code] }\`;
+    const makeNativeString = (name = '', type = 'function') => {
+        // Clean the name - remove "bound " prefix if present
+        const cleanName = name.replace(/^bound /, '');
+        
+        // Different native string formats
+        if (type === 'getter') {
+            return \`function get \${cleanName}() { [native code] }\`;
+        }
+        if (type === 'setter') {
+            return \`function set \${cleanName}() { [native code] }\`;
+        }
+        if (type === 'async') {
+            return \`async function \${cleanName}() { [native code] }\`;
+        }
+        if (type === 'generator') {
+            return \`function* \${cleanName}() { [native code] }\`;
+        }
+        
+        return \`function \${cleanName}() { [native code] }\`;
     };
     
     /**
      * Register a function to appear native when toString is called
+     * Enhanced to handle bound functions and proxies
      */
-    const registerNativeFunction = (fn, name = '') => {
-        nativeFunctionOverrides.set(fn, name);
+    const registerNativeFunction = (fn, name = '', type = 'function') => {
+        if (typeof fn !== 'function') return;
+        
+        nativeFunctionOverrides.set(fn, { name, type });
+        
+        // Also register any bound versions
+        try {
+            const boundVersion = fn.bind(null);
+            if (boundVersion !== fn) {
+                boundFunctionMap.set(boundVersion, fn);
+            }
+        } catch (e) {
+            // Some functions can't be bound, ignore
+        }
+    };
+    
+    /**
+     * Check if a function is a Proxy
+     */
+    const isProxy = (fn) => {
+        try {
+            // Proxies throw when you try to get their prototype in certain ways
+            return proxyTargetMap.has(fn);
+        } catch (e) {
+            return false;
+        }
+    };
+    
+    /**
+     * Register a Proxy and its target for toString lookup
+     */
+    const registerProxyTarget = (proxy, target, name = '') => {
+        proxyTargetMap.set(proxy, { target, name });
+        registerNativeFunction(proxy, name);
     };
     
     /**
      * Patch Function.prototype.toString to hide overridden functions
+     * Enhanced with multiple levels of protection
      */
     const patchToString = () => {
         const patchedToString = function() {
-            // Check if this function should appear native
+            // Handle registered native functions
             if (nativeFunctionOverrides.has(this)) {
-                const name = nativeFunctionOverrides.get(this);
-                return makeNativeString(name);
+                const info = nativeFunctionOverrides.get(this);
+                return makeNativeString(info.name, info.type);
+            }
+            
+            // Handle bound functions - look up original
+            if (boundFunctionMap.has(this)) {
+                const original = boundFunctionMap.get(this);
+                if (nativeFunctionOverrides.has(original)) {
+                    const info = nativeFunctionOverrides.get(original);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // Handle proxies
+            if (proxyTargetMap.has(this)) {
+                const { target, name } = proxyTargetMap.get(this);
+                if (name) {
+                    return makeNativeString(name);
+                }
+                if (target && nativeFunctionOverrides.has(target)) {
+                    const info = nativeFunctionOverrides.get(target);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // Check if this is an anonymous arrow function that should look native
+            // Arrow functions have no prototype property
+            const result = nativeCall.call(nativeToStringFunc, this);
+            
+            // Clean result to remove CDP/automation markers
+            if (typeof result === 'string') {
+                // Remove sourceURL comments
+                let cleaned = result
+                    .replace(/\\/\\/# sourceURL=[^\\n]*/g, '')
+                    .replace(/\\/\\/# sourceMappingURL=[^\\n]*/g, '')
+                    .replace(/__puppeteer_evaluation_script__/g, '')
+                    .replace(/__playwright_evaluation_script__/g, '')
+                    .replace(/pptr:[^\\n]*/g, '');
+                
+                return cleaned;
             }
-            // Otherwise return original toString
-            return nativeToStringFunc.call(this);
+            
+            return result;
         };
         
         // Make patchedToString itself appear native
-        nativeFunctionOverrides.set(patchedToString, 'toString');
+        nativeFunctionOverrides.set(patchedToString, { name: 'toString', type: 'function' });
         
         // Replace Function.prototype.toString
         Function.prototype.toString = patchedToString;
         
-        // Also patch Function.prototype.toString.toString to look native
+        // Patch toString.call and toString.apply to use our version
+        // CRITICAL: Bypass patchedToString completely - call nativeToStringFunc directly
+        // to prevent infinite recursion when scripts call toString.call.call() etc.
+        const patchedCall = function(thisArg, ...args) {
+            // Handle our registered overrides first
+            if (thisArg && nativeFunctionOverrides.has(thisArg)) {
+                const info = nativeFunctionOverrides.get(thisArg);
+                return makeNativeString(info.name, info.type);
+            }
+            
+            // Handle bound functions
+            if (thisArg && boundFunctionMap.has(thisArg)) {
+                const original = boundFunctionMap.get(thisArg);
+                if (nativeFunctionOverrides.has(original)) {
+                    const info = nativeFunctionOverrides.get(original);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // Handle proxies
+            if (thisArg && proxyTargetMap.has(thisArg)) {
+                const { target, name } = proxyTargetMap.get(thisArg);
+                if (name) return makeNativeString(name);
+                if (target && nativeFunctionOverrides.has(target)) {
+                    const info = nativeFunctionOverrides.get(target);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // CRITICAL: Call native toString directly to avoid any recursion
+            // Never go through patchedToString from here
+            return nativeCall.call(nativeToStringFunc, thisArg);
+        };
+        
+        const patchedApply = function(thisArg, argsArray) {
+            // Handle our registered overrides first
+            if (thisArg && nativeFunctionOverrides.has(thisArg)) {
+                const info = nativeFunctionOverrides.get(thisArg);
+                return makeNativeString(info.name, info.type);
+            }
+            
+            // Handle bound functions
+            if (thisArg && boundFunctionMap.has(thisArg)) {
+                const original = boundFunctionMap.get(thisArg);
+                if (nativeFunctionOverrides.has(original)) {
+                    const info = nativeFunctionOverrides.get(original);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // Handle proxies
+            if (thisArg && proxyTargetMap.has(thisArg)) {
+                const { target, name } = proxyTargetMap.get(thisArg);
+                if (name) return makeNativeString(name);
+                if (target && nativeFunctionOverrides.has(target)) {
+                    const info = nativeFunctionOverrides.get(target);
+                    return makeNativeString(info.name, info.type);
+                }
+            }
+            
+            // CRITICAL: Call native toString directly to avoid any recursion
+            return nativeCall.call(nativeToStringFunc, thisArg);
+        };
+        
+        // Register call/apply as native
+        nativeFunctionOverrides.set(patchedCall, { name: 'call', type: 'function' });
+        nativeFunctionOverrides.set(patchedApply, { name: 'apply', type: 'function' });
+        
+        // Make toString.toString return the native string
         Object.defineProperty(Function.prototype.toString, 'toString', {
             value: patchedToString,
             writable: false,
-            configurable: false
+            configurable: false,
+            enumerable: false
+        });
+        
+        // Patch call and apply on our toString
+        Object.defineProperty(Function.prototype.toString, 'call', {
+            value: patchedCall,
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+        
+        Object.defineProperty(Function.prototype.toString, 'apply', {
+            value: patchedApply,
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+        
+        // Also protect against Function.prototype.toString.bind()
+        const originalBind = Function.prototype.toString.bind;
+        Object.defineProperty(Function.prototype.toString, 'bind', {
+            value: function(...args) {
+                const bound = nativeBind.apply(patchedToString, args);
+                nativeFunctionOverrides.set(bound, { name: 'toString', type: 'function' });
+                boundFunctionMap.set(bound, patchedToString);
+                return bound;
+            },
+            writable: false,
+            configurable: false,
+            enumerable: false
         });
     };
     
@@ -296,12 +493,15 @@ export const createStealthUtilsScript = () => {
     window.__stealthUtils__ = {
         makeNativeString,
         registerNativeFunction,
+        registerProxyTarget,
         canRedefineProperty,
         overridePropertyWithGuard,
         overrideGetterWithNative,
         createNativeProxyHandler,
         cacheAndOverride,
         nativeFunctionOverrides,
+        boundFunctionMap,
+        proxyTargetMap,
         // New logging and safety utilities
         logPropertyOverride,
         verifyOverride,
@@ -309,6 +509,8 @@ export const createStealthUtilsScript = () => {
         withErrorBoundary,
         overridePropertySafe
     };
+    
+    console.log('[CDP-FP-DEBUG] ✓ Stealth utilities initialized with enhanced toString masking');
 })();
 `;
 };

package/dist/fingerprinting/fingerprint-overrides/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAW,EAAE;IACjD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6SV,CAAC;AACF,CAAC,CAAC"}
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAW,EAAE;IACjD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAufV,CAAC;AACF,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/webgl-spoofing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgl-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,WAAW;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,yBAAyB,sBAAuB,WAAW,KAAG,MA8K1E,CAAC"}
+{"version":3,"file":"webgl-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,WAAW;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,yBAAyB,sBAAuB,WAAW,KAAG,MA2M1E,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/webgl-spoofing.js

@@ -23,43 +23,72 @@ export const createWebGLSpoofingScript = (fingerprintWebGL) => {
         console.log('[CDP-FP-DEBUG] WebGL using fingerprint data - Vendor:', selectedVendor, 'Renderer:', selectedRenderer.substring(0, 50));
         ` : `
         // Detect platform from navigator
-        const platform = navigator.platform || 'Linux x86_64';
+        const platform = navigator.platform || 'Win32';
         
-        // Platform-specific GPU configurations
+        // Platform-specific GPU configurations - 2024-2025 updated
+        // IMPORTANT: Windows GPU strings must follow the exact Chrome ANGLE format
         const gpuConfigs = {
             'Win32': {
-                vendors: ['NVIDIA Corporation', 'AMD', 'Intel Inc.'],
+                // Windows uses "Google Inc. (VENDOR)" format for vendor
+                vendors: [
+                    'Google Inc. (NVIDIA)',
+                    'Google Inc. (AMD)',
+                    'Google Inc. (Intel)'
+                ],
+                // Windows renderers use Direct3D11 format - authentic Chrome strings
                 renderers: [
                     'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti Direct3D11 vs_5_0 ps_5_0, D3D11)',
                     'ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (NVIDIA, NVIDIA GeForce RTX 4070 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (AMD, AMD Radeon RX 6700 XT Direct3D11 vs_5_0 ps_5_0, D3D11)',
                     'ANGLE (AMD, AMD Radeon RX 6600 Direct3D11 vs_5_0 ps_5_0, D3D11)',
                     'ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (Intel, Intel(R) Iris(R) Xe Graphics Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                ],
+                vendorPairs: [
+                    { vendor: 'Google Inc. (NVIDIA)', renderer: 'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                    { vendor: 'Google Inc. (NVIDIA)', renderer: 'ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                    { vendor: 'Google Inc. (AMD)', renderer: 'ANGLE (AMD, AMD Radeon RX 6700 XT Direct3D11 vs_5_0 ps_5_0, D3D11)' },
+                    { vendor: 'Google Inc. (Intel)', renderer: 'ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)' },
                 ],
             },
             'MacIntel': {
-                vendors: ['Apple Inc.', 'Intel Inc.', 'AMD'],
+                vendors: ['Google Inc. (Apple)', 'Google Inc. (Intel)', 'Google Inc. (AMD)'],
                 renderers: [
                     'ANGLE (Apple, Apple M1 Pro, OpenGL 4.1)',
                     'ANGLE (Apple, Apple M2, OpenGL 4.1)',
                     'ANGLE (Intel Inc., Intel(R) Iris(TM) Plus Graphics OpenGL Engine, OpenGL 4.1)',
                     'ANGLE (AMD, AMD Radeon Pro 5500M OpenGL Engine, OpenGL 4.1)',
                 ],
+                vendorPairs: [
+                    { vendor: 'Google Inc. (Apple)', renderer: 'ANGLE (Apple, Apple M1 Pro, OpenGL 4.1)' },
+                    { vendor: 'Google Inc. (Intel)', renderer: 'ANGLE (Intel Inc., Intel(R) Iris(TM) Plus Graphics OpenGL Engine, OpenGL 4.1)' },
+                ],
             },
             'Linux x86_64': {
-                vendors: ['Intel', 'NVIDIA Corporation', 'AMD'],
+                vendors: ['Google Inc. (Intel)', 'Google Inc. (NVIDIA)', 'Google Inc. (AMD)'],
                 renderers: [
                     'ANGLE (Intel, Mesa Intel(R) UHD Graphics 630 (CFL GT2), OpenGL 4.6)',
                     'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti/PCIe/SSE2, OpenGL 4.6)',
                     'ANGLE (AMD, AMD Radeon RX 6600 (NAVY_FLOUNDER, DRM 3.42.0, 5.15.0-56-generic, LLVM 12.0.0), OpenGL 4.6)',
-                    'ANGLE (Intel, Mesa Intel(R) Xe Graphics (TGL GT2), OpenGL 4.6)',
+                ],
+                vendorPairs: [
+                    { vendor: 'Google Inc. (Intel)', renderer: 'ANGLE (Intel, Mesa Intel(R) UHD Graphics 630 (CFL GT2), OpenGL 4.6)' },
+                    { vendor: 'Google Inc. (NVIDIA)', renderer: 'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti/PCIe/SSE2, OpenGL 4.6)' },
                 ],
             },
         };
         
-        const config = gpuConfigs[platform] || gpuConfigs['Linux x86_64'];
-        const selectedVendor = config.vendors[Math.floor(Math.random() * config.vendors.length)];
-        const selectedRenderer = config.renderers.find(r => r.includes(selectedVendor.split(' ')[0])) || config.renderers[0];
-        console.log('[CDP-FP-DEBUG] WebGL using platform:', platform, '- Vendor:', selectedVendor, 'Renderer:', selectedRenderer.substring(0, 50));
+        // Default to Windows for better anti-bot evasion (most common platform)
+        const config = gpuConfigs[platform] || gpuConfigs['Win32'];
+        
+        // Select a consistent vendor/renderer pair
+        const pairIndex = Math.floor(Math.random() * config.vendorPairs.length);
+        const selectedPair = config.vendorPairs[pairIndex];
+        const selectedVendor = selectedPair.vendor;
+        const selectedRenderer = selectedPair.renderer;
+        
+        console.log('[CDP-FP-DEBUG] WebGL using platform:', platform, '- Vendor:', selectedVendor, 'Renderer:', selectedRenderer.substring(0, 60) + '...');
         `}
         
         // Override getParameter

package/dist/fingerprinting/fingerprint-overrides/webgl-spoofing.js.map

@@ -1 +1 @@
-{"version":3,"file":"webgl-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,gBAA8B,EAAU,EAAE;IAChF,iFAAiF;IACjF,MAAM,cAAc,GAAG,gBAAgB,IAAI,CAAC,gBAAgB,CAAC,cAAc,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;IAElH,OAAO;;;;;;;;;;UAUD,cAAc,CAAC,CAAC,CAAC;;oCAES,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC;;;;SAI3D,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAuCH;;;;;;;;;;;;;;yBAcgB,cAAc,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,UAAU;;;yBAGxF,cAAc,IAAI,gBAAgB,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2CjH,CAAC,cAAc,CAAC,CAAC,CAAC;;;;;;;;;SASnB,CAAC,CAAC,CAAC;;SAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2CH,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"webgl-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,gBAA8B,EAAU,EAAE;IAChF,iFAAiF;IACjF,MAAM,cAAc,GAAG,gBAAgB,IAAI,CAAC,gBAAgB,CAAC,cAAc,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;IAElH,OAAO;;;;;;;;;;UAUD,cAAc,CAAC,CAAC,CAAC;;oCAES,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC;;;;SAI3D,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAoEH;;;;;;;;;;;;;;yBAcgB,cAAc,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,UAAU;;;yBAGxF,cAAc,IAAI,gBAAgB,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2CjH,CAAC,cAAc,CAAC,CAAC,CAAC;;;;;;;;;SASnB,CAAC,CAAC,CAAC;;SAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2CH,CAAC;AACP,CAAC,CAAC"}

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import CDPCrawler from "./crawler.js";
 import CdpPage from "./page.js";
 export default CDPCrawler;
 export { createCDPRouter } from "./crawler.js";
-export type { CDPRouter } from "./crawler.js";
+export type { CDPRouter, CDPCrawlingContext, CDPCrawlerOptions, CDPLaunchContext, CDPRequestHandler } from "./crawler.js";
 export type { GotoOptions, SelectOptionOptions } from "./page.js";
 export { CdpPage };
 //# sourceMappingURL=index.d.ts.map