@zaplier/sdk 1.0.2 → 1.0.3

package/dist/index.cjs

@@ -235,17 +235,21 @@ function hashStableCore(coreVector) {
  * 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)
@@ -307,40 +311,144 @@ function getDefaultSampleRate() {
     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");
     }
 }
 /**
@@ -352,7 +460,8 @@ async function generateCompressorFingerprint(offlineContext) {
         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);
@@ -381,35 +490,138 @@ async function generateCompressorFingerprint(offlineContext) {
     }
 }
 /**
- * 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,
@@ -423,6 +635,12 @@ async function getAudioFingerprint() {
                 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",
@@ -449,6 +667,411 @@ function isAudioAvailable() {
     }
 }
 
+/**
+ * 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);
+        return Boolean(renderer && typeof renderer === "string");
+    }
+    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
@@ -595,10 +1218,27 @@ function getPlatformInfo() {
         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
@@ -629,9 +1269,10 @@ async function getBrowserFingerprint() {
         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
@@ -643,6 +1284,8 @@ async function getBrowserFingerprint() {
             // Platform information
             platform: platformInfo.platform,
             userAgent: platformInfo.userAgent,
+            // Enhanced browser identification (solves Chromium masquerading!)
+            browserInfo: enhancedBrowserInfo,
             // Hardware information
             hardwareConcurrency: hardwareInfo.hardwareConcurrency,
             // Browser capabilities
@@ -699,117 +1342,324 @@ function isBrowserFingerprintingAvailable() {
  * 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 = [
+    'RabbitTracker 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);
+ * 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, 10, 50, 50);
-    // Draw circle
+    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
+        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;
         }
-        // Check for specific patterns that might indicate canvas blocking
-        const hasExpectedPatterns = textData.includes('data:image/png') &&
-            geometryData.includes('data:image/png');
-        return !hasExpectedPatterns;
+        // 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
+        // Create larger canvas for more detailed fingerprinting
         const canvas = document.createElement('canvas');
-        canvas.width = 200;
-        canvas.height = 250;
-        const ctx = canvas.getContext('2d');
+        canvas.width = 300;
+        canvas.height = 600;
+        const ctx = canvas.getContext('2d', {
+            alpha: true,
+            desynchronized: false,
+            colorSpace: 'srgb'
+        });
         if (!ctx) {
             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
+        // 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,
@@ -822,7 +1672,11 @@ async function getCanvasFingerprint() {
                 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'
@@ -1656,347 +2510,370 @@ function collectWebGLParameters(gl) {
     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
@@ -2212,7 +3089,7 @@ function getPointerCapability() {
  * Enhanced with browser compatibility checks
  */
 function isAccessibilityDetectionAvailable() {
-    const capabilities = getBrowserCapabilities();
+    const capabilities = getBrowserCapabilities$1();
     return capabilities.canRunAccessibility;
 }
 /**
@@ -2791,120 +3668,275 @@ function getDateTimeLocaleHash(localeData) {
 }
 
 /**
- * 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");
+        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");
+        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>
@@ -2923,14 +3955,15 @@ function createMeasurementIframe() {
         <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;
@@ -2939,11 +3972,11 @@ function createMeasurementIframe() {
                     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) {
@@ -2953,7 +3986,7 @@ function createMeasurementIframe() {
                 resolve({
                     document: iframeDocument,
                     container: body,
-                    cleanup
+                    cleanup,
                 });
             }
             catch (error) {
@@ -2961,7 +3994,7 @@ function createMeasurementIframe() {
             }
         };
         iframe.onerror = () => {
-            reject(new Error('Failed to load iframe'));
+            reject(new Error("Failed to load iframe"));
         };
         document.body.appendChild(iframe);
     });
@@ -2970,12 +4003,13 @@ function createMeasurementIframe() {
  * 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) {
@@ -2989,11 +4023,11 @@ function measureText(document, container, preset) {
     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)) {
@@ -3005,15 +4039,68 @@ async function getFontPreferences() {
                 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",
+        };
     }
 }
 /**
@@ -3021,24 +4108,52 @@ async function getFontPreferences() {
  */
 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
@@ -3047,25 +4162,80 @@ function analyzeFontPreferences(preferences) {
         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(",");
 }
 
 /**
@@ -4365,14 +5535,21 @@ async function collectFingerprint(options = {}) {
             // 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",
@@ -4385,40 +5562,113 @@ async function collectFingerprint(options = {}) {
             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
@@ -4430,50 +5680,163 @@ async function collectFingerprint(options = {}) {
             // - 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
@@ -9875,7 +11238,7 @@ async function getDomBlockers(options = {}) {
  * Based on FingerprintJS best practices
  */
 function isDomBlockersDetectionAvailable() {
-    const capabilities = getBrowserCapabilities();
+    const capabilities = getBrowserCapabilities$1();
     return capabilities.canRunDOMBlockers;
 }
 async function getDomBlockersFingerprint(options = {}) {
@@ -10527,7 +11890,7 @@ function generatePluginSignature(plugins, mimeTypes) {
  * Enhanced with browser capability checks
  */
 function isEnhancedPluginDetectionAvailable() {
-    const capabilities = getBrowserCapabilities();
+    const capabilities = getBrowserCapabilities$1();
     return capabilities.canRunBrowserAPIs && typeof navigator !== 'undefined';
 }
 /**