jumpy-lion 0.0.33 → 0.0.34

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

@@ -0,0 +1,167 @@
+/**
+ * WebGL Fingerprinting Protection
+ * Platform-aware GPU spoofing for WebGL contexts
+ */
+export const createWebGLSpoofingScript = (fingerprintWebGL) => {
+    // If fingerprint data is provided, use it; otherwise use platform-based defaults
+    const useFingerprint = fingerprintWebGL && (fingerprintWebGL.vendorUnmasked || fingerprintWebGL.rendererUnmasked);
+    return `
+(() => {
+    'use strict';
+    
+    // WebGL Spoofing for 2025 - Platform-aware
+    const spoofWebGL = () => {
+        const getParameterProto = WebGLRenderingContext.prototype.getParameter;
+        const getExtensionProto = WebGLRenderingContext.prototype.getExtension;
+        const getSupportedExtensionsProto = WebGLRenderingContext.prototype.getSupportedExtensions;
+        
+        ${useFingerprint ? `
+        // Use fingerprint-provided WebGL values
+        const fingerprintConfig = ${JSON.stringify(fingerprintWebGL)};
+        const selectedVendor = fingerprintConfig.vendorUnmasked || fingerprintConfig.vendor || 'Intel Inc.';
+        const selectedRenderer = fingerprintConfig.rendererUnmasked || fingerprintConfig.renderer || 'Intel Iris OpenGL Engine';
+        ` : `
+        // Detect platform from navigator
+        const platform = navigator.platform || 'Linux x86_64';
+        
+        // Platform-specific GPU configurations
+        const gpuConfigs = {
+            'Win32': {
+                vendors: ['NVIDIA Corporation', 'AMD', 'Intel Inc.'],
+                renderers: [
+                    'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (AMD, AMD Radeon RX 6600 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                    'ANGLE (Intel, Intel(R) UHD Graphics 630 Direct3D11 vs_5_0 ps_5_0, D3D11)',
+                ],
+            },
+            'MacIntel': {
+                vendors: ['Apple Inc.', 'Intel Inc.', 'AMD'],
+                renderers: [
+                    'ANGLE (Apple, Apple M1 Pro, OpenGL 4.1)',
+                    'ANGLE (Apple, Apple M2, OpenGL 4.1)',
+                    'ANGLE (Intel Inc., Intel(R) Iris(TM) Plus Graphics OpenGL Engine, OpenGL 4.1)',
+                    'ANGLE (AMD, AMD Radeon Pro 5500M OpenGL Engine, OpenGL 4.1)',
+                ],
+            },
+            'Linux x86_64': {
+                vendors: ['Intel', 'NVIDIA Corporation', 'AMD'],
+                renderers: [
+                    'ANGLE (Intel, Mesa Intel(R) UHD Graphics 630 (CFL GT2), OpenGL 4.6)',
+                    'ANGLE (NVIDIA, NVIDIA GeForce GTX 1660 Ti/PCIe/SSE2, OpenGL 4.6)',
+                    'ANGLE (AMD, AMD Radeon RX 6600 (NAVY_FLOUNDER, DRM 3.42.0, 5.15.0-56-generic, LLVM 12.0.0), OpenGL 4.6)',
+                    'ANGLE (Intel, Mesa Intel(R) Xe Graphics (TGL GT2), OpenGL 4.6)',
+                ],
+            },
+        };
+        
+        const config = gpuConfigs[platform] || gpuConfigs['Linux x86_64'];
+        const selectedVendor = config.vendors[Math.floor(Math.random() * config.vendors.length)];
+        const selectedRenderer = config.renderers.find(r => r.includes(selectedVendor.split(' ')[0])) || config.renderers[0];
+        `}
+        
+        // Override getParameter
+        WebGLRenderingContext.prototype.getParameter = function(param) {
+            // UNMASKED_VENDOR_WEBGL
+            if (param === 0x9245) {
+                return selectedVendor;
+            }
+            // UNMASKED_RENDERER_WEBGL
+            if (param === 0x9246) {
+                return selectedRenderer;
+            }
+            // Standard WebGL parameters - use fingerprint values if available
+            if (param === 0x1F00) { // VENDOR
+                return ${useFingerprint && fingerprintWebGL?.vendor ? `'${fingerprintWebGL.vendor}'` : "'WebKit'"};
+            }
+            if (param === 0x1F01) { // RENDERER
+                return ${useFingerprint && fingerprintWebGL?.renderer ? `'${fingerprintWebGL.renderer}'` : "'WebKit WebGL'"};
+            }
+            if (param === 0x1F02) { // VERSION
+                return 'WebGL 1.0 (OpenGL ES 2.0 Chromium)';
+            }
+            // MAX_TEXTURE_SIZE
+            if (param === 0x0D33) {
+                return 16384;
+            }
+            // MAX_VIEWPORT_DIMS
+            if (param === 0x0D3A) {
+                return new Int32Array([32767, 32767]);
+            }
+            
+            return getParameterProto.apply(this, arguments);
+        };
+        
+        // Also apply to WebGL2
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+            WebGL2RenderingContext.prototype.getParameter = function(param) {
+                // For WebGL2, return appropriate version
+                if (param === 0x1F02) { // VERSION
+                    return 'WebGL 2.0 (OpenGL ES 3.0 Chromium)';
+                }
+                // Use same logic as WebGL1 for other params
+                return WebGLRenderingContext.prototype.getParameter.call(this, param);
+            };
+        }
+        
+        // Override getSupportedExtensions with platform-appropriate extensions
+        const baseExtensions = [
+            'ANGLE_instanced_arrays', 'EXT_blend_minmax', 'EXT_color_buffer_half_float',
+            'EXT_disjoint_timer_query', 'EXT_float_blend', 'EXT_frag_depth',
+            'EXT_shader_texture_lod', 'EXT_texture_compression_rgtc',
+            'EXT_texture_filter_anisotropic', 'EXT_sRGB', 'KHR_parallel_shader_compile',
+            'OES_element_index_uint', 'OES_fbo_render_mipmap', 'OES_standard_derivatives',
+            'OES_texture_float', 'OES_texture_float_linear', 'OES_texture_half_float',
+            'OES_texture_half_float_linear', 'OES_vertex_array_object', 'WEBGL_color_buffer_float',
+            'WEBGL_compressed_texture_s3tc', 'WEBGL_compressed_texture_s3tc_srgb',
+            'WEBGL_debug_renderer_info', 'WEBGL_debug_shaders', 'WEBGL_depth_texture',
+            'WEBGL_draw_buffers', 'WEBGL_lose_context', 'WEBGL_multi_draw'
+        ];
+        
+        ${!useFingerprint ? `
+        // Add platform-specific extensions
+        const platformExtensions = {
+            'Win32': ['EXT_texture_compression_bptc', 'WEBGL_compressed_texture_astc'],
+            'MacIntel': ['WEBGL_compressed_texture_pvrtc', 'WEBKIT_WEBGL_compressed_texture_pvrtc'],
+            'Linux x86_64': ['EXT_texture_compression_bptc'],
+        };
+        
+        const allExtensions = [...baseExtensions, ...(platformExtensions[platform] || [])];
+        ` : `
+        const allExtensions = baseExtensions;
+        `}
+        
+        WebGLRenderingContext.prototype.getSupportedExtensions = function() {
+            return allExtensions;
+        };
+        
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+            WebGL2RenderingContext.prototype.getSupportedExtensions = function() {
+                return [...allExtensions, 'EXT_color_buffer_float', 'EXT_disjoint_timer_query_webgl2', 'WEBGL_compressed_texture_etc'];
+            };
+        }
+        
+        // Override getExtension to handle WEBGL_debug_renderer_info properly
+        WebGLRenderingContext.prototype.getExtension = function(name) {
+            const result = getExtensionProto.apply(this, arguments);
+            
+            if (name === 'WEBGL_debug_renderer_info' && result) {
+                // Return the extension but ensure our spoofed values are used
+                return {
+                    UNMASKED_VENDOR_WEBGL: 0x9245,
+                    UNMASKED_RENDERER_WEBGL: 0x9246,
+                };
+            }
+            
+            return result;
+        };
+        
+        if (typeof WebGL2RenderingContext !== 'undefined') {
+            WebGL2RenderingContext.prototype.getExtension = WebGLRenderingContext.prototype.getExtension;
+        }
+    };
+    
+    spoofWebGL();
+})();`;
+};
+//# sourceMappingURL=webgl-spoofing.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,gBAA8B,EAAU,EAAE;IAChF,iFAAiF;IACjF,MAAM,cAAc,GAAG,gBAAgB,IAAI,CAAC,gBAAgB,CAAC,cAAc,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;IAElH,OAAO;;;;;;;;;;UAUD,cAAc,CAAC,CAAC,CAAC;;oCAES,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC;;;SAG3D,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAsCH;;;;;;;;;;;;;;yBAcgB,cAAc,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,UAAU;;;yBAGxF,cAAc,IAAI,gBAAgB,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2CjH,CAAC,cAAc,CAAC,CAAC,CAAC;;;;;;;;;SASnB,CAAC,CAAC,CAAC;;SAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiCH,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/webgpu-spoofing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * WebGPU Fingerprinting Protection
+ * Spoofs GPU adapter information and fakes GPU uptime
+ */
+export declare const createWebGPUSpoofingScript: (experimentalMode?: boolean) => string;
+//# sourceMappingURL=webgpu-spoofing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgpu-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,0BAA0B,kCAA+B,MAuMrE,CAAC"}

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

