jumpy-lion 0.0.41 → 0.0.42

package/dist/fingerprinting/fingerprint-overrides/scroll-humanization.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-humanization.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/scroll-humanization.ts"],"names":[],"mappings":"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"}

package/dist/fingerprinting/fingerprint-overrides/stealth-script.d.ts

@@ -1,6 +1,14 @@
 /**
  * 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 declare const createStealthScript: () => string;
 //# sourceMappingURL=stealth-script.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/stealth-script.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stealth-script.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/stealth-script.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,mBAAmB,QAAO,MAkbtC,CAAC"}
+{"version":3,"file":"stealth-script.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/stealth-script.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,mBAAmB,QAAO,MAowBtC,CAAC"}

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

@@ -1,13 +1,21 @@
 /**
  * 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 - July
+    // Enhanced stealth script for 2025 - December
     
     // Helper functions
     const wrapNative = (fnName) => {
@@ -24,6 +32,42 @@ export const createStealthScript = () => {
             }
         });
     };
+    
+    // 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. Enhanced Error Stack Hiding (2025)
     const hideErrorStack = () => {
@@ -98,9 +142,8 @@ export const createStealthScript = () => {
         });
 
         try {
-            Object.defineProperty(window, 'console', {
+            safeDefineProperty(window, 'console', {
                 value: consoleProxy,
-                configurable: false,
                 writable: false,
                 enumerable: true
             });
@@ -112,12 +155,9 @@ export const createStealthScript = () => {
 
     // 3. WebDriver and Automation Flags Removal (2025)
     const removeAutomationFlags = () => {
-        // Remove webdriver
+        // Remove webdriver (with guard)
         if (navigator.webdriver) {
-            Object.defineProperty(navigator, 'webdriver', {
-                get: () => undefined,
-                configurable: false
-            });
+            safeDefineGetter(navigator, 'webdriver', () => undefined, false);
         }
 
         // Remove automation indicators
@@ -143,17 +183,16 @@ export const createStealthScript = () => {
             } catch (e) {}
         });
 
-        // Remove CDP specific properties
+        // Remove CDP specific properties (with guard)
         if (window.chrome) {
             const originalChrome = window.chrome;
-            Object.defineProperty(window, 'chrome', {
-                get() {
+            safeDefineGetter(window, 'chrome', () => {
+                try {
                     if (new Error().stack.includes('evaluateOnNewDocument')) {
                         return undefined;
                     }
-                    return originalChrome;
-                },
-                configurable: false
+                } catch (e) {}
+                return originalChrome;
             });
         }
     };
@@ -178,7 +217,7 @@ export const createStealthScript = () => {
 
         // Patch Error constructor to prevent stack trace manipulation
         const OriginalError = Error;
-        window.Error = new Proxy(OriginalError, {
+        const ErrorProxy = new Proxy(OriginalError, {
             construct(target, args) {
                 const error = Reflect.construct(target, args);
                 
@@ -194,9 +233,35 @@ export const createStealthScript = () => {
                 });
                 
                 return error;
+            },
+            get(target, prop) {
+                // Return the original prototype when accessing .prototype
+                if (prop === 'prototype') {
+                    return OriginalError.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);
             }
         });
-        window.Error.prototype = OriginalError.prototype;
+        
+        // Use defineProperty to replace Error without modifying frozen prototype
+        try {
+            Object.defineProperty(window, 'Error', {
+                value: ErrorProxy,
+                writable: true,
+                enumerable: false,
+                configurable: true
+            });
+        } catch (e) {
+            // If we can't redefine, just assign
+            window.Error = ErrorProxy;
+        }
     };
 
     // 5. Plugin and MimeType Spoofing (2025)
@@ -237,62 +302,58 @@ export const createStealthScript = () => {
             }
         ];
 
-        // Create fake plugins
+        // Create fake plugins using Object.defineProperty for read-only properties
         const fakePlugins = pluginData.map((p, index) => {
             const plugin = Object.create(Plugin.prototype);
-            plugin.name = p.name;
-            plugin.filename = p.filename;
-            plugin.description = p.description;
-            plugin.length = 1;
+            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
+        // Create fake mimeTypes using Object.defineProperty for read-only properties
         const fakeMimeTypes = mimeData.map((m, index) => {
             const mimeType = Object.create(MimeType.prototype);
-            mimeType.type = m.type;
-            mimeType.suffixes = m.suffixes;
-            mimeType.description = m.description;
-            mimeType.enabledPlugin = fakePlugins[0];
+            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
+        // Override navigator.plugins (with guard)
         try {
-            Object.defineProperty(navigator, 'plugins', {
-                get: () => {
-                    const arr = Object.create(PluginArray.prototype);
-                    fakePlugins.forEach((p, i) => {
-                        arr[i] = p;
-                        arr[p.name] = p;
-                    });
-                    arr.length = fakePlugins.length;
-                    arr.item = (index) => arr[index] || null;
-                    arr.namedItem = (name) => arr[name] || null;
-                    arr.refresh = () => {};
-                    return arr;
-                },
-                configurable: false,
-                enumerable: true
-            });
+            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
-            Object.defineProperty(navigator, 'mimeTypes', {
-                get: () => {
-                    const arr = Object.create(MimeTypeArray.prototype);
-                    fakeMimeTypes.forEach((m, i) => {
-                        arr[i] = m;
-                        arr[m.type] = m;
-                    });
-                    arr.length = fakeMimeTypes.length;
-                    arr.item = (index) => arr[index] || null;
-                    arr.namedItem = (name) => arr[name] || null;
-                    return arr;
-                },
-                configurable: false,
-                enumerable: true
-            });
+            // 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) {}
     };
 
@@ -412,28 +473,313 @@ export const createStealthScript = () => {
             };
             
             if (!window.chrome) window.chrome = {};
-            Object.defineProperty(window.chrome, 'runtime', { 
+            safeDefineProperty(window.chrome, 'runtime', { 
                 value: runtime, 
-                configurable: false,
                 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);
+    };
+
     // 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 {
-        hideErrorStack();
-        patchConsole();
-        removeAutomationFlags();
-        preventRuntimeEnableDetection();
-        spoofPlugins();
-        spoofPermissions();
-        spoofBatteryAPI();
-        spoofConnectionAPI();
-        spoofChromeRuntime(); // NEW
+        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);
+        
+        console.log(DEBUG_PREFIX, '✓ All stealth protections applied successfully');
     } catch (e) {
-        // Silently fail to avoid detection
+        console.error(ERROR_PREFIX, '✗ Failed to apply stealth protections:', e);
+        throw e; // Rethrow to make errors visible
     }
 })();`;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"stealth-script.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/stealth-script.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAW,EAAE;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgbL,CAAC;AACP,CAAC,CAAC"}
+{"version":3,"file":"stealth-script.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/stealth-script.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAW,EAAE;IAC5C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkwBL,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/storage-consistency.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Storage Consistency Spoofing
+ * Handles storage-related fingerprinting for 2024-2025
+ *
+ * Features:
+ * - navigator.storage.estimate() with realistic quota values
+ * - StorageManager.persist() behavior spoofing
+ * - IndexedDB database name consistency
+ * - localStorage/sessionStorage quota reporting
+ * - CacheStorage.keys() consistent cache names
+ */
+export declare const createStorageConsistencyScript: () => string;
+//# sourceMappingURL=storage-consistency.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/storage-consistency.d.ts.map

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