jumpy-lion 0.0.33 → 0.0.34

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.js

@@ -0,0 +1,84 @@
+/**
+ * Runtime.enable Bypass
+ * Prevents CDP detection through console.log(Error) technique
+ */
+export const setupRuntimeEnableBypass = async (client) => {
+    // Intercept Runtime.enable calls to prevent detection
+    await client.send('Runtime.evaluate', {
+        expression: `
+(() => {
+    // Store the original CDP send method if accessible
+    if (window.__CDP_CLIENT__) {
+        const originalSend = window.__CDP_CLIENT__.send;
+        window.__CDP_CLIENT__.send = function(method, params) {
+            // Block or modify Runtime.enable calls
+            if (method === 'Runtime.enable') {
+                console.log('Runtime.enable blocked');
+                return Promise.resolve({});
+            }
+            return originalSend.apply(this, arguments);
+        };
+    }
+    
+    // Additional protection against CDP detection
+    const originalError = Error;
+    let errorCounter = 0;
+    
+    window.Error = new Proxy(originalError, {
+        construct(target, args) {
+            const error = Reflect.construct(target, args);
+            
+            // Detect CDP serialization attempts
+            const stack = new originalError().stack;
+            if (stack && stack.includes('__puppeteer_evaluation_script__')) {
+                // This is likely a CDP evaluation, modify behavior
+                Object.defineProperty(error, 'stack', {
+                    get() {
+                        return 'Error\\n    at <anonymous>:1:1';
+                    },
+                    configurable: false
+                });
+            }
+            
+            return error;
+        }
+    });
+    
+    // Protect against console-based CDP detection
+    const protectedConsole = new Proxy(console, {
+        get(target, prop) {
+            const original = target[prop];
+            if (typeof original === 'function') {
+                return new Proxy(original, {
+                    apply(fn, thisArg, args) {
+                        // Filter out Error objects that might be used for CDP detection
+                        const filteredArgs = args.map(arg => {
+                            if (arg instanceof Error && arg.stack) {
+                                // Check if this might be a CDP detection attempt
+                                const stackString = arg.stack.toString();
+                                if (stackString.includes('Error.captureStackTrace') || 
+                                    stackString.includes('__puppeteer_evaluation_script__')) {
+                                    return arg.toString();
+                                }
+                            }
+                            return arg;
+                        });
+                        return Reflect.apply(fn, thisArg, filteredArgs);
+                    }
+                });
+            }
+            return original;
+        }
+    });
+    
+    try {
+        Object.defineProperty(window, 'console', {
+            value: protectedConsole,
+            writable: false,
+            configurable: false
+        });
+    } catch (e) {}
+})();`,
+    });
+};
+//# sourceMappingURL=runtime-enable-bypass.js.map

package/dist/fingerprinting/fingerprint-overrides/runtime-enable-bypass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-enable-bypass.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/runtime-enable-bypass.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,KAAK,EAAE,MAAW,EAAiB,EAAE;IACzE,sDAAsD;IACtD,MAAM,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE;QAClC,UAAU,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyEd;KACD,CAAC,CAAC;AACP,CAAC,CAAC"}

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