@@ -0,0 +1,205 @@
+/**
+ * WebGPU Fingerprinting Protection
+ * Spoofs GPU adapter information and fakes GPU uptime
+ */
+export const createWebGPUSpoofingScript = (experimentalMode = false) => {
+    return `
+(() => {
+    'use strict';
+    
+    // WebGPU Fingerprinting Protection for 2025
+    const spoofWebGPU = () => {
+        // Experimental mode: completely disable WebGPU
+        ${experimentalMode ? `
+        if ('GPU' in window) {
+            delete window.GPU;
+        }
+        if ('navigator' in window && 'gpu' in navigator) {
+            delete navigator.gpu;
+        }
+        // Return early as WebGPU is completely disabled
+        return;
+        ` : ''}
+        
+        // Standard mode: spoof WebGPU
+        // Fake GPU uptime - make it look like the GPU has been running for hours/days
+        const fakeGPUStartTime = Date.now() - (Math.random() * 48 + 24) * 60 * 60 * 1000; // 24-72 hours ago
+        
+        if ('GPU' in window && window.GPU) {
+            const OriginalGPU = window.GPU;
+            
+            // Override requestAdapter to provide consistent fake adapter info
+            window.GPU = new Proxy(OriginalGPU, {
+                get(target, prop) {
+                    if (prop === 'requestAdapter') {
+                        return async function(options) {
+                            const adapter = await target.requestAdapter.call(target, options);
+                            if (!adapter) return null;
+                            
+                            // Wrap the adapter to provide fake but consistent info
+                            return new Proxy(adapter, {
+                                get(adapterTarget, adapterProp) {
+                                    if (adapterProp === 'name') {
+                                        // Return a common GPU name based on platform
+                                        const gpuNames = [
+                                            'NVIDIA GeForce RTX 3060',
+                                            'NVIDIA GeForce GTX 1660 Ti',
+                                            'AMD Radeon RX 6600',
+                                            'Intel(R) UHD Graphics 630',
+                                            'Apple M1',
+                                        ];
+                                        return gpuNames[Math.floor(Math.random() * gpuNames.length)];
+                                    }
+                                    
+                                    if (adapterProp === 'features') {
+                                        // Return a consistent set of features
+                                        const fakeFeatures = new Set([
+                                            'depth-clip-control',
+                                            'depth32float-stencil8',
+                                            'texture-compression-bc',
+                                            'texture-compression-etc2',
+                                            'texture-compression-astc',
+                                            'timestamp-query',
+                                            'indirect-first-instance',
+                                            'shader-f16',
+                                            'rg11b10ufloat-renderable',
+                                            'bgra8unorm-storage',
+                                            'float32-filterable',
+                                        ]);
+                                        
+                                        return new Proxy(adapterTarget.features || fakeFeatures, {
+                                            get(featuresTarget, featuresProp) {
+                                                if (featuresProp === 'has') {
+                                                    return (feature) => fakeFeatures.has(feature);
+                                                }
+                                                if (featuresProp === 'size') {
+                                                    return fakeFeatures.size;
+                                                }
+                                                if (featuresProp === Symbol.iterator) {
+                                                    return fakeFeatures[Symbol.iterator].bind(fakeFeatures);
+                                                }
+                                                return Reflect.get(featuresTarget, featuresProp);
+                                            }
+                                        });
+                                    }
+                                    
+                                    if (adapterProp === 'limits') {
+                                        // Return realistic GPU limits
+                                        return {
+                                            maxTextureDimension1D: 16384,
+                                            maxTextureDimension2D: 16384,
+                                            maxTextureDimension3D: 2048,
+                                            maxTextureArrayLayers: 2048,
+                                            maxBindGroups: 4,
+                                            maxBindGroupsPlusVertexBuffers: 24,
+                                            maxBindingsPerBindGroup: 1000,
+                                            maxDynamicUniformBuffersPerPipelineLayout: 8,
+                                            maxDynamicStorageBuffersPerPipelineLayout: 4,
+                                            maxSampledTexturesPerShaderStage: 16,
+                                            maxSamplersPerShaderStage: 16,
+                                            maxStorageBuffersPerShaderStage: 8,
+                                            maxStorageTexturesPerShaderStage: 4,
+                                            maxUniformBuffersPerShaderStage: 12,
+                                            maxUniformBufferBindingSize: 65536,
+                                            maxStorageBufferBindingSize: 134217728,
+                                            minUniformBufferOffsetAlignment: 256,
+                                            minStorageBufferOffsetAlignment: 256,
+                                            maxVertexBuffers: 8,
+                                            maxBufferSize: 268435456,
+                                            maxVertexAttributes: 16,
+                                            maxVertexBufferArrayStride: 2048,
+                                            maxInterStageShaderComponents: 60,
+                                            maxInterStageShaderVariables: 16,
+                                            maxColorAttachments: 8,
+                                            maxColorAttachmentBytesPerSample: 32,
+                                            maxComputeWorkgroupStorageSize: 16384,
+                                            maxComputeInvocationsPerWorkgroup: 256,
+                                            maxComputeWorkgroupSizeX: 256,
+                                            maxComputeWorkgroupSizeY: 256,
+                                            maxComputeWorkgroupSizeZ: 64,
+                                            maxComputeWorkgroupsPerDimension: 65535,
+                                        };
+                                    }
+                                    
+                                    if (adapterProp === 'requestDevice') {
+                                        return async function(descriptor) {
+                                            const device = await adapterTarget.requestDevice.call(adapterTarget, descriptor);
+                                            if (!device) return null;
+                                            
+                                            // Wrap the device to intercept timing queries
+                                            return new Proxy(device, {
+                                                get(deviceTarget, deviceProp) {
+                                                    if (deviceProp === 'createQuerySet') {
+                                                        return function(descriptor) {
+                                                            const querySet = deviceTarget.createQuerySet.call(deviceTarget, descriptor);
+                                                            
+                                                            // If it's a timestamp query, we need to fake the results
+                                                            if (descriptor.type === 'timestamp') {
+                                                                return new Proxy(querySet, {
+                                                                    get(queryTarget, queryProp) {
+                                                                        // Intercept resolve operations to fake timestamps
+                                                                        return Reflect.get(queryTarget, queryProp);
+                                                                    }
+                                                                });
+                                                            }
+                                                            
+                                                            return querySet;
+                                                        };
+                                                    }
+                                                    
+                                                    return Reflect.get(deviceTarget, deviceProp);
+                                                }
+                                            });
+                                        };
+                                    }
+                                    
+                                    return Reflect.get(adapterTarget, adapterProp);
+                                }
+                            });
+                        };
+                    }
+                    
+                    if (prop === 'getPreferredCanvasFormat') {
+                        return function() {
+                            // Return the most common format
+                            return 'bgra8unorm';
+                        };
+                    }
+                    
+                    return Reflect.get(target, prop);
+                }
+            });
+        }
+        
+        // Override performance.now() to fake GPU uptime when called from WebGPU context
+        const originalPerformanceNow = performance.now;
+        performance.now = function() {
+            const stack = new Error().stack;
+            
+            // Check if called from WebGPU context
+            if (stack && (stack.includes('GPU') || stack.includes('WebGPU') || stack.includes('gpu'))) {
+                // Return a time that makes it look like GPU has been running for a while
+                const currentTime = originalPerformanceNow.call(this);
+                const fakeUptime = Date.now() - fakeGPUStartTime;
+                return Math.min(currentTime, fakeUptime);
+            }
+            
+            return originalPerformanceNow.call(this);
+        };
+        
+        // Override GPU timing-related APIs
+        if (window.GPUCommandEncoder) {
+            const originalWriteTimestamp = GPUCommandEncoder.prototype.writeTimestamp;
+            if (originalWriteTimestamp) {
+                GPUCommandEncoder.prototype.writeTimestamp = function(querySet, queryIndex) {
+                    // Call original but the query results will be intercepted elsewhere
+                    return originalWriteTimestamp.call(this, querySet, queryIndex);
+                };
+            }
+        }
+    };
+    
+    spoofWebGPU();
+})();`;
+};
+//# sourceMappingURL=webgpu-spoofing.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-spoofing.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgpu-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,gBAAgB,GAAG,KAAK,EAAU,EAAE;IAC3E,OAAO;;;;;;;UAOD,gBAAgB,CAAC,CAAC,CAAC;;;;;;;;;SASpB,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqLR,CAAC;AACP,CAAC,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/webrtc-spoofing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * WebRTC Spoofing
+ * Prevents IP leaks and provides fake device information
+ */
+export declare const createWebRTCSpoofingScript: () => string;
+//# sourceMappingURL=webrtc-spoofing.d.ts.map

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

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

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

