jumpy-lion 0.0.41 → 0.0.42

package/dist/fingerprinting/fingerprint-overrides/datadome-bypass.d.ts

@@ -0,0 +1,14 @@
+/**
+ * DataDome-Specific Bypass Module
+ * Targeted countermeasures for DataDome bot detection 2024-2025
+ *
+ * Features:
+ * - JavaScript challenge response handling
+ * - Proof-of-work computation timing spoofing
+ * - eval() and Function() source hiding
+ * - DataDome cookie consistency
+ * - dd-* header handling
+ * - Device Check signal spoofing
+ */
+export declare const createDataDomeBypassScript: () => string;
+//# sourceMappingURL=datadome-bypass.d.ts.map

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

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

package/dist/fingerprinting/fingerprint-overrides/datadome-bypass.js

@@ -0,0 +1,536 @@
+/**
+ * DataDome-Specific Bypass Module
+ * Targeted countermeasures for DataDome bot detection 2024-2025
+ *
+ * Features:
+ * - JavaScript challenge response handling
+ * - Proof-of-work computation timing spoofing
+ * - eval() and Function() source hiding
+ * - DataDome cookie consistency
+ * - dd-* header handling
+ * - Device Check signal spoofing
+ */
+export const createDataDomeBypassScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // DataDome-Specific Bypass for 2024-2025
+    const bypassDataDome = () => {
+        // Generate consistent session identifiers
+        const generateSessionId = () => {
+            const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+            let result = '';
+            for (let i = 0; i < 32; i++) {
+                result += chars.charAt(Math.floor(Math.random() * chars.length));
+            }
+            return result;
+        };
+        
+        const sessionId = generateSessionId();
+        
+        // 1. Handle DataDome JavaScript challenges
+        const handleJSChallenges = () => {
+            // Track challenge timing to appear human-like
+            const challengeStartTimes = new Map();
+            
+            // Override setTimeout to add realistic delays to challenges
+            const originalSetTimeout = window.setTimeout;
+            window.setTimeout = function(callback, delay, ...args) {
+                // DataDome often uses very short timeouts for detection
+                // Add slight variance to appear more human
+                const isDataDomeChallenge = callback && 
+                    (callback.toString().includes('dd_') || 
+                     callback.toString().includes('datadome'));
+                
+                if (isDataDomeChallenge && delay < 100) {
+                    delay = delay + Math.floor(Math.random() * 50);
+                }
+                
+                return originalSetTimeout.call(this, callback, delay, ...args);
+            };
+            
+            // Monitor for challenge scripts - but wait for DOM to be ready
+            const setupObserver = () => {
+                if (!document.documentElement) {
+                    console.log('[CDP-FP-DEBUG] document.documentElement not ready, will retry');
+                    return;
+                }
+                
+                try {
+                    const observer = new MutationObserver((mutations) => {
+                        for (const mutation of mutations) {
+                            for (const node of mutation.addedNodes) {
+                                if (node.nodeName === 'SCRIPT') {
+                                    const script = node;
+                                    if (script.src && script.src.includes('datadome')) {
+                                        // Mark challenge start time
+                                        challengeStartTimes.set(script.src, performance.now());
+                                    }
+                                }
+                            }
+                        }
+                    });
+                    
+                    // Double-check documentElement exists before observing
+                    if (document.documentElement) {
+                        observer.observe(document.documentElement, {
+                            childList: true,
+                            subtree: true
+                        });
+                        console.log('[CDP-FP-DEBUG] DataDome challenge observer set up');
+                    }
+                } catch (e) {
+                    console.log('[CDP-FP-DEBUG] Could not set up DataDome observer:', e.message);
+                }
+            };
+            
+            // Try to set up observer, or wait for DOM
+            if (document.documentElement) {
+                setupObserver();
+            } else {
+                // Wait for DOM to be ready
+                if (document.readyState === 'loading') {
+                    document.addEventListener('DOMContentLoaded', setupObserver);
+                } else {
+                    // DOM is interactive or complete, set up immediately
+                    setupObserver();
+                }
+            }
+        };
+
+        // 2. Spoof proof-of-work computation timing
+        const spoofPOWTiming = () => {
+            // DataDome may use proof-of-work challenges
+            // These should complete in human-like time (not instant)
+            
+            const originalWorker = window.Worker;
+            
+            if (originalWorker) {
+                window.Worker = function(scriptURL, options) {
+                    const worker = new originalWorker(scriptURL, options);
+                    
+                    // Intercept messages to/from worker
+                    const originalPostMessage = worker.postMessage;
+                    worker.postMessage = function(message, transfer) {
+                        // Add delay before sending to worker
+                        const delay = 10 + Math.random() * 20;
+                        
+                        setTimeout(() => {
+                            originalPostMessage.call(this, message, transfer);
+                        }, delay);
+                    };
+                    
+                    // Add delay to worker responses
+                    const originalOnMessage = Object.getOwnPropertyDescriptor(Worker.prototype, 'onmessage');
+                    if (originalOnMessage) {
+                        Object.defineProperty(worker, 'onmessage', {
+                            get() {
+                                return originalOnMessage.get.call(this);
+                            },
+                            set(handler) {
+                                const wrappedHandler = function(event) {
+                                    // Add slight delay to appear like real computation
+                                    setTimeout(() => {
+                                        handler.call(this, event);
+                                    }, 5 + Math.random() * 15);
+                                };
+                                originalOnMessage.set.call(this, wrappedHandler);
+                            }
+                        });
+                    }
+                    
+                    return worker;
+                };
+                
+                // Note: Don't assign to prototype - it may be frozen in modern Chrome
+            }
+        };
+
+        // 3. Protect eval() and Function() from source detection
+        const protectEvalSources = () => {
+            const originalEval = window.eval;
+            const OriginalFunction = window.Function;
+            
+            // DataDome may check eval source strings
+            window.eval = function(code) {
+                // Clean DataDome detection patterns
+                if (typeof code === 'string') {
+                    // Remove obvious eval markers
+                    code = code.replace(/\\/\\/.*datadome.*$/gm, '');
+                    code = code.replace(/\\/\\*.*datadome.*\\*\\//g, '');
+                }
+                
+                return originalEval.call(this, code);
+            };
+            
+            const FunctionProxy = new Proxy(OriginalFunction, {
+                construct(target, args) {
+                    // Clean function body
+                    if (args.length > 0 && typeof args[args.length - 1] === 'string') {
+                        args[args.length - 1] = args[args.length - 1]
+                            .replace(/\\/\\/.*datadome.*$/gm, '')
+                            .replace(/\\/\\*.*datadome.*\\*\\//g, '');
+                    }
+                    
+                    return Reflect.construct(target, args);
+                },
+                apply(target, thisArg, args) {
+                    // Clean function body for apply calls
+                    if (args.length > 0 && typeof args[args.length - 1] === 'string') {
+                        args[args.length - 1] = args[args.length - 1]
+                            .replace(/\\/\\/.*datadome.*$/gm, '')
+                            .replace(/\\/\\*.*datadome.*\\*\\//g, '');
+                    }
+                    
+                    return Reflect.apply(target, thisArg, args);
+                },
+                get(target, prop) {
+                    // Return the original prototype when accessing .prototype
+                    if (prop === 'prototype') {
+                        return OriginalFunction.prototype;
+                    }
+                    return Reflect.get(target, prop);
+                }
+            });
+            
+            // Use defineProperty to replace Function without modifying frozen prototype
+            try {
+                Object.defineProperty(window, 'Function', {
+                    value: FunctionProxy,
+                    writable: true,
+                    enumerable: false,
+                    configurable: true
+                });
+            } catch (e) {
+                // If we can't redefine, just assign
+                window.Function = FunctionProxy;
+            }
+        };
+
+        // 4. Handle DataDome cookies consistently
+        const handleDataDomeCookies = () => {
+            // Track datadome cookies
+            const datadomePattern = /^datadome/i;
+            
+            // Override document.cookie getter/setter
+            const cookieDescriptor = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie');
+            
+            if (cookieDescriptor) {
+                Object.defineProperty(document, 'cookie', {
+                    get() {
+                        const cookies = cookieDescriptor.get.call(this);
+                        // Return cookies normally, datadome expects them
+                        return cookies;
+                    },
+                    set(value) {
+                        // Allow datadome cookies to be set normally
+                        return cookieDescriptor.set.call(this, value);
+                    },
+                    configurable: true
+                });
+            }
+        };
+
+        // 5. Spoof DataDome device signals
+        const spoofDeviceSignals = () => {
+            // DataDome Device Check looks for specific signals
+            
+            // 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;
+                }
+            };
+            
+            // Ensure consistent hardware concurrency (only if not already defined as non-configurable)
+            if (canRedefineProperty(navigator, 'hardwareConcurrency')) {
+                const expectedConcurrency = navigator.hardwareConcurrency || 8;
+                try {
+                    Object.defineProperty(navigator, 'hardwareConcurrency', {
+                        get: () => expectedConcurrency,
+                        configurable: true  // Allow other scripts to modify
+                    });
+                } catch (e) {
+                    // Property already defined, skip
+                }
+            }
+            
+            // Ensure deviceMemory is present and reasonable (only if not already defined as non-configurable)
+            if (canRedefineProperty(navigator, 'deviceMemory')) {
+                const expectedMemory = navigator.deviceMemory || 8;
+                try {
+                    Object.defineProperty(navigator, 'deviceMemory', {
+                        get: () => expectedMemory,
+                        configurable: true  // Allow other scripts to modify
+                    });
+                } catch (e) {
+                    // Property already defined, skip
+                }
+            }
+            
+            // Ensure connection info looks real
+            if ('connection' in navigator) {
+                const conn = navigator.connection;
+                if (conn) {
+                    try {
+                        if (canRedefineProperty(conn, 'effectiveType')) {
+                            Object.defineProperty(conn, 'effectiveType', {
+                                get: () => '4g',
+                                configurable: true
+                            });
+                        }
+                        if (canRedefineProperty(conn, 'rtt')) {
+                            Object.defineProperty(conn, 'rtt', {
+                                get: () => 50 + Math.floor(Math.random() * 50),
+                                configurable: true
+                            });
+                        }
+                        if (canRedefineProperty(conn, 'downlink')) {
+                            Object.defineProperty(conn, 'downlink', {
+                                get: () => 10 + Math.random() * 40,
+                                configurable: true
+                            });
+                        }
+                    } catch (e) {}
+                }
+            }
+        };
+
+        // 6. Handle dd-* headers in fetch/XHR
+        const handleDataDomeHeaders = () => {
+            // Override fetch to ensure proper headers
+            const originalFetch = window.fetch;
+            
+            window.fetch = function(input, init = {}) {
+                // Ensure proper headers are sent
+                if (!init.headers) {
+                    init.headers = {};
+                }
+                
+                // Clone headers if needed
+                if (init.headers instanceof Headers) {
+                    const headersObj = {};
+                    init.headers.forEach((value, key) => {
+                        headersObj[key] = value;
+                    });
+                    init.headers = headersObj;
+                }
+                
+                // Add realistic browser headers if missing
+                if (!init.headers['Accept-Language']) {
+                    init.headers['Accept-Language'] = 'en-US,en;q=0.9';
+                }
+                
+                return originalFetch.call(this, input, init);
+            };
+            
+            // Override XMLHttpRequest
+            const originalOpen = XMLHttpRequest.prototype.open;
+            const originalSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+            const headersMap = new WeakMap();
+            
+            XMLHttpRequest.prototype.open = function(method, url, ...args) {
+                headersMap.set(this, {});
+                return originalOpen.call(this, method, url, ...args);
+            };
+            
+            XMLHttpRequest.prototype.setRequestHeader = function(name, value) {
+                const headers = headersMap.get(this) || {};
+                headers[name.toLowerCase()] = value;
+                headersMap.set(this, headers);
+                return originalSetRequestHeader.call(this, name, value);
+            };
+        };
+
+        // 7. Protect canvas fingerprinting from DataDome
+        const protectCanvasForDataDome = () => {
+            // DataDome uses specific canvas tests
+            const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
+            const canvasCache = new WeakMap();
+            
+            HTMLCanvasElement.prototype.toDataURL = function(...args) {
+                // Cache canvas results for consistency
+                const key = this.width + 'x' + this.height;
+                
+                if (canvasCache.has(this)) {
+                    const cached = canvasCache.get(this);
+                    if (cached.key === key) {
+                        return cached.result;
+                    }
+                }
+                
+                const result = originalToDataURL.apply(this, args);
+                canvasCache.set(this, { key, result });
+                
+                return result;
+            };
+        };
+
+        // 8. Handle visibility/focus detection
+        const handleVisibilityDetection = () => {
+            // DataDome may check if page is visible/focused
+            Object.defineProperty(document, 'hidden', {
+                get: () => false,
+                configurable: true
+            });
+            
+            Object.defineProperty(document, 'visibilityState', {
+                get: () => 'visible',
+                configurable: true
+            });
+            
+            // Ensure hasFocus returns true
+            const originalHasFocus = document.hasFocus;
+            document.hasFocus = function() {
+                return true;
+            };
+        };
+
+        // 9. Spoof mouse/touch presence
+        const spoofInputPresence = () => {
+            // DataDome checks for input device presence
+            
+            // Ensure pointer events are supported
+            Object.defineProperty(navigator, 'maxTouchPoints', {
+                get: () => 0, // Desktop has 0 touch points
+                configurable: true
+            });
+            
+            // Ensure we have a mouse (matchMedia for hover)
+            const originalMatchMedia = window.matchMedia;
+            window.matchMedia = function(query) {
+                const result = originalMatchMedia.call(this, query);
+                
+                // Ensure hover is supported (we have a mouse)
+                if (query === '(hover: hover)') {
+                    return Object.assign({}, result, { matches: true });
+                }
+                
+                // Ensure pointer is fine (mouse, not touch)
+                if (query === '(pointer: fine)') {
+                    return Object.assign({}, result, { matches: true });
+                }
+                
+                return result;
+            };
+        };
+
+        // 10. Handle DataDome's timing checks
+        const handleTimingChecks = () => {
+            // DataDome measures various timing signals
+            
+            // Ensure navigation timing looks normal
+            if (performance.timing) {
+                const timing = performance.timing;
+                
+                // These should look like a real page load
+                const loadTime = timing.loadEventEnd - timing.navigationStart;
+                
+                // If load time is suspiciously fast, we need to appear slower
+                if (loadTime > 0 && loadTime < 500) {
+                    // Page loaded too fast, might be detected
+                    // The timing is already set, but we can affect new measurements
+                }
+            }
+            
+            // Add realistic performance entries
+            if (performance.mark && performance.measure) {
+                try {
+                    performance.mark('dd_page_start');
+                    setTimeout(() => {
+                        performance.mark('dd_page_ready');
+                        performance.measure('dd_load_time', 'dd_page_start', 'dd_page_ready');
+                    }, 100 + Math.random() * 200);
+                } catch (e) {}
+            }
+        };
+
+        // 11. Ensure WebGL looks consistent
+        const ensureWebGLConsistency = () => {
+            // DataDome checks WebGL renderer consistency
+            const originalGetParameter = WebGLRenderingContext.prototype.getParameter;
+            let cachedRenderer = null;
+            let cachedVendor = null;
+            
+            WebGLRenderingContext.prototype.getParameter = function(param) {
+                // Cache WebGL values for consistency across calls
+                if (param === 0x9245) { // UNMASKED_VENDOR_WEBGL
+                    if (!cachedVendor) {
+                        cachedVendor = originalGetParameter.call(this, param);
+                    }
+                    return cachedVendor;
+                }
+                
+                if (param === 0x9246) { // UNMASKED_RENDERER_WEBGL
+                    if (!cachedRenderer) {
+                        cachedRenderer = originalGetParameter.call(this, param);
+                    }
+                    return cachedRenderer;
+                }
+                
+                return originalGetParameter.call(this, param);
+            };
+            
+            if (typeof WebGL2RenderingContext !== 'undefined') {
+                WebGL2RenderingContext.prototype.getParameter = WebGLRenderingContext.prototype.getParameter;
+            }
+        };
+
+        // 12. Handle iframe detection
+        const handleIframeDetection = () => {
+            // DataDome may check if running in iframe
+            // Helper to safely define
+            const safeDefine = (obj, prop, getter) => {
+                try {
+                    const desc = Object.getOwnPropertyDescriptor(obj, prop);
+                    if (desc && desc.configurable === false) return;
+                    Object.defineProperty(obj, prop, {
+                        get: getter,
+                        configurable: true
+                    });
+                } catch (e) {}
+            };
+            
+            safeDefine(window, 'self', () => window);
+            safeDefine(window, 'top', () => window);
+            safeDefine(window, 'parent', () => window);
+        };
+
+        // Initialize all DataDome bypasses
+        try {
+            handleJSChallenges();
+            spoofPOWTiming();
+            protectEvalSources();
+            handleDataDomeCookies();
+            spoofDeviceSignals();
+            handleDataDomeHeaders();
+            protectCanvasForDataDome();
+            handleVisibilityDetection();
+            spoofInputPresence();
+            handleTimingChecks();
+            ensureWebGLConsistency();
+            handleIframeDetection();
+        } catch (e) {
+            console.error('[DATADOME-BYPASS] Failed to apply DataDome bypass:', e);
+            throw e; // Rethrow to make errors visible
+        }
+    };
+
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting DataDome bypass...');
+        bypassDataDome();
+        console.log(DEBUG_PREFIX, '✓ DataDome bypass applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply DataDome bypass:', e);
+        throw e;
+    }
+})();`;
+};
+//# sourceMappingURL=datadome-bypass.js.map

package/dist/fingerprinting/fingerprint-overrides/datadome-bypass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datadome-bypass.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/datadome-bypass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,GAAW,EAAE;IACnD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwgBL,CAAC;AACP,CAAC,CAAC"}

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

@@ -1 +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"}
+{"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,MA8N3C,CAAC"}

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

@@ -212,7 +212,17 @@ export const createFontSpoofingScript = () => {
         };
     };
     
-    spoofFonts();
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting font spoofing...');
+        spoofFonts();
+        console.log(DEBUG_PREFIX, '✓ Font spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply font spoofing:', e);
+        throw e;
+    }
 })();
 `;
 };

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4NV,CAAC;AACF,CAAC,CAAC"}

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

