jumpy-lion 0.0.40 → 0.0.42

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

@@ -81,7 +81,17 @@ export const createAudioFingerprintSpoofingScript = () => {
         }
     };
     
-    spoofAudioContext();
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting audio context spoofing...');
+        spoofAudioContext();
+        console.log(DEBUG_PREFIX, '✓ Audio context spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply audio context spoofing:', e);
+        throw e; // Rethrow to make errors visible
+    }
 })();`;
 };
 //# sourceMappingURL=audio-spoofing.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"audio-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/audio-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,oCAAoC,GAAG,GAAW,EAAE;IAC7D,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+EL,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"audio-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/audio-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,oCAAoC,GAAG,GAAW,EAAE;IAC7D,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyFL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/canvas-protection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvas-protection.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/canvas-protection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,oCAAoC,QAAO,MAyFvD,CAAC"}
+{"version":3,"file":"canvas-protection.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/canvas-protection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,oCAAoC,QAAO,MAmGvD,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/canvas-protection.js

@@ -89,7 +89,17 @@ export const createAdvancedCanvasProtectionScript = () => {
         };
     };
     
-    protectCanvas();
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting canvas protection...');
+        protectCanvas();
+        console.log(DEBUG_PREFIX, '✓ Canvas protection applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply canvas protection:', e);
+        throw e; // Rethrow to make errors visible
+    }
 })();`;
 };
 //# sourceMappingURL=canvas-protection.js.map

package/dist/fingerprinting/fingerprint-overrides/canvas-protection.js.map

