jumpy-lion 0.0.33 → 0.0.34

package/dist/fingerprinting/fingerprint-overrides/mouse-humanization.js

@@ -0,0 +1,103 @@
+/**
+ * Mouse Movement Humanization
+ * Generates bezier curve movements instead of straight lines
+ * Includes automatic human-like interactions after page load
+ */
+export const setupMouseMovementHumanization = async (client) => {
+    // Override CDP Input domain to add human-like variations
+    await client.send('Runtime.evaluate', {
+        expression: `
+(() => {
+    'use strict';
+    
+    // Store original mouse position
+    let lastX = 0;
+    let lastY = 0;
+    
+    // Add bezier curve movement simulation
+    window.__humanizeMouseMovement = (fromX, fromY, toX, toY) => {
+        const steps = 20 + Math.floor(Math.random() * 10);
+        const points = [];
+        
+        // Generate control points for bezier curve
+        const cp1x = fromX + (toX - fromX) * 0.25 + (Math.random() - 0.5) * 50;
+        const cp1y = fromY + (toY - fromY) * 0.25 + (Math.random() - 0.5) * 50;
+        const cp2x = fromX + (toX - fromX) * 0.75 + (Math.random() - 0.5) * 50;
+        const cp2y = fromY + (toY - fromY) * 0.75 + (Math.random() - 0.5) * 50;
+        
+        // Calculate bezier curve points
+        for (let i = 0; i <= steps; i++) {
+            const t = i / steps;
+            const t2 = t * t;
+            const t3 = t2 * t;
+            const mt = 1 - t;
+            const mt2 = mt * mt;
+            const mt3 = mt2 * mt;
+            
+            const x = mt3 * fromX + 3 * mt2 * t * cp1x + 3 * mt * t2 * cp2x + t3 * toX;
+            const y = mt3 * fromY + 3 * mt2 * t * cp1y + 3 * mt * t2 * cp2y + t3 * toY;
+            
+            points.push({ x: Math.round(x), y: Math.round(y) });
+        }
+        
+        return points;
+    };
+    
+    // Add automatic human-like behavior after page load
+    const simulateHumanBehavior = () => {
+        setTimeout(() => {
+            // Random mouse movement
+            const startX = 100 + Math.random() * 200;
+            const startY = 100 + Math.random() * 200;
+            const endX = 300 + Math.random() * 400;
+            const endY = 200 + Math.random() * 300;
+            
+            // Simulate mouse movement event
+            const moveEvent = new MouseEvent('mousemove', {
+                clientX: startX,
+                clientY: startY,
+                bubbles: true,
+                cancelable: true
+            });
+            document.dispatchEvent(moveEvent);
+            
+            // Small scroll to simulate user reading
+            setTimeout(() => {
+                const scrollAmount = 100 + Math.random() * 200;
+                window.scrollBy(0, scrollAmount);
+                
+                // Set storage continuity marker
+                try {
+                    const visitHash = btoa(window.location.hostname + Date.now()).substring(0, 16);
+                    localStorage.setItem('g2_visit', visitHash);
+                    sessionStorage.setItem('cdp_human_interaction', Date.now().toString());
+                } catch (e) {
+                    // Storage might be disabled
+                }
+            }, 500 + Math.random() * 1000);
+            
+        }, 1000 + Math.random() * 2000); // 1-3 seconds after load
+    };
+    
+    // Trigger human behavior on DOMContentLoaded
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', simulateHumanBehavior);
+    } else {
+        simulateHumanBehavior();
+    }
+    
+    // Also add storage continuity for returning visitors
+    window.addEventListener('beforeunload', () => {
+        try {
+            const currentVisit = localStorage.getItem('g2_visit');
+            if (currentVisit) {
+                localStorage.setItem('g2_last_visit', currentVisit);
+            }
+        } catch (e) {
+            // Storage might be disabled
+        }
+    });
+})();`,
+    });
+};
+//# sourceMappingURL=mouse-humanization.js.map