@@ -1,6 +1,14 @@
 /**
  * Fingerprint Overrides Index
  * Exports all individual fingerprint override modules
+ *
+ * 2024-2025 Additions:
+ * - CDP Detection Bypass
+ * - Storage Consistency
+ * - Timing Consistency
+ * - Keyboard Humanization
+ * - Scroll Humanization
+ * - DataDome Bypass
  */
 export { createStealthScript } from './stealth-script.js';
 export { createWebGLSpoofingScript, type WebGLConfig } from './webgl-spoofing.js';
@@ -11,9 +19,16 @@ 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 { createRuntimeEnableBypassScript } 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';
+export { createStealthUtilsScript } from './utils.js';
+export { createCDPDetectionBypassScript } from './cdp-detection-bypass.js';
+export { createStorageConsistencyScript } from './storage-consistency.js';
+export { createTimingConsistencyScript } from './timing-consistency.js';
+export { createKeyboardHumanizationScript, setupKeyboardHumanization, generateTypingDelays, createHumanTypingFunction } from './keyboard-humanization.js';
+export { createScrollHumanizationScript, setupScrollHumanization, humanScroll, humanScrollToElement, generateScrollPath } from './scroll-humanization.js';
+export { createDataDomeBypassScript } from './datadome-bypass.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,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,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AAC7E,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;AAG/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAGtD,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EACH,gCAAgC,EAChC,yBAAyB,EACzB,oBAAoB,EACpB,yBAAyB,EAC5B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACH,8BAA8B,EAC9B,uBAAuB,EACvB,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EACrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC"}

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