@@ -1 +1 @@
-{"version":3,"file":"canvas-protection.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/canvas-protection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,oCAAoC,GAAG,GAAW,EAAE;IAC7D,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuFL,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"canvas-protection.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/canvas-protection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,oCAAoC,GAAG,GAAW,EAAE;IAC7D,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiGL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/cdp-detection-bypass.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CDP Detection Bypass
+ * Comprehensive CDP and automation detection bypass for 2024-2025
+ *
+ * Handles:
+ * - Iframe contentWindow access hiding
+ * - Puppeteer/Playwright evaluation script traces
+ * - Error.captureStackTrace patching
+ * - Storage access API spoofing
+ * - SourceURL/SourceMap hiding
+ * - Chrome DevTools property removal
+ */
+export declare const createCDPDetectionBypassScript: () => string;
+//# sourceMappingURL=cdp-detection-bypass.d.ts.map

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

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

package/dist/fingerprinting/fingerprint-overrides/cdp-detection-bypass.js

@@ -0,0 +1,497 @@
+/**
+ * CDP Detection Bypass
+ * Comprehensive CDP and automation detection bypass for 2024-2025
+ *
+ * Handles:
+ * - Iframe contentWindow access hiding
+ * - Puppeteer/Playwright evaluation script traces
+ * - Error.captureStackTrace patching
+ * - Storage access API spoofing
+ * - SourceURL/SourceMap hiding
+ * - Chrome DevTools property removal
+ */
+export const createCDPDetectionBypassScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // CDP Detection Bypass for 2025
+    const bypassCDPDetection = () => {
+        
+        // 1. Remove Chrome DevTools / Selenium / Puppeteer specific properties
+        const removeAutomationProperties = () => {
+            const cdcProperties = Object.getOwnPropertyNames(window).filter(prop => 
+                prop.startsWith('cdc_') || 
+                prop.startsWith('$cdc_') ||
+                prop.includes('webdriver') ||
+                prop.includes('selenium') ||
+                prop.includes('puppeteer') ||
+                prop.includes('playwright')
+            );
+            
+            cdcProperties.forEach(prop => {
+                try {
+                    delete window[prop];
+                } catch (e) {
+                    try {
+                        Object.defineProperty(window, prop, {
+                            get: () => undefined,
+                            configurable: true
+                        });
+                    } catch (e2) {}
+                }
+            });
+            
+            // Remove from document as well
+            const docProperties = Object.getOwnPropertyNames(document).filter(prop =>
+                prop.startsWith('$') || 
+                prop.includes('webdriver') ||
+                prop.includes('selenium')
+            );
+            
+            docProperties.forEach(prop => {
+                try {
+                    delete document[prop];
+                } catch (e) {}
+            });
+        };
+
+        // 2. Override HTMLIFrameElement.prototype.contentWindow to hide CDP access
+        const protectIframeContentWindow = () => {
+            const originalContentWindowDescriptor = Object.getOwnPropertyDescriptor(
+                HTMLIFrameElement.prototype, 
+                'contentWindow'
+            );
+            
+            if (originalContentWindowDescriptor) {
+                Object.defineProperty(HTMLIFrameElement.prototype, 'contentWindow', {
+                    get() {
+                        const contentWindow = originalContentWindowDescriptor.get.call(this);
+                        
+                        if (!contentWindow) return contentWindow;
+                        
+                        // Check if the iframe is same-origin
+                        try {
+                            // Access a property to check if we have access
+                            const _ = contentWindow.document;
+                            
+                            // If accessible, wrap it to hide automation traces
+                            return new Proxy(contentWindow, {
+                                get(target, prop) {
+                                    // Hide automation-related properties
+                                    if (prop === 'webdriver' || 
+                                        prop === '__webdriver_evaluate' ||
+                                        prop === '__selenium_evaluate' ||
+                                        prop === '__driver_evaluate' ||
+                                        prop === '__webdriver_script_function' ||
+                                        prop === '__webdriver_script_fn' ||
+                                        prop === '__fxdriver_evaluate' ||
+                                        prop === '__webdriver_unwrapped' ||
+                                        String(prop).startsWith('cdc_') ||
+                                        String(prop).startsWith('$cdc_')) {
+                                        return undefined;
+                                    }
+                                    
+                                    const value = target[prop];
+                                    if (typeof value === 'function') {
+                                        return value.bind(target);
+                                    }
+                                    return value;
+                                },
+                                has(target, prop) {
+                                    if (String(prop).startsWith('cdc_') || 
+                                        String(prop).startsWith('$cdc_') ||
+                                        prop === 'webdriver') {
+                                        return false;
+                                    }
+                                    return prop in target;
+                                }
+                            });
+                        } catch (e) {
+                            // Cross-origin, return as-is
+                            return contentWindow;
+                        }
+                    },
+                    configurable: true,
+                    enumerable: true
+                });
+            }
+        };
+
+        // 3. Patch Error.captureStackTrace to hide automation stack frames
+        const patchErrorCaptureStackTrace = () => {
+            if (Error.captureStackTrace) {
+                const originalCaptureStackTrace = Error.captureStackTrace;
+                
+                Error.captureStackTrace = function(targetObject, constructorOpt) {
+                    originalCaptureStackTrace.call(this, targetObject, constructorOpt);
+                    
+                    // Clean the stack trace of automation markers
+                    if (targetObject.stack) {
+                        const cleanStack = targetObject.stack
+                            .split('\\n')
+                            .filter(line => {
+                                const lowerLine = line.toLowerCase();
+                                return !lowerLine.includes('puppeteer') &&
+                                       !lowerLine.includes('playwright') &&
+                                       !lowerLine.includes('selenium') &&
+                                       !lowerLine.includes('webdriver') &&
+                                       !lowerLine.includes('__puppeteer_evaluation_script__') &&
+                                       !lowerLine.includes('__playwright_evaluation_script__') &&
+                                       !lowerLine.includes('evaluateonNewDocument') &&
+                                       !lowerLine.includes('pptr:') &&
+                                       !lowerLine.includes('devtools://');
+                            })
+                            .join('\\n');
+                        
+                        Object.defineProperty(targetObject, 'stack', {
+                            value: cleanStack,
+                            writable: true,
+                            configurable: true
+                        });
+                    }
+                };
+            }
+        };
+
+        // 4. Override Function constructor to hide sourceURL
+        const protectFunctionConstructor = () => {
+            const OriginalFunction = Function;
+            
+            const FunctionProxy = new Proxy(OriginalFunction, {
+                construct(target, args) {
+                    // Remove sourceURL comments from function body
+                    if (args.length > 0) {
+                        const lastArg = args[args.length - 1];
+                        if (typeof lastArg === 'string') {
+                            args[args.length - 1] = lastArg
+                                .replace(/\\/\\/# sourceURL=[^\\n]*/g, '')
+                                .replace(/\\/\\/# sourceMappingURL=[^\\n]*/g, '')
+                                .replace(/__puppeteer_evaluation_script__/g, 'anonymous')
+                                .replace(/__playwright_evaluation_script__/g, 'anonymous')
+                                .replace(/pptr:[^\\n]*/g, '');
+                        }
+                    }
+                    
+                    return Reflect.construct(target, args);
+                },
+                apply(target, thisArg, args) {
+                    if (args.length > 0) {
+                        const lastArg = args[args.length - 1];
+                        if (typeof lastArg === 'string') {
+                            args[args.length - 1] = lastArg
+                                .replace(/\\/\\/# sourceURL=[^\\n]*/g, '')
+                                .replace(/\\/\\/# sourceMappingURL=[^\\n]*/g, '')
+                                .replace(/__puppeteer_evaluation_script__/g, 'anonymous')
+                                .replace(/__playwright_evaluation_script__/g, 'anonymous');
+                        }
+                    }
+                    
+                    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);
+                },
+                set(target, prop, value) {
+                    // Prevent setting prototype or other frozen properties
+                    if (prop === 'prototype') {
+                        return true; // Silently ignore
+                    }
+                    return Reflect.set(target, prop, value);
+                }
+            });
+            
+            // 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;
+            }
+        };
+
+        // 5. Override eval to hide sourceURL
+        const protectEval = () => {
+            const originalEval = window.eval;
+            
+            window.eval = function(code) {
+                if (typeof code === 'string') {
+                    code = code
+                        .replace(/\\/\\/# sourceURL=[^\\n]*/g, '')
+                        .replace(/\\/\\/# sourceMappingURL=[^\\n]*/g, '')
+                        .replace(/__puppeteer_evaluation_script__/g, 'anonymous')
+                        .replace(/__playwright_evaluation_script__/g, 'anonymous')
+                        .replace(/pptr:[^)\\n]*/g, 'eval');
+                }
+                
+                return originalEval.call(this, code);
+            };
+            
+            // Make eval look native
+            Object.defineProperty(window.eval, 'toString', {
+                value: function() { return 'function eval() { [native code] }'; },
+                configurable: false
+            });
+        };
+
+        // 6. Override document.hasStorageAccess for sandbox detection
+        const protectStorageAccess = () => {
+            if (document.hasStorageAccess) {
+                const originalHasStorageAccess = document.hasStorageAccess;
+                
+                document.hasStorageAccess = function() {
+                    // Always return a promise that resolves to true for same-origin
+                    return Promise.resolve(true);
+                };
+                
+                // Make it look native
+                Object.defineProperty(document.hasStorageAccess, 'toString', {
+                    value: function() { return 'function hasStorageAccess() { [native code] }'; }
+                });
+            }
+            
+            if (document.requestStorageAccess) {
+                document.requestStorageAccess = function() {
+                    return Promise.resolve();
+                };
+            }
+        };
+
+        // 7. Protect window.name from automation markers
+        const protectWindowName = () => {
+            let windowName = window.name;
+            
+            Object.defineProperty(window, 'name', {
+                get() {
+                    // Filter out automation-related markers from window name
+                    if (windowName && typeof windowName === 'string') {
+                        if (windowName.includes('puppeteer') || 
+                            windowName.includes('playwright') ||
+                            windowName.includes('selenium') ||
+                            windowName.includes('webdriver')) {
+                            return '';
+                        }
+                    }
+                    return windowName;
+                },
+                set(value) {
+                    windowName = value;
+                },
+                configurable: true,
+                enumerable: true
+            });
+        };
+
+        // 8. Override Object.getOwnPropertyDescriptor to hide automation properties
+        const protectPropertyDescriptor = () => {
+            const originalGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+            
+            Object.getOwnPropertyDescriptor = function(obj, prop) {
+                // Hide automation-related properties
+                if (obj === navigator && prop === 'webdriver') {
+                    return undefined;
+                }
+                
+                if (typeof prop === 'string' && 
+                    (prop.startsWith('cdc_') || 
+                     prop.startsWith('$cdc_') ||
+                     prop.includes('__webdriver') ||
+                     prop.includes('__selenium') ||
+                     prop.includes('__puppeteer') ||
+                     prop.includes('__playwright'))) {
+                    return undefined;
+                }
+                
+                return originalGetOwnPropertyDescriptor.call(this, obj, prop);
+            };
+        };
+
+        // 9. Override Object.getOwnPropertyNames to hide automation properties
+        const protectPropertyNames = () => {
+            const originalGetOwnPropertyNames = Object.getOwnPropertyNames;
+            
+            Object.getOwnPropertyNames = function(obj) {
+                const names = originalGetOwnPropertyNames.call(this, obj);
+                
+                return names.filter(name => {
+                    const lowerName = name.toLowerCase();
+                    return !name.startsWith('cdc_') &&
+                           !name.startsWith('$cdc_') &&
+                           !lowerName.includes('webdriver') &&
+                           !lowerName.includes('selenium') &&
+                           !lowerName.includes('puppeteer') &&
+                           !lowerName.includes('playwright') &&
+                           !name.startsWith('__driver') &&
+                           !name.startsWith('__selenium') &&
+                           !name.startsWith('__webdriver');
+                });
+            };
+        };
+
+        // 10. Override Object.keys similarly
+        const protectObjectKeys = () => {
+            const originalKeys = Object.keys;
+            
+            Object.keys = function(obj) {
+                const keys = originalKeys.call(this, obj);
+                
+                return keys.filter(key => {
+                    const lowerKey = key.toLowerCase();
+                    return !key.startsWith('cdc_') &&
+                           !key.startsWith('$cdc_') &&
+                           !lowerKey.includes('webdriver') &&
+                           !lowerKey.includes('selenium') &&
+                           !lowerKey.includes('puppeteer');
+                });
+            };
+        };
+
+        // 11. Protect against Reflect.ownKeys detection
+        const protectReflectOwnKeys = () => {
+            const originalOwnKeys = Reflect.ownKeys;
+            
+            Reflect.ownKeys = function(obj) {
+                const keys = originalOwnKeys.call(this, obj);
+                
+                return keys.filter(key => {
+                    const keyStr = String(key).toLowerCase();
+                    return !keyStr.startsWith('cdc_') &&
+                           !keyStr.startsWith('$cdc_') &&
+                           !keyStr.includes('webdriver') &&
+                           !keyStr.includes('selenium') &&
+                           !keyStr.includes('puppeteer');
+                });
+            };
+        };
+
+        // 12. Protect navigator.permissions.query for automation detection
+        const protectPermissionsQuery = () => {
+            if (navigator.permissions && navigator.permissions.query) {
+                const originalQuery = navigator.permissions.query;
+                
+                navigator.permissions.query = function(descriptor) {
+                    // Handle notifications permission specifically
+                    if (descriptor && descriptor.name === 'notifications') {
+                        return Promise.resolve({
+                            state: 'prompt',
+                            name: 'notifications',
+                            onchange: null,
+                            addEventListener: () => {},
+                            removeEventListener: () => {},
+                            dispatchEvent: () => true
+                        });
+                    }
+                    
+                    return originalQuery.apply(this, arguments);
+                };
+            }
+        };
+
+        // 13. Protect MediaSession API
+        const protectMediaSession = () => {
+            if (navigator.mediaSession) {
+                // Ensure mediaSession appears properly configured
+                try {
+                    Object.defineProperty(navigator.mediaSession, 'playbackState', {
+                        get: () => 'none',
+                        configurable: true
+                    });
+                } catch (e) {}
+            }
+        };
+
+        // 14. Protect against CDP Runtime detection via timing
+        const protectRuntimeTiming = () => {
+            // Detect CDP calls that happen synchronously
+            const originalDateNow = Date.now;
+            let lastCallTime = 0;
+            
+            Date.now = function() {
+                const now = originalDateNow.call(this);
+                
+                // Ensure minimum 1ms between calls to appear human
+                if (now - lastCallTime < 1) {
+                    lastCallTime = now + 1;
+                    return lastCallTime;
+                }
+                
+                lastCallTime = now;
+                return now;
+            };
+        };
+
+        // 15. Clean up any existing automation markers in the DOM
+        const cleanDOMAutomationMarkers = () => {
+            // Remove data attributes that might indicate automation
+            const elements = document.querySelectorAll('[data-webdriver], [data-selenium], [data-puppeteer]');
+            elements.forEach(el => {
+                el.removeAttribute('data-webdriver');
+                el.removeAttribute('data-selenium');
+                el.removeAttribute('data-puppeteer');
+            });
+            
+            // Clean script tags with automation-related src
+            const scripts = document.querySelectorAll('script');
+            scripts.forEach(script => {
+                if (script.src && (
+                    script.src.includes('puppeteer') ||
+                    script.src.includes('playwright') ||
+                    script.src.includes('selenium')
+                )) {
+                    script.remove();
+                }
+            });
+        };
+
+        // Initialize all protections
+        try {
+            removeAutomationProperties();
+            protectIframeContentWindow();
+            patchErrorCaptureStackTrace();
+            protectFunctionConstructor();
+            protectEval();
+            protectStorageAccess();
+            protectWindowName();
+            protectPropertyDescriptor();
+            protectPropertyNames();
+            protectObjectKeys();
+            protectReflectOwnKeys();
+            protectPermissionsQuery();
+            protectMediaSession();
+            protectRuntimeTiming();
+            
+            // Clean DOM after a short delay to catch dynamically added elements
+            if (document.readyState === 'loading') {
+                document.addEventListener('DOMContentLoaded', cleanDOMAutomationMarkers);
+            } else {
+                cleanDOMAutomationMarkers();
+            }
+        } catch (e) {
+            console.error('[CDP-DETECTION-BYPASS] Failed to apply CDP detection 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 CDP detection bypass...');
+        bypassCDPDetection();
+        console.log(DEBUG_PREFIX, '✓ CDP detection bypass applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply CDP detection bypass:', e);
+        throw e;
+    }
+})();`;
+};
+//# sourceMappingURL=cdp-detection-bypass.js.map

package/dist/fingerprinting/fingerprint-overrides/cdp-detection-bypass.js.map

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

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

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

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

@@ -90,7 +90,17 @@ export const createClientRectSpoofingScript = () => {
         }
     };
     
-    spoofClientRects();
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    try {
+        console.log(DEBUG_PREFIX, 'Starting client rect spoofing...');
+        spoofClientRects();
+        console.log(DEBUG_PREFIX, '✓ Client rect spoofing applied');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply client rect spoofing:', e);
+        throw e;
+    }
 })();`;
 };
 //# sourceMappingURL=client-rect-spoofing.js.map

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

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

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