@@ -0,0 +1,96 @@
+/**
+ * WebRTC Spoofing
+ * Prevents IP leaks and provides fake device information
+ */
+export const createWebRTCSpoofingScript = () => {
+    return `
+(() => {
+    'use strict';
+    
+    // WebRTC Spoofing for 2025
+    const spoofWebRTC = () => {
+        // Override RTCPeerConnection
+        const OriginalRTCPeerConnection = window.RTCPeerConnection || window.webkitRTCPeerConnection || window.mozRTCPeerConnection;
+        
+        if (OriginalRTCPeerConnection) {
+            window.RTCPeerConnection = window.webkitRTCPeerConnection = window.mozRTCPeerConnection = new Proxy(OriginalRTCPeerConnection, {
+                construct(target, args) {
+                    const config = args[0] || {};
+                    
+                    // Modify ICE servers to prevent IP leaks
+                    if (config.iceServers) {
+                        config.iceServers = config.iceServers.filter(server => {
+                            // Remove STUN servers that might leak IP
+                            if (server.urls) {
+                                if (Array.isArray(server.urls)) {
+                                    server.urls = server.urls.filter(url => !url.includes('stun:'));
+                                } else if (typeof server.urls === 'string' && server.urls.includes('stun:')) {
+                                    return false;
+                                }
+                            }
+                            return true;
+                        });
+                    }
+                    
+                    const pc = Reflect.construct(target, [config, ...args.slice(1)]);
+                    
+                    // Override createDataChannel to prevent fingerprinting
+                    const originalCreateDataChannel = pc.createDataChannel;
+                    pc.createDataChannel = function(label, options) {
+                        // Add random ID to make fingerprinting harder
+                        const modifiedLabel = label + '_' + Math.random().toString(36).substr(2, 9);
+                        return originalCreateDataChannel.call(this, modifiedLabel, options);
+                    };
+                    
+                    // Override getStats to provide fake statistics
+                    const originalGetStats = pc.getStats;
+                    pc.getStats = function() {
+                        return originalGetStats.apply(this, arguments).then(stats => {
+                            // Modify stats to hide identifying information
+                            const modifiedStats = new Map();
+                            stats.forEach((stat, key) => {
+                                const modifiedStat = Object.assign({}, stat);
+                                
+                                // Randomize some values
+                                if ('bytesReceived' in modifiedStat) {
+                                    modifiedStat.bytesReceived = Math.floor(modifiedStat.bytesReceived * (0.9 + Math.random() * 0.2));
+                                }
+                                if ('bytesSent' in modifiedStat) {
+                                    modifiedStat.bytesSent = Math.floor(modifiedStat.bytesSent * (0.9 + Math.random() * 0.2));
+                                }
+                                if ('jitter' in modifiedStat) {
+                                    modifiedStat.jitter = modifiedStat.jitter * (0.9 + Math.random() * 0.2);
+                                }
+                                
+                                modifiedStats.set(key, modifiedStat);
+                            });
+                            return modifiedStats;
+                        });
+                    };
+                    
+                    return pc;
+                }
+            });
+        }
+        
+        // Override MediaDevices.enumerateDevices
+        if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
+            const originalEnumerateDevices = navigator.mediaDevices.enumerateDevices;
+            navigator.mediaDevices.enumerateDevices = function() {
+                return originalEnumerateDevices.apply(this, arguments).then(devices => {
+                    // Provide fake but consistent device IDs
+                    return devices.map((device, index) => ({
+                        deviceId: 'device_' + device.kind + '_' + index,
+                        kind: device.kind,
+                        label: device.label || '',
+                        groupId: 'group_' + Math.floor(index / 2),
+                    }));
+                });
+            };
+        }
+    };
+    
+    spoofWebRTC();
+})();`;
+};
+//# sourceMappingURL=webrtc-spoofing.js.map

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

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

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import CDPCrawler from "./crawler.js";
 import CdpPage from "./page.js";
 export default CDPCrawler;
