jumpy-lion 0.0.32 → 0.0.34

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

@@ -0,0 +1,262 @@
+/**
+ * Locale Spoofing
+ * Ensures consistent Windows-style locale formatting for dates, numbers, and currencies
+ */
+export const createLocaleSpoofingScript = () => {
+    return `
+(() => {
+    'use strict';
+    
+    // Locale Spoofing for 2025 - Windows-consistent formatting
+    const spoofLocale = () => {
+        // Platform-specific locale configurations
+        const platform = navigator.platform || 'Win32';
+        
+        // Windows-specific locale settings
+        const windowsLocaleConfig = {
+            dateFormat: {
+                weekday: 'long',
+                year: 'numeric',
+                month: 'long',
+                day: 'numeric'
+            },
+            timeFormat: {
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit',
+                hour12: true
+            },
+            numberFormat: {
+                minimumFractionDigits: 0,
+                maximumFractionDigits: 3,
+                useGrouping: true
+            },
+            currencyFormat: {
+                style: 'currency',
+                currency: 'USD',
+                currencyDisplay: 'symbol'
+            }
+        };
+        
+        // Override Intl.DateTimeFormat to use Windows-consistent formatting
+        const OriginalDateTimeFormat = Intl.DateTimeFormat;
+        Intl.DateTimeFormat = function(locales, options) {
+            // Ensure Windows-like date formatting regardless of actual locale
+            const windowsOptions = Object.assign({}, windowsLocaleConfig.dateFormat, options);
+            
+            // Force specific Windows locale patterns
+            if (platform === 'Win32' || !platform.includes('Linux')) {
+                if (!options || !options.timeZone) {
+                    // Use common Windows timezone handling
+                    windowsOptions.timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+                }
+            }
+            
+            const formatter = new OriginalDateTimeFormat(locales, windowsOptions);
+            
+            // Override format method to ensure Windows-style output
+            const originalFormat = formatter.format;
+            formatter.format = function(date) {
+                let result = originalFormat.call(this, date);
+                
+                // Apply Windows-specific formatting adjustments
+                if (platform === 'Win32') {
+                    // Windows often uses specific date separators and formats
+                    result = result.replace(/\\b(\\d{1,2})\\/(\\d{1,2})\\/(\\d{4})\\b/, '$1/$2/$3');
+                    result = result.replace(/\\b(\\d{4})-(\\d{2})-(\\d{2})\\b/, '$2/$3/$1');
+                }
+                
+                return result;
+            };
+            
+            return formatter;
+        };
+        
+        // Override Intl.NumberFormat for Windows-consistent number formatting
+        const OriginalNumberFormat = Intl.NumberFormat;
+        Intl.NumberFormat = function(locales, options) {
+            const windowsOptions = Object.assign({}, windowsLocaleConfig.numberFormat, options);
+            
+            // Windows-specific number formatting
+            if (platform === 'Win32') {
+                windowsOptions.useGrouping = true;
+                if (options && options.style === 'currency') {
+                    Object.assign(windowsOptions, windowsLocaleConfig.currencyFormat, options);
+                }
+            }
+            
+            const formatter = new OriginalNumberFormat(locales, windowsOptions);
+            
+            // Override format method for Windows-style numbers
+            const originalFormat = formatter.format;
+            formatter.format = function(number) {
+                let result = originalFormat.call(this, number);
+                
+                // Windows-specific formatting adjustments
+                if (platform === 'Win32') {
+                    // Ensure Windows-style thousand separators and decimal points
+                    if (typeof number === 'number' && Math.abs(number) >= 1000) {
+                        result = result.replace(/\\s/g, ','); // Replace spaces with commas for thousands
+                    }
+                }
+                
+                return result;
+            };
+            
+            return formatter;
+        };
+        
+        // Override Date.prototype methods for consistent formatting
+        const originalToLocaleString = Date.prototype.toLocaleString;
+        const originalToLocaleDateString = Date.prototype.toLocaleDateString;
+        const originalToLocaleTimeString = Date.prototype.toLocaleTimeString;
+        
+        Date.prototype.toLocaleString = function(locales, options) {
+            const windowsOptions = Object.assign({}, windowsLocaleConfig.dateFormat, windowsLocaleConfig.timeFormat, options);
+            return originalToLocaleString.call(this, locales || 'en-US', windowsOptions);
+        };
+        
+        Date.prototype.toLocaleDateString = function(locales, options) {
+            const windowsOptions = Object.assign({}, windowsLocaleConfig.dateFormat, options);
+            return originalToLocaleDateString.call(this, locales || 'en-US', windowsOptions);
+        };
+        
+        Date.prototype.toLocaleTimeString = function(locales, options) {
+            const windowsOptions = Object.assign({}, windowsLocaleConfig.timeFormat, options);
+            return originalToLocaleTimeString.call(this, locales || 'en-US', windowsOptions);
+        };
+        
+        // Override Number.prototype methods for consistent formatting
+        const originalToLocaleString = Number.prototype.toLocaleString;
+        Number.prototype.toLocaleString = function(locales, options) {
+            let windowsOptions = Object.assign({}, windowsLocaleConfig.numberFormat, options);
+            
+            if (options && options.style === 'currency') {
+                windowsOptions = Object.assign({}, windowsLocaleConfig.currencyFormat, options);
+            }
+            
+            return originalToLocaleString.call(this, locales || 'en-US', windowsOptions);
+        };
+        
+        // Spoof timezone-related methods for consistency
+        const originalGetTimezoneOffset = Date.prototype.getTimezoneOffset;
+        Date.prototype.getTimezoneOffset = function() {
+            const offset = originalGetTimezoneOffset.call(this);
+            
+            // Ensure timezone offset is reported consistently
+            // Windows tends to handle DST slightly differently
+            if (platform === 'Win32') {
+                const now = new Date();
+                const winterOffset = new Date(now.getFullYear(), 0, 1).getTimezoneOffset();
+                const summerOffset = new Date(now.getFullYear(), 6, 1).getTimezoneOffset();
+                
+                // Apply Windows-style DST calculation if needed
+                if (winterOffset !== summerOffset) {
+                    const isDST = offset === Math.min(winterOffset, summerOffset);
+                    return isDST ? summerOffset : winterOffset;
+                }
+            }
+            
+            return offset;
+        };
+        
+        // Override Intl.Collator for Windows-consistent string comparison
+        if (typeof Intl.Collator !== 'undefined') {
+            const OriginalCollator = Intl.Collator;
+            Intl.Collator = function(locales, options) {
+                const windowsOptions = Object.assign({
+                    sensitivity: 'base',
+                    usage: 'sort',
+                    caseFirst: 'upper' // Windows typically sorts uppercase first
+                }, options);
+                
+                return new OriginalCollator(locales, windowsOptions);
+            };
+        }
+        
+        // Override Intl.PluralRules for consistency
+        if (typeof Intl.PluralRules !== 'undefined') {
+            const OriginalPluralRules = Intl.PluralRules;
+            Intl.PluralRules = function(locales, options) {
+                return new OriginalPluralRules(locales || 'en-US', options);
+            };
+        }
+        
+        // Override Intl.RelativeTimeFormat if available
+        if (typeof Intl.RelativeTimeFormat !== 'undefined') {
+            const OriginalRelativeTimeFormat = Intl.RelativeTimeFormat;
+            Intl.RelativeTimeFormat = function(locales, options) {
+                const windowsOptions = Object.assign({
+                    style: 'long',
+                    numeric: 'auto'
+                }, options);
+                
+                return new OriginalRelativeTimeFormat(locales || 'en-US', windowsOptions);
+            };
+        }
+        
+        // Spoof locale-specific string methods
+        const originalLocaleCompare = String.prototype.localeCompare;
+        String.prototype.localeCompare = function(compareString, locales, options) {
+            const windowsOptions = Object.assign({
+                sensitivity: 'base',
+                caseFirst: 'upper'
+            }, options);
+            
+            return originalLocaleCompare.call(this, compareString, locales || 'en-US', windowsOptions);
+        };
+        
+        // Override console time formatting to be Windows-consistent
+        const originalConsoleTime = console.time;
+        const originalConsoleTimeEnd = console.timeEnd;
+        const originalConsoleTimeLog = console.timeLog;
+        
+        if (originalConsoleTime) {
+            console.time = function(label) {
+                // Windows console tends to use specific time formatting
+                return originalConsoleTime.call(this, label);
+            };
+        }
+        
+        if (originalConsoleTimeEnd) {
+            console.timeEnd = function(label) {
+                return originalConsoleTimeEnd.call(this, label);
+            };
+        }
+        
+        if (originalConsoleTimeLog) {
+            console.timeLog = function(label, ...data) {
+                return originalConsoleTimeLog.call(this, label, ...data);
+            };
+        }
+        
+        // Ensure consistent navigator.language reporting
+        if (navigator.language) {
+            Object.defineProperty(navigator, 'language', {
+                get: function() {
+                    // Return Windows-common locale
+                    return platform === 'Win32' ? 'en-US' : navigator.language;
+                },
+                configurable: false
+            });
+        }
+        
+        if (navigator.languages) {
+            Object.defineProperty(navigator, 'languages', {
+                get: function() {
+                    // Return Windows-typical language array
+                    if (platform === 'Win32') {
+                        return ['en-US', 'en'];
+                    }
+                    return navigator.languages;
+                },
+                configurable: false
+            });
+        }
+    };
+    
+    spoofLocale();
+})();
+`;
+};
+//# sourceMappingURL=locale-spoofing.js.map

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

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

package/dist/fingerprinting/fingerprint-overrides/mouse-humanization.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mouse Movement Humanization
+ * Generates bezier curve movements instead of straight lines
+ * Includes automatic human-like interactions after page load
+ */
+export declare const setupMouseMovementHumanization: (client: any) => Promise<void>;
+//# sourceMappingURL=mouse-humanization.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/mouse-humanization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mouse-humanization.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/mouse-humanization.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,8BAA8B,WAAkB,GAAG,KAAG,OAAO,CAAC,IAAI,CAgG9E,CAAC"}

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"}