jumpy-lion 0.1.0 → 0.1.2

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

@@ -0,0 +1,301 @@
+/**
+ * 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
+        // CRITICAL: Store reference BEFORE override and use recursion guard
+        const OriginalDateTimeFormat = Intl.DateTimeFormat;
+        let isCreatingDateTimeFormat = false; // Recursion guard
+        let cachedTimeZone = 'UTC';
+        try {
+            cachedTimeZone = new OriginalDateTimeFormat().resolvedOptions().timeZone;
+        } catch (e) {
+            // Fallback to UTC if timezone detection fails
+        }
+        
+        Intl.DateTimeFormat = function(locales, options) {
+            // CRITICAL: Recursion guard - if we're already inside this function, use original directly
+            if (isCreatingDateTimeFormat) {
+                return Reflect.construct(OriginalDateTimeFormat, [locales, options], OriginalDateTimeFormat);
+            }
+            
+            isCreatingDateTimeFormat = true;
+            try {
+                // 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) {
+                        windowsOptions.timeZone = cachedTimeZone;
+                    }
+                }
+                
+                // Use Reflect.construct to properly create instance with original constructor
+                const formatter = Reflect.construct(OriginalDateTimeFormat, [locales, windowsOptions], OriginalDateTimeFormat);
+                
+                return formatter;
+            } finally {
+                isCreatingDateTimeFormat = false;
+            }
+        };
+        
+        // Override Intl.NumberFormat for Windows-consistent number formatting
+        const OriginalNumberFormat = Intl.NumberFormat;
+        let isCreatingNumberFormat = false; // Recursion guard
+        
+        Intl.NumberFormat = function(locales, options) {
+            // CRITICAL: Recursion guard
+            if (isCreatingNumberFormat) {
+                return Reflect.construct(OriginalNumberFormat, [locales, options], OriginalNumberFormat);
+            }
+            
+            isCreatingNumberFormat = true;
+            try {
+                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);
+                    }
+                }
+                
+                // Use Reflect.construct to properly create instance with original constructor
+                return Reflect.construct(OriginalNumberFormat, [locales, windowsOptions], OriginalNumberFormat);
+            } finally {
+                isCreatingNumberFormat = false;
+            }
+        };
+        
+        // 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 originalNumberToLocaleString = 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 originalNumberToLocaleString.call(this, locales || 'en-US', windowsOptions);
+        };
+        
+        // Spoof timezone-related methods for consistency
+        const originalGetTimezoneOffset = Date.prototype.getTimezoneOffset;
+        // Cache winter/summer offsets at init time to prevent recursion
+        let cachedWinterOffset = null;
+        let cachedSummerOffset = null;
+        try {
+            const now = new Date();
+            cachedWinterOffset = originalGetTimezoneOffset.call(new Date(now.getFullYear(), 0, 1));
+            cachedSummerOffset = originalGetTimezoneOffset.call(new Date(now.getFullYear(), 6, 1));
+        } catch (e) {
+            // Fallback - no DST adjustment
+        }
+        
+        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' && cachedWinterOffset !== null && cachedSummerOffset !== null) {
+                // Apply Windows-style DST calculation if needed
+                if (cachedWinterOffset !== cachedSummerOffset) {
+                    const isDST = offset === Math.min(cachedWinterOffset, cachedSummerOffset);
+                    return isDST ? cachedSummerOffset : cachedWinterOffset;
+                }
+            }
+            
+            return offset;
+        };
+        
+        // Override Intl.Collator for Windows-consistent string comparison
+        if (typeof Intl.Collator !== 'undefined') {
+            const OriginalCollator = Intl.Collator;
+            let isCreatingCollator = false;
+            Intl.Collator = function(locales, options) {
+                if (isCreatingCollator) {
+                    return Reflect.construct(OriginalCollator, [locales, options], OriginalCollator);
+                }
+                isCreatingCollator = true;
+                try {
+                    const windowsOptions = Object.assign({
+                        sensitivity: 'base',
+                        usage: 'sort',
+                        caseFirst: 'upper'
+                    }, options);
+                    return Reflect.construct(OriginalCollator, [locales, windowsOptions], OriginalCollator);
+                } finally {
+                    isCreatingCollator = false;
+                }
+            };
+        }
+        
+        // Override Intl.PluralRules for consistency
+        if (typeof Intl.PluralRules !== 'undefined') {
+            const OriginalPluralRules = Intl.PluralRules;
+            let isCreatingPluralRules = false;
+            Intl.PluralRules = function(locales, options) {
+                if (isCreatingPluralRules) {
+                    return Reflect.construct(OriginalPluralRules, [locales, options], OriginalPluralRules);
+                }
+                isCreatingPluralRules = true;
+                try {
+                    return Reflect.construct(OriginalPluralRules, [locales || 'en-US', options], OriginalPluralRules);
+                } finally {
+                    isCreatingPluralRules = false;
+                }
+            };
+        }
+        
+        // Override Intl.RelativeTimeFormat if available
+        if (typeof Intl.RelativeTimeFormat !== 'undefined') {
+            const OriginalRelativeTimeFormat = Intl.RelativeTimeFormat;
+            let isCreatingRelativeTimeFormat = false;
+            Intl.RelativeTimeFormat = function(locales, options) {
+                if (isCreatingRelativeTimeFormat) {
+                    return Reflect.construct(OriginalRelativeTimeFormat, [locales, options], OriginalRelativeTimeFormat);
+                }
+                isCreatingRelativeTimeFormat = true;
+                try {
+                    const windowsOptions = Object.assign({
+                        style: 'long',
+                        numeric: 'auto'
+                    }, options);
+                    return Reflect.construct(OriginalRelativeTimeFormat, [locales || 'en-US', windowsOptions], OriginalRelativeTimeFormat);
+                } finally {
+                    isCreatingRelativeTimeFormat = false;
+                }
+            };
+        }
+        
+        // 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);
+        };
+        
+        // Helper to check if property can be redefined
+        const canRedefineProperty = (obj, prop) => {
+            try {
+                const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+                return !descriptor || descriptor.configurable !== false;
+            } catch (e) {
+                return false;
+            }
+        };
+        
+        // IMPORTANT: Cache original values BEFORE any override to prevent infinite recursion
+        const originalLanguage = navigator.language;
+        const originalLanguages = navigator.languages ? [...navigator.languages] : ['en-US'];
+        
+        // Ensure consistent navigator.language reporting
+        if (canRedefineProperty(navigator, 'language')) {
+            try {
+                Object.defineProperty(navigator, 'language', {
+                    get: function() {
+                        // Use cached value to prevent infinite recursion
+                        return platform === 'Win32' ? 'en-US' : originalLanguage;
+                    },
+                    configurable: true // Allow other scripts to modify if needed
+                });
+            } catch (e) {
+                // Property already defined, skip
+            }
+        }
+        
+        if (canRedefineProperty(navigator, 'languages')) {
+            try {
+                Object.defineProperty(navigator, 'languages', {
+                    get: function() {
+                        // Use cached value to prevent infinite recursion
+                        if (platform === 'Win32') {
+                            return ['en-US', 'en'];
+                        }
+                        return originalLanguages;
+                    },
+                    configurable: true // Allow other scripts to modify if needed
+                });
+            } catch (e) {
+                // Property already defined, skip
+            }
+        }
+    };
+    
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting locale spoofing...');
+        spoofLocale();
+        console.log(DEBUG_PREFIX, '✓ Locale spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply locale spoofing:', e);
+        throw e;
+    }
+})();
+`;
+};
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqSV,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
+ * Stores the utility in the __stealth store for internal use only
+ */
+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,CAmD9E,CAAC"}

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