-export { createCDPRouter, CDPRouter } from "./crawler.js";
-export { GotoOptions } from "./page.js";
+export { createCDPRouter } from "./crawler.js";
+export type { CDPRouter } from "./crawler.js";
+export type { GotoOptions } from "./page.js";
 export { CdpPage };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,OAAO,MAAM,WAAW,CAAC;AAEhC,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,OAAO,MAAM,WAAW,CAAC;AAEhC,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,OAAO,MAAM,WAAW,CAAC;AAEhC,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAa,MAAM,cAAc,CAAC;AAE1D,OAAO,EAAE,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,UAAU,MAAM,cAAc,CAAC;AACtC,OAAO,OAAO,MAAM,WAAW,CAAC;AAEhC,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/page.d.ts

@@ -79,6 +79,7 @@ export default class CdpPage extends EventEmitter {
     getTextContent(selector: string): Promise<string>;
     getHref(selector: string): Promise<string>;
     scrollIntoView(selector: string): Promise<void>;
+    setupFetchMetadataHeaders(): Promise<void>;
     blockRequests(urlPatterns: string[]): Promise<void>;
     private getNodeId;
     setCookies(cookies: Cookie[]): Promise<void>;

package/dist/page.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../src/page.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"page.d.ts","sourceRoot":"","sources":["../src/page.ts"],"names":[],"mappings":"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"}

