jumpy-lion 0.0.33 → 0.0.34

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

@@ -0,0 +1,7 @@
+/**
+ * Font Spoofing
+ * Hides Linux-specific fonts and reports Windows/Mac fonts as available
+ * Now includes randomization to prevent cross-session correlation
+ */
+export declare const createFontSpoofingScript: () => string;
+//# sourceMappingURL=font-spoofing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"font-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/font-spoofing.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,wBAAwB,QAAO,MAoN3C,CAAC"}

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

@@ -0,0 +1,219 @@
+/**
+ * Font Spoofing
+ * Hides Linux-specific fonts and reports Windows/Mac fonts as available
+ * Now includes randomization to prevent cross-session correlation
+ */
+export const createFontSpoofingScript = () => {
+    return `
+(() => {
+    'use strict';
+    
+    // Font Spoofing for 2025 - Platform-aware font availability with randomization
+    const spoofFonts = () => {
+        // Generate a session-stable seed from current time and user agent
+        const generateSeed = () => {
+            const ua = navigator.userAgent || '';
+            const timeStamp = Math.floor(Date.now() / (1000 * 60 * 60 * 24)); // Changes daily
+            return ua.split('').reduce((a, b) => a + b.charCodeAt(0), 0) + timeStamp;
+        };
+        
+        // Simple seeded random function
+        const seededRandom = (seed) => {
+            const x = Math.sin(seed) * 10000;
+            return x - Math.floor(x);
+        };
+        
+        const sessionSeed = generateSeed();
+        
+        // Platform-specific font lists
+        const basePlatformFonts = {
+            'Win32': [
+                'Arial', 'Times New Roman', 'Calibri', 'Segoe UI', 'Georgia', 'Verdana', 
+                'Trebuchet MS', 'Impact', 'Comic Sans MS', 'Courier New', 'Palatino Linotype',
+                'Book Antiqua', 'Lucida Console', 'Lucida Sans Unicode', 'MS Sans Serif',
+                'MS Serif', 'Tahoma', 'Century Gothic', 'Franklin Gothic Medium',
+                'Arial Black', 'Garamond', 'Bookman Old Style', 'Copperplate Gothic Bold',
+                'Copperplate Gothic Light', 'Century Schoolbook', 'Monotype Corsiva',
+                'Bradley Hand ITC', 'Brush Script MT', 'Chiller', 'Harrington',
+                'Jokerman', 'Old English Text MT', 'Papyrus', 'Stencil', 'Vivaldi',
+                'Wingdings', 'Wingdings 2', 'Wingdings 3', 'Webdings', 'Symbol'
+            ],
+            'MacIntel': [
+                'Helvetica', 'Times', 'Courier', 'Monaco', 'Geneva', 'Chicago',
+                'New York', 'Palatino', 'Charcoal', 'Sand', 'Techno', 'Textile',
+                'American Typewriter', 'Andale Mono', 'Apple Chancery', 'Apple Color Emoji',
+                'Apple SD Gothic Neo', 'Apple Symbols', 'AppleGothic', 'Arial',
+                'Arial Black', 'Arial Narrow', 'Arial Rounded MT Bold', 'Arial Unicode MS',
+                'Avenir', 'Avenir Next', 'Avenir Next Condensed', 'Baskerville',
+                'Big Caslon', 'Bodoni 72', 'Bodoni 72 Oldstyle', 'Bodoni 72 Smallcaps',
+                'Bradley Hand', 'Brush Script MT', 'Chalkboard', 'Chalkboard SE',
+                'Chalkduster', 'Charter', 'Cochin', 'Comic Sans MS', 'Copperplate',
+                'Courier New', 'Didot', 'Futura', 'Georgia', 'Gill Sans', 'Helvetica Neue',
+                'Hoefler Text', 'Impact', 'Lucida Grande', 'Marker Felt', 'Menlo',
+                'Optima', 'Papyrus', 'Phosphate', 'Rockwell', 'Savoye LET', 'SignPainter',
+                'Skia', 'Snell Roundhand', 'Tahoma', 'Times New Roman', 'Trattatello',
+                'Trebuchet MS', 'Verdana', 'Zapfino'
+            ],
+            'Linux x86_64': [
+                // Limited font set typical for Linux systems
+                'Arial', 'Times New Roman', 'Courier New', 'Georgia', 'Verdana',
+                'Tahoma', 'Trebuchet MS', 'Impact', 'Comic Sans MS', 'Palatino Linotype',
+                'Lucida Console', 'Lucida Sans Unicode', 'DejaVu Sans', 'DejaVu Serif',
+                'DejaVu Sans Mono', 'Liberation Sans', 'Liberation Serif', 'Liberation Mono',
+                'Ubuntu', 'Ubuntu Mono', 'Droid Sans', 'Droid Serif', 'Droid Sans Mono'
+            ]
+        };
+        
+        // Get platform from navigator (this should be spoofed by platform consistency)
+        const platform = navigator.platform || 'Win32';
+        const baseFonts = basePlatformFonts[platform] || basePlatformFonts['Win32'];
+        
+        // Randomize font availability (remove 2-5 fonts randomly but consistently per session)
+        const fontsToRemove = Math.floor(seededRandom(sessionSeed) * 4) + 2; // 2-5 fonts
+        const shuffledFonts = [...baseFonts];
+        
+        // Remove some fonts based on session seed to create variance
+        for (let i = 0; i < fontsToRemove; i++) {
+            const indexToRemove = Math.floor(seededRandom(sessionSeed + i + 100) * shuffledFonts.length);
+            // Don't remove core fonts
+            const coreFonts = ['Arial', 'Times New Roman', 'Courier New', 'Georgia', 'Verdana'];
+            if (!coreFonts.includes(shuffledFonts[indexToRemove])) {
+                shuffledFonts.splice(indexToRemove, 1);
+            }
+        }
+        
+        const availableFonts = shuffledFonts;
+        
+        // Store the font list in session to ensure consistency
+        if (!sessionStorage.getItem('cdp_font_list')) {
+            sessionStorage.setItem('cdp_font_list', JSON.stringify(availableFonts));
+        } else {
+            // Use stored list for consistency within session
+            try {
+                const stored = JSON.parse(sessionStorage.getItem('cdp_font_list'));
+                if (Array.isArray(stored) && stored.length > 0) {
+                    availableFonts.splice(0, availableFonts.length, ...stored);
+                }
+            } catch (e) {
+                // Fallback to generated list
+            }
+        }
+        
+        // Override document.fonts.check if available
+        if (document.fonts && document.fonts.check) {
+            const originalCheck = document.fonts.check;
+            document.fonts.check = function(font, text) {
+                // Extract font family from font descriptor
+                const fontFamily = font.match(/(?:^|\\s)(['"]?)([^'"\\s,]+)\\1(?=\\s|,|$)/)?.[2];
+                
+                if (fontFamily && availableFonts.includes(fontFamily)) {
+                    return true;
+                }
+                
+                // For fonts not in our list, return false to hide Linux-specific fonts
+                if (fontFamily) {
+                    const linuxSpecificFonts = [
+                        'Ubuntu', 'Liberation Sans', 'DejaVu Sans', 'Noto Sans', 'Cantarell',
+                        'Source Sans Pro', 'Droid Sans', 'Roboto', 'Open Sans'
+                    ];
+                    if (linuxSpecificFonts.includes(fontFamily)) {
+                        return false;
+                    }
+                }
+                
+                // Fall back to original check for other cases
+                try {
+                    return originalCheck.call(this, font, text);
+                } catch (e) {
+                    return false;
+                }
+            };
+        }
+        
+        // Override FontFace constructor to control font loading
+        if (typeof FontFace !== 'undefined') {
+            const OriginalFontFace = FontFace;
+            window.FontFace = new Proxy(OriginalFontFace, {
+                construct(target, args) {
+                    const [family, source, descriptors] = args;
+                    
+                    // Check if this font should be available on our target platform
+                    if (availableFonts.includes(family)) {
+                        return Reflect.construct(target, args);
+                    } else {
+                        // Create a font face that will fail to load for unavailable fonts
+                        const fontFace = Reflect.construct(target, [family, 'url(data:,)', descriptors]);
+                        // Override the load method to always reject
+                        fontFace.load = function() {
+                            return Promise.reject(new DOMException('Font load failed', 'NetworkError'));
+                        };
+                        return fontFace;
+                    }
+                }
+            });
+        }
+        
+        // Spoof canvas font measurement for consistent results
+        const originalMeasureText = CanvasRenderingContext2D.prototype.measureText;
+        CanvasRenderingContext2D.prototype.measureText = function(text) {
+            const metrics = originalMeasureText.apply(this, arguments);
+            
+            // Get current font family from context
+            const font = this.font || '10px sans-serif';
+            const fontFamily = font.match(/(?:^|\\s)(['"]?)([^'"\\s,]+)\\1(?=\\s|,|$)/)?.[2] || 'Arial';
+            
+            // Apply platform-specific text measurement adjustments
+            let osMultiplier = 1.0;
+            if (platform === 'Win32') {
+                osMultiplier = 1.02 + seededRandom(sessionSeed + 1000) * 0.01; // 1.02-1.03
+            } else if (platform === 'MacIntel') {
+                osMultiplier = 0.97 + seededRandom(sessionSeed + 1001) * 0.02; // 0.97-0.99
+            }
+            
+            // Apply font-specific adjustments with session variance
+            const fontAdjustments = {
+                'Arial': 1.0 + seededRandom(sessionSeed + 2000) * 0.005,
+                'Times New Roman': 1.05 + seededRandom(sessionSeed + 2001) * 0.01,
+                'Courier New': 0.95 + seededRandom(sessionSeed + 2002) * 0.005,
+                'Helvetica': 0.98 + seededRandom(sessionSeed + 2003) * 0.005,
+                'Georgia': 1.03 + seededRandom(sessionSeed + 2004) * 0.01
+            };
+            
+            const fontMultiplier = fontAdjustments[fontFamily] || (1.0 + seededRandom(sessionSeed + fontFamily.charCodeAt(0)) * 0.005);
+            const finalMultiplier = osMultiplier * fontMultiplier;
+            
+            return new Proxy(metrics, {
+                get(target, prop) {
+                    if (typeof target[prop] === 'number' && prop.includes('width')) {
+                        return target[prop] * finalMultiplier;
+                    }
+                    return target[prop];
+                }
+            });
+        };
+        
+        // Override getComputedStyle to return consistent font information
+        const originalGetComputedStyle = window.getComputedStyle;
+        window.getComputedStyle = function(element, pseudoElement) {
+            const styles = originalGetComputedStyle.call(this, element, pseudoElement);
+            
+            return new Proxy(styles, {
+                get(target, prop) {
+                    if (prop === 'fontFamily') {
+                        const fontFamily = target.fontFamily;
+                        // Ensure reported font families are from our available list
+                        const families = fontFamily.split(',').map(f => f.trim().replace(/['"]/g, ''));
+                        const availableFamily = families.find(f => availableFonts.includes(f));
+                        return availableFamily ? \`"\${availableFamily}"\` : '"Arial"';
+                    }
+                    return target[prop];
+                }
+            });
+        };
+    };
+    
+    spoofFonts();
+})();
+`;
+};
+//# sourceMappingURL=font-spoofing.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"font-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/font-spoofing.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAW,EAAE;IACjD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkNV,CAAC;AACF,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Fingerprint Overrides Index
+ * Exports all individual fingerprint override modules
+ */
+export { createStealthScript } from './stealth-script.js';
+export { createWebGLSpoofingScript, type WebGLConfig } from './webgl-spoofing.js';
+export { createAudioFingerprintSpoofingScript } from './audio-spoofing.js';
+export { createAdvancedCanvasProtectionScript } from './canvas-protection.js';
+export { createClientRectSpoofingScript } from './client-rect-spoofing.js';
+export { createWebRTCSpoofingScript } from './webrtc-spoofing.js';
+export { createWebGPUSpoofingScript } from './webgpu-spoofing.js';
+export { createPlatformConsistencyScript, type PlatformConfig } from './platform-consistency.js';
+export { setupMouseMovementHumanization } from './mouse-humanization.js';
+export { setupRuntimeEnableBypass } from './runtime-enable-bypass.js';
+export { createFontSpoofingScript } from './font-spoofing.js';
+export { createPerformanceSpoofingScript } from './performance-spoofing.js';
+export { createLocaleSpoofingScript } from './locale-spoofing.js';
+export { createUAClientHintsSpoofingScript } from './ua-ch.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,yBAAyB,EAAE,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClF,OAAO,EAAE,oCAAoC,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,oCAAoC,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,+BAA+B,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AACjG,OAAO,EAAE,8BAA8B,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,iCAAiC,EAAE,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1,19 @@
+/**
+ * Fingerprint Overrides Index
+ * Exports all individual fingerprint override modules
+ */
+export { createStealthScript } from './stealth-script.js';
+export { createWebGLSpoofingScript } from './webgl-spoofing.js';
+export { createAudioFingerprintSpoofingScript } from './audio-spoofing.js';
+export { createAdvancedCanvasProtectionScript } from './canvas-protection.js';
+export { createClientRectSpoofingScript } from './client-rect-spoofing.js';
+export { createWebRTCSpoofingScript } from './webrtc-spoofing.js';
+export { createWebGPUSpoofingScript } from './webgpu-spoofing.js';
+export { createPlatformConsistencyScript } from './platform-consistency.js';
+export { setupMouseMovementHumanization } from './mouse-humanization.js';
+export { setupRuntimeEnableBypass } from './runtime-enable-bypass.js';
+export { createFontSpoofingScript } from './font-spoofing.js';
+export { createPerformanceSpoofingScript } from './performance-spoofing.js';
+export { createLocaleSpoofingScript } from './locale-spoofing.js';
+export { createUAClientHintsSpoofingScript } from './ua-ch.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAE,yBAAyB,EAAoB,MAAM,qBAAqB,CAAC;AAClF,OAAO,EAAE,oCAAoC,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,oCAAoC,EAAE,MAAM,wBAAwB,CAAC;AAC9E,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,+BAA+B,EAAuB,MAAM,2BAA2B,CAAC;AACjG,OAAO,EAAE,8BAA8B,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,iCAAiC,EAAE,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1,6 @@
+/**
+ * Locale Spoofing
+ * Ensures consistent Windows-style locale formatting for dates, numbers, and currencies
+ */
+export declare const createLocaleSpoofingScript: () => string;
+//# sourceMappingURL=locale-spoofing.d.ts.map

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

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

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