@@ -0,0 +1,6 @@
+/**
+ * Base stealth script for hiding automation indicators
+ * Includes error stack hiding, console patching, and automation flags removal
+ */
+export declare const createStealthScript: () => string;
+//# sourceMappingURL=stealth-script.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,440 @@
+/**
+ * Base stealth script for hiding automation indicators
+ * Includes error stack hiding, console patching, and automation flags removal
+ */
+export const createStealthScript = () => {
+    return `
+(() => {
+    'use strict';
+
+    // Enhanced stealth script for 2025 - July
+    
+    // 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;
+            }
+        });
+    };
+
+    // 1. Enhanced Error Stack Hiding (2025)
+    const hideErrorStack = () => {
+        const originalStackDescriptor = Object.getOwnPropertyDescriptor(Error.prototype, 'stack');
+        if (originalStackDescriptor?.configurable) {
+            const originalPrepareStackTrace = Error.prepareStackTrace;
+            
+            Object.defineProperty(Error.prototype, 'stack', {
+                get() {
+                    // Return a Chrome-like stack trace instead of Node.js
+                    const stack = \`Error
+    at Object.invoke (chrome-extension://invalid/0.js:1:23)
+    at Object.next (chrome-extension://invalid/0.js:1:53)
+    at async HTMLDocument.<anonymous> (https://g2.com/:1:107)\`;
+                    return stack;
+                },
+                set() {},
+                configurable: false,
+                enumerable: false
+            });
+
+            // Override prepareStackTrace to prevent CDP detection
+            Error.prepareStackTrace = function(error, stack) {
+                if (originalPrepareStackTrace) {
+                    return originalPrepareStackTrace(error, stack);
+                }
+                return error.toString();
+            };
+        }
+    };
+
+    // 2. Advanced Console Patching (2025)
+    const patchConsole = () => {
+        const _console = window.console;
+        if (!_console || typeof _console !== 'object') return;
+
+        // Store original methods
+        const originalMethods = {};
+        ['log', 'warn', 'error', 'info', 'debug', 'trace', 'dir', 'dirxml', 'group', 
+         'groupCollapsed', 'groupEnd', 'time', 'timeEnd', 'timeLog', 'assert', 'count', 
+         'countReset', 'profile', 'profileEnd', 'table'].forEach(method => {
+            if (_console[method]) {
+                originalMethods[method] = _console[method];
+            }
+        });
+
+        // Create a proxy for console to intercept CDP detection
+        const consoleProxy = new Proxy(_console, {
+            get(target, prop) {
+                if (prop in originalMethods) {
+                    return new Proxy(originalMethods[prop], {
+                        apply(fn, thisArg, args) {
+                            // Filter out Error objects to prevent stack serialization
+                            const filteredArgs = args.map(arg => {
+                                if (arg instanceof Error) {
+                                    return arg.toString();
+                                }
+                                return arg;
+                            });
+                            return Reflect.apply(fn, _console, filteredArgs);
+                        },
+                        get(target, prop) {
+                            if (prop === 'toString') {
+                                return wrapNative(prop);
+                            }
+                            return Reflect.get(target, prop);
+                        }
+                    });
+                }
+                return Reflect.get(target, prop);
+            }
+        });
+
+        try {
+            Object.defineProperty(window, 'console', {
+                value: consoleProxy,
+                configurable: false,
+                writable: false,
+                enumerable: true
+            });
+        } catch (e) {
+            // Fallback if defineProperty fails
+            window.console = consoleProxy;
+        }
+    };
+
+    // 3. WebDriver and Automation Flags Removal (2025)
+    const removeAutomationFlags = () => {
+        // Remove webdriver
+        if (navigator.webdriver) {
+            Object.defineProperty(navigator, 'webdriver', {
+                get: () => undefined,
+                configurable: 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) {}
+        });
+
+        // Remove CDP specific properties
+        if (window.chrome) {
+            const originalChrome = window.chrome;
+            Object.defineProperty(window, 'chrome', {
+                get() {
+                    if (new Error().stack.includes('evaluateOnNewDocument')) {
+                        return undefined;
+                    }
+                    return originalChrome;
+                },
+                configurable: false
+            });
+        }
+    };
+
+    // 4. CDP Runtime.enable Detection Prevention (2025)
+    const preventRuntimeEnableDetection = () => {
+        // Override Object.defineProperty to prevent CDP detection
+        const originalDefineProperty = Object.defineProperty;
+        Object.defineProperty = new Proxy(originalDefineProperty, {
+            apply(target, thisArg, args) {
+                const [obj, prop, descriptor] = args;
+                
+                // Prevent CDP from defining properties that expose automation
+                if (prop === 'stack' && descriptor && descriptor.get) {
+                    // This is likely a CDP detection attempt
+                    return obj;
+                }
+                
+                return Reflect.apply(target, thisArg, args);
+            }
+        });
+
+        // Patch Error constructor to prevent stack trace manipulation
+        const OriginalError = Error;
+        window.Error = new Proxy(OriginalError, {
+            construct(target, args) {
+                const error = Reflect.construct(target, args);
+                
+                // Override the stack getter/setter with Chrome-like stack
+                Object.defineProperty(error, 'stack', {
+                    get() {
+                        return \`Error: \${error.message}
+    at Object.invoke (chrome-extension://invalid/0.js:1:23)
+    at Object.next (chrome-extension://invalid/0.js:1:53)\`;
+                    },
+                    set() {},
+                    configurable: false
+                });
+                
+                return error;
+            }
+        });
+        window.Error.prototype = OriginalError.prototype;
+    };
+
+    // 5. Plugin and MimeType Spoofing (2025)
+    const spoofPlugins = () => {
+        const pluginData = [
+            {
+                name: 'Chrome PDF Plugin',
+                filename: 'internal-pdf-viewer',
+                description: 'Portable Document Format'
+            },
+            {
+                name: 'Chrome PDF Viewer',
+                filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai',
+                description: 'Portable Document Format'
+            },
+            {
+                name: 'Native Client',
+                filename: 'internal-nacl-plugin',
+                description: 'Native Client Executable'
+            }
+        ];
+
+        const mimeData = [
+            {
+                type: 'application/pdf',
+                suffixes: 'pdf',
+                description: 'Portable Document Format'
+            },
+            {
+                type: 'application/x-nacl',
+                suffixes: '',
+                description: 'Native Client Executable'
+            },
+            {
+                type: 'application/x-pnacl',
+                suffixes: '',
+                description: 'Portable Native Client Executable'
+            }
+        ];
+
+        // Create fake plugins
+        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;
+            plugin[0] = mimeData[index] || mimeData[0];
+            return plugin;
+        });
+
+        // Create fake mimeTypes
+        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];
+            return mimeType;
+        });
+
+        // Override navigator.plugins
+        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
+            });
+
+            // 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
+            });
+        } 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) {
+            navigator.getBattery = async () => {
+                return {
+                    charging: true,
+                    chargingTime: 0,
+                    dischargingTime: Infinity,
+                    level: 0.92 + Math.random() * 0.08, // Random between 0.92-1.0
+                    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: () => ({}),
+                id: 'chrome-extension-id-' + Math.random().toString(36).substr(2, 9),
+                connect: () => ({
+                    name: '',
+                    disconnect: () => {},
+                    onDisconnect: { addListener: () => {}, removeListener: () => {} },
+                    onMessage: { addListener: () => {}, removeListener: () => {} },
+                    postMessage: () => {}
+                }),
+                sendMessage: () => {},
+                getURL: (path) => 'chrome-extension://invalid/' + 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 = {};
+            Object.defineProperty(window.chrome, 'runtime', { 
+                value: runtime, 
+                configurable: false,
+                enumerable: true,
+                writable: false
+            });
+        }
+    };
+
+    // Initialize all protections
+    try {
+        hideErrorStack();
+        patchConsole();
+        removeAutomationFlags();
+        preventRuntimeEnableDetection();
+        spoofPlugins();
+        spoofPermissions();
+        spoofBatteryAPI();
+        spoofConnectionAPI();
+        spoofChromeRuntime(); // NEW
+    } catch (e) {
+        // Silently fail to avoid detection
+    }
+})();`;
+};
+//# sourceMappingURL=stealth-script.js.map

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

