jumpy-lion 0.1.0 → 0.1.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"platform-consistency.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/platform-consistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,cAAc;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,eAAO,MAAM,+BAA+B,aAAc,MAAM,oBAAoB,cAAc,KAAG,MA+lBpG,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/platform-consistency.js

@@ -0,0 +1,618 @@
+/**
+ * Platform Consistency Script
+ * Ensures all browser properties match the specified platform (1:1 fingerprinting)
+ *
+ * 2024-2025 Enhancements:
+ * - Screen orientation API consistency
+ * - screen.availLeft/availTop for Windows
+ * - visualViewport properties consistency
+ * - window.outerWidth/outerHeight ratios
+ * - window.screenX/screenY typical values
+ * - matchMedia() platform-appropriate results
+ */
+export const createPlatformConsistencyScript = (platform, fingerprintData) => {
+    // Platform-specific configurations for 1:1 consistency
+    const platformConfigs = {
+        'Win32': {
+            devicePixelRatio: 1.0,
+            screenDepth: 24,
+            colorDepth: 24,
+            hardwareConcurrency: 8,
+            maxTouchPoints: 0,
+            platform: 'Win32',
+            oscpu: 'Windows NT 10.0; Win64; x64',
+            vendor: '',
+            vendorSub: '',
+            productSub: '20030107',
+            cookieEnabled: true,
+            onLine: true,
+            language: 'en-US',
+            languages: ['en-US', 'en'],
+            userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
+            appVersion: '5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36',
+            appName: 'Netscape',
+            appCodeName: 'Mozilla',
+            product: 'Gecko',
+            // Chrome 120+ only reports PDF-related plugins (Native Client removed in 2019)
+            plugins: [
+                { 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' },
+            ],
+            mimeTypes: [
+                { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format' },
+                { type: 'text/pdf', suffixes: 'pdf', description: 'Portable Document Format' },
+            ],
+            // Windows-specific connection properties
+            connection: {
+                downlink: 10,
+                effectiveType: '4g',
+                onchange: null,
+                rtt: 50,
+                saveData: false,
+                type: 'ethernet',
+            },
+        },
+        'MacIntel': {
+            devicePixelRatio: 2.0,
+            screenDepth: 30,
+            colorDepth: 30,
+            hardwareConcurrency: 8,
+            maxTouchPoints: 0,
+            platform: 'MacIntel',
+            oscpu: undefined,
+            vendor: 'Google Inc.',
+            vendorSub: '',
+            productSub: '20030107',
+            cookieEnabled: true,
+            onLine: true,
+            language: 'en-US',
+            languages: ['en-US', 'en'],
+            plugins: [
+                { name: 'PDF Viewer', filename: 'internal-pdf-viewer' },
+                { name: 'Chrome PDF Viewer', filename: 'internal-pdf-viewer' },
+                { name: 'Chromium PDF Viewer', filename: 'internal-pdf-viewer' },
+                { name: 'WebKit built-in PDF', filename: 'internal-pdf-viewer' },
+            ],
+        },
+        'Linux x86_64': {
+            devicePixelRatio: 1.0,
+            screenDepth: 24,
+            colorDepth: 24,
+            hardwareConcurrency: 8,
+            maxTouchPoints: 0,
+            platform: 'Linux x86_64',
+            oscpu: 'Linux x86_64',
+            vendor: 'Google Inc.',
+            vendorSub: '',
+            productSub: '20030107',
+            cookieEnabled: true,
+            onLine: true,
+            language: 'en-US',
+            languages: ['en-US', 'en'],
+            plugins: [
+                { name: 'PDF Viewer', filename: 'internal-pdf-viewer' },
+                { name: 'Chrome PDF Viewer', filename: 'internal-pdf-viewer' },
+                { name: 'Chromium PDF Viewer', filename: 'internal-pdf-viewer' },
+            ],
+        },
+    };
+    const defaultConfig = platformConfigs[platform] || platformConfigs['Linux x86_64'];
+    // Merge fingerprint data with defaults if provided
+    const config = fingerprintData ? {
+        ...defaultConfig,
+        ...fingerprintData,
+        // Ensure platform consistency
+        platform: fingerprintData.platform || platform,
+    } : defaultConfig;
+    return `
+(() => {
+    'use strict';
+    
+    // Platform Consistency for ${platform}
+    const config = ${JSON.stringify(config)};
+    
+    // Helper to safely define property with guards
+    const safeDefineProperty = (obj, prop, getter) => {
+        try {
+            const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+            if (descriptor && descriptor.configurable === false) {
+                return false; // Property already defined as non-configurable
+            }
+            Object.defineProperty(obj, prop, { 
+                get: getter, 
+                configurable: true,  // Allow other scripts to modify if needed
+                enumerable: true 
+            });
+            return true;
+        } catch (e) {
+            return false;
+        }
+    };
+    
+    // Override navigator properties for platform consistency (with guards)
+    safeDefineProperty(navigator, 'platform', () => config.platform);
+    safeDefineProperty(navigator, 'vendor', () => config.vendor);
+    safeDefineProperty(navigator, 'vendorSub', () => config.vendorSub);
+    safeDefineProperty(navigator, 'productSub', () => config.productSub);
+    safeDefineProperty(navigator, 'hardwareConcurrency', () => config.hardwareConcurrency);
+    safeDefineProperty(navigator, 'maxTouchPoints', () => config.maxTouchPoints);
+    safeDefineProperty(navigator, 'cookieEnabled', () => config.cookieEnabled);
+    safeDefineProperty(navigator, 'onLine', () => config.onLine);
+    safeDefineProperty(navigator, 'language', () => config.language);
+    safeDefineProperty(navigator, 'languages', () => config.languages);
+    
+    // Additional navigator properties for Windows consistency
+    if (config.userAgent) {
+        safeDefineProperty(navigator, 'userAgent', () => config.userAgent);
+    }
+    if (config.appVersion) {
+        safeDefineProperty(navigator, 'appVersion', () => config.appVersion);
+    }
+    if (config.appName) {
+        safeDefineProperty(navigator, 'appName', () => config.appName);
+    }
+    if (config.appCodeName) {
+        safeDefineProperty(navigator, 'appCodeName', () => config.appCodeName);
+    }
+    if (config.product) {
+        safeDefineProperty(navigator, 'product', () => config.product);
+    }
+    if (config.oscpu !== undefined) {
+        safeDefineProperty(navigator, 'oscpu', () => config.oscpu);
+    }
+    
+    // Override navigator.plugins for Windows consistency (with guards)
+    if (config.plugins) {
+        const pluginsGetter = () => {
+            const arr = Object.create(PluginArray.prototype);
+            config.plugins.forEach((p, i) => {
+                const plugin = Object.create(Plugin.prototype);
+                // Use Object.defineProperty for read-only properties
+                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] = config.mimeTypes?.[i] || { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format' };
+                arr[i] = plugin;
+                arr[p.name] = plugin;
+            });
+            // Use Object.defineProperty for length (PluginArray.prototype.length is read-only)
+            Object.defineProperty(arr, 'length', { value: config.plugins.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;
+        };
+        safeDefineProperty(navigator, 'plugins', pluginsGetter);
+    }
+    
+    // Override navigator.mimeTypes for Windows consistency (with guards)
+    if (config.mimeTypes) {
+        const mimeTypesGetter = () => {
+            const arr = Object.create(MimeTypeArray.prototype);
+            config.mimeTypes.forEach((m, i) => {
+                const mimeType = Object.create(MimeType.prototype);
+                // Use Object.defineProperty for read-only properties
+                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: config.plugins?.[0] || null, writable: false, enumerable: true });
+                arr[i] = mimeType;
+                arr[m.type] = mimeType;
+            });
+            // Use Object.defineProperty for length (MimeTypeArray.prototype.length is read-only)
+            Object.defineProperty(arr, 'length', { value: config.mimeTypes.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;
+        };
+        safeDefineProperty(navigator, 'mimeTypes', mimeTypesGetter);
+    }
+    
+    // Override navigator.connection for Windows consistency
+    // Note: Some connection properties (like downlink, rtt) are non-configurable in Chrome
+    if (config.connection && navigator.connection) {
+        Object.keys(config.connection).forEach(key => {
+            try {
+                const descriptor = Object.getOwnPropertyDescriptor(navigator.connection, key);
+                if (descriptor && descriptor.configurable === false) {
+                    // Property is non-configurable, skip it
+                    return;
+                }
+                Object.defineProperty(navigator.connection, key, {
+                    value: config.connection[key],
+                    writable: false,
+                    configurable: true
+                });
+            } catch (e) {
+                // Silently ignore non-configurable properties
+            }
+        });
+    }
+    
+    // Override screen properties (with guards)
+    safeDefineProperty(window, 'devicePixelRatio', () => config.devicePixelRatio);
+    safeDefineProperty(screen, 'colorDepth', () => config.colorDepth);
+    safeDefineProperty(screen, 'pixelDepth', () => config.screenDepth || config.colorDepth);
+    
+    // Ensure WebGL returns platform-appropriate values
+    const getParameterProto = WebGLRenderingContext.prototype.getParameter;
+    WebGLRenderingContext.prototype.getParameter = function(param) {
+        if (param === 0x9245 || param === 0x9246) { // UNMASKED_VENDOR_WEBGL / UNMASKED_RENDERER_WEBGL
+            // Return platform-appropriate GPU with corrected ANGLE token count
+            if (config.platform === 'Win32') {
+                return param === 0x9245 
+                    ? 'NVIDIA Corporation' 
+                    : 'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti Direct3D 11.0)'; // Fixed: fewer tokens
+            } else if (config.platform === 'MacIntel') {
+                return param === 0x9245 ? 'Apple Inc.' : 'ANGLE (Apple, Apple M1 Pro, OpenGL 4.1)';
+            } else {
+                return param === 0x9245 ? 'Intel' : 'ANGLE (Intel, Mesa Intel(R) UHD Graphics 630, OpenGL 4.6)';
+            }
+        }
+        return getParameterProto.apply(this, arguments);
+    };
+    
+    if (typeof WebGL2RenderingContext !== 'undefined') {
+        WebGL2RenderingContext.prototype.getParameter = WebGLRenderingContext.prototype.getParameter;
+    }
+    
+    // ========== 2024-2025 Enhanced Platform Consistency ==========
+    
+    // Screen Orientation API Consistency
+    const spoofScreenOrientation = () => {
+        if (screen.orientation) {
+            Object.defineProperty(screen.orientation, 'type', {
+                get: () => 'landscape-primary',
+                configurable: true,
+                enumerable: true
+            });
+            
+            Object.defineProperty(screen.orientation, 'angle', {
+                get: () => 0,
+                configurable: true,
+                enumerable: true
+            });
+        }
+    };
+    
+    // Screen availLeft/availTop for Windows (taskbar consideration)
+    const spoofScreenAvailability = () => {
+        const screenConfig = {
+            'Win32': {
+                availLeft: 0,
+                availTop: 0,
+                availWidth: screen.width || 1920,
+                availHeight: (screen.height || 1080) - 40 // Windows taskbar ~40px
+            },
+            'MacIntel': {
+                availLeft: 0,
+                availTop: 25, // macOS menu bar
+                availWidth: screen.width || 1920,
+                availHeight: (screen.height || 1080) - 25
+            },
+            'Linux x86_64': {
+                availLeft: 0,
+                availTop: 0,
+                availWidth: screen.width || 1920,
+                availHeight: (screen.height || 1080) - 30 // GNOME panel
+            }
+        };
+        
+        const screenVals = screenConfig[config.platform] || screenConfig['Win32'];
+        
+        Object.defineProperty(screen, 'availLeft', {
+            get: () => screenVals.availLeft,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(screen, 'availTop', {
+            get: () => screenVals.availTop,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(screen, 'availWidth', {
+            get: () => screenVals.availWidth,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(screen, 'availHeight', {
+            get: () => screenVals.availHeight,
+            configurable: true,
+            enumerable: true
+        });
+    };
+    
+    // Visual Viewport consistency
+    const spoofVisualViewport = () => {
+        if (window.visualViewport) {
+            const originalViewport = window.visualViewport;
+            
+            // Ensure consistent values
+            Object.defineProperty(originalViewport, 'scale', {
+                get: () => 1,
+                configurable: true
+            });
+            
+            Object.defineProperty(originalViewport, 'offsetLeft', {
+                get: () => 0,
+                configurable: true
+            });
+            
+            Object.defineProperty(originalViewport, 'offsetTop', {
+                get: () => 0,
+                configurable: true
+            });
+            
+            Object.defineProperty(originalViewport, 'pageLeft', {
+                get: () => window.scrollX || 0,
+                configurable: true
+            });
+            
+            Object.defineProperty(originalViewport, 'pageTop', {
+                get: () => window.scrollY || 0,
+                configurable: true
+            });
+        }
+    };
+    
+    // Window outer dimensions (browser chrome size)
+    const spoofWindowDimensions = () => {
+        const outerConfig = {
+            'Win32': {
+                outerWidthOffset: 16, // Windows chrome borders
+                outerHeightOffset: 92 // Title bar + tabs + bookmarks
+            },
+            'MacIntel': {
+                outerWidthOffset: 0, // macOS has no side borders
+                outerHeightOffset: 87 // Title bar + tabs
+            },
+            'Linux x86_64': {
+                outerWidthOffset: 2, // Minimal borders
+                outerHeightOffset: 85 // GNOME decorations
+            }
+        };
+        
+        const dimConfig = outerConfig[config.platform] || outerConfig['Win32'];
+        
+        Object.defineProperty(window, 'outerWidth', {
+            get: () => window.innerWidth + dimConfig.outerWidthOffset,
+            configurable: true,
+            enumerable: true
+        });
+        
+        Object.defineProperty(window, 'outerHeight', {
+            get: () => window.innerHeight + dimConfig.outerHeightOffset,
+            configurable: true,
+            enumerable: true
+        });
+    };
+    
+    // Window screen position
+    const spoofWindowPosition = () => {
+        const posConfig = {
+            'Win32': { screenX: 0, screenY: 0 },
+            'MacIntel': { screenX: 0, screenY: 25 }, // Below menu bar
+            'Linux x86_64': { screenX: 0, screenY: 0 }
+        };
+
+        const pos = posConfig[config.platform] || posConfig['Win32'];
+
+        Object.defineProperty(window, 'screenX', {
+            get: () => pos.screenX,
+            configurable: true,
+            enumerable: true
+        });
+
+        Object.defineProperty(window, 'screenY', {
+            get: () => pos.screenY,
+            configurable: true,
+            enumerable: true
+        });
+
+        Object.defineProperty(window, 'screenLeft', {
+            get: () => pos.screenX,
+            configurable: true,
+            enumerable: true
+        });
+
+        Object.defineProperty(window, 'screenTop', {
+            get: () => pos.screenY,
+            configurable: true,
+            enumerable: true
+        });
+
+        // Fix screenX/screenY in MouseEvent for headless/CDP dispatch.
+        // In headless mode, CDP-dispatched events have screenY == clientY
+        // (no browser chrome offset), which is a detection vector.
+        // Real browsers have ~85px chrome offset (title + tab + address bars).
+        const chromeOffsets = {
+            'Win32': { x: 0, y: 85 },
+            'MacIntel': { x: 0, y: 75 },
+            'Linux x86_64': { x: 0, y: 85 }
+        };
+        const chromeOffset = chromeOffsets[config.platform] || chromeOffsets['Win32'];
+
+        const origScreenYDesc = Object.getOwnPropertyDescriptor(MouseEvent.prototype, 'screenY');
+        const origScreenXDesc = Object.getOwnPropertyDescriptor(MouseEvent.prototype, 'screenX');
+
+        if (origScreenYDesc && origScreenYDesc.get) {
+            const origGetScreenY = origScreenYDesc.get;
+            Object.defineProperty(MouseEvent.prototype, 'screenY', {
+                get() {
+                    const val = origGetScreenY.call(this);
+                    // In headless, screenY == clientY (no chrome). Add offset.
+                    if (val === this.clientY && chromeOffset.y > 0) {
+                        return val + chromeOffset.y + pos.screenY;
+                    }
+                    return val;
+                },
+                configurable: true,
+                enumerable: true
+            });
+        }
+
+        if (origScreenXDesc && origScreenXDesc.get) {
+            const origGetScreenX = origScreenXDesc.get;
+            Object.defineProperty(MouseEvent.prototype, 'screenX', {
+                get() {
+                    const val = origGetScreenX.call(this);
+                    if (val === this.clientX && chromeOffset.x > 0) {
+                        return val + chromeOffset.x + pos.screenX;
+                    }
+                    return val;
+                },
+                configurable: true,
+                enumerable: true
+            });
+        }
+    };
+    
+    // matchMedia platform-specific behavior
+    const spoofMatchMedia = () => {
+        const originalMatchMedia = window.matchMedia;
+        
+        window.matchMedia = function(query) {
+            const result = originalMatchMedia.call(this, query);
+            
+            // Platform-specific media query handling
+            if (query.includes('prefers-color-scheme')) {
+                // Default to light mode (most common)
+                const isDark = query.includes('dark');
+                return new Proxy(result, {
+                    get(target, prop) {
+                        if (prop === 'matches') {
+                            return !isDark; // Most users use light mode
+                        }
+                        return target[prop];
+                    }
+                });
+            }
+            
+            if (query.includes('prefers-reduced-motion')) {
+                // Most users don't have reduced motion
+                return new Proxy(result, {
+                    get(target, prop) {
+                        if (prop === 'matches') {
+                            return false;
+                        }
+                        return target[prop];
+                    }
+                });
+            }
+            
+            if (query.includes('prefers-contrast')) {
+                // Most users use default contrast
+                return new Proxy(result, {
+                    get(target, prop) {
+                        if (prop === 'matches') {
+                            return query.includes('no-preference');
+                        }
+                        return target[prop];
+                    }
+                });
+            }
+            
+            if (query.includes('pointer')) {
+                // Desktop platforms have fine pointer (mouse)
+                const hasFinePointer = config.platform !== 'Android' && config.maxTouchPoints === 0;
+                return new Proxy(result, {
+                    get(target, prop) {
+                        if (prop === 'matches') {
+                            if (query.includes('fine')) return hasFinePointer;
+                            if (query.includes('coarse')) return !hasFinePointer;
+                            if (query.includes('none')) return false;
+                        }
+                        return target[prop];
+                    }
+                });
+            }
+            
+            if (query.includes('hover')) {
+                // Desktop platforms support hover
+                return new Proxy(result, {
+                    get(target, prop) {
+                        if (prop === 'matches') {
+                            return query.includes('hover') && !query.includes('none');
+                        }
+                        return target[prop];
+                    }
+                });
+            }
+            
+            return result;
+        };
+    };
+    
+    // ScreenDetails API (multi-monitor detection)
+    const spoofScreenDetails = () => {
+        if ('getScreenDetails' in window) {
+            window.getScreenDetails = function() {
+                return Promise.resolve({
+                    screens: [{
+                        availHeight: screen.availHeight,
+                        availWidth: screen.availWidth,
+                        availLeft: 0,
+                        availTop: 0,
+                        colorDepth: config.colorDepth || 24,
+                        devicePixelRatio: config.devicePixelRatio || 1,
+                        height: screen.height,
+                        width: screen.width,
+                        isExtended: false,
+                        isPrimary: true,
+                        label: 'Primary Display',
+                        left: 0,
+                        orientation: screen.orientation || { angle: 0, type: 'landscape-primary' },
+                        pixelDepth: config.screenDepth || 24,
+                        top: 0
+                    }],
+                    currentScreen: null,
+                    onscreenschange: null,
+                    oncurrentscreenchange: null,
+                    addEventListener: () => {},
+                    removeEventListener: () => {}
+                });
+            };
+        }
+    };
+    
+    // Initialize all enhanced spoofing
+    const DEBUG_PREFIX = '[CDP-FP-DEBUG]';
+    const ERROR_PREFIX = '[CDP-FP-ERROR]';
+    
+    console.log(DEBUG_PREFIX, 'Starting platform consistency overrides for:', config.platform);
+    
+    const applyConsistency = (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 {
+        applyConsistency('Screen Orientation', spoofScreenOrientation);
+        applyConsistency('Screen Availability', spoofScreenAvailability);
+        applyConsistency('Visual Viewport', spoofVisualViewport);
+        applyConsistency('Window Dimensions', spoofWindowDimensions);
+        applyConsistency('Window Position', spoofWindowPosition);
+        applyConsistency('Match Media', spoofMatchMedia);
+        applyConsistency('Screen Details API', spoofScreenDetails);
+        
+        console.log(DEBUG_PREFIX, \`✓ Platform consistency complete for \${config.platform}\`);
+    } catch (e) {
+        console.error(ERROR_PREFIX, '✗ Failed to apply platform consistency:', e);
+        throw e; // Rethrow to make errors visible
+    }
+})();`;
+};
+//# sourceMappingURL=platform-consistency.js.map

package/dist/fingerprinting/fingerprint-overrides/platform-consistency.js.map

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

package/dist/fingerprinting/fingerprint-overrides/prototype-integrity.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Prototype Integrity Module
+ *
+ * Ensures all property overrides are undetectable by:
+ * - Making overridden properties appear native (configurable: false)
+ * - Hiding modified property descriptors from Object.getOwnPropertyDescriptor
+ * - Protecting prototype chains from Object.getPrototypeOf inspection
+ * - Masking shadow properties from enumeration
+ *
+ * This module MUST be injected FIRST, before any other fingerprint overrides.
+ */
+export declare const createPrototypeIntegrityScript: () => string;
+//# sourceMappingURL=prototype-integrity.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/prototype-integrity.d.ts.map

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