@@ -1,7 +1,16 @@
 /**
  * Fingerprint Overrides Index
  * Exports all individual fingerprint override modules
+ *
+ * 2024-2025 Additions:
+ * - CDP Detection Bypass
+ * - Storage Consistency
+ * - Timing Consistency
+ * - Keyboard Humanization
+ * - Scroll Humanization
+ * - DataDome Bypass
  */
+// Base stealth and protection scripts
 export { createStealthScript } from './stealth-script.js';
 export { createWebGLSpoofingScript } from './webgl-spoofing.js';
 export { createAudioFingerprintSpoofingScript } from './audio-spoofing.js';
@@ -11,9 +20,18 @@ 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 { createRuntimeEnableBypassScript } 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';
+// Stealth utilities (must be injected first)
+export { createStealthUtilsScript } from './utils.js';
+// 2024-2025 New modules
+export { createCDPDetectionBypassScript } from './cdp-detection-bypass.js';
+export { createStorageConsistencyScript } from './storage-consistency.js';
+export { createTimingConsistencyScript } from './timing-consistency.js';
+export { createKeyboardHumanizationScript, setupKeyboardHumanization, generateTypingDelays, createHumanTypingFunction } from './keyboard-humanization.js';
+export { createScrollHumanizationScript, setupScrollHumanization, humanScroll, humanScrollToElement, generateScrollPath } from './scroll-humanization.js';
+export { createDataDomeBypassScript } from './datadome-bypass.js';
 //# sourceMappingURL=index.js.map

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

@@ -1 +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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,sCAAsC;AACtC,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,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AAC7E,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;AAE/D,6CAA6C;AAC7C,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEtD,wBAAwB;AACxB,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EACH,gCAAgC,EAChC,yBAAyB,EACzB,oBAAoB,EACpB,yBAAyB,EAC5B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACH,8BAA8B,EAC9B,uBAAuB,EACvB,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EACrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC"}