package/dist/fingerprinting/fingerprint-overrides/mouse-humanization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mouse-humanization.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/mouse-humanization.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,KAAK,EAAE,MAAW,EAAiB,EAAE;IAC/E,yDAAyD;IACzD,MAAM,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE;QAClC,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2Fd;KACD,CAAC,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/performance-spoofing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Performance Spoofing
+ * Adjusts timing and memory characteristics to match Windows systems
+ */
+export declare const createPerformanceSpoofingScript: () => string;
+//# sourceMappingURL=performance-spoofing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"performance-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/performance-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,+BAA+B,QAAO,MA8NlD,CAAC"}

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

@@ -0,0 +1,228 @@
+/**
+ * Performance Spoofing
+ * Adjusts timing and memory characteristics to match Windows systems
+ */
+export const createPerformanceSpoofingScript = () => {
+    return `
+(() => {
+    'use strict';
+    
+    // Performance Spoofing for 2025 - Windows-like characteristics
+    const spoofPerformance = () => {
+        // Store original methods
+        const originalNow = performance.now;
+        const originalGetEntries = performance.getEntries;
+        const originalGetEntriesByType = performance.getEntriesByType;
+        const originalGetEntriesByName = performance.getEntriesByName;
+        
+        // Platform-specific timing characteristics
+        const platform = navigator.platform || 'Win32';
+        let timingOffset = 0;
+        let baseTime = originalNow.call(performance);
+        
+        // Windows tends to have slightly different timing precision
+        const timingConfig = {
+            'Win32': {
+                precision: 0.1, // Windows has 0.1ms precision in many cases
+                jitter: 0.05,   // Small random variation
+                baseOffset: 0   // No offset needed
+            },
+            'MacIntel': {
+                precision: 0.1,
+                jitter: 0.03,
+                baseOffset: 1.2
+            },
+            'Linux x86_64': {
+                precision: 0.001,
+                jitter: 0.02,
+                baseOffset: 0.8
+            }
+        };
+        
+        const config = timingConfig[platform] || timingConfig['Win32'];
+        
+        // Spoof performance.now() with Windows-like characteristics
+        performance.now = function() {
+            const realTime = originalNow.call(performance) - baseTime;
+            const adjustedTime = realTime * (1 + config.baseOffset / 100);
+            
+            // Add Windows-like timing jitter and precision
+            const jitter = (Math.random() - 0.5) * config.jitter;
+            const timeWithJitter = adjustedTime + jitter;
+            
+            // Round to Windows-like precision
+            const rounded = Math.round(timeWithJitter / config.precision) * config.precision;
+            
+            return baseTime + rounded;
+        };
+        
+        // Spoof memory information to look like Windows
+        if (performance.memory) {
+            // Windows Chrome typically reports different memory values
+            const memoryConfig = {
+                'Win32': {
+                    usedJSHeapSize: { min: 25000000, variance: 15000000 },
+                    totalJSHeapSize: { min: 45000000, variance: 25000000 },
+                    jsHeapSizeLimit: 2172649472 // Typical Windows limit
+                },
+                'MacIntel': {
+                    usedJSHeapSize: { min: 20000000, variance: 12000000 },
+                    totalJSHeapSize: { min: 40000000, variance: 20000000 },
+                    jsHeapSizeLimit: 4294705152 // Mac typically has higher limits
+                },
+                'Linux x86_64': {
+                    usedJSHeapSize: { min: 18000000, variance: 10000000 },
+                    totalJSHeapSize: { min: 35000000, variance: 18000000 },
+                    jsHeapSizeLimit: 2147483648 // Linux varies more
+                }
+            };
+            
+            const memConfig = memoryConfig[platform] || memoryConfig['Win32'];
+            
+            // Generate consistent but realistic memory values
+            const seed = navigator.userAgent.length + (navigator.platform || '').length;
+            const pseudoRandom = (seed * 9301 + 49297) % 233280 / 233280;
+            
+            const fakeMemory = {
+                usedJSHeapSize: Math.floor(memConfig.usedJSHeapSize.min + 
+                    pseudoRandom * memConfig.usedJSHeapSize.variance),
+                totalJSHeapSize: Math.floor(memConfig.totalJSHeapSize.min + 
+                    pseudoRandom * memConfig.totalJSHeapSize.variance),
+                jsHeapSizeLimit: memConfig.jsHeapSizeLimit
+            };
+            
+            // Ensure logical consistency
+            if (fakeMemory.usedJSHeapSize > fakeMemory.totalJSHeapSize) {
+                fakeMemory.totalJSHeapSize = fakeMemory.usedJSHeapSize + 5000000;
+            }
+            
+            Object.defineProperty(performance, 'memory', {
+                value: fakeMemory,
+                writable: false,
+                configurable: true
+            });
+        }
+        
+        // Spoof navigation timing to appear more like Windows
+        if (performance.navigation) {
+            Object.defineProperty(performance.navigation, 'type', {
+                value: 0, // TYPE_NAVIGATE - most common on Windows
+                writable: false
+            });
+            
+            Object.defineProperty(performance.navigation, 'redirectCount', {
+                value: 0,
+                writable: false
+            });
+        }
+        
+        // Spoof timing entries to have Windows-like characteristics
+        performance.getEntries = function() {
+            const entries = originalGetEntries.call(this);
+            return entries.map(entry => spoofTimingEntry(entry));
+        };
+        
+        performance.getEntriesByType = function(type) {
+            const entries = originalGetEntriesByType.call(this, type);
+            return entries.map(entry => spoofTimingEntry(entry));
+        };
+        
+        performance.getEntriesByName = function(name, type) {
+            const entries = originalGetEntriesByName.call(this, name, type);
+            return entries.map(entry => spoofTimingEntry(entry));
+        };
+        
+        function spoofTimingEntry(entry) {
+            if (!entry) return entry;
+            
+            // Create a copy of the entry with adjusted timings
+            const spoofedEntry = Object.assign({}, entry);
+            
+            // Adjust timing values to be more Windows-like
+            const timingProps = [
+                'startTime', 'duration', 'fetchStart', 'domainLookupStart',
+                'domainLookupEnd', 'connectStart', 'connectEnd', 'requestStart',
+                'responseStart', 'responseEnd', 'domLoading', 'domInteractive',
+                'domContentLoadedEventStart', 'domContentLoadedEventEnd',
+                'domComplete', 'loadEventStart', 'loadEventEnd'
+            ];
+            
+            timingProps.forEach(prop => {
+                if (typeof spoofedEntry[prop] === 'number' && spoofedEntry[prop] > 0) {
+                    // Apply Windows-like timing adjustments
+                    const adjustment = 1 + (config.baseOffset / 100) + 
+                        (Math.random() - 0.5) * config.jitter / 10;
+                    spoofedEntry[prop] = Math.round(spoofedEntry[prop] * adjustment / config.precision) * config.precision;
+                }
+            });
+            
+            return spoofedEntry;
+        }
+        
+        // Spoof requestIdleCallback timing (if available)
+        if ('requestIdleCallback' in window) {
+            const originalRequestIdleCallback = window.requestIdleCallback;
+            window.requestIdleCallback = function(callback, options) {
+                // Windows systems typically have different idle characteristics
+                const windowsOptions = Object.assign({}, options, {
+                    timeout: options?.timeout ? Math.min(options.timeout, 5000) : 5000
+                });
+                
+                return originalRequestIdleCallback.call(this, function(deadline) {
+                    // Modify deadline to appear more Windows-like
+                    const modifiedDeadline = {
+                        didTimeout: deadline.didTimeout,
+                        timeRemaining: function() {
+                            const remaining = deadline.timeRemaining();
+                            // Windows tends to report slightly less remaining time
+                            return Math.max(0, remaining * 0.95 - Math.random() * 2);
+                        }
+                    };
+                    
+                    return callback.call(this, modifiedDeadline);
+                }, windowsOptions);
+            };
+        }
+        
+        // Spoof scheduler API (if available)
+        if ('scheduler' in window && window.scheduler) {
+            const originalPostTask = window.scheduler.postTask;
+            if (originalPostTask) {
+                window.scheduler.postTask = function(callback, options) {
+                    // Windows scheduling tends to be slightly different
+                    const windowsOptions = Object.assign({}, options);
+                    if (windowsOptions.delay) {
+                        windowsOptions.delay = Math.max(0, windowsOptions.delay - Math.random() * 2);
+                    }
+                    
+                    return originalPostTask.call(this, callback, windowsOptions);
+                };
+            }
+        }
+        
+        // Spoof performance observer timing
+        if ('PerformanceObserver' in window) {
+            const OriginalPerformanceObserver = PerformanceObserver;
+            window.PerformanceObserver = class extends OriginalPerformanceObserver {
+                constructor(callback) {
+                    super(function(list, observer) {
+                        const entries = list.getEntries().map(entry => spoofTimingEntry(entry));
+                        const modifiedList = {
+                            getEntries: () => entries,
+                            getEntriesByType: (type) => entries.filter(e => e.entryType === type),
+                            getEntriesByName: (name, type) => entries.filter(e => 
+                                e.name === name && (!type || e.entryType === type)
+                            )
+                        };
+                        return callback.call(this, modifiedList, observer);
+                    });
+                }
+            };
+        }
+    };
+    
+    spoofPerformance();
+})();
+`;
+};
+//# sourceMappingURL=performance-spoofing.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"performance-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/performance-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAAW,EAAE;IACxD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4NV,CAAC;AACF,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/platform-consistency.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Platform Consistency Script
+ * Ensures all browser properties match the specified platform (1:1 fingerprinting)
+ */
+export interface PlatformConfig {
+    platform?: string;
+    devicePixelRatio?: number;
+    screenDepth?: number;
+    colorDepth?: number;
+    hardwareConcurrency?: number;
+    maxTouchPoints?: number;
+    vendor?: string;
+    vendorSub?: string;
+    productSub?: string;
+    language?: string;
+    languages?: string[];
+    oscpu?: string;
+}
+export declare const createPlatformConsistencyScript: (platform: string, fingerprintData?: PlatformConfig) => string;
+//# sourceMappingURL=platform-consistency.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/platform-consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-consistency.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/platform-consistency.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,+BAA+B,aAAc,MAAM,oBAAoB,cAAc,KAAG,MAgOpG,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/platform-consistency.js

