@zaplier/sdk 1.0.2 → 1.0.4

package/dist/sdk.js

@@ -179,8 +179,10 @@
      * Hash fingerprint components into a stable identifier
      */
     function hashFingerprint(components) {
-        // Convert components to canonical string representation
-        const canonical = JSON.stringify(components, Object.keys(components).sort());
+        // Convert components to canonical string representation using deep sorting
+        // CRITICAL: Do NOT use JSON.stringify(obj, keys) as it filters out nested properties!
+        // Use canonicalizeStable instead which handles deep sorting and normalization.
+        const canonical = JSON.stringify(canonicalizeStable(components));
         // Use MurmurHash3 x64 for consistent hashing
         return x64hash128(canonical);
     }
@@ -237,17 +239,21 @@
      * Based on FingerprintJS audio component using AudioContext
      */
     /**
-     * Audio configuration for fingerprinting
+     * Enhanced audio configuration for maximum differentiation
      */
     const AUDIO_CONFIG = {
         SAMPLE_RATE: 44100,
         DURATION: 0.1, // 100ms
-        FREQUENCY: 1000, // 1kHz tone
+        FREQUENCIES: [440, 1000, 1760, 3520], // Multiple frequencies for better differentiation
         COMPRESSOR_THRESHOLD: -50,
         COMPRESSOR_KNEE: 40,
         COMPRESSOR_RATIO: 12,
         COMPRESSOR_ATTACK: 0.003,
         COMPRESSOR_RELEASE: 0.25,
+        // NEW: Additional audio processing parameters
+        FILTER_FREQUENCY: 2000,
+        GAIN_VALUE: 0.5,
+        DELAY_TIME: 0.02,
     };
     /**
      * Create offline audio context (doesn't require user gesture)
@@ -309,40 +315,144 @@
         return 44100; // Default fallback (standard sample rate)
     }
     /**
-     * Generate oscillator fingerprint using OfflineAudioContext (no user gesture required)
-     */
-    async function generateOscillatorFingerprint(offlineContext) {
-        try {
-            const osc = offlineContext.createOscillator();
-            const comp = offlineContext.createDynamicsCompressor();
-            // Configure oscillator
-            osc.type = "triangle";
-            osc.frequency.setValueAtTime(AUDIO_CONFIG.FREQUENCY, offlineContext.currentTime);
-            // Configure compressor
-            comp.threshold.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_THRESHOLD, offlineContext.currentTime);
-            comp.knee.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_KNEE, offlineContext.currentTime);
-            comp.ratio.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_RATIO, offlineContext.currentTime);
-            comp.attack.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_ATTACK, offlineContext.currentTime);
-            comp.release.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_RELEASE, offlineContext.currentTime);
-            // Connect within offline graph (no audible output, no user gesture needed)
-            osc.connect(comp);
-            comp.connect(offlineContext.destination);
-            osc.start();
-            osc.stop(AUDIO_CONFIG.DURATION);
-            const buf = await offlineContext.startRendering();
-            const ch = buf.getChannelData(0);
-            // Sample a few deterministic points for fingerprinting
-            const pts = [
-                ch[0] || 0,
-                ch[Math.floor(ch.length * 0.33)] || 0,
-                ch[Math.floor(ch.length * 0.66)] || 0,
-                ch[ch.length - 1] || 0,
+     * Generate advanced multiple oscillator fingerprint for maximum DAC/hardware differentiation
+     */
+    async function generateMultiOscillatorFingerprint(offlineContext) {
+        try {
+            // Create multiple oscillators with different waveforms and frequencies
+            const oscillators = AUDIO_CONFIG.FREQUENCIES.map((freq, index) => {
+                const osc = offlineContext.createOscillator();
+                const waveforms = ['sine', 'square', 'sawtooth', 'triangle'];
+                const waveformIndex = index % waveforms.length;
+                const selectedWaveform = waveforms[waveformIndex];
+                // Type guard to ensure we have a valid waveform
+                if (selectedWaveform) {
+                    osc.type = selectedWaveform;
+                }
+                else {
+                    osc.type = 'sine'; // Fallback to sine wave
+                }
+                osc.frequency.setValueAtTime(freq, offlineContext.currentTime);
+                return osc;
+            });
+            // Create advanced audio processing chain
+            const compressor = offlineContext.createDynamicsCompressor();
+            const biquadFilter = offlineContext.createBiquadFilter();
+            const gainNode = offlineContext.createGain();
+            const delayNode = offlineContext.createDelay();
+            const analyserNode = offlineContext.createAnalyser();
+            // Configure compressor with specific settings
+            compressor.threshold.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_THRESHOLD, offlineContext.currentTime);
+            compressor.knee.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_KNEE, offlineContext.currentTime);
+            compressor.ratio.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_RATIO, offlineContext.currentTime);
+            compressor.attack.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_ATTACK, offlineContext.currentTime);
+            compressor.release.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_RELEASE, offlineContext.currentTime);
+            // Configure biquad filter for frequency response differences
+            biquadFilter.type = 'bandpass';
+            biquadFilter.frequency.setValueAtTime(AUDIO_CONFIG.FILTER_FREQUENCY, offlineContext.currentTime);
+            biquadFilter.Q.setValueAtTime(0.7, offlineContext.currentTime);
+            // Configure gain node
+            gainNode.gain.setValueAtTime(AUDIO_CONFIG.GAIN_VALUE, offlineContext.currentTime);
+            // Configure delay node for additional processing
+            delayNode.delayTime.setValueAtTime(AUDIO_CONFIG.DELAY_TIME, offlineContext.currentTime);
+            // Create a mixer node to combine oscillators
+            const mixerGain = offlineContext.createGain();
+            mixerGain.gain.setValueAtTime(0.25, offlineContext.currentTime); // Reduce volume when mixing
+            // Connect oscillators to mixer
+            oscillators.forEach(osc => {
+                osc.connect(mixerGain);
+            });
+            // Create complex audio processing chain:
+            // Mixed Oscillators -> Filter -> Compressor -> Gain -> Delay -> Analyser -> Destination
+            mixerGain.connect(biquadFilter);
+            biquadFilter.connect(compressor);
+            compressor.connect(gainNode);
+            gainNode.connect(delayNode);
+            delayNode.connect(analyserNode);
+            analyserNode.connect(offlineContext.destination);
+            // Start all oscillators
+            oscillators.forEach((osc, index) => {
+                osc.start(index * 0.01); // Slightly staggered start times
+                osc.stop(AUDIO_CONFIG.DURATION);
+            });
+            const buffer = await offlineContext.startRendering();
+            const channelData = buffer.getChannelData(0);
+            // Enhanced sampling for better differentiation
+            const samplePoints = [];
+            for (let i = 0; i < 32; i++) {
+                const index = Math.floor((channelData.length / 32) * i);
+                samplePoints.push(channelData[index] || 0);
+            }
+            // Calculate additional characteristics
+            const rms = Math.sqrt(samplePoints.reduce((sum, val) => sum + val * val, 0) / samplePoints.length);
+            const maxAmplitude = Math.max(...samplePoints.map(Math.abs));
+            const averageAmplitude = samplePoints.reduce((sum, val) => sum + Math.abs(val), 0) / samplePoints.length;
+            // Frequency domain analysis
+            let spectralCentroid = 0;
+            for (let i = 0; i < Math.min(samplePoints.length, 16); i++) {
+                const sample = samplePoints[i];
+                if (sample !== undefined) {
+                    spectralCentroid += i * Math.abs(sample);
+                }
+            }
+            const characteristics = [
+                ...samplePoints,
+                rms,
+                maxAmplitude,
+                averageAmplitude,
+                spectralCentroid
             ];
