jumpy-lion 0.0.32 → 0.0.34

package/dist/fingerprinting/fingerprint-overrides/client-rect-spoofing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Client Rect Spoofing
+ * Adds small variations to DOM measurements to prevent fingerprinting
+ */
+export declare const createClientRectSpoofingScript: () => string;
+//# sourceMappingURL=client-rect-spoofing.d.ts.map

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

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

package/dist/fingerprinting/fingerprint-overrides/client-rect-spoofing.js

@@ -0,0 +1,96 @@
+/**
+ * Client Rect Spoofing
+ * Adds small variations to DOM measurements to prevent fingerprinting
+ */
+export const createClientRectSpoofingScript = () => {
+    return `
+(() => {
+    'use strict';
+    
+    // Client Rect Spoofing for 2025
+    const spoofClientRects = () => {
+        // Add small random variations to rect values
+        const addVariation = (value) => {
+            return value + (Math.random() - 0.5) * 0.1;
+        };
+        
+        // Override getBoundingClientRect
+        const originalGetBoundingClientRect = Element.prototype.getBoundingClientRect;
+        Element.prototype.getBoundingClientRect = function() {
+            const rect = originalGetBoundingClientRect.apply(this, arguments);
+            
+            // Create a new DOMRect with slight variations
+            const newRect = {
+                x: addVariation(rect.x),
+                y: addVariation(rect.y),
+                width: addVariation(rect.width),
+                height: addVariation(rect.height),
+                top: addVariation(rect.top),
+                right: addVariation(rect.right),
+                bottom: addVariation(rect.bottom),
+                left: addVariation(rect.left),
+                toJSON: rect.toJSON
+            };
+            
+            // Make it look like a real DOMRect
+            Object.setPrototypeOf(newRect, DOMRect.prototype);
+            
+            return newRect;
+        };
+        
+        // Override getClientRects
+        const originalGetClientRects = Element.prototype.getClientRects;
+        Element.prototype.getClientRects = function() {
+            const rects = originalGetClientRects.apply(this, arguments);
+            const newRects = [];
+            
+            for (let i = 0; i < rects.length; i++) {
+                const rect = rects[i];
+                const newRect = {
+                    x: addVariation(rect.x),
+                    y: addVariation(rect.y),
+                    width: addVariation(rect.width),
+                    height: addVariation(rect.height),
+                    top: addVariation(rect.top),
+                    right: addVariation(rect.right),
+                    bottom: addVariation(rect.bottom),
+                    left: addVariation(rect.left)
+                };
+                Object.setPrototypeOf(newRect, DOMRect.prototype);
+                newRects.push(newRect);
+            }
+            
+            // Create a DOMRectList-like object
+            const rectList = {
+                length: newRects.length,
+                item: (index) => newRects[index] || null,
+                [Symbol.iterator]: function*() {
+                    for (let i = 0; i < this.length; i++) {
+                        yield this.item(i);
+                    }
+                }
+            };
+            
+            // Add indexed properties
+            for (let i = 0; i < newRects.length; i++) {
+                rectList[i] = newRects[i];
+            }
+            
+            Object.setPrototypeOf(rectList, DOMRectList.prototype);
+            return rectList;
+        };
+        
+        // Override Range methods
+        if (typeof Range !== 'undefined') {
+            const originalGetBoundingClientRectRange = Range.prototype.getBoundingClientRect;
+            Range.prototype.getBoundingClientRect = Element.prototype.getBoundingClientRect;
+            
+            const originalGetClientRectsRange = Range.prototype.getClientRects;
+            Range.prototype.getClientRects = Element.prototype.getClientRects;
+        }
+    };
+    
+    spoofClientRects();
+})();`;
+};
+//# sourceMappingURL=client-rect-spoofing.js.map

package/dist/fingerprinting/fingerprint-overrides/client-rect-spoofing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-rect-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/client-rect-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,GAAW,EAAE;IACvD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwFL,CAAC;AACP,CAAC,CAAC"}

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