@@ -0,0 +1,58 @@
+/**
+ * Mouse Movement Humanization
+ * Generates bezier curve movements instead of straight lines
+ * Stores the utility in the __stealth store for internal use only
+ */
+export const setupMouseMovementHumanization = async (client) => {
+    // NOTE: Using addScriptToEvaluateOnNewDocument instead of Runtime.evaluate
+    // Runtime.evaluate is a CDP detection vector - it modifies console bindings and Error stacks
+    await client.Page.addScriptToEvaluateOnNewDocument({ source: `
+(() => {
+    'use strict';
+
+    const _s = typeof __stealth !== 'undefined' ? __stealth : {};
+
+    // Seeded PRNG (mulberry32) for deterministic curves
+    const createSeededRNG = (seed) => {
+        let s = seed | 0;
+        return () => {
+            s = s + 0x6D2B79F5 | 0;
+            let t = Math.imul(s ^ s >>> 15, 1 | s);
+            t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+            return ((t ^ t >>> 14) >>> 0) / 4294967296;
+        };
+    };
+    const sessionSeed = Date.now() ^ (Math.random() * 0xFFFFFFFF >>> 0);
+    const seededRandom = createSeededRNG(sessionSeed);
+
+    // Bezier curve movement generator
+    _s.humanizeMouse = (fromX, fromY, toX, toY) => {
+        const steps = 20 + Math.floor(seededRandom() * 10);
+        const points = [];
+
+        // Generate control points for bezier curve
+        const cp1x = fromX + (toX - fromX) * 0.25 + (seededRandom() - 0.5) * 50;
+        const cp1y = fromY + (toY - fromY) * 0.25 + (seededRandom() - 0.5) * 50;
+        const cp2x = fromX + (toX - fromX) * 0.75 + (seededRandom() - 0.5) * 50;
+        const cp2y = fromY + (toY - fromY) * 0.75 + (seededRandom() - 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;
+    };
+})();` });
+};
+//# 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,2EAA2E;IAC3E,6FAA6F;IAC7F,MAAM,MAAM,CAAC,IAAI,CAAC,gCAAgC,CAAC,EAAE,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+C3D,EAAE,CAAC,CAAC;AACV,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,MAmPlD,CAAC"}

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

