jumpy-lion 0.1.1 → 0.1.2

package/dist/fingerprinting/fingerprint-overrides/stealth-script.js

@@ -0,0 +1,925 @@
+/**
+ * Base stealth script for hiding automation indicators
+ * Includes error stack hiding, console patching, and automation flags removal
+ *
+ * 2024-2025 Enhancements:
+ * - deviceMemory spoofing
+ * - pdfViewerEnabled consistency
+ * - Notification.permission handling
+ * - Bluetooth/USB/Serial API masking
+ * - Speech synthesis voice spoofing
+ * - Credentials API consistency
+ */
+export const createStealthScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // Enhanced stealth script for 2025 - December
+    
+    // Helper functions
+    const wrapNative = (fnName) => {
+        const nativeCode = 'function ' + fnName + '() { [native code] }';
+        return new Proxy(function() {}, {
+            get(target, prop) {
+                if (prop === 'toString') {
+                    return () => nativeCode;
+                }
+                return Reflect.get(target, prop);
+            },
+            apply(target, thisArg, args) {
+                return undefined;
+            }
+        });
+    };
+    
+    // Generate consistent session seed for stable values
+    const generateSessionSeed = () => {
+        const ua = navigator.userAgent || '';
+        const screen = window.screen;
+        const seed = ua.length + (screen.width || 0) + (screen.height || 0);
+        return seed;
+    };
+    
+    const sessionSeed = generateSessionSeed();
+    
+    // Helper to safely define property with guards
+    const safeDefineProperty = (obj, prop, descriptor) => {
+        try {
+            const existing = Object.getOwnPropertyDescriptor(obj, prop);
+            if (existing && existing.configurable === false) {
+                return false; // Cannot redefine
+            }
+            // Always use configurable: true to allow other scripts to modify
+            Object.defineProperty(obj, prop, {
+                ...descriptor,
+                configurable: true
+            });
+            return true;
+        } catch (e) {
+            return false;
+        }
+    };
+    
+    // Helper to safely define getter property
+    const safeDefineGetter = (obj, prop, getter, enumerable = true) => {
+        return safeDefineProperty(obj, prop, {
+            get: getter,
+            enumerable: enumerable
+        });
+    };
+
+    // 1. Error Stack Hiding
+    // NOTE: Removed - this was returning a HARDCODED fake stack for ALL errors
+    // (chrome-extension://invalid/0.js) with configurable:false, which blocked
+    // runtime-enable-bypass.ts from applying proper stack sanitization.
+    // Stack trace protection is now handled by runtime-enable-bypass.ts.
+    const hideErrorStack = () => {};
+
+    // 2. Console Patching
+    // NOTE: Removed - wrapping ALL console methods in double-Proxy is detectable
+    // and conflicts with runtime-enable-bypass.ts which handles the actual
+    // detection vector (console.debug Error serialization) surgically.
+    const patchConsole = () => {};
+
+    // 3. WebDriver and Automation Flags Removal (2025)
+    const removeAutomationFlags = () => {
+        // Remove webdriver (with guard)
+        if (navigator.webdriver) {
+            safeDefineGetter(navigator, 'webdriver', () => undefined, false);
+        }
+
+        // Remove automation indicators
+        const automationProperties = [
+            'webdriver', '_Selenium_IDE_Recorder', '_selenium', 'callSelenium',
+            '_WEBDRIVER_ELEM_CACHE', '__webdriver_script_fn', '__driver_evaluate',
+            '__webdriver_evaluate', '__selenium_evaluate', '__fxdriver_evaluate',
+            '__driver_unwrapped', '__webdriver_unwrapped', '__selenium_unwrapped',
+            '__fxdriver_unwrapped', '__webdriver_scripts_executed',
+            '__webdriver_script_func', '__webdriver_script_function',
+            '$cdc_asdjflasutopfhvcZLmcfl_', '$chrome_asyncScriptInfo',
+            '__$webdriverAsyncExecutor', '__lastWatirAlert', '__lastWatirConfirm',
+            '__lastWatirPrompt', '_WEBDRIVER_ELEM_CACHE', 'ChromeDriverw',
+            'driver-evaluate', 'webdriver-evaluate', 'selenium-evaluate',
+            'webdriverCommand', 'webdriver-evaluate-response'
+        ];
+
+        automationProperties.forEach(prop => {
+            try {
+                delete window[prop];
+                delete document[prop];
+                delete navigator[prop];
+            } catch (e) {}
+        });
+
+        // Ensure window.chrome exists (handled more fully by spoofChromeRuntime)
+        // NOTE: Removed stack-trace-based chrome getter that created new Error()
+        // on every access - expensive and broken since stack sanitization removes
+        // the markers it checked for.
+    };
+
+    // 4. CDP Runtime.enable Detection Prevention
+    // NOTE: Removed entirely. This was:
+    // - Blocking ALL Object.defineProperty(*, 'stack', ...) calls (broke our own code)
+    // - Replacing Error constructor with Proxy returning hardcoded fake stacks
+    // Both are handled properly by runtime-enable-bypass.ts with surgical stack sanitization.
+    const preventRuntimeEnableDetection = () => {};
+
+    // 5. Plugin and MimeType Spoofing (2025)
+    const spoofPlugins = () => {
+        // Chrome 120+ only reports PDF-related plugins
+        // Native Client was removed in Chrome 76 (2019)
+        const pluginData = [
+            {
+                name: 'PDF Viewer',
+                filename: 'internal-pdf-viewer',
+                description: 'Portable Document Format'
+            },
+            {
+                name: 'Chrome PDF Viewer',
+                filename: 'internal-pdf-viewer',
+                description: 'Portable Document Format'
+            },
+            {
+                name: 'Chromium PDF Viewer',
+                filename: 'internal-pdf-viewer',
+                description: 'Portable Document Format'
+            },
+            {
+                name: 'Microsoft Edge PDF Viewer',
+                filename: 'internal-pdf-viewer',
+                description: 'Portable Document Format'
+            },
+            {
+                name: 'WebKit built-in PDF',
+                filename: 'internal-pdf-viewer',
+                description: 'Portable Document Format'
+            }
+        ];
+
+        const mimeData = [
+            {
+                type: 'application/pdf',
+                suffixes: 'pdf',
+                description: 'Portable Document Format'
+            },
+            {
+                type: 'text/pdf',
+                suffixes: 'pdf',
+                description: 'Portable Document Format'
+            }
+        ];
+
+        // Create fake plugins using Object.defineProperty for read-only properties
+        const fakePlugins = pluginData.map((p, index) => {
+            const plugin = Object.create(Plugin.prototype);
+            Object.defineProperty(plugin, 'name', { value: p.name, writable: false, enumerable: true });
+            Object.defineProperty(plugin, 'filename', { value: p.filename, writable: false, enumerable: true });
+            Object.defineProperty(plugin, 'description', { value: p.description, writable: false, enumerable: true });
+            Object.defineProperty(plugin, 'length', { value: 1, writable: false, enumerable: true });
+            plugin[0] = mimeData[index] || mimeData[0];
+            return plugin;
+        });
+
+        // Create fake mimeTypes using Object.defineProperty for read-only properties
+        const fakeMimeTypes = mimeData.map((m, index) => {
+            const mimeType = Object.create(MimeType.prototype);
+            Object.defineProperty(mimeType, 'type', { value: m.type, writable: false, enumerable: true });
+            Object.defineProperty(mimeType, 'suffixes', { value: m.suffixes, writable: false, enumerable: true });
+            Object.defineProperty(mimeType, 'description', { value: m.description, writable: false, enumerable: true });
+            Object.defineProperty(mimeType, 'enabledPlugin', { value: fakePlugins[0], writable: false, enumerable: true });
+            return mimeType;
+        });
+
+        // Override navigator.plugins (with guard)
+        try {
+            const pluginsGetter = () => {
+                const arr = Object.create(PluginArray.prototype);
+                fakePlugins.forEach((p, i) => {
+                    arr[i] = p;
+                    arr[p.name] = p;
+                });
+                // Use Object.defineProperty for read-only properties
+                Object.defineProperty(arr, 'length', { value: fakePlugins.length, writable: false, enumerable: true });
+                Object.defineProperty(arr, 'item', { value: (index) => arr[index] || null, writable: false, enumerable: false });
+                Object.defineProperty(arr, 'namedItem', { value: (name) => arr[name] || null, writable: false, enumerable: false });
+                Object.defineProperty(arr, 'refresh', { value: () => {}, writable: false, enumerable: false });
+                return arr;
+            };
+            safeDefineGetter(navigator, 'plugins', pluginsGetter);
+
+            // Override navigator.mimeTypes (with guard)
+            const mimeTypesGetter = () => {
+                const arr = Object.create(MimeTypeArray.prototype);
+                fakeMimeTypes.forEach((m, i) => {
+                    arr[i] = m;
+                    arr[m.type] = m;
+                });
+                // Use Object.defineProperty for read-only properties
+                Object.defineProperty(arr, 'length', { value: fakeMimeTypes.length, writable: false, enumerable: true });
+                Object.defineProperty(arr, 'item', { value: (index) => arr[index] || null, writable: false, enumerable: false });
+                Object.defineProperty(arr, 'namedItem', { value: (name) => arr[name] || null, writable: false, enumerable: false });
+                return arr;
+            };
+            safeDefineGetter(navigator, 'mimeTypes', mimeTypesGetter);
+        } catch (e) {}
+    };
+
+    // 6. Permission API Spoofing (2025) - Fixed to return consistent Promise identity
+    const spoofPermissions = () => {
+        if (!navigator.permissions) return;
+
+        const promiseCache = new Map();
+        const originalQuery = navigator.permissions.query;
+        
+        navigator.permissions.query = function(descriptor) {
+            // Common permissions that should be granted for a normal user
+            const allowedPermissions = ['geolocation', 'notifications', 'camera', 'microphone'];
+            
+            if (descriptor && allowedPermissions.includes(descriptor.name)) {
+                // Return the same Promise instance for identical queries (Datadome checks this)
+                const key = JSON.stringify(descriptor);
+                if (promiseCache.has(key)) {
+                    return promiseCache.get(key);
+                }
+                
+                const promise = Promise.resolve({
+                    state: 'prompt',
+                    onchange: null,
+                    addEventListener: () => {},
+                    removeEventListener: () => {},
+                    dispatchEvent: () => true
+                });
+                
+                promiseCache.set(key, promise);
+                return promise;
+            }
+            
+            return originalQuery.apply(this, arguments);
+        };
+    };
+
+    // 7. Battery API Spoofing (2025)
+    const spoofBatteryAPI = () => {
+        if ('getBattery' in navigator) {
+            // Use session seed for deterministic battery level
+            const batteryLevel = 0.92 + ((sessionSeed % 80) / 1000); // 0.92-0.999
+            navigator.getBattery = async () => {
+                return {
+                    charging: true,
+                    chargingTime: 0,
+                    dischargingTime: Infinity,
+                    level: batteryLevel,
+                    onchargingchange: null,
+                    onchargingtimechange: null,
+                    ondischargingtimechange: null,
+                    onlevelchange: null,
+                    addEventListener: () => {},
+                    removeEventListener: () => {},
+                    dispatchEvent: () => true
+                };
+            };
+        }
+    };
+
+    // 8. Connection API Spoofing (2025)
+    const spoofConnectionAPI = () => {
+        if ('connection' in navigator || 'mozConnection' in navigator || 'webkitConnection' in navigator) {
+            const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+            if (connection) {
+                try {
+                    Object.defineProperty(connection, 'rtt', { value: 50, writable: false });
+                    Object.defineProperty(connection, 'downlink', { value: 10.0, writable: false });
+                    Object.defineProperty(connection, 'effectiveType', { value: '4g', writable: false });
+                    Object.defineProperty(connection, 'saveData', { value: false, writable: false });
+                } catch (e) {}
+            }
+        }
+    };
+
+    // 9. Chrome Runtime API Spoofing (2025) - NEW
+    const spoofChromeRuntime = () => {
+        if (!window.chrome?.runtime) {
+            const runtime = {
+                PlatformOs: { MAC: 'mac', WIN: 'win', ANDROID: 'android', CROS: 'cros', LINUX: 'linux', OPENBSD: 'openbsd' },
+                PlatformArch: { ARM: 'arm', ARM64: 'arm64', MIPS: 'mips', MIPS64: 'mips64', X86_32: 'x86-32', X86_64: 'x86-64' },
+                PlatformNaclArch: { ARM: 'arm', MIPS: 'mips', MIPS64: 'mips64', X86_32: 'x86-32', X86_64: 'x86-64' },
+                RequestUpdateCheckStatus: { THROTTLED: 'throttled', NO_UPDATE: 'no_update', UPDATE_AVAILABLE: 'update_available' },
+                OnInstalledReason: { INSTALL: 'install', UPDATE: 'update', CHROME_UPDATE: 'chrome_update', SHARED_MODULE_UPDATE: 'shared_module_update' },
+                OnRestartRequiredReason: { APP_UPDATE: 'app_update', OS_UPDATE: 'os_update', PERIODIC: 'periodic' },
+                getManifest: () => ({}),
+                // Real Chrome extension IDs are 32 lowercase alpha chars (a-p, base16 with a-p)
+                id: undefined,
+                connect: () => ({
+                    name: '',
+                    disconnect: () => {},
+                    onDisconnect: { addListener: () => {}, removeListener: () => {} },
+                    onMessage: { addListener: () => {}, removeListener: () => {} },
+                    postMessage: () => {}
+                }),
+                sendMessage: () => {},
+                getURL: (path) => '',
+                onConnect: { addListener: () => {}, removeListener: () => {} },
+                onMessage: { addListener: () => {}, removeListener: () => {} },
+                onStartup: { addListener: () => {}, removeListener: () => {} },
+                onInstalled: { addListener: () => {}, removeListener: () => {} },
+                onSuspend: { addListener: () => {}, removeListener: () => {} },
+                onSuspendCanceled: { addListener: () => {}, removeListener: () => {} },
+                onUpdateAvailable: { addListener: () => {}, removeListener: () => {} },
+                onBrowserUpdateAvailable: { addListener: () => {}, removeListener: () => {} },
+                onRestartRequired: { addListener: () => {}, removeListener: () => {} },
+                openOptionsPage: () => {},
+                setUninstallURL: () => {},
+                reload: () => {},
+                requestUpdateCheck: () => Promise.resolve(['no_update', {}]),
+                restart: () => {},
+                restartAfterDelay: () => {},
+                getPlatformInfo: () => Promise.resolve({ 
+                    os: 'win', 
+                    arch: 'x86-64', 
+                    nacl_arch: 'x86-64' 
+                }),
+                getPackageDirectoryEntry: () => Promise.resolve({}),
+                lastError: null
+            };
+            
+            if (!window.chrome) window.chrome = {};
+            safeDefineProperty(window.chrome, 'runtime', { 
+                value: runtime, 
+                enumerable: true,
+                writable: false
+            });
+        }
+    };
+
+    // 10. Device Memory Spoofing (2024-2025)
+    const spoofDeviceMemory = () => {
+        const platform = navigator.platform || 'Win32';
+        
+        // Platform-appropriate device memory values
+        const memoryConfig = {
+            'Win32': [4, 8, 16], // Most Windows PCs have 4-16GB
+            'MacIntel': [8, 16], // Macs typically have 8-16GB
+            'Linux x86_64': [4, 8, 16]
+        };
+        
+        const memories = memoryConfig[platform] || memoryConfig['Win32'];
+        // Use session seed for consistency
+        const selectedMemory = memories[sessionSeed % memories.length];
+        
+        // Use guard to avoid conflicts with other scripts
+        if ('deviceMemory' in navigator) {
+            safeDefineGetter(navigator, 'deviceMemory', () => selectedMemory);
+        }
+    };
+
+    // 11. PDF Viewer Enabled Spoofing (2024-2025)
+    const spoofPdfViewerEnabled = () => {
+        // Chrome always has PDF viewer enabled (use guard)
+        safeDefineGetter(navigator, 'pdfViewerEnabled', () => true);
+    };
+
+    // 12. Notification Permission Spoofing (2024-2025)
+    const spoofNotificationPermission = () => {
+        if ('Notification' in window) {
+            // Override the permission property to return 'default' (user hasn't been asked) - with guard
+            safeDefineGetter(Notification, 'permission', () => 'default');
+            
+            // Override requestPermission to behave normally
+            const originalRequestPermission = Notification.requestPermission;
+            Notification.requestPermission = function(callback) {
+                // Return a promise that resolves to 'default' or 'denied'
+                const result = Promise.resolve('default');
+                if (callback && typeof callback === 'function') {
+                    result.then(callback);
+                }
+                return result;
+            };
+        }
+    };
+
+    // 13. Bluetooth API Spoofing (2024-2025)
+    const spoofBluetoothAPI = () => {
+        if ('bluetooth' in navigator) {
+            // Make bluetooth appear available but return empty results
+            const fakeBluetooth = {
+                getAvailability: () => Promise.resolve(true),
+                requestDevice: () => Promise.reject(new DOMException('User cancelled the requestDevice() chooser.', 'NotFoundError')),
+                getDevices: () => Promise.resolve([]),
+                addEventListener: () => {},
+                removeEventListener: () => {},
+                dispatchEvent: () => true
+            };
+            
+            safeDefineGetter(navigator, 'bluetooth', () => fakeBluetooth);
+        }
+    };
+
+    // 14. USB API Spoofing (2024-2025)
+    const spoofUSBAPI = () => {
+        if ('usb' in navigator) {
+            const fakeUSB = {
+                getDevices: () => Promise.resolve([]),
+                requestDevice: () => Promise.reject(new DOMException('No device selected.', 'NotFoundError')),
+                addEventListener: () => {},
+                removeEventListener: () => {},
+                dispatchEvent: () => true,
+                onconnect: null,
+                ondisconnect: null
+            };
+            
+            safeDefineGetter(navigator, 'usb', () => fakeUSB);
+        }
+    };
+
+    // 15. Serial API Spoofing (2024-2025)
+    const spoofSerialAPI = () => {
+        if ('serial' in navigator) {
+            const fakeSerial = {
+                getPorts: () => Promise.resolve([]),
+                requestPort: () => Promise.reject(new DOMException('No port selected.', 'NotFoundError')),
+                addEventListener: () => {},
+                removeEventListener: () => {},
+                dispatchEvent: () => true,
+                onconnect: null,
+                ondisconnect: null
+            };
+            
+            safeDefineGetter(navigator, 'serial', () => fakeSerial);
+        }
+    };
+
+    // 16. Speech Synthesis Voices Spoofing (2024-2025)
+    const spoofSpeechSynthesis = () => {
+        if ('speechSynthesis' in window) {
+            const platform = navigator.platform || 'Win32';
+            
+            // Platform-specific voices
+            const voiceConfigs = {
+                'Win32': [
+                    { name: 'Microsoft David - English (United States)', lang: 'en-US', localService: true, default: true },
+                    { name: 'Microsoft Zira - English (United States)', lang: 'en-US', localService: true, default: false },
+                    { name: 'Microsoft Mark - English (United States)', lang: 'en-US', localService: true, default: false },
+                    { name: 'Google US English', lang: 'en-US', localService: false, default: false },
+                    { name: 'Google UK English Female', lang: 'en-GB', localService: false, default: false },
+                    { name: 'Google UK English Male', lang: 'en-GB', localService: false, default: false }
+                ],
+                'MacIntel': [
+                    { name: 'Alex', lang: 'en-US', localService: true, default: true },
+                    { name: 'Samantha', lang: 'en-US', localService: true, default: false },
+                    { name: 'Daniel', lang: 'en-GB', localService: true, default: false },
+                    { name: 'Google US English', lang: 'en-US', localService: false, default: false }
+                ],
+                'Linux x86_64': [
+                    { name: 'Google US English', lang: 'en-US', localService: false, default: true },
+                    { name: 'Google UK English Female', lang: 'en-GB', localService: false, default: false }
+                ]
+            };
+            
+            const voices = voiceConfigs[platform] || voiceConfigs['Win32'];
+            
+            // Create SpeechSynthesisVoice-like objects
+            const fakeVoices = voices.map(v => ({
+                voiceURI: v.name,
+                name: v.name,
+                lang: v.lang,
+                localService: v.localService,
+                default: v.default
+            }));
+            
+            // Override getVoices
+            const originalGetVoices = speechSynthesis.getVoices;
+            speechSynthesis.getVoices = function() {
+                // Return our platform-appropriate voices
+                return fakeVoices;
+            };
+            
+            // Trigger voiceschanged event after a delay to simulate loading
+            setTimeout(() => {
+                try {
+                    const event = new Event('voiceschanged');
+                    speechSynthesis.dispatchEvent(event);
+                } catch (e) {}
+            }, 100);
+        }
+    };
+
+    // 17. Credentials API Spoofing (2024-2025)
+    const spoofCredentialsAPI = () => {
+        if ('credentials' in navigator) {
+            const originalGet = navigator.credentials.get;
+            const originalCreate = navigator.credentials.create;
+            const originalStore = navigator.credentials.store;
+            
+            // Make credentials API behave like a normal browser
+            navigator.credentials.get = function(options) {
+                // For publicKey (WebAuthn), reject like a normal user cancellation
+                if (options && options.publicKey) {
+                    return Promise.reject(new DOMException(
+                        'The operation either timed out or was not allowed.',
+                        'NotAllowedError'
+                    ));
+                }
+                // For password credentials, return null (no saved credentials)
+                return Promise.resolve(null);
+            };
+            
+            navigator.credentials.create = function(options) {
+                if (options && options.publicKey) {
+                    return Promise.reject(new DOMException(
+                        'The operation either timed out or was not allowed.',
+                        'NotAllowedError'
+                    ));
+                }
+                return originalCreate.apply(this, arguments);
+            };
+            
+            navigator.credentials.store = function(credential) {
+                // Accept but don't actually store
+                return Promise.resolve(credential);
+            };
+        }
+    };
+
+    // 18. HID API Spoofing (2024-2025)
+    const spoofHIDAPI = () => {
+        if ('hid' in navigator) {
+            const fakeHID = {
+                getDevices: () => Promise.resolve([]),
+                requestDevice: () => Promise.reject(new DOMException('No device selected.', 'NotFoundError')),
+                addEventListener: () => {},
+                removeEventListener: () => {},
+                dispatchEvent: () => true,
+                onconnect: null,
+                ondisconnect: null
+            };
+            
+            safeDefineGetter(navigator, 'hid', () => fakeHID);
+        }
+    };
+
+    // 19. Gamepad API Spoofing (2024-2025)
+    const spoofGamepadAPI = () => {
+        // Return empty array for getGamepads
+        const originalGetGamepads = navigator.getGamepads;
+        if (originalGetGamepads) {
+            navigator.getGamepads = function() {
+                // Return empty array like no gamepads connected
+                return [];
+            };
+        }
+    };
+
+    // 20. Clipboard API Protection (2024-2025)
+    const spoofClipboardAPI = () => {
+        if (navigator.clipboard) {
+            const originalReadText = navigator.clipboard.readText;
+            const originalRead = navigator.clipboard.read;
+            
+            // Make clipboard read behave like permission not granted
+            navigator.clipboard.readText = function() {
+                return Promise.reject(new DOMException(
+                    'Read permission denied.',
+                    'NotAllowedError'
+                ));
+            };
+            
+            navigator.clipboard.read = function() {
+                return Promise.reject(new DOMException(
+                    'Read permission denied.',
+                    'NotAllowedError'
+                ));
+            };
+        }
+    };
+
+    // 21. Do Not Track Spoofing (2024-2025)
+    const spoofDoNotTrack = () => {
+        // Most real users have DNT disabled or not set
+        safeDefineGetter(navigator, 'doNotTrack', () => null);
+    };
+
+    // 22. Global Privacy Control Spoofing (2024-2025)
+    const spoofGlobalPrivacyControl = () => {
+        // Most users don't have GPC enabled
+        safeDefineGetter(navigator, 'globalPrivacyControl', () => false);
+    };
+
+    // 23. Keyboard API Spoofing (2024-2025) - DataDome checks getLayoutMap()
+    const spoofKeyboardAPI = () => {
+        // Full US QWERTY keyboard layout map
+        const qwertyLayoutMap = new Map([
+            ['Backquote', '\`'], ['Digit1', '1'], ['Digit2', '2'], ['Digit3', '3'],
+            ['Digit4', '4'], ['Digit5', '5'], ['Digit6', '6'], ['Digit7', '7'],
+            ['Digit8', '8'], ['Digit9', '9'], ['Digit0', '0'], ['Minus', '-'],
+            ['Equal', '='], ['Backspace', ''], ['Tab', ''], ['KeyQ', 'q'],
+            ['KeyW', 'w'], ['KeyE', 'e'], ['KeyR', 'r'], ['KeyT', 't'],
+            ['KeyY', 'y'], ['KeyU', 'u'], ['KeyI', 'i'], ['KeyO', 'o'],
+            ['KeyP', 'p'], ['BracketLeft', '['], ['BracketRight', ']'],
+            ['Backslash', '\\\\'], ['CapsLock', ''], ['KeyA', 'a'], ['KeyS', 's'],
+            ['KeyD', 'd'], ['KeyF', 'f'], ['KeyG', 'g'], ['KeyH', 'h'],
+            ['KeyJ', 'j'], ['KeyK', 'k'], ['KeyL', 'l'], ['Semicolon', ';'],
+            ['Quote', "'"], ['Enter', ''], ['ShiftLeft', ''], ['KeyZ', 'z'],
+            ['KeyX', 'x'], ['KeyC', 'c'], ['KeyV', 'v'], ['KeyB', 'b'],
+            ['KeyN', 'n'], ['KeyM', 'm'], ['Comma', ','], ['Period', '.'],
+            ['Slash', '/'], ['ShiftRight', ''], ['ControlLeft', ''],
+            ['AltLeft', ''], ['Space', ' '], ['AltRight', ''], ['ControlRight', ''],
+            ['ArrowLeft', ''], ['ArrowUp', ''], ['ArrowDown', ''], ['ArrowRight', ''],
+            ['NumpadDivide', '/'], ['NumpadMultiply', '*'], ['NumpadSubtract', '-'],
+            ['Numpad7', '7'], ['Numpad8', '8'], ['Numpad9', '9'], ['NumpadAdd', '+'],
+            ['Numpad4', '4'], ['Numpad5', '5'], ['Numpad6', '6'], ['Numpad1', '1'],
+            ['Numpad2', '2'], ['Numpad3', '3'], ['NumpadEnter', ''], ['Numpad0', '0'],
+            ['NumpadDecimal', '.']
+        ]);
+        
+        // Create a KeyboardLayoutMap-like object
+        const createLayoutMap = () => {
+            const map = {
+                entries: function* () { yield* qwertyLayoutMap.entries(); },
+                keys: function* () { yield* qwertyLayoutMap.keys(); },
+                values: function* () { yield* qwertyLayoutMap.values(); },
+                forEach: (callback) => qwertyLayoutMap.forEach(callback),
+                get: (key) => qwertyLayoutMap.get(key),
+                has: (key) => qwertyLayoutMap.has(key),
+                size: qwertyLayoutMap.size,
+                [Symbol.iterator]: function* () { yield* qwertyLayoutMap.entries(); }
+            };
+            
+            // Make it look like a KeyboardLayoutMap
+            Object.defineProperty(map, Symbol.toStringTag, {
+                value: 'KeyboardLayoutMap',
+                configurable: true
+            });
+            
+            return map;
+        };
+        
+        // Cache the layout map promise for consistency (DataDome may check promise identity)
+        let cachedLayoutMapPromise = null;
+        
+        const fakeKeyboard = {
+            getLayoutMap: function() {
+                if (!cachedLayoutMapPromise) {
+                    cachedLayoutMapPromise = Promise.resolve(createLayoutMap());
+                }
+                return cachedLayoutMapPromise;
+            },
+            lock: function() { return Promise.resolve(); },
+            unlock: function() {}
+        };
+        
+        // Register with stealth utils for centralized toString masking
+        const _s = typeof __stealth !== 'undefined' ? __stealth : {};
+        if (_s.utils) {
+            _s.utils.registerNativeFunction(fakeKeyboard.getLayoutMap, 'getLayoutMap');
+            _s.utils.registerNativeFunction(fakeKeyboard.lock, 'lock');
+            _s.utils.registerNativeFunction(fakeKeyboard.unlock, 'unlock');
+        }
+
+        safeDefineGetter(navigator, 'keyboard', () => fakeKeyboard);
+    };
+
+    // 24. MediaDevices API Spoofing
+    // NOTE: Removed - webrtc-spoofing.ts handles enumerateDevices with
+    // realistic hex device IDs. Having two overrides creates detectable
+    // double-wrapping and inconsistent device ID formats.
+    const spoofMediaDevicesAPI = () => {};
+
+    // 25. ServiceWorker API Protection (2024-2025) - DataDome checks ready/register
+    const spoofServiceWorkerAPI = () => {
+        if (!navigator.serviceWorker) return;
+        
+        const sw = navigator.serviceWorker;
+        
+        // Wrap register to work normally but look native
+        const originalRegister = sw.register;
+        if (originalRegister) {
+            sw.register = function(scriptURL, options) {
+                return originalRegister.apply(this, arguments);
+            };
+
+            const _s2 = typeof __stealth !== 'undefined' ? __stealth : {};
+            if (_s2.utils) _s2.utils.registerNativeFunction(sw.register, 'register');
+        }
+        
+        // Ensure ready returns a proper promise
+        // Note: ready is a getter, we shouldn't override it as it's already a promise
+    };
+
+    // 26. Undefined Navigator Properties (2024-2025) - DataDome checks these
+    const spoofUndefinedNavigatorProps = () => {
+        // navigator.brave - Only present in Brave browser, must be undefined for Chrome
+        safeDefineGetter(navigator, 'brave', () => undefined);
+        
+        // navigator.buildID - Firefox-specific, undefined for Chrome
+        safeDefineGetter(navigator, 'buildID', () => undefined);
+        
+        // navigator.contacts - Not widely supported, should be undefined
+        safeDefineGetter(navigator, 'contacts', () => undefined);
+        
+        // navigator.cookieDeprecationLabel - Chrome 120+ API, undefined in most cases
+        safeDefineGetter(navigator, 'cookieDeprecationLabel', () => undefined);
+        
+        // navigator.loadPurpose - Should be undefined
+        safeDefineGetter(navigator, 'loadPurpose', () => undefined);
+    };
+
+    // 27. Worker Constructor Protection - Prevent fingerprint leakage in worker contexts
+    const protectWorkerConstructor = () => {
+        if (typeof Worker === 'undefined') return;
+        
+        // Cache fingerprint values to inject into workers
+        const fingerprintValues = {
+            userAgent: navigator.userAgent,
+            platform: navigator.platform,
+            vendor: navigator.vendor || '',
+            language: navigator.language,
+            languages: JSON.stringify(navigator.languages || ['en-US']),
+            hardwareConcurrency: navigator.hardwareConcurrency || 8,
+            deviceMemory: navigator.deviceMemory || 8,
+        };
+        
+        // Create the worker override script
+        const workerOverrideScript = \`
+            // Worker fingerprint consistency overrides
+            (function() {
+                const fingerprintValues = \${JSON.stringify(fingerprintValues)};
+                
+                // Override navigator properties in worker context
+                if (typeof WorkerNavigator !== 'undefined' && self.navigator) {
+                    try {
+                        Object.defineProperty(self.navigator, 'userAgent', { get: () => fingerprintValues.userAgent });
+                        Object.defineProperty(self.navigator, 'platform', { get: () => fingerprintValues.platform });
+                        Object.defineProperty(self.navigator, 'vendor', { get: () => fingerprintValues.vendor });
+                        Object.defineProperty(self.navigator, 'language', { get: () => fingerprintValues.language });
+                        Object.defineProperty(self.navigator, 'languages', { get: () => JSON.parse(fingerprintValues.languages) });
+                        Object.defineProperty(self.navigator, 'hardwareConcurrency', { get: () => fingerprintValues.hardwareConcurrency });
+                        Object.defineProperty(self.navigator, 'deviceMemory', { get: () => fingerprintValues.deviceMemory });
+                    } catch (e) {}
+                }
+            })();
+        \`;
+        
+        const OriginalWorker = Worker;
+        
+        window.Worker = function(scriptURL, options) {
+            // For blob URLs, we can try to prepend our overrides
+            if (typeof scriptURL === 'string' && scriptURL.startsWith('blob:')) {
+                // Can't modify blob URLs easily, but the worker will still get our overrides
+                // if it was created from same-origin code
+            }
+            
+            // Create the worker normally
+            const worker = new OriginalWorker(scriptURL, options);
+            
+            // Intercept postMessage to detect fingerprint requests
+            const originalPostMessage = worker.postMessage.bind(worker);
+            worker.postMessage = function(message, transfer) {
+                return originalPostMessage(message, transfer);
+            };
+            
+            return worker;
+        };
+        
+        // Copy static properties
+        window.Worker.prototype = OriginalWorker.prototype;
+        
+        Object.defineProperty(window.Worker, 'name', { value: 'Worker', configurable: true });
+        const _s3 = typeof __stealth !== 'undefined' ? __stealth : {};
+        if (_s3.utils) _s3.utils.registerNativeFunction(window.Worker, 'Worker');
+    };
+
+    // 28. SharedWorker Protection - Similar to Worker
+    const protectSharedWorkerConstructor = () => {
+        if (typeof SharedWorker === 'undefined') return;
+        
+        const OriginalSharedWorker = SharedWorker;
+        
+        window.SharedWorker = function(scriptURL, options) {
+            const worker = new OriginalSharedWorker(scriptURL, options);
+            return worker;
+        };
+        
+        // Copy prototype
+        window.SharedWorker.prototype = OriginalSharedWorker.prototype;
+        
+        Object.defineProperty(window.SharedWorker, 'name', { value: 'SharedWorker', configurable: true });
+        const _s4 = typeof __stealth !== 'undefined' ? __stealth : {};
+        if (_s4.utils) _s4.utils.registerNativeFunction(window.SharedWorker, 'SharedWorker');
+    };
+
+    // 29. PostMessage Fingerprint Protection - Prevent cross-context fingerprint detection
+    const protectPostMessage = () => {
+        // Cache consistent fingerprint values
+        const consistentFingerprint = {
+            navigator: {
+                userAgent: navigator.userAgent,
+                platform: navigator.platform,
+                vendor: navigator.vendor,
+                language: navigator.language,
+                languages: navigator.languages ? [...navigator.languages] : ['en-US'],
+                hardwareConcurrency: navigator.hardwareConcurrency,
+                deviceMemory: navigator.deviceMemory,
+                maxTouchPoints: navigator.maxTouchPoints,
+                webdriver: undefined,
+            },
+            screen: {
+                width: screen.width,
+                height: screen.height,
+                availWidth: screen.availWidth,
+                availHeight: screen.availHeight,
+                colorDepth: screen.colorDepth,
+                pixelDepth: screen.pixelDepth,
+            }
+        };
+        
+        // Listen for fingerprint requests from iframes/workers
+        window.addEventListener('message', function(event) {
+            // Detect common fingerprint request patterns
+            if (event.data && typeof event.data === 'object') {
+                // If message looks like a fingerprint request, respond with consistent values
+                if (event.data.type === 'fingerprintRequest' || 
+                    event.data.action === 'getFingerprint' ||
+                    event.data.cmd === 'getNavigator') {
+                    
+                    if (event.source) {
+                        try {
+                            event.source.postMessage({
+                                type: 'fingerprintResponse',
+                                data: consistentFingerprint
+                            }, event.origin || '*');
+                        } catch (e) {}
+                    }
+                }
+            }
+        }, false);
+        
+        // Wrap postMessage to ensure consistent data
+        const originalPostMessage = window.postMessage.bind(window);
+        window.postMessage = function(message, targetOrigin, transfer) {
+            return originalPostMessage(message, targetOrigin, transfer);
+        };
+        
+        const _s5 = typeof __stealth !== 'undefined' ? __stealth : {};
+        if (_s5.utils) _s5.utils.registerNativeFunction(window.postMessage, 'postMessage');
+    };
+
+    // Initialize all protections
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    console.log(DEBUG_PREFIX, 'Starting stealth protection injection...');
+    
+    const applyProtection = (name, fn) => {
+        try {
+            fn();
+            console.log(DEBUG_PREFIX, \`✓ Applied \${name}\`);
+            return true;
+        } catch (e) {
+            console.error(ERROR_PREFIX, \`✗ Failed to apply \${name}:\`, e);
+            throw e; // Rethrow to make errors visible
+        }
+    };
+    
+    try {
+        applyProtection('Error Stack Hiding', hideErrorStack);
+        applyProtection('Console Patching', patchConsole);
+        applyProtection('Automation Flags Removal', removeAutomationFlags);
+        applyProtection('Runtime.enable Detection Prevention', preventRuntimeEnableDetection);
+        applyProtection('Plugin Spoofing', spoofPlugins);
+        applyProtection('Permissions API Spoofing', spoofPermissions);
+        applyProtection('Battery API Spoofing', spoofBatteryAPI);
+        applyProtection('Connection API Spoofing', spoofConnectionAPI);
+        applyProtection('Chrome Runtime API Spoofing', spoofChromeRuntime);
+        // New 2024-2025 protections
+        applyProtection('Device Memory Spoofing', spoofDeviceMemory);
+        applyProtection('PDF Viewer Enabled Spoofing', spoofPdfViewerEnabled);
+        applyProtection('Notification Permission Spoofing', spoofNotificationPermission);
+        applyProtection('Bluetooth API Spoofing', spoofBluetoothAPI);
+        applyProtection('USB API Spoofing', spoofUSBAPI);
+        applyProtection('Serial API Spoofing', spoofSerialAPI);
+        applyProtection('Speech Synthesis Spoofing', spoofSpeechSynthesis);
+        applyProtection('Credentials API Spoofing', spoofCredentialsAPI);
+        applyProtection('HID API Spoofing', spoofHIDAPI);
+        applyProtection('Gamepad API Spoofing', spoofGamepadAPI);
+        applyProtection('Clipboard API Protection', spoofClipboardAPI);
+        applyProtection('Do Not Track Spoofing', spoofDoNotTrack);
+        applyProtection('Global Privacy Control Spoofing', spoofGlobalPrivacyControl);
+        // DataDome-specific protections
+        applyProtection('Keyboard API Spoofing', spoofKeyboardAPI);
+        applyProtection('MediaDevices API Spoofing', spoofMediaDevicesAPI);
+        applyProtection('ServiceWorker API Protection', spoofServiceWorkerAPI);
+        applyProtection('Undefined Navigator Props', spoofUndefinedNavigatorProps);
+        // Cross-context consistency protections
+        applyProtection('Worker Constructor Protection', protectWorkerConstructor);
+        applyProtection('SharedWorker Protection', protectSharedWorkerConstructor);
+        applyProtection('PostMessage Protection', protectPostMessage);
+        
+        console.log(DEBUG_PREFIX, '✓ All stealth protections applied successfully');
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply stealth protections:', e);
+        throw e; // Rethrow to make errors visible
+    }
+})();`;
+};
+//# sourceMappingURL=stealth-script.js.map