package/dist/page.js

@@ -273,7 +273,7 @@ export default class CdpPage extends EventEmitter {
     async click(selector) {
         await Promise.all([
             this._enableDomain('DOM'),
-            this._enableDomain('Input')
+            this._enableDomain('Input'),
         ]);
         const { DOM, Input } = this.client;
         await this.waitForSelector(selector);
@@ -456,6 +456,47 @@ export default class CdpPage extends EventEmitter {
             }
         }, selector);
     }
+    // Add proper Fetch Metadata headers to avoid CDP detection
+    async setupFetchMetadataHeaders() {
+        const { Network } = this.client;
+        await this._enableDomain('Network');
+        await Network.setRequestInterception({ patterns: [{ urlPattern: '*' }] });
+        Network.on('requestIntercepted', async (params) => {
+            const { request, interceptionId } = params;
+            const url = new URL(request.url);
+            // Add proper fetch metadata headers
+            const headers = { ...request.headers };
+            // Set sec-fetch-* headers based on request type and destination
+            if (request.method === 'GET' && !headers['sec-fetch-dest']) {
+                if (url.pathname.endsWith('.js')) {
+                    headers['sec-fetch-dest'] = 'script';
+                    headers['sec-fetch-mode'] = 'no-cors';
+                    headers['sec-fetch-site'] = url.origin === headers.origin ? 'same-origin' : 'cross-site';
+                }
+                else if (url.pathname.endsWith('.css')) {
+                    headers['sec-fetch-dest'] = 'style';
+                    headers['sec-fetch-mode'] = 'no-cors';
+                    headers['sec-fetch-site'] = url.origin === headers.origin ? 'same-origin' : 'cross-site';
+                }
+                else if (url.pathname.match(/\.(png|jpg|jpeg|gif|webp|svg)$/i)) {
+                    headers['sec-fetch-dest'] = 'image';
+                    headers['sec-fetch-mode'] = 'no-cors';
+                    headers['sec-fetch-site'] = url.origin === headers.origin ? 'same-origin' : 'cross-site';
+                }
+                else if (url.pathname === '/' || !url.pathname.includes('.')) {
+                    headers['sec-fetch-dest'] = 'document';
+                    headers['sec-fetch-mode'] = 'navigate';
+                    headers['sec-fetch-site'] = 'none';
+                    headers['sec-fetch-user'] = '?1';
+                }
+            }
+            // Continue the request with modified headers
+            await Network.continueInterceptedRequest({
+                interceptionId,
+                headers,
+            });
+        });
+    }
     // Block requests matching URL patterns
     async blockRequests(urlPatterns) {
         const { Network } = this.client;