@@ -0,0 +1,249 @@
+/**
+ * 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 = () => {
+        const createSeededRNG = (seed) => {
+            let s = seed | 0;
+            return () => {
+                s = s + 0x6D2B79F5 | 0;
+                let t = Math.imul(s ^ s >>> 15, 1 | s);
+                t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+                return ((t ^ t >>> 14) >>> 0) / 4294967296;
+            };
+        };
+        const sessionSeed = Date.now() ^ 0xE7A31B49;
+        const seededRandom = createSeededRNG(sessionSeed);
+
+        // 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 = (seededRandom() - 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 pseudoRandom = seededRandom();
+            
+            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) + 
+                        (seededRandom() - 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 - seededRandom() * 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 - seededRandom() * 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);
+                    });
+                }
+            };
+        }
+    };
+    
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting performance spoofing...');
+        spoofPerformance();
+        console.log(DEBUG_PREFIX, '✓ Performance spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply performance spoofing:', e);
+        throw e;
+    }
+})();
+`;
+};
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiPV,CAAC;AACF,CAAC,CAAC"}

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

@@ -0,0 +1,33 @@
+/**
+ * Platform Consistency Script
+ * Ensures all browser properties match the specified platform (1:1 fingerprinting)
+ *
+ * 2024-2025 Enhancements:
+ * - Screen orientation API consistency
+ * - screen.availLeft/availTop for Windows
+ * - visualViewport properties consistency
+ * - window.outerWidth/outerHeight ratios
+ * - window.screenX/screenY typical values
+ * - matchMedia() platform-appropriate results
+ */
+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;
+    userAgent?: string;
+    appVersion?: string;
+    appName?: string;
+    appCodeName?: string;
+    product?: string;
+}
+export declare const createPlatformConsistencyScript: (platform: string, fingerprintData?: PlatformConfig) => string;
+//# sourceMappingURL=platform-consistency.d.ts.map