@@ -0,0 +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"}

package/dist/fingerprinting/fingerprint-overrides/ua-ch.d.ts

@@ -0,0 +1,6 @@
+/**
+ * navigator.userAgentData spoofing
+ * Generates brand list & bitness matching the chosen platform.
+ */
+export declare const createUAClientHintsSpoofingScript: (platform?: string) => string;
+//# sourceMappingURL=ua-ch.d.ts.map

package/dist/fingerprinting/fingerprint-overrides/ua-ch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua-ch.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/ua-ch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,iCAAiC,yBAAyB,MAyFtE,CAAC"}

package/dist/fingerprinting/fingerprint-overrides/ua-ch.js

@@ -0,0 +1,95 @@
+/**
+ * navigator.userAgentData spoofing
+ * Generates brand list & bitness matching the chosen platform.
+ */
+export const createUAClientHintsSpoofingScript = (platform = 'Win32') => {
+    let platformData;
+    let platformVersion;
+    if (platform.startsWith('Win')) {
+        platformData = 'Windows';
+        platformVersion = '15.0.0';
+    }
+    else if (platform.startsWith('Mac')) {
+        platformData = 'macOS';
+        platformVersion = '14.0.0';
+    }
+    else {
+        platformData = 'Linux';
+        platformVersion = '6.2.0';
+    }
+    return `
+(() => {
+    'use strict';
+    
+    // UA-CH (User-Agent Client Hints) spoofing for 2025
+    const brands = [
+        { brand: "Chromium", version: "125" },
+        { brand: "Google Chrome", version: "125" },
+        { brand: "Not A(Brand", version: "99" }
+    ];
+    
+    const mobile = false;
+    const platformData = "${platformData}";
+    
+    const uaData = {
+        brands: brands,
+        mobile: mobile,
+        platform: platformData,
+        
+        getHighEntropyValues(hints) {
+            return new Promise((resolve) => {
+                const base = {
+                    architecture: "x86",
+                    bitness: "64",
+                    brands: brands,
+                    mobile: mobile,
+                    model: "",
+                    platform: platformData,
+                    platformVersion: "${platformVersion}",
+                    uaFullVersion: "125.0.6422.4",
+                    fullVersionList: brands.map(b => ({ brand: b.brand, version: "125.0.6422.4" })),
+                    wow64: false
+                };
+                
+                const result = {};
+                hints.forEach(hint => {
+                    if (hint in base) {
+                        result[hint] = base[hint];
+                    }
+                });
+                
+                resolve(result);
+            });
+        },
+        
+        toJSON() {
+            return {
+                brands: brands,
+                mobile: mobile,
+                platform: platformData
+            };
+        }
+    };
+    
+    // Override navigator.userAgentData
+    Object.defineProperty(navigator, "userAgentData", {
+        get: () => uaData,
+        configurable: false,
+        enumerable: true
+    });
+    
+    // Also ensure the property exists and is not writable
+    try {
+        Object.defineProperty(navigator, "userAgentData", {
+            value: uaData,
+            writable: false,
+            configurable: false,
+            enumerable: true
+        });
+    } catch (e) {
+        // Property might already be defined
+    }
+})();
+`;
+};
+//# sourceMappingURL=ua-ch.js.map