@@ -0,0 +1,227 @@
+/**
+ * Platform Consistency Script
+ * Ensures all browser properties match the specified platform (1:1 fingerprinting)
+ */
+export const createPlatformConsistencyScript = (platform, fingerprintData) => {
+    // Platform-specific configurations for 1:1 consistency
+    const platformConfigs = {
+        'Win32': {
+            devicePixelRatio: 1.0,
+            screenDepth: 24,
+            colorDepth: 24,
+            hardwareConcurrency: 8,
+            maxTouchPoints: 0,
+            platform: 'Win32',
+            oscpu: 'Windows NT 10.0; Win64; x64',
+            vendor: '',
+            vendorSub: '',
+            productSub: '20030107',
+            cookieEnabled: true,
+            onLine: true,
+            language: 'en-US',
+            languages: ['en-US', 'en'],
+            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            appVersion: '5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            appName: 'Netscape',
+            appCodeName: 'Mozilla',
+            product: 'Gecko',
+            plugins: [
+                { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
+                { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: 'Portable Document Format' },
+                { name: 'Native Client', filename: 'internal-nacl-plugin', description: 'Native Client Executable' },
+                { name: 'Microsoft Edge PDF Plugin', filename: 'edge-pdf-viewer', description: 'Microsoft Edge PDF Viewer' },
+                { name: 'Widevine Content Decryption Module', filename: 'widevinecdmadapter', description: 'Enables Widevine licenses for playback of HTML audio/video content' },
+            ],
+            mimeTypes: [
+                { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format' },
+                { type: 'application/x-nacl', suffixes: '', description: 'Native Client Executable' },
+                { type: 'application/x-pnacl', suffixes: '', description: 'Portable Native Client Executable' },
+                { type: 'application/x-ppapi-widevine-cdm', suffixes: '', description: 'Widevine Content Decryption Module' },
+            ],
+            // Windows-specific connection properties
+            connection: {
+                downlink: 10,
+                effectiveType: '4g',
+                onchange: null,
+                rtt: 50,
+                saveData: false,
+                type: 'ethernet',
+            },
+        },
+        'MacIntel': {
+            devicePixelRatio: 2.0,
+            screenDepth: 30,
+            colorDepth: 30,
+            hardwareConcurrency: 8,
+            maxTouchPoints: 0,
+            platform: 'MacIntel',
+            oscpu: undefined,
+            vendor: 'Google Inc.',
+            vendorSub: '',
+            productSub: '20030107',
+            cookieEnabled: true,
+            onLine: true,
+            language: 'en-US',
+            languages: ['en-US', 'en'],
+            plugins: [
+                { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer' },
+                { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai' },
+            ],
+        },
+        'Linux x86_64': {
+            devicePixelRatio: 1.0,
+            screenDepth: 24,
+            colorDepth: 24,
+            hardwareConcurrency: 8,
+            maxTouchPoints: 0,
+            platform: 'Linux x86_64',
+            oscpu: 'Linux x86_64',
+            vendor: 'Google Inc.',
+            vendorSub: '',
+            productSub: '20030107',
+            cookieEnabled: true,
+            onLine: true,
+            language: 'en-US',
+            languages: ['en-US', 'en'],
+            plugins: [
+                { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer' },
+            ],
+        },
+    };
+    const defaultConfig = platformConfigs[platform] || platformConfigs['Linux x86_64'];
+    // Merge fingerprint data with defaults if provided
+    const config = fingerprintData ? {
+        ...defaultConfig,
+        ...fingerprintData,
+        // Ensure platform consistency
+        platform: fingerprintData.platform || platform,
+    } : defaultConfig;
+    return `
+(() => {
+    'use strict';
+    
+    // Platform Consistency for ${platform}
+    const config = ${JSON.stringify(config)};
+    
+    // Override navigator properties for platform consistency
+    Object.defineProperty(navigator, 'platform', { get: () => config.platform, configurable: false });
+    Object.defineProperty(navigator, 'vendor', { get: () => config.vendor, configurable: false });
+    Object.defineProperty(navigator, 'vendorSub', { get: () => config.vendorSub, configurable: false });
+    Object.defineProperty(navigator, 'productSub', { get: () => config.productSub, configurable: false });
+    Object.defineProperty(navigator, 'hardwareConcurrency', { get: () => config.hardwareConcurrency, configurable: false });
+    Object.defineProperty(navigator, 'maxTouchPoints', { get: () => config.maxTouchPoints, configurable: false });
+    Object.defineProperty(navigator, 'cookieEnabled', { get: () => config.cookieEnabled, configurable: false });
+    Object.defineProperty(navigator, 'onLine', { get: () => config.onLine, configurable: false });
+    Object.defineProperty(navigator, 'language', { get: () => config.language, configurable: false });
+    Object.defineProperty(navigator, 'languages', { get: () => config.languages, configurable: false });
+    
+    // Additional navigator properties for Windows consistency
+    if (config.userAgent) {
+        Object.defineProperty(navigator, 'userAgent', { get: () => config.userAgent, configurable: false });
+    }
+    if (config.appVersion) {
+        Object.defineProperty(navigator, 'appVersion', { get: () => config.appVersion, configurable: false });
+    }
+    if (config.appName) {
+        Object.defineProperty(navigator, 'appName', { get: () => config.appName, configurable: false });
+    }
+    if (config.appCodeName) {
+        Object.defineProperty(navigator, 'appCodeName', { get: () => config.appCodeName, configurable: false });
+    }
+    if (config.product) {
+        Object.defineProperty(navigator, 'product', { get: () => config.product, configurable: false });
+    }
+    if (config.oscpu !== undefined) {
+        Object.defineProperty(navigator, 'oscpu', { get: () => config.oscpu, configurable: false });
+    }
+    
+    // Override navigator.plugins for Windows consistency
+    if (config.plugins) {
+        Object.defineProperty(navigator, 'plugins', {
+            get: () => {
+                const arr = Object.create(PluginArray.prototype);
+                config.plugins.forEach((p, i) => {
+                    const plugin = Object.create(Plugin.prototype);
+                    plugin.name = p.name;
+                    plugin.filename = p.filename;
+                    plugin.description = p.description;
+                    plugin.length = 1;
+                    plugin[0] = config.mimeTypes?.[i] || { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format' };
+                    arr[i] = plugin;
+                    arr[p.name] = plugin;
+                });
+                arr.length = config.plugins.length;
+                arr.item = (index) => arr[index] || null;
+                arr.namedItem = (name) => arr[name] || null;
+                arr.refresh = () => {};
+                return arr;
+            },
+            configurable: false,
+            enumerable: true
+        });
+    }
+    
+    // Override navigator.mimeTypes for Windows consistency
+    if (config.mimeTypes) {
+        Object.defineProperty(navigator, 'mimeTypes', {
+            get: () => {
+                const arr = Object.create(MimeTypeArray.prototype);
+                config.mimeTypes.forEach((m, i) => {
+                    const mimeType = Object.create(MimeType.prototype);
+                    mimeType.type = m.type;
+                    mimeType.suffixes = m.suffixes;
+                    mimeType.description = m.description;
+                    mimeType.enabledPlugin = config.plugins?.[0] || null;
+                    arr[i] = mimeType;
+                    arr[m.type] = mimeType;
+                });
+                arr.length = config.mimeTypes.length;
+                arr.item = (index) => arr[index] || null;
+                arr.namedItem = (name) => arr[name] || null;
+                return arr;
+            },
+            configurable: false,
+            enumerable: true
+        });
+    }
+    
+    // Override navigator.connection for Windows consistency
+    if (config.connection && navigator.connection) {
+        Object.keys(config.connection).forEach(key => {
+            Object.defineProperty(navigator.connection, key, {
+                value: config.connection[key],
+                writable: false,
+                configurable: true
+            });
+        });
+    }
+    
+    // Override screen properties
+    Object.defineProperty(window, 'devicePixelRatio', { get: () => config.devicePixelRatio, configurable: false });
+    Object.defineProperty(screen, 'colorDepth', { get: () => config.colorDepth, configurable: false });
+    Object.defineProperty(screen, 'pixelDepth', { get: () => config.screenDepth || config.colorDepth, configurable: false });
+    
+    // Ensure WebGL returns platform-appropriate values
+    const getParameterProto = WebGLRenderingContext.prototype.getParameter;
+    WebGLRenderingContext.prototype.getParameter = function(param) {
+        if (param === 0x9245 || param === 0x9246) { // UNMASKED_VENDOR_WEBGL / UNMASKED_RENDERER_WEBGL
+            // Return platform-appropriate GPU with corrected ANGLE token count
+            if (config.platform === 'Win32') {
+                return param === 0x9245 
+                    ? 'NVIDIA Corporation' 
+                    : 'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti Direct3D 11.0)'; // Fixed: fewer tokens
+            } else if (config.platform === 'MacIntel') {
+                return param === 0x9245 ? 'Apple Inc.' : 'ANGLE (Apple, Apple M1 Pro, OpenGL 4.1)';
+            } else {
+                return param === 0x9245 ? 'Intel' : 'ANGLE (Intel, Mesa Intel(R) UHD Graphics 630, OpenGL 4.6)';
+            }
+        }
+        return getParameterProto.apply(this, arguments);
+    };
+    
+    if (typeof WebGL2RenderingContext !== 'undefined') {
+        WebGL2RenderingContext.prototype.getParameter = WebGLRenderingContext.prototype.getParameter;
+    }
+})();`;
+};
+//# sourceMappingURL=platform-consistency.js.map

package/dist/fingerprinting/fingerprint-overrides/platform-consistency.js.map

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

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runtime.enable Bypass
+ * Prevents CDP detection through console.log(Error) technique
+ */
+export declare const setupRuntimeEnableBypass: (client: any) => Promise<void>;
+//# sourceMappingURL=runtime-enable-bypass.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-enable-bypass.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/runtime-enable-bypass.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,wBAAwB,WAAkB,GAAG,KAAG,OAAO,CAAC,IAAI,CA8ExE,CAAC"}