-            return hash32(pts.join(","));
+            return hash32(characteristics.join(","));
         }
         catch (error) {
-            // If OfflineAudioContext fails, return fallback hash
-            return hash32("oscillator_error");
+            return hash32("multi_oscillator_error");
+        }
+    }
+    /**
+     * Generate frequency response fingerprint to detect DAC characteristics
+     */
+    async function generateFrequencyResponseFingerprint(offlineContext) {
+        try {
+            // Test multiple frequencies to detect DAC/audio hardware frequency response
+            const testFrequencies = [100, 440, 1000, 2000, 4000, 8000, 12000, 16000];
+            const responses = [];
+            for (const frequency of testFrequencies) {
+                const osc = offlineContext.createOscillator();
+                const analyser = offlineContext.createAnalyser();
+                osc.type = 'sine';
+                osc.frequency.setValueAtTime(frequency, offlineContext.currentTime);
+                // Configure analyser for frequency analysis
+                analyser.fftSize = 256;
+                analyser.smoothingTimeConstant = 0;
+                osc.connect(analyser);
+                analyser.connect(offlineContext.destination);
+                osc.start();
+                osc.stop(0.05); // Short test for each frequency
+                // Create a new offline context for each frequency test
+                const testContext = createOfflineAudioContext();
+                if (testContext) {
+                    const testOsc = testContext.createOscillator();
+                    testOsc.type = 'sine';
+                    testOsc.frequency.setValueAtTime(frequency, testContext.currentTime);
+                    testOsc.connect(testContext.destination);
+                    testOsc.start();
+                    testOsc.stop(0.05);
+                    try {
+                        const testBuffer = await testContext.startRendering();
+                        const testData = testBuffer.getChannelData(0);
+                        // Calculate RMS for this frequency
+                        const rms = Math.sqrt(testData.reduce((sum, val) => sum + val * val, 0) / testData.length);
+                        responses.push(rms);
+                    }
+                    catch {
+                        responses.push(0);
+                    }
+                }
+            }
+            return hash32(responses.join(","));
+        }
+        catch (error) {
+            return hash32("frequency_response_error");
         }
     }
     /**
@@ -354,7 +464,8 @@
             const offlineCompressor = offlineContext.createDynamicsCompressor();
             // Configure nodes
             offlineOscillator.type = "triangle";
-            offlineOscillator.frequency.setValueAtTime(AUDIO_CONFIG.FREQUENCY, offlineContext.currentTime);
+            offlineOscillator.frequency.setValueAtTime(AUDIO_CONFIG.FREQUENCIES[0], // Use first frequency from the array
+            offlineContext.currentTime);
             offlineCompressor.threshold.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_THRESHOLD, offlineContext.currentTime);
             offlineCompressor.knee.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_KNEE, offlineContext.currentTime);
             offlineCompressor.ratio.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_RATIO, offlineContext.currentTime);
@@ -383,35 +494,138 @@
         }
     }
     /**
-     * Generate audio fingerprint using OfflineAudioContext (no user gesture required)
-     * This is the recommended approach for fingerprinting - no audio output, no user interaction needed
+     * Get detailed audio context characteristics
+     */
+    function getAudioContextCharacteristics() {
+        const characteristics = {};
+        try {
+            // Try to get characteristics from OfflineAudioContext
+            const testContext = createOfflineAudioContext();
+            if (testContext) {
+                characteristics.sampleRate = testContext.sampleRate;
+                characteristics.length = testContext.length;
+                characteristics.state = testContext.state;
+                // Test supported sample rates
+                const supportedRates = [];
+                const testRates = [8000, 22050, 44100, 48000, 96000];
+                for (const rate of testRates) {
+                    try {
+                        const testCtx = new (window.OfflineAudioContext || window.webkitOfflineAudioContext)(1, 1, rate);
+                        if (testCtx.sampleRate === rate) {
+                            supportedRates.push(rate);
+                        }
+                        // OfflineAudioContext doesn't have close method - it's automatically disposed after rendering
+                        if ('close' in testCtx && typeof testCtx.close === 'function') {
+                            testCtx.close();
+                        }
+                    }
+                    catch {
+                        // Rate not supported
+                    }
+                }
+                characteristics.supportedSampleRates = supportedRates;
+                // Test base latency (if available)
+                if ('baseLatency' in testContext) {
+                    characteristics.baseLatency = testContext.baseLatency;
+                }
+                // OfflineAudioContext doesn't have close method - it's automatically disposed after rendering
+                if ('close' in testContext && typeof testContext.close === 'function') {
+                    testContext.close();
+                }
+            }
+        }
+        catch (error) {
+            characteristics.error = 'context_characteristics_error';
+        }
+        return characteristics;
+    }
+    /**
+     * Generate enhanced audio fingerprint with multiple analysis methods
      */
     async function getAudioFingerprint() {
         const startTime = performance.now();
         try {
-            // Get sample rate from default context (for metadata only)
+            // Get sample rate and context characteristics
             const sampleRate = getDefaultSampleRate();
-            // Create offline contexts for fingerprinting (no user gesture needed)
-            const offlineContextOsc = createOfflineAudioContext();
-            if (!offlineContextOsc) {
+            const contextCharacteristics = getAudioContextCharacteristics();
+            // Create multiple offline contexts for different analysis methods
+            const contexts = {
+                multiOsc: createOfflineAudioContext(),
+                compressor: createOfflineAudioContext(),
+                frequencyResponse: createOfflineAudioContext(),
+            };
+            // Verify all contexts are available
+            if (!contexts.multiOsc || !contexts.compressor || !contexts.frequencyResponse) {
                 throw new Error("OfflineAudioContext not available");
             }
-            // Create another offline context for compressor fingerprint
-            const offlineContextComp = createOfflineAudioContext();
-            if (!offlineContextComp) {
-                throw new Error("OfflineAudioContext not available for compressor");
-            }
-            // Generate fingerprints in parallel (both use OfflineAudioContext, no user gesture needed)
-            const [oscillatorHash, compressorHash] = await Promise.all([
-                generateOscillatorFingerprint(offlineContextOsc).catch(() => "oscillator_error"),
-                generateCompressorFingerprint(offlineContextComp).catch(() => "compressor_error"),
+            // Generate multiple fingerprints in parallel for enhanced differentiation
+            const [multiOscillatorHash, compressorHash, frequencyResponseHash] = await Promise.all([
+                generateMultiOscillatorFingerprint(contexts.multiOsc).catch(() => "multi_oscillator_error"),
+                generateCompressorFingerprint(contexts.compressor).catch(() => "compressor_error"),
+                generateFrequencyResponseFingerprint(contexts.frequencyResponse).catch(() => "frequency_response_error"),
             ]);
+            // Test audio node creation capabilities
+            const nodeCapabilities = {};
+            try {
+                const testContext = createOfflineAudioContext();
+                if (testContext) {
+                    const nodeTypes = [
+                        'createOscillator',
+                        'createAnalyser',
+                        'createBiquadFilter',
+                        'createConvolver',
+                        'createDelay',
+                        'createDynamicsCompressor',
+                        'createGain',
+                        'createWaveShaper',
+                        'createStereoPanner',
+                        'createChannelSplitter',
+                        'createChannelMerger'
+                    ];
+                    for (const nodeType of nodeTypes) {
+                        try {
+                            if (typeof testContext[nodeType] === 'function') {
+                                testContext[nodeType]();
+                                nodeCapabilities[nodeType] = true;
+                            }
+                        }
+                        catch {
+                            nodeCapabilities[nodeType] = false;
+                        }
+                    }
+                    // OfflineAudioContext doesn't have close method - it's automatically disposed after rendering
+                    if ('close' in testContext && typeof testContext.close === 'function') {
+                        testContext.close();
+                    }
+                }
+            }
+            catch {
+                // Node capability testing failed
+            }
+            // Calculate audio stack fingerprint
+            const audioStackComponents = [
+                multiOscillatorHash,
+                compressorHash,
+                frequencyResponseHash,
+                sampleRate.toString(),
+                JSON.stringify(contextCharacteristics),
+                JSON.stringify(nodeCapabilities)
+            ];
+            const audioStackHash = hash32(audioStackComponents.join("|"));
             const endTime = performance.now();
             const result = {
-                oscillator: oscillatorHash,
+                // Legacy fields for compatibility
+                oscillator: multiOscillatorHash,
                 compressor: compressorHash,
                 sampleRate: sampleRate,
-                maxChannelCount: 2, // Default stereo, doesn't affect fingerprint quality
+                maxChannelCount: contextCharacteristics.supportedSampleRates?.length || 2,
+                // NEW: Enhanced audio analysis
+                multiOscillatorFingerprint: multiOscillatorHash,
+                frequencyResponseFingerprint: frequencyResponseHash,
+                contextCharacteristics: contextCharacteristics,
+                nodeCapabilities: nodeCapabilities,
+                audioStackHash: audioStackHash,
+                supportedSampleRates: contextCharacteristics.supportedSampleRates || []
             };
             return {
                 value: result,
@@ -425,6 +639,12 @@
                     compressor: "error",
                     sampleRate: 0,
                     maxChannelCount: 0,
+                    multiOscillatorFingerprint: "error",
+                    frequencyResponseFingerprint: "error",
+                    contextCharacteristics: {},
+                    nodeCapabilities: {},
+                    audioStackHash: "error",
+                    supportedSampleRates: []
                 },
                 duration: performance.now() - startTime,
                 error: error instanceof Error ? error.message : "Audio fingerprinting failed",
@@ -451,6 +671,417 @@
         }
     }
 
+    /**
+     * Browser Detection Utilities
+     * Based on FingerprintJS browser detection patterns
+     * Uses feature detection instead of user-agent parsing for reliability
+     */
+    /**
+     * Detects if the browser is WebKit-based (Safari, mobile Safari)
+     */
+    function isWebKit$1() {
+        try {
+            return ("WebKitAppearance" in document.documentElement.style ||
+                "webkitRequestFileSystem" in window ||
+                "webkitResolveLocalFileSystemURL" in window ||
+                Boolean(window.safari));
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is running on Android
+     */
+    function isAndroid$1() {
+        try {
+            return ("ontouchstart" in window &&
+                ("orientation" in window || "onorientationchange" in window) &&
+                /android/i.test(navigator.userAgent));
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is Brave
+     * Brave masquerades as Chrome but has specific APIs
+     */
+    function isBrave() {
+        try {
+            // Brave has navigator.brave API (most reliable method)
+            if ("brave" in navigator && navigator.brave) {
+                return true;
+            }
+            // Secondary check: Brave blocks certain APIs that Chrome doesn't
+            // Brave has specific user agent string patterns (less reliable)
+            const ua = navigator.userAgent;
+            if (ua.includes("Brave")) {
+                return true;
+            }
+            // Brave detection through missing APIs that Chrome has
+            if (window.chrome &&
+                window.chrome.runtime &&
+                !window.chrome.webstore &&
+                !window.navigator.getBattery && // Brave removes some APIs for privacy
+                /Chrome/.test(ua)) {
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is Arc
+     * Arc browser is Chromium-based but has unique characteristics
+     */
+    function isArc() {
+        try {
+            const ua = navigator.userAgent;
+            // Arc specific detection
+            if (ua.includes("Arc/")) {
+                return true;
+            }
+            // Arc may have specific window properties
+            if (window.arc || window.Arc) {
+                return true;
+            }
+            // Arc modifies some Chrome APIs
+            if (window.chrome &&
+                window.chrome.runtime &&
+                /Chrome/.test(ua) &&
+                // Arc specific user agent patterns or missing features
+                (ua.includes("ArcBrowser") || window.location.protocol === "arc:")) {
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is Opera (modern Chromium-based)
+     */
+    function isOpera() {
+        try {
+            // Opera has specific properties
+            if (window.opr || window.opera) {
+                return true;
+            }
+            const ua = navigator.userAgent;
+            if (ua.includes("OPR/") || ua.includes("Opera/")) {
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is Vivaldi
+     */
+    function isVivaldi() {
+        try {
+            const ua = navigator.userAgent;
+            if (ua.includes("Vivaldi/")) {
+                return true;
+            }
+            // Vivaldi has specific window properties
+            if (window.vivaldi) {
+                return true;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is Samsung Internet
+     */
+    function isSamsungInternet$1() {
+        try {
+            const ua = navigator.userAgent;
+            return ua.includes("SamsungBrowser/") || ua.includes("Samsung Internet");
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is Chrome/Chromium-based (pure Chrome, not derivatives)
+     */
+    function isChrome() {
+        try {
+            // First, exclude known Chromium derivatives
+            if (isBrave() ||
+                isArc() ||
+                isOpera() ||
+                isVivaldi() ||
+                isEdge() ||
+                isSamsungInternet$1()) {
+                return false;
+            }
+            return Boolean(window.chrome &&
+                (window.chrome.webstore || window.chrome.runtime) &&
+                /Chrome/.test(navigator.userAgent) &&
+                !/Edg|OPR|Opera|Vivaldi|SamsungBrowser|Arc|Brave/.test(navigator.userAgent));
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is Firefox
+     */
+    function isFirefox() {
+        try {
+            return ("InstallTrigger" in window ||
+                "mozInnerScreenX" in window ||
+                "mozPaintCount" in window ||
+                Boolean(navigator.mozApps));
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is Edge (legacy or Chromium)
+     */
+    function isEdge() {
+        try {
+            return ("msCredentials" in navigator ||
+                Boolean(window.StyleMedia) ||
+                (isChrome() && /edg/i.test(navigator.userAgent)));
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is Safari (not just WebKit)
+     */
+    function isSafari() {
+        try {
+            return (isWebKit$1() &&
+                !isChrome() &&
+                !isEdge() &&
+                Boolean(window.safari) &&
+                /safari/i.test(navigator.userAgent));
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is in a secure context
+     */
+    function isSecureContext() {
+        try {
+            return window.isSecureContext || location.protocol === "https:";
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detects if the browser is likely in private/incognito mode
+     * This is a best-effort detection and not 100% reliable
+     */
+    function isLikelyPrivateMode() {
+        try {
+            // Quick checks for obvious private mode indicators
+            if ("webkitTemporaryStorage" in navigator) {
+                return false; // Likely not private
+            }
+            // Check for reduced storage quotas (common in private mode)
+            if (navigator.storage && navigator.storage.estimate) {
+                navigator.storage.estimate().then((estimate) => {
+                    const quota = estimate.quota || 0;
+                    return quota < 1024 * 1024 * 100; // Less than 100MB likely indicates private mode
+                });
+            }
+            return false; // Default to not private if we can't determine
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Gets the exact browser name with proper Chromium-based browser detection
+     */
+    function getBrowserName() {
+        try {
+            // Check specific Chromium-based browsers first (order matters!)
+            if (isBrave())
+                return "Brave";
+            if (isArc())
+                return "Arc";
+            if (isOpera())
+                return "Opera";
+            if (isVivaldi())
+                return "Vivaldi";
+            if (isSamsungInternet$1())
+                return "Samsung Internet";
+            if (isEdge())
+                return "Edge";
+            // Check non-Chromium browsers
+            if (isFirefox())
+                return "Firefox";
+            if (isSafari())
+                return "Safari";
+            // Finally check pure Chrome (after excluding derivatives)
+            if (isChrome())
+                return "Chrome";
+            // Fallback: try to parse from user agent
+            const ua = navigator.userAgent;
+            if (/Firefox/i.test(ua) && !isChrome())
+                return "Firefox";
+            if (/Safari/i.test(ua) && !isChrome())
+                return "Safari";
+            if (/Chrome/i.test(ua))
+                return "Chrome"; // Last resort fallback
+            return "Unknown";
+        }
+        catch {
+            return "Unknown";
+        }
+    }
+    /**
+     * Gets browser engine name for debugging
+     */
+    function getBrowserEngine$1() {
+        if (isBrave() ||
+            isArc() ||
+            isOpera() ||
+            isVivaldi() ||
+            isSamsungInternet$1() ||
+            isChrome())
+            return "Blink";
+        if (isEdge())
+            return "EdgeHTML/Blink";
+        if (isFirefox())
+            return "Gecko";
+        if (isWebKit$1() || isSafari())
+            return "WebKit";
+        return "Unknown";
+    }
+    /**
+     * Gets detailed browser information with accurate Chromium-based detection
+     */
+    function getBrowserInfo() {
+        const name = getBrowserName();
+        const engine = getBrowserEngine$1();
+        const chromiumBased = [
+            "Brave",
+            "Arc",
+            "Opera",
+            "Vivaldi",
+            "Samsung Internet",
+            "Edge",
+            "Chrome",
+        ].includes(name);
+        // Browser family for fingerprinting stability
+        let family = name.toLowerCase();
+        if (chromiumBased && name !== "Chrome") {
+            family = `${name.toLowerCase()}-chromium`; // e.g., "brave-chromium"
+        }
+        return {
+            name,
+            engine,
+            isChromiumBased: chromiumBased,
+            family,
+        };
+    }
+    /**
+     * Checks if the current environment supports DOM manipulation
+     */
+    function supportsDOMManipulation() {
+        try {
+            return (typeof document !== "undefined" &&
+                typeof document.createElement === "function" &&
+                typeof document.body !== "undefined");
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Checks if the current environment supports media queries
+     */
+    function supportsMediaQueries() {
+        try {
+            return (typeof window !== "undefined" && typeof window.matchMedia === "function");
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Checks if WebGL is likely to be available and stable
+     */
+    function supportsWebGL() {
+        try {
+            if (!supportsDOMManipulation())
+                return false;
+            const canvas = document.createElement("canvas");
+            const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+            if (!gl)
+                return false;
+            // Quick stability check
+            const webglContext = gl;
+            const renderer = webglContext.getParameter(webglContext.RENDERER);
+            const isSupported = Boolean(renderer && typeof renderer === "string");
+            // Cleanup context to avoid "Too many active WebGL contexts" warning
+            const ext = webglContext.getExtension("WEBGL_lose_context");
+            if (ext) {
+                ext.loseContext();
+            }
+            return isSupported;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Checks if audio context is available and not suspended
+     */
+    function supportsAudioContext() {
+        try {
+            const AudioContext = window.AudioContext || window.webkitAudioContext;
+            if (!AudioContext)
+                return false;
+            // Don't create context here, just check availability
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function getBrowserCapabilities$1() {
+        const supportsDOM = supportsDOMManipulation();
+        const supportsMedia = supportsMediaQueries();
+        return {
+            engine: getBrowserEngine$1(),
+            supportsDOM,
+            supportsMediaQueries: supportsMedia,
+            supportsWebGL: supportsWebGL(),
+            supportsAudio: supportsAudioContext(),
+            isSecure: isSecureContext(),
+            isPrivateMode: isLikelyPrivateMode(),
+            // DOM blockers work best on WebKit and Android
+            canRunDOMBlockers: (isWebKit$1() || isAndroid$1()) && supportsDOM,
+            // Accessibility requires media queries
+            canRunAccessibility: supportsMedia,
+            // Browser APIs need secure context for many features
+            canRunBrowserAPIs: supportsDOM && typeof navigator !== "undefined",
+        };
+    }
+
     /**
      * Browser and System Information Fingerprinting
      * Based on FingerprintJS browser component with enhanced detection
@@ -597,10 +1228,27 @@
             return { platform: '', userAgent: '' };
         }
     }
+    /**
+     * Get precise browser information with Chromium-based browser detection
+     */
+    function getEnhancedBrowserInfo() {
+        try {
+            return getBrowserInfo();
+        }
+        catch {
+            // Fallback if detection fails
+            return {
+                name: 'Unknown',
+                engine: 'Unknown',
+                isChromiumBased: false,
+                family: 'unknown'
+            };
+        }
+    }
     /**
      * Get browser capabilities
      */
-    function getBrowserCapabilities$1() {
+    function getBrowserCapabilities() {
         try {
             const cookieEnabled = navigator.cookieEnabled !== false;
             // Do Not Track
@@ -631,9 +1279,10 @@
             const timezoneInfo = getTimezoneInfo();
             const platformInfo = getPlatformInfo();
             const hardwareInfo = getHardwareInfo();
-            const capabilities = getBrowserCapabilities$1();
+            const capabilities = getBrowserCapabilities();
             const pluginInfo = getPluginInfo();
             const touchSupport = getTouchSupport$1();
+            const enhancedBrowserInfo = getEnhancedBrowserInfo();
             const endTime = performance.now();
             const result = {
                 // Language and locale
@@ -645,6 +1294,8 @@
                 // Platform information
                 platform: platformInfo.platform,
                 userAgent: platformInfo.userAgent,
+                // Enhanced browser identification (solves Chromium masquerading!)
+                browserInfo: enhancedBrowserInfo,
                 // Hardware information
                 hardwareConcurrency: hardwareInfo.hardwareConcurrency,
                 // Browser capabilities
@@ -701,133 +1352,361 @@
      * Based on FingerprintJS canvas component with incognito detection
      */
     /**
-     * Text to render for canvas fingerprinting
+     * Text to render for canvas fingerprinting with maximum differentiation
      */
-    const CANVAS_TEXT = 'RabbitTracker Canvas 🎨 🔒 2024';
+    const CANVAS_TEXTS = [
+        "Zap Canvas 🎨🔒2024",
+        "Żółć gęślą jaźń €$¢£¥",
+        "αβγδεζηθικλμνξο",
+        "中文测试字体渲染",
+        "🌟🎯🚀💎🌊🎨",
+    ];
     /**
-     * Geometric shapes for canvas fingerprinting
-     */
-    function drawGeometry(ctx) {
-        // Set up styles
-        ctx.fillStyle = 'rgb(102, 204, 0)';
-        ctx.fillRect(10, 10, 50, 50);
-        ctx.fillStyle = '#f60';
-        ctx.fillRect(70, 10, 50, 50);
-        // Draw circle
+     * Enhanced geometric shapes for canvas fingerprinting with sub-pixel precision
+     */
+    function drawAdvancedGeometry(ctx) {
+        // Enable high-quality rendering for sub-pixel differences
+        ctx.imageSmoothingEnabled = true;
+        ctx.imageSmoothingQuality = "high";
+        // Complex gradient with multiple stops
+        const radialGradient = ctx.createRadialGradient(75, 75, 0, 75, 75, 50);
+        radialGradient.addColorStop(0, "rgba(255, 0, 0, 0.8)");
+        radialGradient.addColorStop(0.3, "rgba(0, 255, 0, 0.6)");
+        radialGradient.addColorStop(0.7, "rgba(0, 0, 255, 0.4)");
+        radialGradient.addColorStop(1, "rgba(255, 255, 0, 0.2)");
+        ctx.fillStyle = radialGradient;
+        ctx.fillRect(10, 10, 130, 100);
+        // Sub-pixel positioned shapes for GPU/anti-aliasing differentiation
+        ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+        ctx.fillRect(15.5, 15.3, 49.7, 49.2);
+        ctx.fillStyle = "#f60";
+        ctx.fillRect(70.3, 10.7, 50.1, 50.9);
+        // Complex bezier curves that stress different rendering engines
         ctx.beginPath();
-        ctx.arc(50, 80, 20, 0, Math.PI * 2, true);
+        ctx.moveTo(25.2, 120.1);
+        ctx.bezierCurveTo(25.2, 120.1, 75.8, 90.3, 125.5, 120.7);
+        ctx.bezierCurveTo(125.5, 120.7, 90.1, 150.2, 60.8, 140.9);
         ctx.closePath();
+        ctx.fillStyle = "rgba(200, 100, 50, 0.6)";
         ctx.fill();
-        // Draw triangle
+        // Overlapping circles with complex blending
+        ctx.globalCompositeOperation = "multiply";
         ctx.beginPath();
-        ctx.moveTo(100, 80);
-        ctx.lineTo(120, 120);
-        ctx.lineTo(80, 120);
-        ctx.closePath();
-        ctx.stroke();
-        // Add gradient
-        const gradient = ctx.createLinearGradient(0, 0, 150, 150);
-        gradient.addColorStop(0, 'red');
-        gradient.addColorStop(1, 'blue');
-        ctx.fillStyle = gradient;
-        ctx.fillRect(130, 10, 50, 50);
-    }
-    /**
-     * Draw text with various styles
-     */
-    function drawText(ctx) {
-        // Text with emoji and special characters
-        ctx.textBaseline = 'top';
-        ctx.font = '14px Arial, sans-serif';
-        ctx.fillStyle = '#000';
-        ctx.fillText(CANVAS_TEXT, 4, 140);
-        // Different font
-        ctx.font = '12px Georgia, serif';
-        ctx.fillStyle = '#666';
-        ctx.fillText('Georgia Font Test', 4, 160);
-        // Bold text
-        ctx.font = 'bold 16px Helvetica';
-        ctx.fillStyle = '#333';
-        ctx.fillText('Bold Helvetica', 4, 180);
-        // Apply transformations
+        ctx.arc(50.7, 80.3, 20.1, 0, Math.PI * 2);
+        ctx.fillStyle = "rgba(255, 0, 100, 0.5)";
+        ctx.fill();
+        ctx.beginPath();
+        ctx.arc(70.3, 80.7, 20.9, 0, Math.PI * 2);
+        ctx.fillStyle = "rgba(0, 255, 100, 0.5)";
+        ctx.fill();
+        ctx.globalCompositeOperation = "source-over";
+        // Thin lines to test anti-aliasing
+        ctx.strokeStyle = "rgba(50, 50, 50, 0.8)";
+        ctx.lineWidth = 0.5;
+        ctx.setLineDash([2.3, 1.7]);
+        for (let i = 0; i < 10; i++) {
+            ctx.beginPath();
+            ctx.moveTo(10 + i * 13.7, 160);
+            ctx.lineTo(50 + i * 11.3, 200);
+            ctx.stroke();
+        }
+        // Reset line dash
+        ctx.setLineDash([]);
+        // Pattern with complex repeating elements
+        const patternCanvas = document.createElement("canvas");
+        patternCanvas.width = 20;
+        patternCanvas.height = 20;
+        const patternCtx = patternCanvas.getContext("2d");
+        if (patternCtx) {
+            patternCtx.fillStyle = "rgba(150, 75, 200, 0.3)";
+            patternCtx.fillRect(0, 0, 10, 10);
+            patternCtx.fillRect(10, 10, 10, 10);
+            const pattern = ctx.createPattern(patternCanvas, "repeat");
+            if (pattern) {
+                ctx.fillStyle = pattern;
+                ctx.fillRect(150, 120, 80, 60);
+            }
+        }
+        // Shadow effects for additional GPU differentiation
+        ctx.shadowColor = "rgba(0, 0, 0, 0.5)";
+        ctx.shadowBlur = 3.2;
+        ctx.shadowOffsetX = 2.1;
+        ctx.shadowOffsetY = 2.7;
+        ctx.fillStyle = "rgba(100, 200, 150, 0.8)";
+        ctx.fillRect(160, 30, 60, 40);
+        // Reset shadow
+        ctx.shadowColor = "transparent";
+        ctx.shadowBlur = 0;
+        ctx.shadowOffsetX = 0;
+        ctx.shadowOffsetY = 0;
+    }
+    /**
+     * Draw multiple text samples with different fonts and effects for maximum differentiation
+     */
+    function drawAdvancedText(ctx) {
+        const fonts = [
+            "14px Arial, sans-serif",
+            '13px "Times New Roman", serif',
+            "12px Georgia, serif",
+            "15px Helvetica, Arial, sans-serif",
+            '11px "Courier New", monospace',
+            "13px Verdana, sans-serif",
+            "16px Impact, fantasy",
+            '12px "Comic Sans MS", cursive',
+        ];
+        const colors = [
+            "#000",
+            "#333",
+            "#666",
+            "#999",
+            "rgba(255, 0, 0, 0.8)",
+            "rgba(0, 255, 0, 0.7)",
+            "rgba(0, 0, 255, 0.6)",
+            "rgba(128, 64, 192, 0.9)",
+        ];
+        // Test different text baselines and alignments
+        const baselines = [
+            "top",
+            "hanging",
+            "middle",
+            "alphabetic",
+            "bottom",
+        ];
+        const alignments = ["left", "center", "right"];
+        let y = 250;
+        CANVAS_TEXTS.forEach((text, textIndex) => {
+            fonts.forEach((font, fontIndex) => {
+                const colorIndex = (textIndex + fontIndex) % colors.length;
+                const baselineIndex = fontIndex % baselines.length;
+                const alignIndex = fontIndex % alignments.length;
+                ctx.font = font;
+                ctx.fillStyle = colors[colorIndex] || colors[0];
+                ctx.textBaseline = baselines[baselineIndex] || "top";
+                ctx.textAlign = alignments[alignIndex] || "left";
+                // Sub-pixel positioning for enhanced differentiation
+                const x = 10 + ((fontIndex * 0.7) % 200);
+                const yPos = y + ((fontIndex * 18.3) % 100);
+                ctx.fillText(text, x, yPos);
+                // Add stroke text for additional GPU stress testing
+                if (fontIndex % 2 === 0) {
+                    ctx.strokeStyle = `rgba(${100 + fontIndex * 20}, ${50 + fontIndex * 15}, ${150 + fontIndex * 10}, 0.5)`;
+                    ctx.lineWidth = 0.3;
+                    ctx.strokeText(text, x + 0.5, yPos + 0.5);
+                }
+            });
+            y += 120;
+        });
+        // Test text with transformations that stress different rendering engines
         ctx.save();
+        ctx.translate(100, 400);
+        ctx.rotate(Math.PI / 6);
         ctx.scale(1.2, 0.8);
-        ctx.font = '10px Courier New';
-        ctx.fillStyle = '#999';
-        ctx.fillText('Transformed Text', 4, 220);
+        ctx.font = "italic 14px Arial";
+        ctx.fillStyle = "rgba(200, 100, 50, 0.8)";
+        ctx.fillText("Transformed & Rotated Text", 0, 0);
         ctx.restore();
+        // Test very small and very large text
+        ctx.font = "6px Arial";
+        ctx.fillStyle = "#000";
+        ctx.fillText("Tiny text rendering test", 10, 500);
+        ctx.font = "32px Arial";
+        ctx.fillStyle = "rgba(255, 0, 0, 0.5)";
+        ctx.fillText("Large", 10, 540);
+        // Reset text properties
+        ctx.textAlign = "left";
+        ctx.textBaseline = "top";
+    }
+    /**
+     * Analyze sub-pixel differences for enhanced GPU/anti-aliasing detection
+     */
+    function analyzeSubPixels(ctx, canvas) {
+        try {
+            // Create test pattern for sub-pixel analysis
+            ctx.clearRect(0, 0, canvas.width, canvas.height);
+            // Draw shapes at sub-pixel coordinates to stress anti-aliasing
+            ctx.fillStyle = "rgb(100, 150, 200)";
+            ctx.fillRect(10.3, 10.7, 20.1, 20.9);
+            ctx.strokeStyle = "rgb(200, 100, 50)";
+            ctx.lineWidth = 1.3;
+            ctx.beginPath();
+            ctx.moveTo(15.2, 35.8);
+            ctx.lineTo(25.7, 45.1);
+            ctx.stroke();
+            // Get pixel data for analysis
+            const imageData = ctx.getImageData(10, 10, 30, 40);
+            const pixels = imageData.data;
+            // Calculate sub-pixel characteristics
+            let redSum = 0, greenSum = 0, blueSum = 0;
+            let edgeVariance = 0;
+            for (let i = 0; i < pixels.length; i += 4) {
+                redSum += pixels[i] || 0;
+                greenSum += pixels[i + 1] || 0;
+                blueSum += pixels[i + 2] || 0;
+                // Calculate edge variance for anti-aliasing detection
+                if (i > 0) {
+                    const prevR = pixels[i - 4] || 0;
+                    const currR = pixels[i] || 0;
+                    edgeVariance += Math.abs(currR - prevR);
+                }
+            }
+            const pixelCount = pixels.length / 4;
+            const avgRed = Math.round(redSum / pixelCount);
+            const avgGreen = Math.round(greenSum / pixelCount);
+            const avgBlue = Math.round(blueSum / pixelCount);
+            const avgVariance = Math.round(edgeVariance / pixelCount);
+            return `${avgRed}-${avgGreen}-${avgBlue}-${avgVariance}`;
+        }
+        catch (error) {
+            return "subpixel-error";
+        }
     }
     /**
-     * Detect potential incognito mode through canvas inconsistencies
+     * Detect potential incognito mode and canvas blocking through multiple methods
      */
-    function detectInconsistencies(textData, geometryData, ctx) {
+    function detectAdvancedInconsistencies(textHash, geometryHash, subPixelData, ctx) {
+        const reasons = [];
+        let suspiciousSignals = 0;
         try {
-            // Test if getImageData works consistently
+            // Test 1: Check if getImageData works consistently
             const imageData = ctx.getImageData(0, 0, 1, 1);
-            // In some browsers in incognito mode, canvas operations might be slightly different
-            // This is a heuristic check
-            if (textData.length < 100 || geometryData.length < 100) {
-                return true; // Suspiciously short data
-            }
-            // Check for specific patterns that might indicate canvas blocking
-            const hasExpectedPatterns = textData.includes('data:image/png') &&
-                geometryData.includes('data:image/png');
-            return !hasExpectedPatterns;
+            if (!imageData || imageData.data.length === 0) {
+                reasons.push("getImageData-blocked");
+                suspiciousSignals += 3;
+            }
+            // Test 2: Check hash lengths (blocked canvas often returns default values)
+            if (textHash.length < 8 || geometryHash.length < 8) {
+                reasons.push("short-hash");
+                suspiciousSignals += 2;
+            }
+            // Test 3: Check for known blocked patterns
+            const knownBlockedHashes = [
+                "error",
+                "blocked",
+                "disabled",
+                "00000000",
+                "ffffffff",
+                "12345678",
+            ];
+            if (knownBlockedHashes.includes(textHash) ||
+                knownBlockedHashes.includes(geometryHash)) {
+                reasons.push("known-blocked-hash");
+                suspiciousSignals += 3;
+            }
+            // Test 4: Sub-pixel analysis indicates blocking
+            if (subPixelData === "subpixel-error" || subPixelData.includes("0-0-0")) {
+                reasons.push("subpixel-anomaly");
+                suspiciousSignals += 2;
+            }
+            // Test 5: Same hash for different operations (indicates fake canvas)
+            if (textHash === geometryHash && textHash !== "error") {
+                reasons.push("identical-hashes");
+                suspiciousSignals += 2;
+            }
+            // Test 6: toDataURL performance (some privacy tools slow it down)
+            const canvas = document.createElement("canvas");
+            canvas.width = 10;
+            canvas.height = 10;
+            const testCtx = canvas.getContext("2d");
+            if (testCtx) {
+                const start = performance.now();
+                testCtx.fillStyle = "red";
+                testCtx.fillRect(0, 0, 10, 10);
+                canvas.toDataURL();
+                const duration = performance.now() - start;
+                // Suspiciously slow canvas operations
+                if (duration > 50) {
+                    reasons.push("slow-canvas");
+                    suspiciousSignals += 1;
+                }
+            }
+            const confidence = Math.min(suspiciousSignals / 5, 1); // Normalize to 0-1
+            const isInconsistent = suspiciousSignals >= 2; // Threshold for inconsistency
+            return { isInconsistent, confidence, reasons };
         }
         catch (error) {
-            // If getImageData fails, it might indicate blocking
-            return true;
+            return {
+                isInconsistent: true,
+                confidence: 1,
+                reasons: ["detection-error"],
+            };
         }
     }
     /**
-     * Generate canvas fingerprint
+     * Generate enhanced canvas fingerprint with multiple primitives and sub-pixel analysis
      */
     async function getCanvasFingerprint() {
         const startTime = performance.now();
         try {
-            // Create canvas element
-            const canvas = document.createElement('canvas');
-            canvas.width = 200;
-            canvas.height = 250;
-            const ctx = canvas.getContext('2d');
+            // Create larger canvas for more detailed fingerprinting
+            const canvas = document.createElement("canvas");
+            canvas.width = 300;
+            canvas.height = 600;
+            const ctx = canvas.getContext("2d", {
+                alpha: true,
+                desynchronized: false,
+                colorSpace: "srgb",
+                willReadFrequently: true,
+            });
             if (!ctx) {
-                throw new Error('Canvas 2D context not available');
+                throw new Error("Canvas 2D context not available");
             }
-            // Test canvas winding (different behavior across browsers)
+            // Test canvas winding (different behavior across browsers/GPUs)
             ctx.rect(0, 0, 10, 10);
             ctx.rect(2, 2, 6, 6);
-            const isClockwise = ctx.isPointInPath(5, 5, 'evenodd');
-            // Draw text
-            drawText(ctx);
-            const textData = canvas.toDataURL();
-            // Clear and draw geometry
+            const isClockwise = ctx.isPointInPath(5, 5, "evenodd");
+            // ENHANCED: Draw advanced text with multiple fonts and effects
+            drawAdvancedText(ctx);
+            const textData = canvas.toDataURL("image/png");
+            const textHash = hash32(textData);
+            // Clear and draw advanced geometry
             ctx.clearRect(0, 0, canvas.width, canvas.height);
-            drawGeometry(ctx);
-            const geometryData = canvas.toDataURL();
-            // Check for inconsistencies that might indicate incognito mode
-            const isInconsistent = detectInconsistencies(textData, geometryData, ctx);
+            drawAdvancedGeometry(ctx);
+            const geometryData = canvas.toDataURL("image/png");
+            const geometryHash = hash32(geometryData);
+            // ENHANCED: Analyze sub-pixels for GPU/anti-aliasing differentiation
+            const subPixelAnalysis = analyzeSubPixels(ctx, canvas);
+            // ENHANCED: Advanced inconsistency detection
+            const inconsistencyAnalysis = detectAdvancedInconsistencies(textHash, geometryHash, subPixelAnalysis, ctx);
+            // Create composite canvas with both text and geometry for additional hash
+            ctx.clearRect(0, 0, canvas.width, canvas.height);
+            // Draw both text and geometry together
+            drawAdvancedText(ctx);
+            ctx.globalCompositeOperation = "multiply";
+            drawAdvancedGeometry(ctx);
+            ctx.globalCompositeOperation = "source-over";
+            const compositeData = canvas.toDataURL("image/png");
+            const compositeHash = hash32(compositeData);
             const endTime = performance.now();
             const result = {
-                text: hash32(textData),
-                geometry: hash32(geometryData),
+                text: textHash,
+                geometry: geometryHash,
                 winding: isClockwise,
-                isInconsistent
+                isInconsistent: inconsistencyAnalysis.isInconsistent,
+                // NEW FIELDS
+                subPixelAnalysis, // Sub-pixel characteristics for GPU differentiation
+                compositeHash, // Combined text+geometry hash
+                inconsistencyConfidence: inconsistencyAnalysis.confidence,
+                blockingReasons: inconsistencyAnalysis.reasons,
             };
             return {
                 value: result,
-                duration: endTime - startTime
+                duration: endTime - startTime,
             };
         }
         catch (error) {
             return {
                 value: {
-                    text: 'error',
-                    geometry: 'error',
+                    text: "error",
+                    geometry: "error",
                     winding: false,
-                    isInconsistent: true
+                    isInconsistent: true,
+                    subPixelAnalysis: "error",
+                    compositeHash: "error",
+                    inconsistencyConfidence: 1,
+                    blockingReasons: ["canvas-error"],
                 },
                 duration: performance.now() - startTime,
-                error: error instanceof Error ? error.message : 'Canvas fingerprinting failed'
+                error: error instanceof Error ? error.message : "Canvas fingerprinting failed",
             };
         }
     }
@@ -836,9 +1715,9 @@
      */
     function isCanvasAvailable$1() {
         try {
-            const canvas = document.createElement('canvas');
-            const ctx = canvas.getContext('2d');
-            return ctx !== null && typeof ctx.fillText === 'function';
+            const canvas = document.createElement("canvas");
+            const ctx = canvas.getContext("2d");
+            return ctx !== null && typeof ctx.fillText === "function";
         }
         catch {
             return false;
@@ -1658,347 +2537,370 @@
         return parameters;
     }
     /**
-     * Generate WebGL fingerprint (enhanced with caching)
-     */
-    async function getWebGLFingerprint() {
-        const startTime = performance.now();
-        try {
-            // Check if WebGL is available for this browser
-            if (!isWebGLAvailable()) {
-                throw new Error('WebGL not supported in this browser');
-            }
-            const gl = getCachedWebGLContext();
-            if (!gl) {
-                throw new Error('WebGL context not available');
-            }
-            // Verify context is still valid
-            if (!isWebGLContextValid()) {
-                throw new Error('WebGL context lost');
-            }
-            // Get basic WebGL information using cached parameters
-            const cachedParams = getWebGLParameters();
-            const vendor = cachedParams.VENDOR || 'unknown';
-            const renderer = cachedParams.RENDERER || 'unknown';
-            const version = cachedParams.VERSION || 'unknown';
-            // Get unmasked vendor/renderer if available (more specific GPU info)
-            let unmaskedVendor = vendor;
-            let unmaskedRenderer = renderer;
-            try {
-                const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
-                if (debugInfo) {
-                    unmaskedVendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) || vendor;
-                    unmaskedRenderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || renderer;
-                }
-            }
-            catch {
-                // Debug renderer info blocked or not available
-            }
-            // Collect extensions (cached)
-            const extensions = getWebGLExtensions$1();
-            // Collect parameters (cached)
-            const parameters = collectWebGLParameters(gl);
-            // Get shader precision
-            const shaderPrecision = getShaderPrecision(gl);
-            const endTime = performance.now();
-            const result = {
-                vendor: unmaskedVendor,
-                renderer: unmaskedRenderer,
-                version,
-                extensions,
-                parameters,
-                shaderPrecision
-            };
-            return {
-                value: result,
-                duration: endTime - startTime
-            };
-        }
-        catch (error) {
-            return {
-                value: {
-                    vendor: 'unknown',
-                    renderer: 'unknown',
-                    version: 'unknown',
-                    extensions: [],
-                    parameters: {},
-                    shaderPrecision: { vertex: '', fragment: '' }
-                },
-                duration: performance.now() - startTime,
-                error: error instanceof Error ? error.message : 'WebGL fingerprinting failed'
-            };
-        }
-    }
-    /**
-     * Singleton instance for WebGL availability check
-     */
-    let webglAvailabilityCache = null;
-    /**
-     * Check if WebGL fingerprinting is available (with proper cleanup)
-     */
-    function isWebGLAvailable() {
-        // Use cached result if available
-        if (webglAvailabilityCache !== null) {
-            return webglAvailabilityCache;
-        }
-        try {
-            const canvas = document.createElement('canvas');
-            canvas.width = 1;
-            canvas.height = 1;
-            const gl = canvas.getContext('webgl', {
-                failIfMajorPerformanceCaveat: true,
-                antialias: false,
-                alpha: false,
-                depth: false,
-                stencil: false,
-                preserveDrawingBuffer: false
-            }) || canvas.getContext('experimental-webgl', {
-                failIfMajorPerformanceCaveat: true,
-                antialias: false,
-                alpha: false,
-                depth: false,
-                stencil: false,
-                preserveDrawingBuffer: false
-            });
-            const isAvailable = gl !== null;
-            // Proper cleanup to prevent context leak
-            if (gl && 'getExtension' in gl) {
-                try {
-                    const webglContext = gl;
-                    const ext = webglContext.getExtension('WEBGL_lose_context');
-                    if (ext) {
-                        ext.loseContext();
-                    }
-                }
-                catch (e) {
-                    // Ignore cleanup errors
-                }
-            }
-            // Clean up canvas
-            canvas.width = 0;
-            canvas.height = 0;
-            // Cache the result
-            webglAvailabilityCache = isAvailable;
-            return isAvailable;
-        }
-        catch {
-            webglAvailabilityCache = false;
-            return false;
-        }
-    }
-
-    /**
-     * Browser Detection Utilities
-     * Based on FingerprintJS browser detection patterns
-     * Uses feature detection instead of user-agent parsing for reliability
-     */
-    /**
-     * Detects if the browser is WebKit-based (Safari, mobile Safari)
-     */
-    function isWebKit$1() {
-        try {
-            return ('WebKitAppearance' in document.documentElement.style ||
-                'webkitRequestFileSystem' in window ||
-                'webkitResolveLocalFileSystemURL' in window ||
-                Boolean(window.safari));
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Detects if the browser is running on Android
-     */
-    function isAndroid$1() {
-        try {
-            return ('ontouchstart' in window &&
-                ('orientation' in window || 'onorientationchange' in window) &&
-                /android/i.test(navigator.userAgent));
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Detects if the browser is Chrome/Chromium-based
-     */
-    function isChrome() {
-        try {
-            return Boolean(window.chrome &&
-                (window.chrome.webstore || window.chrome.runtime));
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Detects if the browser is Firefox
-     */
-    function isFirefox() {
-        try {
-            return ('InstallTrigger' in window ||
-                'mozInnerScreenX' in window ||
-                'mozPaintCount' in window ||
-                Boolean(navigator.mozApps));
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Detects if the browser is Edge (legacy or Chromium)
-     */
-    function isEdge() {
-        try {
-            return ('msCredentials' in navigator ||
-                Boolean(window.StyleMedia) ||
-                (isChrome() && /edg/i.test(navigator.userAgent)));
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Detects if the browser is Safari (not just WebKit)
+     * Create and compile a shader
      */
-    function isSafari() {
-        try {
-            return (isWebKit$1() &&
-                !isChrome() &&
-                !isEdge() &&
-                Boolean(window.safari) &&
-                /safari/i.test(navigator.userAgent));
-        }
-        catch {
-            return false;
+    function createShader(gl, type, source) {
+        const shader = gl.createShader(type);
+        if (!shader)
+            return null;
+        gl.shaderSource(shader, source);
+        gl.compileShader(shader);
+        if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+            gl.deleteShader(shader);
+            return null;
         }
+        return shader;
     }
     /**
-     * Detects if the browser is in a secure context
+     * Create and link a shader program
      */
-    function isSecureContext() {
-        try {
-            return window.isSecureContext || location.protocol === 'https:';
-        }
-        catch {
-            return false;
+    function createProgram(gl, vertexShader, fragmentShader) {
+        const program = gl.createProgram();
+        if (!program)
+            return null;
+        gl.attachShader(program, vertexShader);
+        gl.attachShader(program, fragmentShader);
+        gl.linkProgram(program);
+        if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+            gl.deleteProgram(program);
+            return null;
         }
-    }
-    /**
-     * Detects if the browser is likely in private/incognito mode
-     * This is a best-effort detection and not 100% reliable
-     */
-    function isLikelyPrivateMode() {
-        try {
-            // Quick checks for obvious private mode indicators
-            if ('webkitTemporaryStorage' in navigator) {
-                return false; // Likely not private
-            }
-            // Check for reduced storage quotas (common in private mode)
-            if (navigator.storage && navigator.storage.estimate) {
-                navigator.storage.estimate().then(estimate => {
-                    const quota = estimate.quota || 0;
-                    return quota < 1024 * 1024 * 100; // Less than 100MB likely indicates private mode
-                });
+        return program;
+    }
+    /**
+     * Render 3D scene to generate GPU-specific hash
+     * Based on FingerprintJS methodology for maximum differentiation
+     */
+    function render3DScene(gl) {
+        try {
+            // Vertex shader with complex calculations for GPU differentiation
+            const vertexShaderSource = `
+      attribute vec2 a_position;
+      attribute vec3 a_color;
+      varying vec3 v_color;
+      uniform float u_time;
+      
+      void main() {
+        // Complex mathematical operations to differentiate GPUs
+        float wave = sin(a_position.x * 10.0 + u_time) * 0.1;
+        vec2 position = a_position + vec2(wave, cos(a_position.y * 8.0) * 0.1);
+        
+        // GPU-specific floating point calculations
+        float precision = sin(position.x * 123.456) + cos(position.y * 789.012);
+        position += vec2(precision * 0.001);
+        
+        gl_Position = vec4(position, 0.0, 1.0);
+        v_color = a_color;
+      }
+    `;
+            // Fragment shader with GPU-specific precision differences
+            const fragmentShaderSource = `
+      precision mediump float;
+      varying vec3 v_color;
+      uniform float u_time;
+      
+      void main() {
+        // Complex color calculations that vary between GPU vendors
+        vec3 color = v_color;
+        color.r += sin(gl_FragCoord.x * 0.1 + u_time) * 0.1;
+        color.g += cos(gl_FragCoord.y * 0.1 + u_time) * 0.1;
+        color.b += sin((gl_FragCoord.x + gl_FragCoord.y) * 0.05) * 0.1;
+        
+        // GPU-specific precision in color calculations
+        color = normalize(color) * length(v_color);
+        
+        gl_FragColor = vec4(color, 1.0);
+      }
+    `;
+            // Create shaders
+            const vertexShader = createShader(gl, gl.VERTEX_SHADER, vertexShaderSource);
+            const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, fragmentShaderSource);
+            if (!vertexShader || !fragmentShader) {
+                return '';
             }
-            return false; // Default to not private if we can't determine
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Gets browser engine name for debugging
-     */
-    function getBrowserEngine$1() {
-        if (isChrome())
-            return 'Blink';
-        if (isFirefox())
-            return 'Gecko';
-        if (isWebKit$1())
-            return 'WebKit';
-        if (isEdge())
-            return 'EdgeHTML/Blink';
-        return 'Unknown';
-    }
-    /**
-     * Checks if the current environment supports DOM manipulation
-     */
-    function supportsDOMManipulation() {
-        try {
-            return (typeof document !== 'undefined' &&
-                typeof document.createElement === 'function' &&
-                typeof document.body !== 'undefined');
+            // Create program
+            const program = createProgram(gl, vertexShader, fragmentShader);
+            if (!program) {
+                return '';
+            }
+            gl.useProgram(program);
+            // Create complex geometry that differentiates GPU rendering
+            const vertices = new Float32Array([
+                // Triangle 1 (with colors)
+                -0.8, -0.6, 1.0, 0.2, 0.3,
+                0.0, 0.8, 0.3, 1.0, 0.2,
+                0.8, -0.6, 0.2, 0.3, 1.0,
+                // Triangle 2 (overlapping for blend complexity)
+                -0.5, -0.2, 0.8, 0.9, 0.1,
+                0.3, 0.6, 0.1, 0.8, 0.9,
+                0.7, -0.3, 0.9, 0.1, 0.8,
+            ]);
+            const buffer = gl.createBuffer();
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+            gl.bufferData(gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW);
+            // Set up attributes
+            const positionLocation = gl.getAttribLocation(program, 'a_position');
+            const colorLocation = gl.getAttribLocation(program, 'a_color');
+            const timeLocation = gl.getUniformLocation(program, 'u_time');
+            gl.enableVertexAttribArray(positionLocation);
+            gl.enableVertexAttribArray(colorLocation);
+            gl.vertexAttribPointer(positionLocation, 2, gl.FLOAT, false, 20, 0);
+            gl.vertexAttribPointer(colorLocation, 3, gl.FLOAT, false, 20, 8);
+            // Set time uniform to create animation-like effects
+            gl.uniform1f(timeLocation, 1.23456789);
+            // Enable blending for more complex GPU calculations
+            gl.enable(gl.BLEND);
+            gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+            // Clear with specific color to affect background
+            gl.clearColor(0.1, 0.2, 0.3, 1.0);
+            gl.clear(gl.COLOR_BUFFER_BIT);
+            // Draw triangles
+            gl.drawArrays(gl.TRIANGLES, 0, 6);
+            // Read pixels to generate hash
+            const pixels = new Uint8Array(gl.canvas.width * gl.canvas.height * 4);
+            gl.readPixels(0, 0, gl.canvas.width, gl.canvas.height, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
+            // Generate hash from rendered pixels
+            let hash = 0;
+            for (let i = 0; i < pixels.length; i += 4) {
+                // Combine RGBA values with different weights (with null checks)
+                const r = (pixels[i] ?? 0) * 1;
+                const g = (pixels[i + 1] ?? 0) * 256;
+                const b = (pixels[i + 2] ?? 0) * 65536;
+                const a = (pixels[i + 3] ?? 0) * 16777216;
+                const pixelValue = r + g + b + a;
+                hash = (hash * 33 + pixelValue) >>> 0; // Use unsigned 32-bit arithmetic
+            }
+            // Cleanup
+            gl.deleteProgram(program);
+            gl.deleteShader(vertexShader);
+            gl.deleteShader(fragmentShader);
+            gl.deleteBuffer(buffer);
+            return hash.toString(16);
         }
-        catch {
-            return false;
+        catch (error) {
+            return '';
+        }
+    }
+    /**
+     * Get advanced WebGL capabilities for differentiation
+     */
+    function getAdvancedWebGLCapabilities(gl) {
+        const capabilities = {};
+        try {
+            // GPU Memory information (if available)
+            const memoryInfo = gl.getExtension('WEBGL_debug_renderer_info');
+            if (memoryInfo) {
+                capabilities.unmaskedVendor = gl.getParameter(memoryInfo.UNMASKED_VENDOR_WEBGL);
+                capabilities.unmaskedRenderer = gl.getParameter(memoryInfo.UNMASKED_RENDERER_WEBGL);
+            }
+            // Texture capabilities
+            capabilities.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
+            capabilities.maxCombinedTextureImageUnits = gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS);
+            // Viewport and rendering capabilities
+            capabilities.maxViewportDims = gl.getParameter(gl.MAX_VIEWPORT_DIMS);
+            capabilities.maxRenderbufferSize = gl.getParameter(gl.MAX_RENDERBUFFER_SIZE);
+            // Vertex and fragment shader limits
+            capabilities.maxVertexAttribs = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
+            capabilities.maxVertexUniformVectors = gl.getParameter(gl.MAX_VERTEX_UNIFORM_VECTORS);
+            capabilities.maxFragmentUniformVectors = gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS);
+            capabilities.maxVaryingVectors = gl.getParameter(gl.MAX_VARYING_VECTORS);
+            // Antialiasing support
+            capabilities.antialias = gl.getContextAttributes()?.antialias || false;
+            // Floating point texture support
+            const floatTextureExt = gl.getExtension('OES_texture_float');
+            capabilities.floatTextures = !!floatTextureExt;
+            // Half float texture support
+            const halfFloatTextureExt = gl.getExtension('OES_texture_half_float');
+            capabilities.halfFloatTextures = !!halfFloatTextureExt;
+            // Compressed texture formats
+            const compressedFormats = gl.getParameter(gl.COMPRESSED_TEXTURE_FORMATS);
+            capabilities.compressedTextureFormats = Array.isArray(compressedFormats) ? compressedFormats.length : 0;
+            // WebGL 2.0 specific features (if available)
+            const isWebGL2 = gl instanceof WebGL2RenderingContext;
+            capabilities.webgl2 = isWebGL2;
+            if (isWebGL2) {
+                const gl2 = gl;
+                capabilities.maxColorAttachments = gl2.getParameter(gl2.MAX_COLOR_ATTACHMENTS);
+                capabilities.maxDrawBuffers = gl2.getParameter(gl2.MAX_DRAW_BUFFERS);
+                capabilities.maxTexture3DSize = gl2.getParameter(gl2.MAX_3D_TEXTURE_SIZE);
+            }
+            // Line width range
+            const lineWidthRange = gl.getParameter(gl.ALIASED_LINE_WIDTH_RANGE);
+            capabilities.lineWidthRange = Array.isArray(lineWidthRange) ? lineWidthRange.join(',') : '';
+            // Point size range
+            const pointSizeRange = gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE);
+            capabilities.pointSizeRange = Array.isArray(pointSizeRange) ? pointSizeRange.join(',') : '';
+        }
+        catch (error) {
+            // Capabilities detection failed
         }
+        return capabilities;
     }
     /**
-     * Checks if the current environment supports media queries
+     * Generate WebGL fingerprint (enhanced with 3D rendering and advanced capabilities)
      */
-    function supportsMediaQueries() {
+    async function getWebGLFingerprint() {
+        const startTime = performance.now();
         try {
-            return (typeof window !== 'undefined' &&
-                typeof window.matchMedia === 'function');
+            // Check if WebGL is available for this browser
+            if (!isWebGLAvailable()) {
+                throw new Error('WebGL not supported in this browser');
+            }
+            const gl = getCachedWebGLContext();
+            if (!gl) {
+                throw new Error('WebGL context not available');
+            }
+            // Verify context is still valid
+            if (!isWebGLContextValid()) {
+                throw new Error('WebGL context lost');
+            }
+            // Get basic WebGL information using cached parameters
+            const cachedParams = getWebGLParameters();
+            const vendor = cachedParams.VENDOR || 'unknown';
+            const renderer = cachedParams.RENDERER || 'unknown';
+            const version = cachedParams.VERSION || 'unknown';
+            // ENHANCED: Get unmasked vendor/renderer with retry logic
+            let unmaskedVendor = vendor;
+            let unmaskedRenderer = renderer;
+            for (let attempt = 0; attempt < 3; attempt++) {
+                try {
+                    const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+                    if (debugInfo) {
+                        const vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+                        const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+                        if (vendor && vendor !== 'unknown')
+                            unmaskedVendor = vendor;
+                        if (renderer && renderer !== 'unknown')
+                            unmaskedRenderer = renderer;
+                        break; // Success, exit retry loop
+                    }
+                }
+                catch (error) {
+                    if (attempt === 2) {
+                        // Final attempt failed, use fallback
+                        break;
+                    }
+                    // Wait a bit before retry
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                }
+            }
+            // Collect extensions (cached)
+            const extensions = getWebGLExtensions$1();
+            // Collect parameters (cached)
+            const parameters = collectWebGLParameters(gl);
+            // Get shader precision
+            const shaderPrecision = getShaderPrecision(gl);
+            // ENHANCED: Render 3D scene for GPU-specific hash
+            const renderHash = render3DScene(gl);
+            // ENHANCED: Get advanced capabilities
+            const capabilities = getAdvancedWebGLCapabilities(gl);
+            // ENHANCED: Create vendor/renderer hash for stable identification
+            const vendorRendererHash = (() => {
+                const vendorStr = unmaskedVendor || vendor || '';
+                const rendererStr = unmaskedRenderer || renderer || '';
+                const combined = `${vendorStr}|${rendererStr}`.toLowerCase();
+                // Simple hash function for consistent results
+                let hash = 0;
+                for (let i = 0; i < combined.length; i++) {
+                    const char = combined.charCodeAt(i);
+                    hash = ((hash << 5) - hash + char) & 0xffffffff;
+                }
+                return Math.abs(hash).toString(16);
+            })();
+            const endTime = performance.now();
+            const result = {
+                vendor: unmaskedVendor,
+                renderer: unmaskedRenderer,
+                version,
+                extensions,
+                parameters,
+                shaderPrecision,
+                renderHash, // NEW: GPU-specific 3D rendering hash
+                capabilities, // NEW: Advanced WebGL capabilities
+                vendorRendererHash, // NEW: Stable vendor/renderer identification
+                contextAttributes: gl.getContextAttributes() || {} // NEW: Context configuration
+            };
+            return {
+                value: result,
+                duration: endTime - startTime
+            };
         }
-        catch {
-            return false;
+        catch (error) {
+            return {
+                value: {
+                    vendor: 'unknown',
+                    renderer: 'unknown',
+                    version: 'unknown',
+                    extensions: [],
+                    parameters: {},
+                    shaderPrecision: { vertex: '', fragment: '' },
+                    renderHash: '',
+                    capabilities: {},
+                    vendorRendererHash: '',
+                    contextAttributes: {}
+                },
+                duration: performance.now() - startTime,
+                error: error instanceof Error ? error.message : 'WebGL fingerprinting failed'
+            };
         }
     }
     /**
-     * Checks if WebGL is likely to be available and stable
+     * Singleton instance for WebGL availability check
      */
-    function supportsWebGL() {
-        try {
-            if (!supportsDOMManipulation())
-                return false;
-            const canvas = document.createElement('canvas');
-            const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
-            if (!gl)
-                return false;
-            // Quick stability check
-            const webglContext = gl;
-            const renderer = webglContext.getParameter(webglContext.RENDERER);
-            return Boolean(renderer && typeof renderer === 'string');
-        }
-        catch {
-            return false;
-        }
-    }
+    let webglAvailabilityCache = null;
     /**
-     * Checks if audio context is available and not suspended
+     * Check if WebGL fingerprinting is available (with proper cleanup)
      */
-    function supportsAudioContext() {
+    function isWebGLAvailable() {
+        // Use cached result if available
+        if (webglAvailabilityCache !== null) {
+            return webglAvailabilityCache;
+        }
         try {
-            const AudioContext = window.AudioContext || window.webkitAudioContext;
-            if (!AudioContext)
-                return false;
-            // Don't create context here, just check availability
-            return true;
+            const canvas = document.createElement('canvas');
+            canvas.width = 1;
+            canvas.height = 1;
+            const gl = canvas.getContext('webgl', {
+                failIfMajorPerformanceCaveat: true,
+                antialias: false,
+                alpha: false,
+                depth: false,
+                stencil: false,
+                preserveDrawingBuffer: false
+            }) || canvas.getContext('experimental-webgl', {
+                failIfMajorPerformanceCaveat: true,
+                antialias: false,
+                alpha: false,
+                depth: false,
+                stencil: false,
+                preserveDrawingBuffer: false
+            });
+            const isAvailable = gl !== null;
+            // Proper cleanup to prevent context leak
+            if (gl && 'getExtension' in gl) {
+                try {
+                    const webglContext = gl;
+                    const ext = webglContext.getExtension('WEBGL_lose_context');
+                    if (ext) {
+                        ext.loseContext();
+                    }
+                }
+                catch (e) {
+                    // Ignore cleanup errors
+                }
+            }
+            // Clean up canvas
+            canvas.width = 0;
+            canvas.height = 0;
+            // Cache the result
+            webglAvailabilityCache = isAvailable;
+            return isAvailable;
         }
         catch {
+            webglAvailabilityCache = false;
             return false;
         }
     }
-    function getBrowserCapabilities() {
-        const supportsDOM = supportsDOMManipulation();
-        const supportsMedia = supportsMediaQueries();
-        return {
-            engine: getBrowserEngine$1(),
-            supportsDOM,
-            supportsMediaQueries: supportsMedia,
-            supportsWebGL: supportsWebGL(),
-            supportsAudio: supportsAudioContext(),
-            isSecure: isSecureContext(),
-            isPrivateMode: isLikelyPrivateMode(),
-            // DOM blockers work best on WebKit and Android
-            canRunDOMBlockers: (isWebKit$1() || isAndroid$1()) && supportsDOM,
-            // Accessibility requires media queries
-            canRunAccessibility: supportsMedia,
-            // Browser APIs need secure context for many features
-            canRunBrowserAPIs: supportsDOM && typeof navigator !== 'undefined',
-        };
-    }
 
     /**
      * Enhanced Accessibility & Media Queries Detection Module
@@ -2214,7 +3116,7 @@
      * Enhanced with browser compatibility checks
      */
     function isAccessibilityDetectionAvailable() {
-        const capabilities = getBrowserCapabilities();
+        const capabilities = getBrowserCapabilities$1();
         return capabilities.canRunAccessibility;
     }
     /**
@@ -2793,120 +3695,275 @@
     }
 
     /**
-     * Font Preferences Detection
-     * Based on FingerprintJS font preferences detection
+     * Enhanced Font Preferences Detection with Iframe Isolation
+     * Based on FingerprintJS font preferences detection with enhanced security and accuracy
      *
-     * This component measures text rendering widths with different font settings
+     * This component measures text rendering with different font settings using isolated iframes
      * to detect user's font preferences, OS-specific fonts, and browser rendering differences.
      *
      * Key advantages:
-     * - Detects OS-specific font rendering
-     * - Captures user font size preferences
-     * - Reveals browser-specific text rendering
-     * - Very stable across sessions
-     * - Difficult to spoof
+     * - Iframe isolation prevents external interference
+     * - Detects OS-specific font rendering and anti-aliasing
+     * - Captures user font size preferences and system settings
+     * - Reveals browser-specific text rendering differences
+     * - Very stable across sessions and difficult to spoof
+     * - Enhanced with sub-pixel rendering analysis
      */
     /**
      * Text content for measurements - chosen for maximum variation
      */
-    const defaultText = 'mmMwWLliI0fiflO&1';
-    const cjkText = '中文测试';
-    const arabicText = 'اختبار';
-    const hebrewText = 'בדיקה';
-    const emojiText = '🎯🔥💯';
-    const mathText = '∑∆∇∂';
-    const ligatureText = 'ffi ffl fi fl';
+    const defaultText = "mmMwWLliI0fiflO&1";
+    const cjkText = "中文测试";
+    const arabicText = "اختبار";
+    const hebrewText = "בדיקה";
+    const emojiText = "🎯🔥💯";
+    const mathText = "∑∆∇∂";
+    const ligatureText = "ffi ffl fi fl";
     const presets = {
         // Basic font families
         default: { text: defaultText },
         serif: {
-            style: { fontFamily: 'serif' },
-            text: defaultText
+            style: { fontFamily: "serif" },
+            text: defaultText,
         },
         sans: {
-            style: { fontFamily: 'sans-serif' },
-            text: defaultText
+            style: { fontFamily: "sans-serif" },
+            text: defaultText,
         },
         mono: {
-            style: { fontFamily: 'monospace' },
-            text: defaultText
+            style: { fontFamily: "monospace" },
+            text: defaultText,
         },
         // OS-specific fonts
         apple: {
-            style: { font: '-apple-system-body' },
-            text: defaultText
+            style: { font: "-apple-system-body" },
+            text: defaultText,
         },
         system: {
-            style: { fontFamily: 'system-ui' },
-            text: defaultText
+            style: { fontFamily: "system-ui" },
+            text: defaultText,
         },
         // Size variations
         min: {
-            style: { fontSize: '1px' },
-            text: defaultText
+            style: { fontSize: "1px" },
+            text: defaultText,
         },
         large: {
-            style: { fontSize: '72px' },
-            text: defaultText
+            style: { fontSize: "72px" },
+            text: defaultText,
         },
         // Browser UI fonts
         ui: {
-            style: { fontFamily: 'ui-serif' },
-            text: defaultText
+            style: { fontFamily: "ui-serif" },
+            text: defaultText,
         },
         emoji: {
-            style: { fontFamily: 'Apple Color Emoji, Segoe UI Emoji, Noto Color Emoji' },
-            text: emojiText
+            style: {
+                fontFamily: "Apple Color Emoji, Segoe UI Emoji, Noto Color Emoji",
+            },
+            text: emojiText,
         },
         math: {
-            style: { fontFamily: 'STIX Two Math, Cambria Math' },
-            text: mathText
+            style: { fontFamily: "STIX Two Math, Cambria Math" },
+            text: mathText,
         },
         // Script-specific fonts
         cjk: {
-            style: { fontFamily: 'Hiragino Sans, Microsoft YaHei, SimSun' },
-            text: cjkText
+            style: { fontFamily: "Hiragino Sans, Microsoft YaHei, SimSun" },
+            text: cjkText,
         },
         arabic: {
-            style: { fontFamily: 'Tahoma, Arial Unicode MS' },
-            text: arabicText
+            style: { fontFamily: "Tahoma, Arial Unicode MS" },
+            text: arabicText,
         },
         hebrew: {
-            style: { fontFamily: 'Tahoma, Arial Unicode MS' },
-            text: hebrewText
+            style: { fontFamily: "Tahoma, Arial Unicode MS" },
+            text: hebrewText,
         },
         // Advanced rendering features
         subpixel: {
             style: {
-                fontFamily: 'Arial',
-                fontSize: '11px',
-                textRendering: 'optimizeLegibility'
+                fontFamily: "Arial",
+                fontSize: "11px",
+                textRendering: "optimizeLegibility",
             },
-            text: defaultText
+            text: defaultText,
         },
         kerning: {
             style: {
-                fontFamily: 'Times',
-                fontSize: '24px',
-                fontKerning: 'normal'
+                fontFamily: "Times",
+                fontSize: "24px",
+                fontKerning: "normal",
             },
-            text: 'AV To'
+            text: "AV To",
         },
         ligatures: {
             style: {
-                fontFamily: 'Times',
-                fontSize: '24px',
-                fontVariantLigatures: 'common-ligatures'
+                fontFamily: "Times",
+                fontSize: "24px",
+                fontVariantLigatures: "common-ligatures",
             },
-            text: ligatureText
-        }
+            text: ligatureText,
+        },
     };
+    /**
+     * Analyze rendering quality to detect anti-aliasing and font smoothing
+     */
+    function analyzeRenderingQuality(iframeDoc, container, fontFamily = "Arial") {
+        try {
+            // Create canvas for pixel analysis
+            const canvas = iframeDoc.createElement("canvas");
+            canvas.width = 100;
+            canvas.height = 50;
+            const ctx = canvas.getContext("2d", { willReadFrequently: true });
+            if (!ctx)
+                return { quality: 0, antiAliasing: false, smoothing: 0 };
+            // Draw text at sub-pixel position to trigger anti-aliasing
+            ctx.font = `24px "${fontFamily}"`;
+            ctx.fillStyle = "#000000";
+            ctx.fillText("Wg", 10.5, 30.7);
+            // Analyze pixel data for anti-aliasing detection
+            const imageData = ctx.getImageData(10, 20, 30, 20);
+            const pixels = imageData.data;
+            let edgePixels = 0;
+            let grayscalePixels = 0;
+            let totalNonWhitePixels = 0;
+            for (let i = 0; i < pixels.length; i += 4) {
+                const r = pixels[i] || 0;
+                const g = pixels[i + 1] || 0;
+                const b = pixels[i + 2] || 0;
+                const alpha = pixels[i + 3] || 0;
+                // Skip transparent pixels
+                if (alpha < 10)
+                    continue;
+                totalNonWhitePixels++;
+                // Detect grayscale pixels (anti-aliasing indicator)
+                if (r === g && g === b && r > 0 && r < 255) {
+                    grayscalePixels++;
+                }
+                // Detect edge transitions
+                if (i > 4 && Math.abs(r - (pixels[i - 4] || 0)) > 50) {
+                    edgePixels++;
+                }
+            }
+            const antiAliasingRatio = totalNonWhitePixels > 0 ? grayscalePixels / totalNonWhitePixels : 0;
+            const smoothingLevel = totalNonWhitePixels > 0
+                ? (grayscalePixels * 100) / totalNonWhitePixels
+                : 0;
+            return {
+                quality: Math.round(smoothingLevel),
+                antiAliasing: antiAliasingRatio > 0.1,
+                smoothing: Math.round(smoothingLevel * 100) / 100,
+            };
+        }
+        catch (error) {
+            return { quality: 0, antiAliasing: false, smoothing: 0 };
+        }
+    }
+    /**
+     * Detect system font hinting and ClearType
+     */
+    function detectSystemFontHints(iframeDoc, container) {
+        try {
+            const canvas = iframeDoc.createElement("canvas");
+            canvas.width = 100;
+            canvas.height = 50;
+            const ctx = canvas.getContext("2d", { willReadFrequently: true });
+            if (!ctx) {
+                return { clearType: false, hintingLevel: 0, subpixelRendering: false };
+            }
+            // Test with known problematic character combinations
+            const testTexts = ["rn", "il", "WW", "mm"];
+            let clearTypeIndicators = 0;
+            let subpixelIndicators = 0;
+            let hintingScore = 0;
+            for (const text of testTexts) {
+                ctx.clearRect(0, 0, canvas.width, canvas.height);
+                ctx.font = "16px Arial";
+                ctx.fillStyle = "#000";
+                ctx.fillText(text, 10, 25);
+                const imageData = ctx.getImageData(10, 15, 40, 20);
+                const pixels = imageData.data;
+                // Analyze RGB sub-pixel rendering patterns
+                for (let i = 0; i < pixels.length; i += 12) {
+                    // Check every 3rd pixel
+                    const r1 = pixels[i] || 0;
+                    const g1 = pixels[i + 1] || 0;
+                    const b1 = pixels[i + 2] || 0;
+                    const r2 = pixels[i + 4] || 0;
+                    const g2 = pixels[i + 5] || 0;
+                    const b2 = pixels[i + 6] || 0;
+                    // ClearType creates RGB fringing
+                    if (Math.abs(r1 - g1) > 20 || Math.abs(g1 - b1) > 20) {
+                        clearTypeIndicators++;
+                    }
+                    // Sub-pixel rendering shows color channel differences
+                    if (Math.abs(r1 - r2) + Math.abs(g1 - g2) + Math.abs(b1 - b2) > 50) {
+                        subpixelIndicators++;
+                    }
+                    // Font hinting creates consistent patterns
+                    if ((r1 > 0 && r1 < 255) ||
+                        (g1 > 0 && g1 < 255) ||
+                        (b1 > 0 && b1 < 255)) {
+                        hintingScore++;
+                    }
+                }
+            }
+            return {
+                clearType: clearTypeIndicators > 10,
+                hintingLevel: Math.min(Math.round(hintingScore / 10), 5),
+                subpixelRendering: subpixelIndicators > 5,
+            };
+        }
+        catch (error) {
+            return {
+                clearType: false,
+                hintingLevel: 0,
+                subpixelRendering: false,
+            };
+        }
+    }
+    /**
+     * Test font fallback behavior
+     */
+    function testFontFallback(iframeDoc, container, fontFamily) {
+        try {
+            const testString = "mmmmmmmmmmlli"; // Characters that vary significantly between fonts
+            // Measure with specified font
+            const withFont = measureText(iframeDoc, container, {
+                style: { fontFamily },
+                text: testString,
+            });
+            // Measure with known fallback
+            const withFallback = measureText(iframeDoc, container, {
+                style: { fontFamily: "monospace" },
+                text: testString,
+            });
+            // Compare dimensions to detect fallback
+            const widthDiff = Math.abs(withFont - withFallback);
+            if (widthDiff < 1) {
+                return "monospace-fallback";
+            }
+            const withSansSerif = measureText(iframeDoc, container, {
+                style: { fontFamily: "sans-serif" },
+                text: testString,
+            });
+            const sansWidthDiff = Math.abs(withFont - withSansSerif);
+            if (sansWidthDiff < 1) {
+                return "sans-serif-fallback";
+            }
+            return "native-font";
+        }
+        catch (error) {
+            return "fallback-error";
+        }
+    }
     /**
      * Create measurement iframe for isolated font rendering
      */
     function createMeasurementIframe() {
         return new Promise((resolve, reject) => {
-            const iframe = document.createElement('iframe');
+            const iframe = document.createElement("iframe");
             // Iframe HTML with proper viewport for Android font size detection
             const iframeHtml = `<!doctype html>
       <html>
@@ -2925,14 +3982,15 @@
         <body></body>
       </html>`;
             // Hide iframe
-            iframe.style.cssText = 'position: absolute; left: -9999px; top: -9999px; width: 1px; height: 1px; opacity: 0;';
+            iframe.style.cssText =
+                "position: absolute; left: -9999px; top: -9999px; width: 1px; height: 1px; opacity: 0;";
             iframe.srcdoc = iframeHtml;
             iframe.onload = () => {
                 try {
                     const iframeDocument = iframe.contentDocument;
                     const iframeWindow = iframe.contentWindow;
                     if (!iframeDocument || !iframeWindow) {
-                        reject(new Error('Cannot access iframe content'));
+                        reject(new Error("Cannot access iframe content"));
                         return;
                     }
                     const body = iframeDocument.body;
@@ -2941,11 +3999,11 @@
                         body.style.zoom = `${1 / iframeWindow.devicePixelRatio}`;
                     }
                     else if (isWebKit$1()) {
-                        body.style.zoom = 'reset';
+                        body.style.zoom = "reset";
                     }
                     // Add dummy content for Android font size detection
-                    const dummyText = iframeDocument.createElement('div');
-                    dummyText.textContent = Array(200).fill('word').join(' ');
+                    const dummyText = iframeDocument.createElement("div");
+                    dummyText.textContent = Array(200).fill("word").join(" ");
                     body.appendChild(dummyText);
                     const cleanup = () => {
                         if (iframe.parentNode) {
@@ -2955,7 +4013,7 @@
                     resolve({
                         document: iframeDocument,
                         container: body,
-                        cleanup
+                        cleanup,
                     });
                 }
                 catch (error) {
@@ -2963,7 +4021,7 @@
                 }
             };
             iframe.onerror = () => {
-                reject(new Error('Failed to load iframe'));
+                reject(new Error("Failed to load iframe"));
             };
             document.body.appendChild(iframe);
         });
@@ -2972,12 +4030,13 @@
      * Measure text width with specific font settings
      */
     function measureText(document, container, preset) {
-        const element = document.createElement('span');
+        const element = document.createElement("span");
         const { style = {}, text = defaultText } = preset;
         // Set text content
         element.textContent = text;
         // Apply base styles
-        element.style.cssText = 'position: absolute; left: 0; top: 0; white-space: nowrap; visibility: hidden;';
+        element.style.cssText =
+            "position: absolute; left: 0; top: 0; white-space: nowrap; visibility: hidden;";
         // Apply preset styles
         Object.entries(style).forEach(([key, value]) => {
             if (value !== undefined) {
@@ -2991,11 +4050,11 @@
         return Math.round(width * 100) / 100; // Round to 2 decimal places
     }
     /**
-     * Get font preferences fingerprint
+     * Get enhanced font preferences fingerprint with iframe isolation
      */
     async function getFontPreferences() {
         try {
-            const { document: iframeDoc, container, cleanup } = await createMeasurementIframe();
+            const { document: iframeDoc, container, cleanup, } = await createMeasurementIframe();
             const measurements = {};
             // Measure all presets
             for (const [key, preset] of Object.entries(presets)) {
@@ -3007,15 +4066,68 @@
                     measurements[key] = 0;
                 }
             }
+            // NEW: Enhanced rendering analysis
+            const renderingAnalysis = analyzeRenderingQuality(iframeDoc, container, "Arial");
+            const systemHints = detectSystemFontHints(iframeDoc, container);
+            // NEW: Test fallback behavior for common fonts
+            const fallbackBehavior = {};
+            const commonFonts = [
+                "Arial",
+                "Helvetica",
+                "Times New Roman",
+                "Georgia",
+                "Courier New",
+            ];
+            for (const font of commonFonts) {
+                try {
+                    fallbackBehavior[font] = testFontFallback(iframeDoc, container, font);
+                }
+                catch (error) {
+                    fallbackBehavior[font] = "fallback-error";
+                }
+            }
+            // NEW: Create comprehensive hash for isolation verification
+            const hashComponents = [
+                JSON.stringify(measurements),
+                JSON.stringify(renderingAnalysis),
+                JSON.stringify(systemHints),
+                JSON.stringify(fallbackBehavior),
+            ];
+            const isolatedHash = hash32(hashComponents.join("|"));
             cleanup();
-            return measurements;
+            return {
+                ...measurements,
+                antiAliasing: {
+                    enabled: renderingAnalysis.antiAliasing,
+                    type: systemHints.clearType
+                        ? "cleartype"
+                        : renderingAnalysis.antiAliasing
+                            ? "standard"
+                            : "none",
+                    smoothingLevel: renderingAnalysis.smoothing,
+                },
+                systemFontHints: systemHints,
+                fallbackBehavior,
+                isolatedHash,
+            };
         }
         catch (error) {
             // Return fallback measurements if iframe creation fails
-            return Object.keys(presets).reduce((acc, key) => {
+            const fallbackMeasurements = Object.keys(presets).reduce((acc, key) => {
                 acc[key] = 0;
                 return acc;
             }, {});
+            return {
+                ...fallbackMeasurements,
+                antiAliasing: { enabled: false, type: "unknown", smoothingLevel: 0 },
+                systemFontHints: {
+                    clearType: false,
+                    hintingLevel: 0,
+                    subpixelRendering: false,
+                },
+                fallbackBehavior: {},
+                isolatedHash: "error",
+            };
         }
     }
     /**
@@ -3023,24 +4135,52 @@
      */
     function isFontPreferencesAvailable() {
         try {
-            return typeof document !== 'undefined' &&
-                typeof document.createElement === 'function' &&
-                typeof document.body !== 'undefined';
+            return (typeof document !== "undefined" &&
+                typeof document.createElement === "function" &&
+                typeof document.body !== "undefined");
         }
         catch {
             return false;
         }
     }
     /**
-     * Analyze font preferences for confidence and uniqueness
+     * Analyze enhanced font preferences for confidence and uniqueness
      */
     function analyzeFontPreferences(preferences) {
-        const values = Object.values(preferences);
+        // Get numeric measurements (excluding enhanced objects)
+        const numericValues = [
+            preferences.default,
+            preferences.serif,
+            preferences.sans,
+            preferences.mono,
+            preferences.apple,
+            preferences.system,
+            preferences.min,
+            preferences.large,
+            preferences.ui,
+            preferences.emoji,
+            preferences.math,
+            preferences.cjk,
+            preferences.arabic,
+            preferences.hebrew,
+            preferences.subpixel,
+            preferences.kerning,
+            preferences.ligatures,
+        ];
         // Check if we have real measurements (not all zeros)
-        const hasRealValues = values.some(val => val > 0);
-        const nonZeroCount = values.filter(val => val > 0).length;
-        const totalCount = values.length;
-        let confidence = hasRealValues ? (nonZeroCount / totalCount) : 0;
+        const hasRealValues = numericValues.some((val) => val > 0);
+        const nonZeroCount = numericValues.filter((val) => val > 0).length;
+        const totalCount = numericValues.length;
+        let confidence = hasRealValues ? nonZeroCount / totalCount : 0;
+        // Boost confidence if enhanced features are working
+        if (preferences.antiAliasing.enabled ||
+            preferences.systemFontHints.clearType) {
+            confidence += 0.2;
+        }
+        if (Object.keys(preferences.fallbackBehavior).length > 0) {
+            confidence += 0.1;
+        }
+        confidence = Math.min(confidence, 1);
         // Check for system font support
         const hasSystemFonts = preferences.apple > 0 || preferences.system > 0;
         // Check for advanced rendering features
@@ -3049,25 +4189,80 @@
             preferences.kerning,
             preferences.ligatures,
             preferences.emoji,
-            preferences.math
-        ].some(val => val > 0);
+            preferences.math,
+        ].some((val) => val > 0) ||
+            preferences.antiAliasing.enabled ||
+            preferences.systemFontHints.clearType;
         // Calculate uniqueness based on measurement variance
-        const average = values.reduce((sum, val) => sum + val, 0) / values.length;
-        const variance = values.reduce((sum, val) => sum + Math.pow(val - average, 2), 0) / values.length;
-        const uniqueness = Math.min(variance / 100, 1); // Normalize to 0-1
+        const average = numericValues.reduce((sum, val) => sum + val, 0) / numericValues.length;
+        const variance = numericValues.reduce((sum, val) => sum + Math.pow(val - average, 2), 0) /
+            numericValues.length;
+        let uniqueness = Math.min(variance / 100, 1); // Normalize to 0-1
+        // Boost uniqueness with enhanced features
+        if (preferences.antiAliasing.smoothingLevel > 0) {
+            uniqueness += 0.1;
+        }
+        if (preferences.systemFontHints.hintingLevel > 0) {
+            uniqueness += 0.1;
+        }
+        uniqueness = Math.min(uniqueness, 1);
+        // Determine rendering quality
+        let renderingQuality = "low";
+        const smoothingLevel = preferences.antiAliasing.smoothingLevel;
+        if (smoothingLevel > 50 || preferences.systemFontHints.clearType) {
+            renderingQuality = "high";
+        }
+        else if (smoothingLevel > 20 ||
+            preferences.systemFontHints.hintingLevel > 2) {
+            renderingQuality = "medium";
+        }
+        // Check isolation integrity
+        const isolationIntegrity = preferences.isolatedHash !== "error" && preferences.isolatedHash.length > 0;
         return {
             confidence: Math.round(confidence * 100) / 100,
             uniqueness: Math.round(uniqueness * 100) / 100,
             hasSystemFonts,
-            hasAdvancedFeatures
+            hasAdvancedFeatures,
+            renderingQuality,
+            isolationIntegrity,
         };
     }
     /**
-     * Get a compact hash of font preferences for quick comparison
+     * Get a compact hash of enhanced font preferences for quick comparison
      */
     function getFontPreferencesHash(preferences) {
-        const values = Object.values(preferences).map(val => Math.round(val));
-        return values.join(',');
+        // Use the isolated hash if available (most comprehensive)
+        if (preferences.isolatedHash && preferences.isolatedHash !== "error") {
+            return preferences.isolatedHash;
+        }
+        // Fallback to creating hash from numeric values
+        const numericValues = [
+            preferences.default,
+            preferences.serif,
+            preferences.sans,
+            preferences.mono,
+            preferences.apple,
+            preferences.system,
+            preferences.min,
+            preferences.large,
+            preferences.ui,
+            preferences.emoji,
+            preferences.math,
+            preferences.cjk,
+            preferences.arabic,
+            preferences.hebrew,
+            preferences.subpixel,
+            preferences.kerning,
+            preferences.ligatures,
+        ].map((val) => Math.round(val));
+        // Include rendering characteristics in fallback hash
+        const renderingIndicators = [
+            preferences.antiAliasing.enabled ? 1 : 0,
+            preferences.systemFontHints.clearType ? 1 : 0,
+            preferences.systemFontHints.hintingLevel,
+            Math.round(preferences.antiAliasing.smoothingLevel),
+        ];
+        return [...numericValues, ...renderingIndicators].join(",");
     }
 
     /**
@@ -4367,14 +5562,21 @@
                 // Silently fail - device signals are optional
             }
             const coreVector = {
-                // User agent family and major version only
-                // PRIORITY 1: Browser family only (no version - versions change frequently)
+                // PRIORITY 1: Enhanced browser detection with precise Chromium-based browser identification
                 ua: (() => {
-                    const ua = uaStr;
-                    const m = ua.match(/(chrome|safari|firefox|edge|edg|brave|opera|opr|chromium)/i);
-                    // Only use browser family, NOT version (versions update frequently causing hash changes)
-                    const family = (m?.[1] || ua.split(" ")[0] || "unknown").toLowerCase();
-                    return family; // Remove version for maximum stability
+                    try {
+                        const browserInfo = getBrowserInfo();
+                        // Use the precise browser family for maximum differentiation
+                        // This properly distinguishes Brave, Arc, Opera, etc. from Chrome
+                        return browserInfo.family; // e.g., "brave-chromium", "arc-chromium", "chrome", "firefox"
+                    }
+                    catch {
+                        // Fallback to legacy detection if imports fail
+                        const ua = uaStr;
+                        const m = ua.match(/(chrome|safari|firefox|edge|edg|brave|opera|opr|chromium)/i);
+                        const family = (m?.[1] || ua.split(" ")[0] || "unknown").toLowerCase();
+                        return family;
+                    }
                 })(),
                 // PRIORITY 2: Timezone (very stable, changes rarely)
                 timezone: browser?.timezone || "unknown",
@@ -4387,40 +5589,113 @@
                 platform: (browser?.platform || "unknown").toLowerCase(),
                 // PRIORITY 5: Device type (critical for differentiation, ultra-stable)
                 deviceType,
-                // PRIORITY 6: Screen resolution bucket (more stable than exact pixels)
+                // PRIORITY 6: Enhanced screen resolution buckets with 2024 display trends
                 screen: screen
                     ? (() => {
-                        // Use screen buckets instead of exact pixels for stability
+                        // Use enhanced screen buckets for modern display landscape
                         const dims = [screen.width, screen.height].sort((a, b) => b - a);
                         const w = dims[0];
                         const h = dims[1];
-                        // Create stability buckets that group similar resolutions
+                        // Enhanced screen bucketing based on 2024 display standards
                         const getScreenBucket = (width, height) => {
-                            // Common resolution buckets for stability
+                            // Ultra-high resolution displays (2024: 8K, 5K, etc.)
+                            if (width >= 7680)
+                                return "8k"; // 8K displays
+                            if (width >= 5120)
+                                return "5k"; // 5K displays (iMac, etc.)
+                            if (width >= 4096)
+                                return "4k_cinema"; // Cinema 4K
+                            if (width >= 3840)
+                                return "4k_uhd"; // 4K UHD standard
+                            if (width >= 3440)
+                                return "ultrawide"; // Ultrawide QHD
+                            if (width >= 2880)
+                                return "retina_4k"; // Retina 4K/5K scaled
                             if (width >= 2560)
-                                return "4k"; // 4K and above
+                                return "qhd"; // QHD/WQHD
+                            // Standard high-resolution displays
+                            if (width >= 2048)
+                                return "qxga"; // QXGA
                             if (width >= 1920)
-                                return "fhd"; // Full HD
+                                return "fhd"; // Full HD 1080p
+                            if (width >= 1680)
+                                return "wsxga+"; // WSXGA+
                             if (width >= 1600)
-                                return "hd+"; // HD+
+                                return "uxga"; // UXGA
+                            if (width >= 1440)
+                                return "wxga++"; // WXGA++
                             if (width >= 1366)
-                                return "hd"; // HD
+                                return "hd"; // HD 720p
+                            if (width >= 1280)
+                                return "sxga"; // SXGA
+                            // Tablet and mobile displays
                             if (width >= 1024)
-                                return "xga"; // XGA
+                                return "xga"; // XGA (tablets)
                             if (width >= 768)
-                                return "tablet"; // Tablet
-                            return "mobile"; // Mobile
+                                return "svga"; // SVGA (small tablets)
+                            if (width >= 640)
+                                return "vga"; // VGA (phones)
+                            if (width >= 480)
+                                return "hvga"; // HVGA (older phones)
+                            if (width >= 320)
+                                return "qvga"; // QVGA (legacy phones)
+                            return "minimal"; // Sub-QVGA
+                        };
+                        // Enhanced aspect ratio classification for device type hints
+                        const getAspectRatioClass = (width, height) => {
+                            if (height === 0)
+                                return "unknown";
+                            const ratio = width / height;
+                            // Ultra-wide displays (gaming, productivity)
+                            if (ratio >= 3.0)
+                                return "super_ultrawide"; // 32:9+
+                            if (ratio >= 2.3)
+                                return "ultrawide"; // 21:9
+                            if (ratio >= 2.0)
+                                return "wide"; // 18:9
+                            // Standard desktop ratios
+                            if (ratio >= 1.7 && ratio <= 1.8)
+                                return "standard"; // 16:9
+                            if (ratio >= 1.6 && ratio <= 1.67)
+                                return "classic"; // 16:10, 5:3
+                            if (ratio >= 1.3 && ratio <= 1.35)
+                                return "traditional"; // 4:3
+                            // Mobile/portrait ratios
+                            if (ratio >= 0.5 && ratio <= 0.8)
+                                return "mobile_portrait"; // Phones in portrait
+                            if (ratio >= 0.4 && ratio <= 0.5)
+                                return "tall_mobile"; // Modern tall phones
+                            return "custom"; // Non-standard ratio
                         };
                         // Ensure w and h are valid numbers
                         const width = w || 0;
                         const height = h || 0;
+                        // Screen density class based on common DPR patterns
+                        const getDensityClass = (pixelRatio) => {
+                            if (!pixelRatio)
+                                return "standard";
+                            if (pixelRatio >= 3.0)
+                                return "ultra_high"; // iPhone Plus, high-end Android
+                            if (pixelRatio >= 2.0)
+                                return "high"; // Retina, standard high-DPI
+                            if (pixelRatio >= 1.5)
+                                return "medium"; // Mid-range displays
+                            if (pixelRatio >= 1.25)
+                                return "enhanced"; // Slightly enhanced DPI
+                            return "standard"; // Standard 1x displays
+                        };
                         return {
                             bucket: getScreenBucket(width),
-                            ratio: height > 0 ? Math.round((width / height) * 10) / 10 : 0, // Aspect ratio rounded to 1 decimal
-                            // Remove exact dimensions and pixel ratio - they can vary slightly
+                            aspectClass: getAspectRatioClass(width, height),
+                            densityClass: getDensityClass(screen.pixelRatio || window.devicePixelRatio),
+                            // Simplified ratio for matching (rounded to prevent micro-variations)
+                            ratio: height > 0 ? Math.round((width / height) * 100) / 100 : 0,
+                            // Size category for general device classification
+                            sizeCategory: width >= 2560 ? "large" : width >= 1920 ? "desktop" :
+                                width >= 1024 ? "laptop" : width >= 768 ? "tablet" : "mobile"
                         };
                     })()
-                    : { bucket: "unknown", ratio: 0 },
+                    : { bucket: "unknown", aspectClass: "unknown", densityClass: "unknown", ratio: 0, sizeCategory: "unknown" },
                 // CRITICAL: Do NOT include availability flags (canvas/webgl/audio) in stableCoreVector
                 // These flags can change between requests due to timeouts, permissions, or hardware issues
                 // and would cause the stableCoreHash to change, breaking visitor identification
@@ -4432,50 +5707,163 @@
                 // - Order may vary despite sorting
                 // Keep plugins only in full fingerprint for analysis, not in stableCoreHash
                 // plugins: removed for stability
-                // PRIORITY 7: Core hardware characteristics (buckets for stability)
-                // Use hardware buckets instead of exact values to prevent micro-variations
+                // PRIORITY 7: Enhanced hardware characteristics with precise 2024 buckets
+                // Use advanced hardware buckets based on current hardware landscape for maximum stability
                 hardware: (() => {
                     const cores = deviceSignals$1.hardwareConcurrency;
                     const memory = deviceSignals$1.deviceMemory;
                     if (!cores && !memory)
                         return undefined;
-                    // Create stable hardware buckets
+                    // Enhanced CPU core buckets based on 2024 hardware trends
                     const getCoreBucket = (cores) => {
+                        // High-end workstations and servers (2024: up to 128 cores available)
+                        if (cores >= 32)
+                            return "workstation"; // 32+ cores: Threadripper, Xeon
+                        if (cores >= 20)
+                            return "ultra"; // 20-31 cores: High-end desktop
                         if (cores >= 16)
-                            return "high"; // 16+ cores
+                            return "high"; // 16-19 cores: Gaming/content creation
+                        if (cores >= 12)
+                            return "premium"; // 12-15 cores: Modern mid-high desktop
                         if (cores >= 8)
-                            return "mid"; // 8-15 cores
+                            return "mid"; // 8-11 cores: Standard desktop/laptop
+                        if (cores >= 6)
+                            return "normal"; // 6-7 cores: Entry-level modern
                         if (cores >= 4)
-                            return "normal"; // 4-7 cores
-                        return "low"; // 1-3 cores
+                            return "basic"; // 4-5 cores: Older desktop/budget laptop
+                        if (cores >= 2)
+                            return "low"; // 2-3 cores: Older mobile/budget
+                        return "minimal"; // 1 core: Legacy/embedded
                     };
+                    // Enhanced memory buckets based on 2024 standards
                     const getMemoryBucket = (memory) => {
+                        // Professional/Gaming systems (2024: up to 256GB+ available)
+                        if (memory >= 64)
+                            return "workstation"; // 64GB+: Professional/content creation
+                        if (memory >= 32)
+                            return "ultra"; // 32-63GB: High-end gaming/work
+                        if (memory >= 24)
+                            return "high"; // 24-31GB: Premium gaming
                         if (memory >= 16)
-                            return "high"; // 16GB+
+                            return "premium"; // 16-23GB: Standard gaming/work
+                        if (memory >= 12)
+                            return "mid"; // 12-15GB: Good performance
                         if (memory >= 8)
-                            return "mid"; // 8-15GB
+                            return "normal"; // 8-11GB: Acceptable performance
                         if (memory >= 4)
-                            return "normal"; // 4-7GB
-                        return "low"; // <4GB
+                            return "basic"; // 4-7GB: Budget desktop/laptop
+                        if (memory >= 2)
+                            return "low"; // 2-3GB: Older mobile devices
+                        return "minimal"; // <2GB: Legacy/embedded devices
+                    };
+                    // CPU architecture detection for additional differentiation
+                    const getArchitectureBucket = (arch) => {
+                        if (arch === undefined)
+                            return "unknown";
+                        // Based on floating point NaN behavior patterns
+                        if (arch === 255)
+                            return "arm64"; // ARM processors
+                        if (arch === 0)
+                            return "x86_64"; // Intel/AMD x86-64
+                        return "other"; // Other architectures
+                    };
+                    // Combined hardware profile for enhanced bucketing
+                    const coresBucket = cores ? getCoreBucket(cores) : "unknown";
+                    const memoryBucket = memory ? getMemoryBucket(memory) : "unknown";
+                    const archBucket = getArchitectureBucket(deviceSignals$1.architecture);
+                    // Create hardware class based on combined characteristics
+                    const getHardwareClass = (cores, memory, arch) => {
+                        // Professional workstation patterns
+                        if ((cores === "workstation" || cores === "ultra") &&
+                            (memory === "workstation" || memory === "ultra")) {
+                            return "professional";
+                        }
+                        // High-end gaming/content creation
+                        if ((cores === "high" || cores === "premium") &&
+                            (memory === "high" || memory === "premium" || memory === "ultra")) {
+                            return "enthusiast";
+                        }
+                        // Standard desktop/laptop
+                        if ((cores === "mid" || cores === "normal") &&
+                            (memory === "mid" || memory === "normal" || memory === "premium")) {
+                            return "mainstream";
+                        }
+                        // Budget/older systems
+                        if ((cores === "basic" || cores === "low") &&
+                            (memory === "basic" || memory === "low" || memory === "normal")) {
+                            return "budget";
+                        }
+                        // Mobile/embedded devices
+                        if (cores === "minimal" || memory === "minimal") {
+                            return "mobile";
+                        }
+                        // Mixed/uncertain configuration
+                        return "mixed";
                     };
                     return {
-                        cores: cores ? getCoreBucket(cores) : undefined,
-                        memory: memory ? getMemoryBucket(memory) : undefined,
+                        cores: coresBucket,
+                        memory: memoryBucket,
+                        arch: archBucket,
+                        class: getHardwareClass(coresBucket, memoryBucket),
+                        // Touch capability for mobile/desktop differentiation
+                        touch: deviceSignals$1.touchSupport?.maxTouchPoints ?
+                            (deviceSignals$1.touchSupport.maxTouchPoints >= 10 ? "multi" :
+                                deviceSignals$1.touchSupport.maxTouchPoints >= 5 ? "standard" : "basic") :
+                            "none"
                     };
                 })(),
-                // PRIORITY 8: Architecture (ultra-stable)
-                arch: deviceSignals$1.architecture || undefined,
-                // PRIORITY 9: Color depth bucket (more stable than exact values)
-                colorBucket: (() => {
+                // PRIORITY 8: Enhanced color and display capabilities bucketing
+                display: (() => {
                     const depth = deviceSignals$1.colorDepth;
-                    if (!depth)
-                        return undefined;
-                    // Bucket color depths for stability
-                    if (depth >= 32)
-                        return "high"; // 32-bit+
-                    if (depth >= 24)
-                        return "normal"; // 24-bit
-                    return "low"; // <24-bit
+                    const gamut = deviceSignals$1.colorGamut;
+                    // Enhanced color depth classification
+                    const getDepthClass = (depth) => {
+                        if (!depth)
+                            return "unknown";
+                        if (depth >= 48)
+                            return "ultra_high"; // 48-bit+ (professional displays)
+                        if (depth >= 32)
+                            return "high"; // 32-bit (high-end displays)
+                        if (depth >= 24)
+                            return "normal"; // 24-bit (standard displays)
+                        if (depth >= 16)
+                            return "basic"; // 16-bit (older displays)
+                        return "low"; // <16-bit (legacy displays)
+                    };
+                    // Color gamut classification for display capabilities
+                    const getGamutClass = (gamut) => {
+                        if (!gamut)
+                            return "unknown";
+                        switch (gamut) {
+                            case "rec2020": return "professional"; // Professional/HDR displays
+                            case "p3": return "enhanced"; // Modern displays (Apple, etc.)
+                            case "srgb": return "standard"; // Standard displays
+                            default: return "unknown";
+                        }
+                    };
+                    // Combined display quality classification
+                    const getDisplayClass = (depthClass, gamutClass) => {
+                        if (depthClass === "ultra_high" || gamutClass === "professional") {
+                            return "professional"; // Pro displays
+                        }
+                        if (depthClass === "high" || gamutClass === "enhanced") {
+                            return "premium"; // High-end displays
+                        }
+                        if (depthClass === "normal" && gamutClass === "standard") {
+                            return "standard"; // Standard displays
+                        }
+                        if (depthClass === "basic") {
+                            return "basic"; // Older displays
+                        }
+                        return "legacy"; // Legacy displays
+                    };
+                    const depthClass = getDepthClass(depth);
+                    const gamutClass = getGamutClass(gamut);
+                    return {
+                        depth: depthClass,
+                        gamut: gamutClass,
+                        class: getDisplayClass(depthClass, gamutClass)
+                    };
                 })(),
             };
             // ADDITIONAL ENTROPY: Add a deterministic but unique component based on ultra-stable signals
@@ -9877,7 +11265,7 @@
      * Based on FingerprintJS best practices
      */
     function isDomBlockersDetectionAvailable() {
-        const capabilities = getBrowserCapabilities();
+        const capabilities = getBrowserCapabilities$1();
         return capabilities.canRunDOMBlockers;
     }
     async function getDomBlockersFingerprint(options = {}) {
@@ -10529,7 +11917,7 @@
      * Enhanced with browser capability checks
      */
     function isEnhancedPluginDetectionAvailable() {
-        const capabilities = getBrowserCapabilities();
+        const capabilities = getBrowserCapabilities$1();
         return capabilities.canRunBrowserAPIs && typeof navigator !== 'undefined';
     }
     /**