package/dist/fingerprinting/fingerprint-overrides/ua-ch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ua-ch.js","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/ua-ch.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAAC,QAAQ,GAAG,OAAO,EAAU,EAAE;IAC5E,IAAI,YAAoB,CAAC;IACzB,IAAI,eAAuB,CAAC;IAE5B,IAAI,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,YAAY,GAAG,SAAS,CAAC;QACzB,eAAe,GAAG,QAAQ,CAAC;IAC/B,CAAC;SAAM,IAAI,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;QACpC,YAAY,GAAG,OAAO,CAAC;QACvB,eAAe,GAAG,QAAQ,CAAC;IAC/B,CAAC;SAAM,CAAC;QACJ,YAAY,GAAG,OAAO,CAAC;QACvB,eAAe,GAAG,OAAO,CAAC;IAC9B,CAAC;IAED,OAAO;;;;;;;;;;;;4BAYiB,YAAY;;;;;;;;;;;;;;;;wCAgBA,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6CtD,CAAC;AACF,CAAC,CAAC"}

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

@@ -0,0 +1,12 @@
+/**
+ * WebGL Fingerprinting Protection
+ * Platform-aware GPU spoofing for WebGL contexts
+ */
+export interface WebGLConfig {
+    vendor?: string;
+    renderer?: string;
+    vendorUnmasked?: string;
+    rendererUnmasked?: string;
+}
+export declare const createWebGLSpoofingScript: (fingerprintWebGL?: WebGLConfig) => string;
+//# sourceMappingURL=webgl-spoofing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-spoofing.d.ts","sourceRoot":"","sources":["../../../src/fingerprinting/fingerprint-overrides/webgl-spoofing.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,WAAW;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,eAAO,MAAM,yBAAyB,sBAAuB,WAAW,KAAG,MAkK1E,CAAC"}