@zaplier/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,3517 @@
+/*!
+ * RabbitTracker SDK v3.0.0
+ * Advanced privacy-first tracking with fingerprinting and security detection
+ * (c) 2025 RabbitTracker Team
+ * Released under the MIT License
+ * https://rabbitracker.com
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * MurmurHash3 x64 Implementation
+ * Based on FingerprintJS hashing utility for consistent fingerprint generation
+ *
+ * Provides 128-bit hash output using the x64 variant of MurmurHash3
+ */
+/**
+ * Adds two 64-bit numbers
+ */
+function x64Add(a, b) {
+    const low = (a[1] + b[1]) & 0xffffffff;
+    const high = (a[0] + b[0] + (low < a[1] ? 1 : 0)) & 0xffffffff;
+    return [high, low];
+}
+/**
+ * Multiplies two 64-bit numbers
+ */
+function x64Multiply(a, b) {
+    const al = a[1] & 0xffff;
+    const ah = a[1] >>> 16;
+    const bl = b[1] & 0xffff;
+    const bh = b[1] >>> 16;
+    const rl = al * bl;
+    const rm = (al * bh + ah * bl) & 0xffffffff;
+    const rh = ah * bh + (rm >>> 16);
+    const low = (rl + ((rm & 0xffff) << 16)) & 0xffffffff;
+    const high = (a[0] * b[1] + a[1] * b[0] + rh) & 0xffffffff;
+    return [high, low];
+}
+/**
+ * Rotates a 64-bit number left by the specified number of bits
+ */
+function x64Rotl(value, shift) {
+    shift %= 64;
+    if (shift === 0)
+        return value;
+    if (shift < 32) {
+        const high = (value[0] << shift) | (value[1] >>> (32 - shift));
+        const low = (value[1] << shift) | (value[0] >>> (32 - shift));
+        return [high & 0xffffffff, low & 0xffffffff];
+    }
+    else {
+        shift -= 32;
+        const high = (value[1] << shift) | (value[0] >>> (32 - shift));
+        const low = (value[0] << shift) | (value[1] >>> (32 - shift));
+        return [high & 0xffffffff, low & 0xffffffff];
+    }
+}
+/**
+ * XORs two 64-bit numbers
+ */
+function x64Xor(a, b) {
+    return [a[0] ^ b[0], a[1] ^ b[1]];
+}
+/**
+ * Finalizes a 64-bit hash value
+ */
+function x64Fmix(hash) {
+    let h = hash;
+    h = x64Xor(h, [0, h[0] >>> 1]);
+    h = x64Multiply(h, [0xff51afd7, 0xed558ccd]);
+    h = x64Xor(h, [0, h[0] >>> 1]);
+    h = x64Multiply(h, [0xc4ceb9fe, 0x1a85ec53]);
+    h = x64Xor(h, [0, h[0] >>> 1]);
+    return h;
+}
+/**
+ * Converts a string to array of 32-bit integers (little-endian)
+ */
+function stringToUint32Array(str) {
+    const arr = [];
+    for (let i = 0; i < str.length; i += 4) {
+        let value = 0;
+        for (let j = Math.min(3, str.length - i - 1); j >= 0; j--) {
+            value = (value << 8) | str.charCodeAt(i + j);
+        }
+        arr.push(value);
+    }
+    return arr;
+}
+/**
+ * MurmurHash3 x64 128-bit hash function
+ * Returns a 128-bit hash as a hex string
+ */
+function x64hash128(input, seed = 0) {
+    const data = stringToUint32Array(input);
+    const nblocks = Math.floor(data.length / 4);
+    let h1 = [0, seed];
+    let h2 = [0, seed];
+    const c1 = [0x87c37b91, 0x114253d5];
+    const c2 = [0x4cf5ad43, 0x2745937f];
+    // Process 16-byte blocks
+    for (let i = 0; i < nblocks; i++) {
+        const k1Index = i * 4;
+        const k2Index = i * 4 + 2;
+        let k1 = [data[k1Index + 1] || 0, data[k1Index] || 0];
+        let k2 = [data[k2Index + 1] || 0, data[k2Index] || 0];
+        k1 = x64Multiply(k1, c1);
+        k1 = x64Rotl(k1, 31);
+        k1 = x64Multiply(k1, c2);
+        h1 = x64Xor(h1, k1);
+        h1 = x64Rotl(h1, 27);
+        h1 = x64Add(h1, h2);
+        h1 = x64Add(x64Multiply(h1, [0, 5]), [0, 0x52dce729]);
+        k2 = x64Multiply(k2, c2);
+        k2 = x64Rotl(k2, 33);
+        k2 = x64Multiply(k2, c1);
+        h2 = x64Xor(h2, k2);
+        h2 = x64Rotl(h2, 31);
+        h2 = x64Add(h2, h1);
+        h2 = x64Add(x64Multiply(h2, [0, 5]), [0, 0x38495ab5]);
+    }
+    // Process remaining bytes
+    const tailIndex = nblocks * 4;
+    const remainingBytes = data.length - tailIndex;
+    let k1 = [0, 0];
+    let k2 = [0, 0];
+    if (remainingBytes >= 12) {
+        k2 = x64Xor(k2, [data[tailIndex + 3] || 0, 0]);
+    }
+    if (remainingBytes >= 8) {
+        k2 = x64Xor(k2, [0, data[tailIndex + 2] || 0]);
+        k2 = x64Multiply(k2, c2);
+        k2 = x64Rotl(k2, 33);
+        k2 = x64Multiply(k2, c1);
+        h2 = x64Xor(h2, k2);
+    }
+    if (remainingBytes >= 4) {
+        k1 = x64Xor(k1, [data[tailIndex + 1] || 0, 0]);
+    }
+    if (remainingBytes >= 1) {
+        k1 = x64Xor(k1, [0, data[tailIndex] || 0]);
+        k1 = x64Multiply(k1, c1);
+        k1 = x64Rotl(k1, 31);
+        k1 = x64Multiply(k1, c2);
+        h1 = x64Xor(h1, k1);
+    }
+    // Finalization
+    h1 = x64Xor(h1, [0, input.length]);
+    h2 = x64Xor(h2, [0, input.length]);
+    h1 = x64Add(h1, h2);
+    h2 = x64Add(h2, h1);
+    h1 = x64Fmix(h1);
+    h2 = x64Fmix(h2);
+    h1 = x64Add(h1, h2);
+    h2 = x64Add(h2, h1);
+    // Convert to hex string
+    const hex1 = h1[0].toString(16).padStart(8, '0') + h1[1].toString(16).padStart(8, '0');
+    const hex2 = h2[0].toString(16).padStart(8, '0') + h2[1].toString(16).padStart(8, '0');
+    return hex1 + hex2;
+}
+/**
+ * Simple 32-bit hash for basic use cases
+ */
+function hash32(input) {
+    let hash = 0;
+    if (input.length === 0)
+        return hash.toString(36);
+    for (let i = 0; i < input.length; i++) {
+        const char = input.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash).toString(36);
+}
+/**
+ * Hash fingerprint components into a stable identifier
+ */
+function hashFingerprint(components) {
+    // Convert components to canonical string representation
+    const canonical = JSON.stringify(components, Object.keys(components).sort());
+    // Use MurmurHash3 x64 for consistent hashing
+    return x64hash128(canonical);
+}
+/**
+ * Generate a visitor ID from fingerprint hash
+ */
+function generateVisitorId(fingerprintHash) {
+    // Use first 16 characters of the hash for visitor ID
+    return 'vis_' + fingerprintHash.substring(0, 16);
+}
+
+/**
+ * Canvas Fingerprinting
+ * Based on FingerprintJS canvas component with incognito detection
+ */
+/**
+ * Text to render for canvas fingerprinting
+ */
+const CANVAS_TEXT = 'RabbitTracker Canvas 🎨 🔒 2024';
+/**
+ * Geometric shapes for canvas fingerprinting
+ */
+function drawGeometry(ctx) {
+    // Set up styles
+    ctx.fillStyle = 'rgb(102, 204, 0)';
+    ctx.fillRect(10, 10, 50, 50);
+    ctx.fillStyle = '#f60';
+    ctx.fillRect(70, 10, 50, 50);
+    // Draw circle
+    ctx.beginPath();
+    ctx.arc(50, 80, 20, 0, Math.PI * 2, true);
+    ctx.closePath();
+    ctx.fill();
+    // Draw triangle
+    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.save();
+    ctx.scale(1.2, 0.8);
+    ctx.font = '10px Courier New';
+    ctx.fillStyle = '#999';
+    ctx.fillText('Transformed Text', 4, 220);
+    ctx.restore();
+}
+/**
+ * Detect potential incognito mode through canvas inconsistencies
+ */
+function detectInconsistencies(textData, geometryData, ctx) {
+    try {
+        // Test if getImageData works consistently
+        const imageData = ctx.getImageData(0, 0, 1, 1);
+        // In some browsers in incognito mode, canvas operations might be slightly different
+        // This is a heuristic check
+        if (textData.length < 100 || geometryData.length < 100) {
+            return true; // Suspiciously short data
+        }
+        // Check for specific patterns that might indicate canvas blocking
+        const hasExpectedPatterns = textData.includes('data:image/png') &&
+            geometryData.includes('data:image/png');
+        return !hasExpectedPatterns;
+    }
+    catch (error) {
+        // If getImageData fails, it might indicate blocking
+        return true;
+    }
+}
+/**
+ * Generate canvas fingerprint
+ */
+async function getCanvasFingerprint() {
+    const startTime = performance.now();
+    try {
+        // Create canvas element
+        const canvas = document.createElement('canvas');
+        canvas.width = 200;
+        canvas.height = 250;
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+            throw new Error('Canvas 2D context not available');
+        }
+        // Test canvas winding (different behavior across browsers)
+        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
+        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);
+        const endTime = performance.now();
+        const result = {
+            text: hash32(textData),
+            geometry: hash32(geometryData),
+            winding: isClockwise,
+            isInconsistent
+        };
+        return {
+            value: result,
+            duration: endTime - startTime
+        };
+    }
+    catch (error) {
+        return {
+            value: {
+                text: 'error',
+                geometry: 'error',
+                winding: false,
+                isInconsistent: true
+            },
+            duration: performance.now() - startTime,
+            error: error instanceof Error ? error.message : 'Canvas fingerprinting failed'
+        };
+    }
+}
+/**
+ * Check if canvas fingerprinting is available
+ */
+function isCanvasAvailable$1() {
+    try {
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        return ctx !== null && typeof ctx.fillText === 'function';
+    }
+    catch {
+        return false;
+    }
+}
+
+/**
+ * WebGL Fingerprinting
+ * Based on FingerprintJS WebGL component for GPU and driver detection
+ */
+/**
+ * WebGL parameter constants for fingerprinting
+ */
+const WEBGL_PARAMS = {
+    VENDOR: 0x1f00,
+    RENDERER: 0x1f01,
+    VERSION: 0x1f02,
+    SHADING_LANGUAGE_VERSION: 0x8b8c,
+    MAX_VERTEX_ATTRIBS: 0x8869,
+    MAX_TEXTURE_SIZE: 0x0d33,
+    MAX_RENDERBUFFER_SIZE: 0x84e8,
+    MAX_VIEWPORT_DIMS: 0x0d3a,
+    ALIASED_LINE_WIDTH_RANGE: 0x846e,
+    ALIASED_POINT_SIZE_RANGE: 0x846d,
+    MAX_FRAGMENT_UNIFORM_VECTORS: 0x8dfd,
+    MAX_VERTEX_UNIFORM_VECTORS: 0x8dfb,
+    MAX_VARYING_VECTORS: 0x8dfc,
+    MAX_VERTEX_TEXTURE_IMAGE_UNITS: 0x8b4c,
+    MAX_TEXTURE_IMAGE_UNITS: 0x8872,
+    MAX_COMBINED_TEXTURE_IMAGE_UNITS: 0x8b4d,
+};
+/**
+ * Get WebGL context with fallback
+ */
+function getWebGLContext() {
+    const canvas = document.createElement('canvas');
+    // Try different context types
+    const contextTypes = ['webgl', 'experimental-webgl', 'webkit-3d', 'moz-webgl'];
+    for (const contextType of contextTypes) {
+        try {
+            const gl = canvas.getContext(contextType);
+            if (gl)
+                return gl;
+        }
+        catch {
+            // Continue trying other context types
+        }
+    }
+    return null;
+}
+/**
+ * Get WebGL extensions
+ */
+function getWebGLExtensions(gl) {
+    const extensions = [];
+    try {
+        const supportedExtensions = gl.getSupportedExtensions();
+        if (supportedExtensions) {
+            extensions.push(...supportedExtensions.sort());
+        }
+    }
+    catch {
+        // Extensions not available
+    }
+    return extensions;
+}
+/**
+ * Get WebGL parameter value safely
+ */
+function getWebGLParameter(gl, param) {
+    try {
+        return gl.getParameter(param);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get shader precision information
+ */
+function getShaderPrecision(gl) {
+    const vertex = [];
+    const fragment = [];
+    try {
+        const precisionTypes = [gl.LOW_FLOAT, gl.MEDIUM_FLOAT, gl.HIGH_FLOAT, gl.LOW_INT, gl.MEDIUM_INT, gl.HIGH_INT];
+        const precisionNames = ['LOW_FLOAT', 'MEDIUM_FLOAT', 'HIGH_FLOAT', 'LOW_INT', 'MEDIUM_INT', 'HIGH_INT'];
+        for (let i = 0; i < precisionTypes.length; i++) {
+            const precisionType = precisionTypes[i];
+            if (precisionType === undefined)
+                continue;
+            const vertexPrecision = gl.getShaderPrecisionFormat(gl.VERTEX_SHADER, precisionType);
+            const fragmentPrecision = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, precisionType);
+            if (vertexPrecision) {
+                vertex.push(`${precisionNames[i]}:${vertexPrecision.precision},${vertexPrecision.rangeMin},${vertexPrecision.rangeMax}`);
+            }
+            if (fragmentPrecision) {
+                fragment.push(`${precisionNames[i]}:${fragmentPrecision.precision},${fragmentPrecision.rangeMin},${fragmentPrecision.rangeMax}`);
+            }
+        }
+    }
+    catch {
+        // Precision format not available
+    }
+    return {
+        vertex: vertex.join(';'),
+        fragment: fragment.join(';')
+    };
+}
+/**
+ * Collect WebGL parameters for fingerprinting
+ */
+function collectWebGLParameters(gl) {
+    const parameters = {};
+    // Collect standard parameters
+    Object.entries(WEBGL_PARAMS).forEach(([name, param]) => {
+        const value = getWebGLParameter(gl, param);
+        if (value !== null) {
+            // Convert arrays to strings for consistent serialization
+            parameters[name] = Array.isArray(value) ? value.join(',') : value;
+        }
+    });
+    // Additional parameters that might be available
+    const additionalParams = [
+        'UNMASKED_VENDOR_WEBGL',
+        'UNMASKED_RENDERER_WEBGL'
+    ];
+    additionalParams.forEach(paramName => {
+        try {
+            const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+            if (debugInfo) {
+                const param = debugInfo[paramName];
+                if (param !== undefined) {
+                    const value = gl.getParameter(param);
+                    if (value) {
+                        parameters[paramName] = value;
+                    }
+                }
+            }
+        }
+        catch {
+            // Debug renderer info not available
+        }
+    });
+    return parameters;
+}
+/**
+ * Generate WebGL fingerprint
+ */
+async function getWebGLFingerprint() {
+    const startTime = performance.now();
+    try {
+        const gl = getWebGLContext();
+        if (!gl) {
+            throw new Error('WebGL not available');
+        }
+        // Get basic WebGL information
+        const vendor = getWebGLParameter(gl, gl.VENDOR) || 'unknown';
+        const renderer = getWebGLParameter(gl, gl.RENDERER) || 'unknown';
+        const version = getWebGLParameter(gl, gl.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
+        const extensions = getWebGLExtensions(gl);
+        // Collect parameters
+        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'
+        };
+    }
+}
+/**
+ * Check if WebGL fingerprinting is available
+ */
+function isWebGLAvailable() {
+    try {
+        const canvas = document.createElement('canvas');
+        const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+        return gl !== null;
+    }
+    catch {
+        return false;
+    }
+}
+
+/**
+ * Audio Fingerprinting
+ * Based on FingerprintJS audio component using AudioContext
+ */
+/**
+ * Audio configuration for fingerprinting
+ */
+const AUDIO_CONFIG = {
+    SAMPLE_RATE: 44100,
+    DURATION: 0.1, // 100ms
+    FREQUENCY: 1000, // 1kHz tone
+    COMPRESSOR_THRESHOLD: -50,
+    COMPRESSOR_KNEE: 40,
+    COMPRESSOR_RATIO: 12,
+    COMPRESSOR_ATTACK: 0.003,
+    COMPRESSOR_RELEASE: 0.25,
+};
+/**
+ * Create audio context with fallbacks
+ */
+function createAudioContext() {
+    try {
+        const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+        if (!AudioContextClass)
+            return null;
+        return new AudioContextClass();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Generate oscillator fingerprint
+ */
+async function generateOscillatorFingerprint(audioContext) {
+    const oscillator = audioContext.createOscillator();
+    const compressor = audioContext.createDynamicsCompressor();
+    const buffer = audioContext.createBuffer(1, audioContext.sampleRate * AUDIO_CONFIG.DURATION, audioContext.sampleRate);
+    // Configure oscillator
+    oscillator.type = 'triangle';
+    oscillator.frequency.setValueAtTime(AUDIO_CONFIG.FREQUENCY, audioContext.currentTime);
+    // Configure compressor
+    compressor.threshold.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_THRESHOLD, audioContext.currentTime);
+    compressor.knee.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_KNEE, audioContext.currentTime);
+    compressor.ratio.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_RATIO, audioContext.currentTime);
+    compressor.attack.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_ATTACK, audioContext.currentTime);
+    compressor.release.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_RELEASE, audioContext.currentTime);
+    // Connect nodes
+    oscillator.connect(compressor);
+    compressor.connect(audioContext.destination);
+    // Start and stop oscillator
+    oscillator.start(audioContext.currentTime);
+    oscillator.stop(audioContext.currentTime + AUDIO_CONFIG.DURATION);
+    // Wait for processing and get buffer data
+    await new Promise(resolve => setTimeout(resolve, AUDIO_CONFIG.DURATION * 1000 + 50));
+    // Generate fingerprint from audio characteristics
+    const channelData = buffer.getChannelData(0);
+    const samples = Array.from(channelData.slice(0, 100)); // First 100 samples
+    return hash32(samples.join(','));
+}
+/**
+ * Generate compressor fingerprint
+ */
+async function generateCompressorFingerprint(audioContext) {
+    try {
+        const oscillator = audioContext.createOscillator();
+        const compressor = audioContext.createDynamicsCompressor();
+        const gain = audioContext.createGain();
+        // Create offline context for deterministic results
+        const offlineContext = new OfflineAudioContext(1, audioContext.sampleRate * AUDIO_CONFIG.DURATION, audioContext.sampleRate);
+        const offlineOscillator = offlineContext.createOscillator();
+        const offlineCompressor = offlineContext.createDynamicsCompressor();
+        // Configure nodes
+        offlineOscillator.type = 'triangle';
+        offlineOscillator.frequency.setValueAtTime(AUDIO_CONFIG.FREQUENCY, 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);
+        offlineCompressor.attack.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_ATTACK, offlineContext.currentTime);
+        offlineCompressor.release.setValueAtTime(AUDIO_CONFIG.COMPRESSOR_RELEASE, offlineContext.currentTime);
+        // Connect and render
+        offlineOscillator.connect(offlineCompressor);
+        offlineCompressor.connect(offlineContext.destination);
+        offlineOscillator.start();
+        offlineOscillator.stop(AUDIO_CONFIG.DURATION);
+        const renderedBuffer = await offlineContext.startRendering();
+        const channelData = renderedBuffer.getChannelData(0);
+        // Create fingerprint from specific samples
+        const fingerprintSamples = [
+            channelData[0] || 0,
+            channelData[Math.floor(channelData.length * 0.25)] || 0,
+            channelData[Math.floor(channelData.length * 0.5)] || 0,
+            channelData[Math.floor(channelData.length * 0.75)] || 0,
+            channelData[channelData.length - 1] || 0
+        ];
+        return hash32(fingerprintSamples.join(','));
+    }
+    catch (error) {
+        // Fallback for browsers without OfflineAudioContext
+        return hash32('compressor_fallback');
+    }
+}
+/**
+ * Generate audio fingerprint
+ */
+async function getAudioFingerprint() {
+    const startTime = performance.now();
+    try {
+        const audioContext = createAudioContext();
+        if (!audioContext) {
+            throw new Error('AudioContext not available');
+        }
+        // Resume context if needed (Chrome autoplay policy)
+        if (audioContext.state === 'suspended') {
+            try {
+                await audioContext.resume();
+            }
+            catch {
+                // Cannot resume context
+            }
+        }
+        // Generate fingerprints
+        const [oscillatorHash, compressorHash] = await Promise.all([
+            generateOscillatorFingerprint(audioContext).catch(() => 'oscillator_error'),
+            generateCompressorFingerprint(audioContext).catch(() => 'compressor_error')
+        ]);
+        // Close audio context to free resources
+        try {
+            await audioContext.close();
+        }
+        catch {
+            // Context close failed
+        }
+        const endTime = performance.now();
+        const result = {
+            oscillator: oscillatorHash,
+            compressor: compressorHash,
+            sampleRate: audioContext.sampleRate,
+            maxChannelCount: audioContext.destination.maxChannelCount
+        };
+        return {
+            value: result,
+            duration: endTime - startTime
+        };
+    }
+    catch (error) {
+        return {
+            value: {
+                oscillator: 'error',
+                compressor: 'error',
+                sampleRate: 0,
+                maxChannelCount: 0
+            },
+            duration: performance.now() - startTime,
+            error: error instanceof Error ? error.message : 'Audio fingerprinting failed'
+        };
+    }
+}
+/**
+ * Check if audio fingerprinting is available
+ */
+function isAudioAvailable() {
+    try {
+        const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+        return typeof AudioContextClass === 'function';
+    }
+    catch {
+        return false;
+    }
+}
+
+/**
+ * Font Detection Fingerprinting
+ * Based on FingerprintJS font detection techniques
+ */
+/**
+ * Font list for detection (commonly available system fonts)
+ */
+const FONT_LIST = [
+    // Windows fonts
+    'Arial', 'Arial Black', 'Calibri', 'Cambria', 'Comic Sans MS', 'Consolas',
+    'Courier New', 'Georgia', 'Impact', 'Lucida Console', 'Lucida Sans Unicode',
+    'Microsoft Sans Serif', 'Palatino Linotype', 'Segoe UI', 'Tahoma', 'Times New Roman',
+    'Trebuchet MS', 'Verdana',
+    // macOS fonts
+    'American Typewriter', 'Avenir', 'Baskerville', 'Big Caslon', 'Brush Script MT',
+    'Copperplate', 'Didot', 'Futura', 'Gill Sans', 'Helvetica', 'Helvetica Neue',
+    'Hoefler Text', 'Lucida Grande', 'Marker Felt', 'Optima', 'Papyrus',
+    'Phosphate', 'Rockwell', 'Savoye LET', 'SignPainter', 'Skia', 'Snell Roundhand',
+    'System Font', 'Zapfino',
+    // Linux fonts
+    'DejaVu Sans', 'DejaVu Sans Mono', 'DejaVu Serif', 'Droid Sans', 'Droid Sans Mono',
+    'Droid Serif', 'Liberation Sans', 'Liberation Sans Narrow', 'Liberation Serif',
+    'Ubuntu', 'Ubuntu Mono',
+    // Android fonts
+    'Roboto', 'Roboto Condensed', 'Roboto Mono', 'Roboto Slab', 'Droid Sans',
+    'Droid Sans Mono', 'Droid Serif',
+    // iOS fonts
+    'Helvetica Neue', 'Arial', 'Helvetica', 'Courier New', 'Times New Roman',
+    'San Francisco', 'Avenir Next',
+    // Common web fonts
+    'Open Sans', 'Lato', 'Montserrat', 'Source Sans Pro', 'Raleway', 'PT Sans',
+    'Lora', 'Playfair Display', 'Oswald', 'Slabo 27px', 'Fira Sans',
+    // East Asian fonts
+    'Hiragino Sans', 'Hiragino Kaku Gothic ProN', 'Meiryo', 'MS Gothic', 'MS Mincho',
+    'SimSun', 'SimHei', 'Microsoft YaHei', 'Malgun Gothic', 'Apple SD Gothic Neo'
+];
+/**
+ * Fallback fonts for measurement
+ */
+const FALLBACK_FONTS = ['monospace', 'sans-serif', 'serif'];
+/**
+ * Test text for font measurement
+ */
+const TEST_TEXT = 'mmMwWLliI0O&1 ※';
+/**
+ * Font measurement using canvas
+ */
+function measureText(text, fontFamily) {
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        return { width: 0, height: 0 };
+    }
+    ctx.font = `12px ${fontFamily}`;
+    const metrics = ctx.measureText(text);
+    return {
+        width: metrics.width,
+        height: metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent
+    };
+}
+/**
+ * Font measurement using DOM (fallback method)
+ */
+function measureTextDOM(text, fontFamily) {
+    const element = document.createElement('span');
+    element.style.position = 'absolute';
+    element.style.left = '-9999px';
+    element.style.top = '-9999px';
+    element.style.fontSize = '12px';
+    element.style.fontFamily = fontFamily;
+    element.style.whiteSpace = 'nowrap';
+    element.textContent = text;
+    document.body.appendChild(element);
+    const rect = element.getBoundingClientRect();
+    const result = {
+        width: rect.width,
+        height: rect.height
+    };
+    document.body.removeChild(element);
+    return result;
+}
+/**
+ * Detect if a font is available by comparing measurements
+ */
+function isFontAvailable(fontName, method = 'canvas') {
+    const measureFunc = method === 'canvas' ? measureText : measureTextDOM;
+    // Measure with fallback fonts first
+    const fallbackMeasurements = FALLBACK_FONTS.map(fallback => measureFunc(TEST_TEXT, fallback));
+    // Measure with target font + fallback
+    const targetMeasurements = FALLBACK_FONTS.map(fallback => measureFunc(TEST_TEXT, `${fontName}, ${fallback}`));
+    // Compare measurements - if font is available, measurements should differ
+    for (let i = 0; i < fallbackMeasurements.length; i++) {
+        const fallback = fallbackMeasurements[i];
+        const target = targetMeasurements[i];
+        if (fallback && target) {
+            // Allow small tolerance for measurement differences
+            const widthDiff = Math.abs(fallback.width - target.width);
+            const heightDiff = Math.abs(fallback.height - target.height);
+            if (widthDiff > 0.1 || heightDiff > 0.1) {
+                return true; // Font likely available
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Advanced font detection with measurements
+ */
+function detectFontsWithMeasurements() {
+    const available = [];
+    const measurements = {};
+    for (const font of FONT_LIST) {
+        try {
+            const measurement = measureText(TEST_TEXT, font);
+            measurements[font] = measurement;
+            if (isFontAvailable(font, 'canvas')) {
+                available.push(font);
+            }
+        }
+        catch (error) {
+            // Skip fonts that cause errors
+            continue;
+        }
+    }
+    return { available, measurements };
+}
+/**
+ * Basic font detection (faster but less detailed)
+ */
+function detectFontsBasic() {
+    const available = [];
+    for (const font of FONT_LIST) {
+        try {
+            if (isFontAvailable(font, 'dom')) {
+                available.push(font);
+            }
+        }
+        catch (error) {
+            // Skip fonts that cause errors
+            continue;
+        }
+    }
+    return available;
+}
+/**
+ * Generate font fingerprint
+ */
+async function getFontFingerprint(useAdvanced = true) {
+    const startTime = performance.now();
+    try {
+        let result;
+        if (useAdvanced && isCanvasAvailable()) {
+            // Advanced detection with measurements
+            const { available, measurements } = detectFontsWithMeasurements();
+            result = {
+                available: available.sort(),
+                method: 'advanced',
+                measurements
+            };
+        }
+        else {
+            // Basic detection
+            const available = detectFontsBasic();
+            result = {
+                available: available.sort(),
+                method: 'basic'
+            };
+        }
+        const endTime = performance.now();
+        return {
+            value: result,
+            duration: endTime - startTime
+        };
+    }
+    catch (error) {
+        return {
+            value: {
+                available: [],
+                method: 'basic'
+            },
+            duration: performance.now() - startTime,
+            error: error instanceof Error ? error.message : 'Font detection failed'
+        };
+    }
+}
+/**
+ * Check if canvas is available for font measurement
+ */
+function isCanvasAvailable() {
+    try {
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        return ctx !== null && typeof ctx.measureText === 'function';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if font detection is available
+ */
+function isFontDetectionAvailable() {
+    try {
+        // Check if we can create DOM elements for measurement
+        const element = document.createElement('span');
+        return element && typeof element.style === 'object';
+    }
+    catch {
+        return false;
+    }
+}
+
+/**
+ * Screen and Viewport Fingerprinting
+ * Based on FingerprintJS screen components
+ */
+/**
+ * Get screen orientation information
+ */
+function getScreenOrientation() {
+    try {
+        // Modern API
+        if (screen.orientation) {
+            return {
+                angle: screen.orientation.angle,
+                type: screen.orientation.type
+            };
+        }
+        // Legacy API
+        const orientation = screen.mozOrientation ||
+            screen.msOrientation ||
+            screen.webkitOrientation;
+        if (orientation !== undefined) {
+            return {
+                angle: orientation,
+                type: 'unknown'
+            };
+        }
+        // Fallback: estimate from dimensions
+        const isLandscape = screen.width > screen.height;
+        return {
+            angle: isLandscape ? 90 : 0,
+            type: isLandscape ? 'landscape-primary' : 'portrait-primary'
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Get device pixel ratio with fallbacks
+ */
+function getPixelRatio() {
+    try {
+        return window.devicePixelRatio || 1;
+    }
+    catch {
+        return 1;
+    }
+}
+/**
+ * Get available screen dimensions (excluding taskbars, docks, etc.)
+ */
+function getAvailableScreenDimensions() {
+    try {
+        return {
+            width: screen.availWidth || screen.width,
+            height: screen.availHeight || screen.height
+        };
+    }
+    catch {
+        return {
+            width: screen.width || 0,
+            height: screen.height || 0
+        };
+    }
+}
+/**
+ * Get viewport dimensions
+ */
+function getViewportDimensions() {
+    try {
+        // Use document.documentElement for more accurate measurements
+        const element = document.documentElement;
+        return {
+            width: Math.max(element.clientWidth || 0, window.innerWidth || 0),
+            height: Math.max(element.clientHeight || 0, window.innerHeight || 0)
+        };
+    }
+    catch {
+        return {
+            width: window.innerWidth || 0,
+            height: window.innerHeight || 0
+        };
+    }
+}
+/**
+ * Generate screen fingerprint
+ */
+async function getScreenFingerprint() {
+    const startTime = performance.now();
+    try {
+        // Get screen dimensions
+        const screenWidth = screen.width || 0;
+        const screenHeight = screen.height || 0;
+        const colorDepth = screen.colorDepth || screen.pixelDepth || 0;
+        // Get available screen space
+        const available = getAvailableScreenDimensions();
+        // Get viewport dimensions
+        const viewport = getViewportDimensions();
+        // Get pixel ratio
+        const pixelRatio = getPixelRatio();
+        // Get orientation
+        const orientation = getScreenOrientation();
+        const endTime = performance.now();
+        const result = {
+            // Screen properties
+            width: screenWidth,
+            height: screenHeight,
+            colorDepth,
+            pixelRatio,
+            // Viewport properties
+            viewportWidth: viewport.width,
+            viewportHeight: viewport.height,
+            // Available screen space
+            availableWidth: available.width,
+            availableHeight: available.height
+        };
+        // Add optional properties conditionally
+        if (orientation) {
+            result.orientation = orientation;
+        }
+        return {
+            value: result,
+            duration: endTime - startTime
+        };
+    }
+    catch (error) {
+        return {
+            value: {
+                width: 0,
+                height: 0,
+                colorDepth: 0,
+                pixelRatio: 1,
+                viewportWidth: 0,
+                viewportHeight: 0,
+                availableWidth: 0,
+                availableHeight: 0
+            },
+            duration: performance.now() - startTime,
+            error: error instanceof Error ? error.message : 'Screen fingerprinting failed'
+        };
+    }
+}
+/**
+ * Check if screen fingerprinting is available
+ */
+function isScreenAvailable() {
+    try {
+        return typeof screen === 'object' &&
+            typeof screen.width === 'number' &&
+            typeof screen.height === 'number';
+    }
+    catch {
+        return false;
+    }
+}
+
+/**
+ * Browser and System Information Fingerprinting
+ * Based on FingerprintJS browser component with enhanced detection
+ */
+/**
+ * Get touch support information
+ */
+function getTouchSupport() {
+    try {
+        let maxTouchPoints = 0;
+        let touchEvent = false;
+        let touchStart = false;
+        // Check maxTouchPoints
+        if ('maxTouchPoints' in navigator) {
+            maxTouchPoints = navigator.maxTouchPoints;
+        }
+        else if ('msMaxTouchPoints' in navigator) {
+            maxTouchPoints = navigator.msMaxTouchPoints;
+        }
+        // Check touch events
+        try {
+            touchEvent = 'TouchEvent' in window;
+        }
+        catch {
+            touchEvent = 'ontouchstart' in window;
+        }
+        // Check touch start
+        touchStart = 'ontouchstart' in window;
+        return { maxTouchPoints, touchEvent, touchStart };
+    }
+    catch {
+        return { maxTouchPoints: 0, touchEvent: false, touchStart: false };
+    }
+}
+/**
+ * Get plugin information (mostly for legacy browser detection)
+ */
+function getPluginInfo() {
+    try {
+        if (!navigator.plugins) {
+            return { length: 0, names: [] };
+        }
+        const plugins = Array.from(navigator.plugins);
+        const names = plugins
+            .map(plugin => plugin.name)
+            .filter(name => name)
+            .sort();
+        return {
+            length: navigator.plugins.length,
+            names: names.slice(0, 10) // Limit to first 10 to avoid huge fingerprints
+        };
+    }
+    catch {
+        return { length: 0, names: [] };
+    }
+}
+/**
+ * Get language and locale information
+ */
+function getLanguageInfo() {
+    try {
+        const language = navigator.language || '';
+        let languages = [];
+        if (navigator.languages) {
+            languages = Array.from(navigator.languages);
+        }
+        else if (navigator.language) {
+            languages = [navigator.language];
+        }
+        // Add fallback language properties
+        const additionalLanguages = [
+            navigator.userLanguage,
+            navigator.browserLanguage,
+            navigator.systemLanguage
+        ].filter(Boolean);
+        languages = [...new Set([...languages, ...additionalLanguages])];
+        return { language, languages };
+    }
+    catch {
+        return { language: '', languages: [] };
+    }
+}
+/**
+ * Get timezone information
+ */
+function getTimezoneInfo() {
+    try {
+        let timezone = '';
+        // Modern API
+        if (Intl && Intl.DateTimeFormat) {
+            try {
+                timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+            }
+            catch {
+                // Fallback
+            }
+        }
+        // Fallback: use timezone offset
+        if (!timezone) {
+            const offset = new Date().getTimezoneOffset();
+            const sign = offset > 0 ? '-' : '+';
+            const hours = Math.floor(Math.abs(offset) / 60);
+            const minutes = Math.abs(offset) % 60;
+            timezone = `UTC${sign}${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}`;
+        }
+        const timezoneOffset = new Date().getTimezoneOffset();
+        return { timezone, timezoneOffset };
+    }
+    catch {
+        return { timezone: '', timezoneOffset: 0 };
+    }
+}
+/**
+ * Get hardware information
+ */
+function getHardwareInfo() {
+    try {
+        const hardwareConcurrency = navigator.hardwareConcurrency || 0;
+        // Device memory (Chrome-specific)
+        let deviceMemory;
+        if ('deviceMemory' in navigator) {
+            deviceMemory = navigator.deviceMemory;
+        }
+        const result = { hardwareConcurrency };
+        if (deviceMemory !== undefined) {
+            result.deviceMemory = deviceMemory;
+        }
+        return result;
+    }
+    catch {
+        return { hardwareConcurrency: 0 };
+    }
+}
+/**
+ * Get platform information with enhanced detection
+ */
+function getPlatformInfo() {
+    try {
+        const platform = navigator.platform || '';
+        const userAgent = navigator.userAgent || '';
+        return { platform, userAgent };
+    }
+    catch {
+        return { platform: '', userAgent: '' };
+    }
+}
+/**
+ * Get browser capabilities
+ */
+function getBrowserCapabilities() {
+    try {
+        const cookieEnabled = navigator.cookieEnabled !== false;
+        // Do Not Track
+        let doNotTrack = null;
+        if ('doNotTrack' in navigator) {
+            doNotTrack = navigator.doNotTrack;
+        }
+        else if ('msDoNotTrack' in navigator) {
+            doNotTrack = navigator.msDoNotTrack;
+        }
+        else if ('mozDoNotTrack' in window) {
+            doNotTrack = window.mozDoNotTrack;
+        }
+        return { cookieEnabled, doNotTrack };
+    }
+    catch {
+        return { cookieEnabled: true, doNotTrack: null };
+    }
+}
+/**
+ * Generate browser fingerprint
+ */
+async function getBrowserFingerprint() {
+    const startTime = performance.now();
+    try {
+        // Collect all browser information
+        const languageInfo = getLanguageInfo();
+        const timezoneInfo = getTimezoneInfo();
+        const platformInfo = getPlatformInfo();
+        const hardwareInfo = getHardwareInfo();
+        const capabilities = getBrowserCapabilities();
+        const pluginInfo = getPluginInfo();
+        const touchSupport = getTouchSupport();
+        const endTime = performance.now();
+        const result = {
+            // Language and locale
+            language: languageInfo.language,
+            languages: languageInfo.languages,
+            // Timezone
+            timezone: timezoneInfo.timezone,
+            timezoneOffset: timezoneInfo.timezoneOffset,
+            // Platform information
+            platform: platformInfo.platform,
+            userAgent: platformInfo.userAgent,
+            // Hardware information
+            hardwareConcurrency: hardwareInfo.hardwareConcurrency,
+            // Browser capabilities
+            cookieEnabled: capabilities.cookieEnabled,
+            doNotTrack: capabilities.doNotTrack,
+            // Plugin information
+            plugins: pluginInfo,
+            // Touch support
+            touchSupport
+        };
+        // Add optional properties conditionally
+        if (hardwareInfo.deviceMemory !== undefined) {
+            result.deviceMemory = hardwareInfo.deviceMemory;
+        }
+        return {
+            value: result,
+            duration: endTime - startTime
+        };
+    }
+    catch (error) {
+        return {
+            value: {
+                language: '',
+                languages: [],
+                timezone: '',
+                timezoneOffset: 0,
+                platform: '',
+                userAgent: '',
+                hardwareConcurrency: 0,
+                cookieEnabled: true,
+                doNotTrack: null,
+                plugins: { length: 0, names: [] },
+                touchSupport: { maxTouchPoints: 0, touchEvent: false, touchStart: false }
+            },
+            duration: performance.now() - startTime,
+            error: error instanceof Error ? error.message : 'Browser fingerprinting failed'
+        };
+    }
+}
+/**
+ * Check if browser fingerprinting is available
+ */
+function isBrowserFingerprintingAvailable() {
+    try {
+        return typeof navigator === 'object' && navigator !== null;
+    }
+    catch {
+        return false;
+    }
+}
+
+/**
+ * Fingerprint Orchestrator
+ * Main fingerprinting engine that coordinates all components
+ * Based on FingerprintJS architecture with privacy-first approach
+ */
+// Import individual fingerprinting components
+/**
+ * Default fingerprint options (cookieless - memory cache only)
+ */
+const DEFAULT_OPTIONS = {
+    gdprMode: false,
+    includeInvasive: true,
+    timeout: 5000,
+    excludeComponents: []
+};
+/**
+ * Session-only cache for fingerprint components (memory only, no persistence)
+ */
+const sessionCache = new Map();
+/**
+ * Check if component should be included based on options
+ */
+function shouldIncludeComponent(component, options) {
+    // Check if component is excluded
+    if (options.excludeComponents.includes(component)) {
+        return false;
+    }
+    // In GDPR mode, exclude invasive components unless explicitly allowed
+    if (options.gdprMode && !options.includeInvasive) {
+        const invasiveComponents = ['canvas', 'webgl', 'audio'];
+        if (invasiveComponents.includes(component)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Get cached component data from session cache (memory only)
+ */
+function getSessionCachedComponent(key) {
+    return sessionCache.get(key) || null;
+}
+/**
+ * Cache component data in session memory only
+ */
+function setSessionCachedComponent(key, data) {
+    sessionCache.set(key, data);
+}
+/**
+ * Collect fingerprint component with timeout and session caching
+ */
+async function collectComponent(componentType, collector, options) {
+    const cacheKey = `${componentType}_${options.gdprMode}`;
+    // Check session cache first (memory only)
+    const cached = getSessionCachedComponent(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    try {
+        // Create timeout promise
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`${componentType} timeout`)), options.timeout);
+        });
+        // Race collection vs timeout
+        const result = await Promise.race([collector(), timeoutPromise]);
+        // Cache successful result in session memory only
+        setSessionCachedComponent(cacheKey, result);
+        return result;
+    }
+    catch (error) {
+        // Return null on error (component will be marked as failed)
+        return null;
+    }
+}
+/**
+ * Main fingerprint collection function
+ */
+async function collectFingerprint(options = {}) {
+    const startTime = performance.now();
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const collectedComponents = [];
+    const failedComponents = [];
+    const fingerprintData = {
+        collectionTime: startTime,
+        gdprMode: opts.gdprMode,
+        components: []
+    };
+    // Collect Canvas fingerprint
+    if (shouldIncludeComponent('canvas', opts) && isCanvasAvailable$1()) {
+        const result = await collectComponent('canvas', getCanvasFingerprint, opts);
+        if (result) {
+            fingerprintData.canvas = result;
+            collectedComponents.push('canvas');
+        }
+        else {
+            failedComponents.push({ component: 'canvas', error: 'Collection failed or timeout' });
+        }
+    }
+    // Collect WebGL fingerprint
+    if (shouldIncludeComponent('webgl', opts) && isWebGLAvailable()) {
+        const result = await collectComponent('webgl', getWebGLFingerprint, opts);
+        if (result) {
+            fingerprintData.webgl = result;
+            collectedComponents.push('webgl');
+        }
+        else {
+            failedComponents.push({ component: 'webgl', error: 'Collection failed or timeout' });
+        }
+    }
+    // Collect Audio fingerprint
+    if (shouldIncludeComponent('audio', opts) && isAudioAvailable()) {
+        const result = await collectComponent('audio', getAudioFingerprint, opts);
+        if (result) {
+            fingerprintData.audio = result;
+            collectedComponents.push('audio');
+        }
+        else {
+            failedComponents.push({ component: 'audio', error: 'Collection failed or timeout' });
+        }
+    }
+    // Collect Font fingerprint
+    if (shouldIncludeComponent('fonts', opts) && isFontDetectionAvailable()) {
+        const result = await collectComponent('fonts', () => getFontFingerprint(!opts.gdprMode), opts);
+        if (result) {
+            fingerprintData.fonts = result;
+            collectedComponents.push('fonts');
+        }
+        else {
+            failedComponents.push({ component: 'fonts', error: 'Collection failed or timeout' });
+        }
+    }
+    // Collect Screen fingerprint (always available)
+    if (shouldIncludeComponent('screen', opts) && isScreenAvailable()) {
+        const result = await collectComponent('screen', getScreenFingerprint, opts);
+        if (result) {
+            fingerprintData.screen = result;
+            collectedComponents.push('screen');
+        }
+        else {
+            failedComponents.push({ component: 'screen', error: 'Collection failed or timeout' });
+        }
+    }
+    // Collect Browser fingerprint (always available)
+    if (shouldIncludeComponent('browser', opts) && isBrowserFingerprintingAvailable()) {
+        const result = await collectComponent('browser', getBrowserFingerprint, opts);
+        if (result) {
+            fingerprintData.browser = result;
+            collectedComponents.push('browser');
+        }
+        else {
+            failedComponents.push({ component: 'browser', error: 'Collection failed or timeout' });
+        }
+    }
+    // Generate hash from collected components
+    const componentValues = {};
+    collectedComponents.forEach(component => {
+        const componentData = fingerprintData[component];
+        if (componentData && componentData.value) {
+            componentValues[component] = componentData.value;
+        }
+    });
+    // Create final fingerprint hash
+    const hash = hashFingerprint(componentValues);
+    // Finalize fingerprint data
+    const finalData = {
+        ...fingerprintData,
+        hash,
+        components: collectedComponents,
+        collectionTime: performance.now() - startTime
+    };
+    const result = {
+        success: collectedComponents.length > 0,
+        collectedComponents,
+        failedComponents
+    };
+    if (collectedComponents.length > 0) {
+        result.data = finalData;
+    }
+    else {
+        result.error = 'No components could be collected';
+    }
+    return result;
+}
+/**
+ * Generate visitor ID from fingerprint
+ */
+function generateVisitorIdFromFingerprint(fingerprintData) {
+    return generateVisitorId(fingerprintData.hash);
+}
+/**
+ * Get a lightweight fingerprint (GDPR-compliant)
+ */
+async function getLightweightFingerprint() {
+    return collectFingerprint({
+        gdprMode: true,
+        includeInvasive: false,
+        excludeComponents: ['canvas', 'webgl', 'audio'],
+        timeout: 2000
+    });
+}
+/**
+ * Get a complete fingerprint (enhanced mode)
+ */
+async function getCompleteFingerprint() {
+    return collectFingerprint({
+        gdprMode: false,
+        includeInvasive: true,
+        timeout: 5000
+    });
+}
+/**
+ * Clear session fingerprint cache (memory only)
+ */
+function clearFingerprintCache() {
+    sessionCache.clear();
+}
+/**
+ * Check if fingerprinting is available
+ */
+function isFingerprintingAvailable() {
+    // At minimum, we need screen and browser fingerprinting
+    return isScreenAvailable() && isBrowserFingerprintingAvailable();
+}
+/**
+ * Get available fingerprinting components
+ */
+function getAvailableComponents() {
+    const available = [];
+    if (isCanvasAvailable$1())
+        available.push('canvas');
+    if (isWebGLAvailable())
+        available.push('webgl');
+    if (isAudioAvailable())
+        available.push('audio');
+    if (isFontDetectionAvailable())
+        available.push('fonts');
+    if (isScreenAvailable())
+        available.push('screen');
+    if (isBrowserFingerprintingAvailable())
+        available.push('browser');
+    return available;
+}
+
+/**
+ * RabbitTracker SDK v3.0.0
+ * 100% Cookieless Analytics Tracking
+ *
+ * Main SDK class for client-side tracking integration
+ */
+/**
+ * Default internal configuration
+ */
+const DEFAULT_CONFIG = {
+    apiEndpoint: 'https://api.rabbitracker.com',
+    retryEnabled: true,
+    maxRetries: 3,
+    retryDelays: [1000, 2000, 4000],
+    autoTrack: true,
+    dedupeEnabled: true,
+    fingerprintEnabled: true,
+    presenceTracking: false,
+    heartbeatInterval: 30000,
+    scrollTracking: true,
+    scrollDepthTracking: true,
+    gdprCompliant: true,
+    enhancedTracking: 'ask',
+    replaySampling: 0.1,
+    replayMaskInputs: true
+};
+/**
+ * Main RabbitTracker SDK Class
+ */
+class RabbitTrackerSDK {
+    constructor(userConfig) {
+        this.version = '3.0.0';
+        this.isInitialized = false;
+        this.eventQueue = [];
+        /**
+         * Heatmap API
+         */
+        this.heatmap = {
+            enable: () => {
+                this.config.heatmap = true;
+                if (this.config.debug) {
+                    console.log('[RabbitTracker] Heatmap enabled');
+                }
+            },
+            disable: () => {
+                this.config.heatmap = false;
+                if (this.config.debug) {
+                    console.log('[RabbitTracker] Heatmap disabled');
+                }
+            }
+        };
+        /**
+         * Replay API
+         */
+        this.replay = {
+            enable: () => {
+                this.config.replay = true;
+                if (this.config.debug) {
+                    console.log('[RabbitTracker] Replay enabled');
+                }
+            },
+            disable: () => {
+                this.config.replay = false;
+                if (this.config.debug) {
+                    console.log('[RabbitTracker] Replay disabled');
+                }
+            },
+            addFunnelStep: (stepData) => {
+                this.sendEvent({
+                    eventType: 'funnel_step',
+                    eventName: 'funnel_step',
+                    customData: stepData
+                });
+            },
+            markConversion: (data) => {
+                this.trackConversion('funnel_conversion', data.value, data.currency, data);
+            }
+        };
+        // Validate required config
+        if (!userConfig.token) {
+            throw new Error('RabbitTracker: token is required');
+        }
+        // Merge user config with defaults
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...userConfig,
+            gdprMode: userConfig.gdprMode ?? false
+        };
+        // Auto-initialize if in browser
+        if (typeof window !== 'undefined') {
+            this.initialize();
+        }
+    }
+    /**
+     * Initialize SDK
+     */
+    async initialize() {
+        try {
+            if (this.config.debug) {
+                console.log('[RabbitTracker] Initializing SDK v' + this.version);
+            }
+            // Check localhost restriction
+            if (!this.config.allow_localhost && this.isLocalhost()) {
+                if (this.config.debug) {
+                    console.log('[RabbitTracker] Skipping tracking on localhost');
+                }
+                return;
+            }
+            // Collect fingerprint
+            await this.collectFingerprint();
+            // Auto-track page view if enabled
+            if (this.config.autoTrack) {
+                this.trackPageView();
+            }
+            this.isInitialized = true;
+            // Process queued events
+            this.processEventQueue();
+            if (this.config.debug) {
+                console.log('[RabbitTracker] SDK initialized successfully', {
+                    visitorId: this.visitorId,
+                    gdprMode: this.config.gdprMode
+                });
+            }
+        }
+        catch (error) {
+            console.error('[RabbitTracker] Initialization failed:', error);
+        }
+    }
+    /**
+     * Collect fingerprint and generate visitor ID
+     */
+    async collectFingerprint() {
+        try {
+            // Use appropriate fingerprinting based on GDPR mode
+            const result = this.config.gdprMode
+                ? await getLightweightFingerprint()
+                : await getCompleteFingerprint();
+            if (result.success && result.data) {
+                this.fingerprint = result.data;
+                this.visitorId = generateVisitorIdFromFingerprint(result.data);
+                if (this.config.debug) {
+                    console.log('[RabbitTracker] Fingerprint collected:', {
+                        components: result.collectedComponents,
+                        visitorId: this.visitorId,
+                        gdprMode: this.config.gdprMode
+                    });
+                }
+            }
+            else {
+                throw new Error('Fingerprint collection failed');
+            }
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error('[RabbitTracker] Fingerprint collection failed:', error);
+            }
+            // Fallback to basic fingerprint
+            this.visitorId = 'fallback_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+        }
+    }
+    /**
+     * Check if running on localhost
+     */
+    isLocalhost() {
+        if (typeof window === 'undefined')
+            return false;
+        return window.location.hostname === 'localhost' ||
+            window.location.hostname === '127.0.0.1' ||
+            window.location.hostname.startsWith('192.168.') ||
+            window.location.hostname.startsWith('10.') ||
+            window.location.hostname.includes('local');
+    }
+    /**
+     * Send event to backend
+     */
+    async sendEvent(eventData) {
+        if (!this.isInitialized) {
+            this.eventQueue.push(eventData);
+            return;
+        }
+        try {
+            const payload = {
+                workspaceId: this.config.token,
+                fingerprint: this.fingerprint?.hash || this.visitorId,
+                fingerprintComponents: this.fingerprint?.components || {},
+                ...eventData,
+                timestamp: new Date().toISOString(),
+                url: window.location.href,
+                referrer: document.referrer,
+                pageTitle: document.title,
+                userAgent: navigator.userAgent,
+                screenWidth: window.screen.width,
+                screenHeight: window.screen.height,
+                viewportWidth: window.innerWidth,
+                viewportHeight: window.innerHeight,
+                gdprMode: this.config.gdprMode
+            };
+            const response = await this.makeRequest('/tracking/event', payload);
+            if (response.sessionId) {
+                this.sessionId = response.sessionId;
+            }
+            return response;
+        }
+        catch (error) {
+            if (this.config.debug) {
+                console.error('[RabbitTracker] Event sending failed:', error);
+            }
+            // Retry logic
+            if (this.config.retryEnabled) {
+                // Queue for retry (simplified)
+                setTimeout(() => this.sendEvent(eventData), 5000);
+            }
+        }
+    }
+    /**
+     * Make HTTP request to backend
+     */
+    async makeRequest(endpoint, data) {
+        const url = `${this.config.apiEndpoint}${endpoint}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data)
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Process queued events
+     */
+    processEventQueue() {
+        while (this.eventQueue.length > 0) {
+            const event = this.eventQueue.shift();
+            this.sendEvent(event);
+        }
+    }
+    // Public API Methods
+    /**
+     * Track generic event
+     */
+    track(eventType, eventData) {
+        this.sendEvent({
+            eventType,
+            eventName: eventType,
+            customData: eventData
+        });
+    }
+    /**
+     * Track custom event
+     */
+    trackCustomEvent(eventName, metadata) {
+        this.sendEvent({
+            eventType: 'custom',
+            eventName,
+            customData: metadata
+        });
+        return true;
+    }
+    /**
+     * Track conversion event
+     */
+    trackConversion(eventName, value, currency, metadata) {
+        this.sendEvent({
+            eventType: 'conversion',
+            eventName,
+            revenue: value,
+            currency: currency || 'USD',
+            customData: metadata
+        });
+        return true;
+    }
+    /**
+     * Track page view
+     */
+    trackPageView(data) {
+        this.sendEvent({
+            eventType: 'page_view',
+            eventName: 'page_view',
+            ...data
+        });
+    }
+    /**
+     * Track purchase
+     */
+    trackPurchase(data) {
+        this.sendEvent({
+            eventType: 'purchase',
+            eventName: 'purchase',
+            revenue: data.value || data.revenue,
+            currency: data.currency || 'USD',
+            quantity: data.quantity || 1,
+            productId: data.productId,
+            customData: {
+                productName: data.productName,
+                orderId: data.orderId,
+                ...data.customData
+            }
+        });
+    }
+    /**
+     * Track add to cart
+     */
+    trackAddToCart(data) {
+        this.sendEvent({
+            eventType: 'add_to_cart',
+            eventName: 'add_to_cart',
+            revenue: data?.price,
+            quantity: data?.quantity || 1,
+            productId: data?.productId,
+            customData: {
+                productName: data?.productName,
+                ...data?.customData
+            }
+        });
+    }
+    /**
+     * Track view content
+     */
+    trackViewContent(data) {
+        this.sendEvent({
+            eventType: 'view_content',
+            eventName: 'view_content',
+            productId: data?.productId,
+            customData: {
+                productName: data?.productName,
+                category: data?.category,
+                ...data?.customData
+            }
+        });
+    }
+    /**
+     * Track initiate checkout
+     */
+    trackInitiateCheckout(data) {
+        this.sendEvent({
+            eventType: 'initiate_checkout',
+            eventName: 'initiate_checkout',
+            revenue: data?.value,
+            currency: data?.currency || 'USD',
+            quantity: data?.numItems,
+            customData: data?.customData
+        });
+    }
+    /**
+     * Track lead
+     */
+    trackLead(data) {
+        this.sendEvent({
+            eventType: 'lead',
+            eventName: 'lead',
+            customData: data
+        });
+    }
+    /**
+     * Identify user
+     */
+    identify(userData) {
+        this.sendEvent({
+            eventType: 'identify',
+            eventName: 'identify',
+            email: userData.email,
+            phone: userData.phone,
+            customData: userData
+        });
+    }
+    /**
+     * Track SPA navigation
+     */
+    trackSPANavigation(url, title) {
+        this.trackPageView({
+            url: url || window.location.href,
+            pageTitle: title || document.title
+        });
+    }
+    /**
+     * Reset scroll tracking
+     */
+    resetScrollTracking() {
+        // Implementation for scroll tracking reset
+        if (this.config.debug) {
+            console.log('[RabbitTracker] Scroll tracking reset');
+        }
+    }
+    /**
+     * Start presence tracking
+     */
+    startPresenceTracking() {
+        this.config.presenceTracking = true;
+        if (this.config.debug) {
+            console.log('[RabbitTracker] Presence tracking started');
+        }
+    }
+    /**
+     * Stop presence tracking
+     */
+    stopPresenceTracking() {
+        this.config.presenceTracking = false;
+        if (this.config.debug) {
+            console.log('[RabbitTracker] Presence tracking stopped');
+        }
+    }
+    /**
+     * Enable enhanced tracking
+     */
+    enableEnhancedTracking() {
+        this.config.enhancedTracking = 'true';
+        this.config.gdprMode = false;
+        // Re-collect fingerprint with enhanced mode
+        this.collectFingerprint();
+        if (this.config.debug) {
+            console.log('[RabbitTracker] Enhanced tracking enabled');
+        }
+        return true;
+    }
+    /**
+     * Disable enhanced tracking
+     */
+    disableEnhancedTracking() {
+        this.config.enhancedTracking = 'false';
+        this.config.gdprMode = true;
+        if (this.config.debug) {
+            console.log('[RabbitTracker] Enhanced tracking disabled');
+        }
+    }
+    /**
+     * Check if enhanced mode is active
+     */
+    isEnhancedMode() {
+        return this.config.enhancedTracking === 'true' && !this.config.gdprMode;
+    }
+    /**
+     * Get user data
+     */
+    getUserData() {
+        return {
+            sessionId: this.sessionId || '',
+            location: {}, // Will be populated by backend
+            device: {
+                userAgent: navigator.userAgent,
+                language: navigator.language,
+                screen: {
+                    width: window.screen.width,
+                    height: window.screen.height
+                }
+            },
+            journey: [], // Will be populated by backend
+            fingerprint: this.fingerprint?.hash
+        };
+    }
+    /**
+     * Get conversion likelihood (mock implementation)
+     */
+    getConversionLikelihood() {
+        return {
+            score: 0.5,
+            factors: ['Requires backend analysis']
+        };
+    }
+    /**
+     * Get user segment (mock implementation)
+     */
+    getUserSegment() {
+        return {
+            type: 'medium_intent',
+            confidence: 0.5
+        };
+    }
+}
+
+/**
+ * Bot Detection Module
+ * Comprehensive client-side bot detection based on multiple techniques
+ * Detects headless browsers, automation tools, and suspicious behavior
+ */
+/**
+ * Known bot user agent patterns
+ */
+const BOT_PATTERNS = [
+    // Headless browsers
+    /HeadlessChrome/i,
+    /PhantomJS/i,
+    /SlimerJS/i,
+    // Automation tools
+    /Selenium/i,
+    /WebDriver/i,
+    /ChromeDriver/i,
+    /GeckoDriver/i,
+    // Crawlers and bots
+    /bot/i,
+    /crawler/i,
+    /spider/i,
+    /scraper/i,
+    // Specific bots
+    /Googlebot/i,
+    /Bingbot/i,
+    /Slurp/i,
+    /DuckDuckBot/i,
+    /Baiduspider/i,
+    /YandexBot/i,
+    /facebookexternalhit/i,
+    /Twitterbot/i,
+    /LinkedInBot/i,
+    /WhatsApp/i,
+    /SkypeUriPreview/i
+];
+/**
+ * Suspicious user agent patterns
+ */
+const SUSPICIOUS_PATTERNS = [
+    /^Mozilla\/5\.0$/,
+    /Headless/i,
+    /automated/i,
+    /testing/i,
+    /^$/
+];
+/**
+ * Detect WebDriver presence
+ */
+function detectWebDriver() {
+    try {
+        // Check for webdriver property
+        if (navigator.webdriver === true) {
+            return {
+                detected: true,
+                confidence: 95,
+                method: 'navigator.webdriver_true'
+            };
+        }
+        // Check for webdriver in window
+        if (window.webdriver === true) {
+            return {
+                detected: true,
+                confidence: 90,
+                method: 'window.webdriver_true'
+            };
+        }
+        // Check for selenium-specific properties
+        const seleniumKeys = [
+            '_selenium',
+            'callSelenium',
+            '_Selenium_IDE_Recorder',
+            'callPhantom',
+            '_phantom',
+            '__phantomas',
+            '__fxdriver_evaluate',
+            '__fxdriver_unwrapped',
+            '_fxdriver_evaluate',
+            '_fxdriver_unwrapped'
+        ];
+        for (const key of seleniumKeys) {
+            if (key in window || key in document) {
+                return {
+                    detected: true,
+                    confidence: 85,
+                    method: `selenium_property_${key}`
+                };
+            }
+        }
+        // Check for webdriver in document
+        if (document.documentElement.getAttribute('webdriver')) {
+            return {
+                detected: true,
+                confidence: 80,
+                method: 'document_webdriver_attribute'
+            };
+        }
+        return {
+            detected: false,
+            confidence: 0,
+            method: 'webdriver_not_detected'
+        };
+    }
+    catch (error) {
+        return {
+            detected: false,
+            confidence: 0,
+            method: 'webdriver_error',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Detect headless browser characteristics
+ */
+function detectHeadlessBrowser() {
+    try {
+        let suspiciousCount = 0;
+        const issues = [];
+        // Check for missing window properties
+        if (!window.outerHeight || !window.outerWidth) {
+            suspiciousCount++;
+            issues.push('missing_outer_dimensions');
+        }
+        // Check for plugins
+        if (navigator.plugins.length === 0) {
+            suspiciousCount++;
+            issues.push('no_plugins');
+        }
+        // Check for languages
+        if (!navigator.languages || navigator.languages.length === 0) {
+            suspiciousCount++;
+            issues.push('no_languages');
+        }
+        // Check for inconsistent user agent
+        const userAgent = navigator.userAgent;
+        if (!userAgent || userAgent.length < 50) {
+            suspiciousCount++;
+            issues.push('short_user_agent');
+        }
+        // Check for notification permission (often undefined in headless)
+        if (typeof Notification?.permission === 'undefined') {
+            suspiciousCount++;
+            issues.push('no_notification_permission');
+        }
+        // Check for missing performance API
+        if (!window.performance || !window.performance.timing) {
+            suspiciousCount++;
+            issues.push('missing_performance_api');
+        }
+        // Check Chrome-specific headless indicators
+        if (userAgent.includes('Chrome')) {
+            // Check for missing chrome object
+            if (!window.chrome) {
+                suspiciousCount++;
+                issues.push('missing_chrome_object');
+            }
+            // Check for headless in user agent
+            if (userAgent.includes('HeadlessChrome')) {
+                return {
+                    detected: true,
+                    confidence: 95,
+                    method: 'chrome_headless_user_agent'
+                };
+            }
+        }
+        const confidence = Math.min(suspiciousCount * 15, 90);
+        return {
+            detected: suspiciousCount >= 3,
+            confidence,
+            method: 'headless_characteristics',
+            details: { issues, suspiciousCount }
+        };
+    }
+    catch (error) {
+        return {
+            detected: false,
+            confidence: 0,
+            method: 'headless_detection_error',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Detect automation tools
+ */
+function detectAutomationTools() {
+    try {
+        const automationIndicators = [
+            'webdriver',
+            'selenium',
+            'phantomjs',
+            'slimerjs',
+            'chromedriver',
+            'geckodriver',
+            'automation',
+            'puppeteer'
+        ];
+        const detectedTools = [];
+        // Check window properties
+        for (const tool of automationIndicators) {
+            if (window[tool] || window[`_${tool}`] || window[`__${tool}`]) {
+                detectedTools.push(tool);
+            }
+        }
+        // Check document properties
+        for (const tool of automationIndicators) {
+            if (document[tool] || document[`_${tool}`] || document[`__${tool}`]) {
+                detectedTools.push(tool);
+            }
+        }
+        // Check for automation-specific errors
+        try {
+            // Use safer method to test navigation object access
+            const nav = window.navigator;
+            if (!nav) {
+                detectedTools.push('navigation_missing');
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : '';
+            if (errorMessage.includes('automation') || errorMessage.includes('webdriver')) {
+                detectedTools.push('navigation_automation_error');
+            }
+        }
+        if (detectedTools.length > 0) {
+            return {
+                detected: true,
+                confidence: Math.min(detectedTools.length * 30, 95),
+                method: 'automation_tools_detected',
+                details: { tools: detectedTools }
+            };
+        }
+        return {
+            detected: false,
+            confidence: 0,
+            method: 'no_automation_tools'
+        };
+    }
+    catch (error) {
+        return {
+            detected: false,
+            confidence: 0,
+            method: 'automation_detection_error',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Detect DOM blockers (ad blockers and privacy tools)
+ */
+function detectDOMBlockers() {
+    try {
+        const blockerSelectors = [
+            // Ad blocker elements
+            '#ad-banner',
+            '.advertisement',
+            '.google-ads',
+            '.adsense',
+            // Analytics blockers
+            '#google-analytics',
+            '.analytics',
+            '[src*="google-analytics"]',
+            '[src*="googletagmanager"]',
+            // Social media blockers
+            '.facebook-widget',
+            '.twitter-widget',
+            '.social-share'
+        ];
+        let blockedCount = 0;
+        for (const selector of blockerSelectors) {
+            const element = document.querySelector(selector);
+            if (!element) {
+                blockedCount++;
+            }
+        }
+        // Test if we can create tracking pixels
+        try {
+            const pixel = document.createElement('img');
+            pixel.src = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
+            pixel.style.display = 'none';
+            document.body.appendChild(pixel);
+            setTimeout(() => {
+                if (pixel.parentNode) {
+                    pixel.parentNode.removeChild(pixel);
+                }
+            }, 100);
+        }
+        catch {
+            blockedCount++;
+        }
+        const confidence = Math.min(blockedCount * 20, 80);
+        return {
+            detected: blockedCount >= 2,
+            confidence,
+            method: 'dom_blockers',
+            details: { blockedCount, totalTests: blockerSelectors.length + 1 }
+        };
+    }
+    catch (error) {
+        return {
+            detected: false,
+            confidence: 0,
+            method: 'dom_blocker_error',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Check for missing languages (common in bots)
+ */
+function detectMissingLanguages() {
+    try {
+        if (!navigator.languages || navigator.languages.length === 0) {
+            return {
+                detected: true,
+                confidence: 70,
+                method: 'no_languages'
+            };
+        }
+        if (navigator.languages.length === 1 && navigator.languages[0] === 'en-US') {
+            return {
+                detected: true,
+                confidence: 40,
+                method: 'single_default_language'
+            };
+        }
+        // Check for inconsistent language settings
+        if (navigator.language !== navigator.languages[0]) {
+            return {
+                detected: true,
+                confidence: 30,
+                method: 'inconsistent_languages',
+                details: {
+                    language: navigator.language,
+                    firstLanguage: navigator.languages[0]
+                }
+            };
+        }
+        return {
+            detected: false,
+            confidence: 0,
+            method: 'languages_normal',
+            details: { languageCount: navigator.languages.length }
+        };
+    }
+    catch (error) {
+        return {
+            detected: true,
+            confidence: 50,
+            method: 'language_detection_error',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Test for inconsistent eval behavior
+ */
+function detectInconsistentEval() {
+    try {
+        // Test if basic math computation works normally
+        const testFunction = new Function('return 2 + 2');
+        const result = testFunction();
+        if (result !== 4) {
+            return {
+                detected: true,
+                confidence: 90,
+                method: 'function_constructor_incorrect_result',
+                details: { expected: 4, actual: result }
+            };
+        }
+        // Test if Function constructor toString() is modified
+        const functionString = Function.toString();
+        if (!functionString.includes('[native code]') && !functionString.includes('function Function()')) {
+            return {
+                detected: true,
+                confidence: 70,
+                method: 'function_constructor_modified_toString',
+                details: { functionString: functionString.substring(0, 100) }
+            };
+        }
+        return {
+            detected: false,
+            confidence: 0,
+            method: 'eval_normal'
+        };
+    }
+    catch (error) {
+        return {
+            detected: true,
+            confidence: 60,
+            method: 'eval_error',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Analyze user agent for bot patterns
+ */
+function analyzeUserAgent$1() {
+    const userAgent = navigator.userAgent;
+    // Check for bot patterns
+    const botPatterns = BOT_PATTERNS.filter(pattern => pattern.test(userAgent));
+    const suspiciousPatterns = SUSPICIOUS_PATTERNS.filter(pattern => pattern.test(userAgent));
+    let category = 'legitimate';
+    if (botPatterns.some(p => p.source.includes('bot|crawler|spider'))) {
+        category = 'crawler';
+    }
+    else if (botPatterns.some(p => p.source.includes('Selenium|WebDriver'))) {
+        category = 'automation';
+    }
+    else if (botPatterns.some(p => p.source.includes('Headless|Phantom'))) {
+        category = 'headless';
+    }
+    const allPatterns = [...botPatterns.map(p => p.source), ...suspiciousPatterns.map(p => p.source)];
+    return {
+        browser: {
+            name: 'Unknown',
+            version: 'Unknown',
+            major: 'Unknown',
+            engine: 'unknown'
+        },
+        os: {
+            name: 'Unknown',
+            version: 'Unknown',
+            family: 'unknown'
+        },
+        device: {
+            type: 'desktop'
+        },
+        suspicious: {
+            isBot: botPatterns.length > 0 || suspiciousPatterns.length > 0,
+            patterns: allPatterns,
+            category: botPatterns.length > 0 ? category : 'legitimate'
+        },
+        isMobile: false,
+        isTablet: false,
+        isDesktop: true,
+        isBot: botPatterns.length > 0 || suspiciousPatterns.length > 0,
+        raw: userAgent
+    };
+}
+/**
+ * Main bot detection function
+ */
+async function detectBot() {
+    // Run all detection methods
+    const detectors = {
+        webDriver: detectWebDriver(),
+        headlessBrowser: detectHeadlessBrowser(),
+        automationTools: detectAutomationTools(),
+        domBlockers: detectDOMBlockers(),
+        missingLanguages: detectMissingLanguages(),
+        inconsistentEval: detectInconsistentEval(),
+        // Behavioral detection (placeholder - would need more time to implement)
+        humanBehavior: { detected: false, confidence: 0, method: 'not_implemented' },
+        mouseMovement: { detected: false, confidence: 0, method: 'not_implemented' },
+        clickPatterns: { detected: false, confidence: 0, method: 'not_implemented' },
+        // Canvas/WebGL consistency (placeholder - would integrate with fingerprinting)
+        canvasInconsistency: { detected: false, confidence: 0, method: 'not_implemented' },
+        webglAnomaly: { detected: false, confidence: 0, method: 'not_implemented' },
+        // Plugin detection
+        missingPlugins: { detected: navigator.plugins.length === 0, confidence: 30, method: 'plugin_count' },
+        inconsistentProperties: { detected: false, confidence: 0, method: 'not_implemented' },
+        // Modified built-ins detection
+        modifiedBuiltins: { detected: false, confidence: 0, method: 'not_implemented' }
+    };
+    // Analyze user agent
+    const userAgent = analyzeUserAgent$1();
+    // Calculate overall bot detection
+    const positiveDetections = Object.values(detectors).filter(d => d.detected);
+    const totalConfidence = positiveDetections.reduce((sum, d) => sum + d.confidence, 0);
+    const averageConfidence = positiveDetections.length > 0 ? totalConfidence / positiveDetections.length : 0;
+    // Determine if bot is detected
+    const isBot = positiveDetections.length >= 2 || // Multiple detections
+        positiveDetections.some(d => d.confidence >= 90) || // High confidence detection
+        (userAgent.suspicious?.isBot ?? false); // User agent indicates bot
+    // Determine risk level
+    let riskLevel = 'low';
+    if (averageConfidence >= 70) {
+        riskLevel = 'high';
+    }
+    else if (averageConfidence >= 40 || positiveDetections.length >= 2) {
+        riskLevel = 'medium';
+    }
+    return {
+        isBot,
+        confidence: Math.round(Math.min(averageConfidence, 95)),
+        riskLevel,
+        detectionMethods: Object.keys(detectors).filter(key => detectors[key]?.detected),
+        detectors,
+        userAgent
+    };
+}
+/**
+ * Quick bot detection (faster, less comprehensive)
+ */
+async function quickBotDetection() {
+    // Check only the most reliable indicators
+    const webDriver = detectWebDriver();
+    const userAgent = analyzeUserAgent$1();
+    return webDriver.detected || (userAgent.suspicious?.isBot ?? false);
+}
+
+/**
+ * Incognito Mode Detection (Analytics Only)
+ *
+ * Detects private/incognito browsing mode for analytics purposes only.
+ * Does NOT use localStorage/sessionStorage for tracking or data persistence.
+ * Used only to enrich analytics data with browser context information.
+ */
+/**
+ * Test localStorage availability and behavior (ANALYTICS ONLY)
+ *
+ * NOTE: This function uses localStorage purely for DETECTION purposes.
+ * It does NOT store any tracking data or persistent information.
+ * Used only to analyze browser capabilities for analytics context.
+ */
+async function testLocalStorage() {
+    try {
+        const testKey = '__incognito_test_' + Date.now();
+        const testValue = 'test';
+        // Try to set and get localStorage item (for detection only, immediately cleaned up)
+        localStorage.setItem(testKey, testValue);
+        const retrieved = localStorage.getItem(testKey);
+        localStorage.removeItem(testKey); // Immediately cleanup test data
+        // In some incognito modes, localStorage works but has limited capacity
+        if (retrieved !== testValue) {
+            return {
+                detected: true,
+                confidence: 80,
+                method: 'localStorage_inconsistency',
+                details: { retrieved, expected: testValue }
+            };
+        }
+        // Test storage capacity (incognito often has reduced limits) - DETECTION ONLY
+        try {
+            const largData = 'x'.repeat(1024 * 1024); // 1MB
+            localStorage.setItem('__capacity_test', largData); // Test only, immediately removed
+            localStorage.removeItem('__capacity_test'); // Immediate cleanup
+            return {
+                detected: false,
+                confidence: 30,
+                method: 'localStorage_capacity'
+            };
+        }
+        catch (capacityError) {
+            // Limited capacity might indicate incognito
+            return {
+                detected: true,
+                confidence: 60,
+                method: 'localStorage_capacity_limited',
+                details: { error: capacityError instanceof Error ? capacityError.message : 'Unknown' }
+            };
+        }
+    }
+    catch (error) {
+        // localStorage completely unavailable
+        return {
+            detected: true,
+            confidence: 90,
+            method: 'localStorage_unavailable',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Test sessionStorage availability (ANALYTICS ONLY)
+ *
+ * NOTE: Uses sessionStorage purely for browser capability detection.
+ * No tracking data is stored - all test data is immediately removed.
+ */
+async function testSessionStorage() {
+    try {
+        const testKey = '__session_test_' + Date.now();
+        const testValue = 'test';
+        sessionStorage.setItem(testKey, testValue); // Test only, immediately cleaned
+        const retrieved = sessionStorage.getItem(testKey);
+        sessionStorage.removeItem(testKey); // Immediate cleanup
+        if (retrieved !== testValue) {
+            return {
+                detected: true,
+                confidence: 75,
+                method: 'sessionStorage_inconsistency',
+                details: { retrieved, expected: testValue }
+            };
+        }
+        return {
+            detected: false,
+            confidence: 20,
+            method: 'sessionStorage_working'
+        };
+    }
+    catch (error) {
+        return {
+            detected: true,
+            confidence: 85,
+            method: 'sessionStorage_unavailable',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Test IndexedDB availability and behavior
+ */
+async function testIndexedDB() {
+    try {
+        if (!window.indexedDB) {
+            return {
+                detected: true,
+                confidence: 70,
+                method: 'indexedDB_unavailable'
+            };
+        }
+        return new Promise((resolve) => {
+            const dbName = '__incognito_test_' + Date.now();
+            const request = indexedDB.open(dbName, 1);
+            const timeout = setTimeout(() => {
+                resolve({
+                    detected: true,
+                    confidence: 60,
+                    method: 'indexedDB_timeout'
+                });
+            }, 1000);
+            request.onerror = () => {
+                clearTimeout(timeout);
+                resolve({
+                    detected: true,
+                    confidence: 80,
+                    method: 'indexedDB_error',
+                    details: { error: request.error?.message }
+                });
+            };
+            request.onsuccess = () => {
+                clearTimeout(timeout);
+                const db = request.result;
+                // Clean up
+                db.close();
+                indexedDB.deleteDatabase(dbName);
+                resolve({
+                    detected: false,
+                    confidence: 25,
+                    method: 'indexedDB_working'
+                });
+            };
+            request.onblocked = () => {
+                clearTimeout(timeout);
+                resolve({
+                    detected: true,
+                    confidence: 70,
+                    method: 'indexedDB_blocked'
+                });
+            };
+        });
+    }
+    catch (error) {
+        return {
+            detected: true,
+            confidence: 85,
+            method: 'indexedDB_exception',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Test WebSQL availability (legacy browsers)
+ */
+async function testOpenDatabase() {
+    try {
+        const openDatabase = window.openDatabase;
+        if (!openDatabase) {
+            return {
+                detected: false,
+                confidence: 10,
+                method: 'openDatabase_unsupported'
+            };
+        }
+        const db = openDatabase('__test', '1.0', 'Test', 1024);
+        if (!db) {
+            return {
+                detected: true,
+                confidence: 60,
+                method: 'openDatabase_failed'
+            };
+        }
+        return {
+            detected: false,
+            confidence: 20,
+            method: 'openDatabase_working'
+        };
+    }
+    catch (error) {
+        return {
+            detected: true,
+            confidence: 70,
+            method: 'openDatabase_error',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Test permissions API behavior
+ */
+async function testPermissions() {
+    try {
+        if (!navigator.permissions) {
+            return {
+                detected: false,
+                confidence: 10,
+                method: 'permissions_unsupported'
+            };
+        }
+        // Test notification permission (often different in incognito)
+        const result = await navigator.permissions.query({ name: 'notifications' });
+        // In some browsers, incognito mode always returns "denied" for notifications
+        if (result.state === 'denied') {
+            return {
+                detected: true,
+                confidence: 40,
+                method: 'permissions_notifications_denied',
+                details: { state: result.state }
+            };
+        }
+        return {
+            detected: false,
+            confidence: 30,
+            method: 'permissions_working',
+            details: { state: result.state }
+        };
+    }
+    catch (error) {
+        return {
+            detected: true,
+            confidence: 50,
+            method: 'permissions_error',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Test quota management API
+ */
+async function testQuotaManagement() {
+    try {
+        if (!navigator.storage || !navigator.storage.estimate) {
+            return {
+                detected: false,
+                confidence: 10,
+                method: 'quota_unsupported'
+            };
+        }
+        const estimate = await navigator.storage.estimate();
+        // Incognito mode often has very limited quota
+        if (estimate.quota && estimate.quota < 10 * 1024 * 1024) { // Less than 10MB
+            return {
+                detected: true,
+                confidence: 70,
+                method: 'quota_limited',
+                details: { quota: estimate.quota, usage: estimate.usage }
+            };
+        }
+        return {
+            detected: false,
+            confidence: 40,
+            method: 'quota_normal',
+            details: { quota: estimate.quota, usage: estimate.usage }
+        };
+    }
+    catch (error) {
+        return {
+            detected: true,
+            confidence: 60,
+            method: 'quota_error',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Test filesystem API availability
+ */
+async function testFilesystem() {
+    try {
+        const requestFileSystem = window.requestFileSystem || window.webkitRequestFileSystem;
+        if (!requestFileSystem) {
+            return {
+                detected: false,
+                confidence: 10,
+                method: 'filesystem_unsupported'
+            };
+        }
+        return new Promise((resolve) => {
+            requestFileSystem(window.TEMPORARY || 0, 1024, () => {
+                resolve({
+                    detected: false,
+                    confidence: 30,
+                    method: 'filesystem_working'
+                });
+            }, (error) => {
+                resolve({
+                    detected: true,
+                    confidence: 60,
+                    method: 'filesystem_error',
+                    details: { error: error.name || 'Unknown' }
+                });
+            });
+            // Timeout
+            setTimeout(() => {
+                resolve({
+                    detected: true,
+                    confidence: 50,
+                    method: 'filesystem_timeout'
+                });
+            }, 1000);
+        });
+    }
+    catch (error) {
+        return {
+            detected: true,
+            confidence: 70,
+            method: 'filesystem_exception',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Test cookies enabled state
+ */
+async function testCookiesEnabled() {
+    try {
+        const cookiesEnabled = navigator.cookieEnabled;
+        // Test by setting a cookie
+        document.cookie = '__incognito_test=test; path=/';
+        const cookieSet = document.cookie.includes('__incognito_test=test');
+        // Clean up
+        document.cookie = '__incognito_test=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/';
+        if (!cookiesEnabled || !cookieSet) {
+            return {
+                detected: true,
+                confidence: 50,
+                method: 'cookies_disabled',
+                details: { cookiesEnabled, cookieSet }
+            };
+        }
+        return {
+            detected: false,
+            confidence: 20,
+            method: 'cookies_working',
+            details: { cookiesEnabled, cookieSet }
+        };
+    }
+    catch (error) {
+        return {
+            detected: true,
+            confidence: 60,
+            method: 'cookies_error',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Test cache detection through timing
+ */
+async function testCacheDetection() {
+    try {
+        const image = new Image();
+        const startTime = performance.now();
+        return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                resolve({
+                    detected: false,
+                    confidence: 10,
+                    method: 'cache_timeout'
+                });
+            }, 3000);
+            image.onload = () => {
+                clearTimeout(timeout);
+                const loadTime = performance.now() - startTime;
+                // Very fast load might indicate cache is disabled (incognito)
+                if (loadTime < 5) {
+                    resolve({
+                        detected: true,
+                        confidence: 30,
+                        method: 'cache_too_fast',
+                        details: { loadTime }
+                    });
+                }
+                else {
+                    resolve({
+                        detected: false,
+                        confidence: 20,
+                        method: 'cache_normal',
+                        details: { loadTime }
+                    });
+                }
+            };
+            image.onerror = () => {
+                clearTimeout(timeout);
+                resolve({
+                    detected: false,
+                    confidence: 10,
+                    method: 'cache_error'
+                });
+            };
+            // Use a small, commonly cached image
+            image.src = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7';
+        });
+    }
+    catch (error) {
+        return {
+            detected: false,
+            confidence: 10,
+            method: 'cache_exception',
+            details: { error: error instanceof Error ? error.message : 'Unknown' }
+        };
+    }
+}
+/**
+ * Detect browser-specific incognito patterns
+ */
+function detectBrowserSpecificPatterns() {
+    const userAgent = navigator.userAgent.toLowerCase();
+    if (userAgent.includes('chrome')) {
+        return { browser: 'Chrome', supportsDetection: true };
+    }
+    else if (userAgent.includes('firefox')) {
+        return { browser: 'Firefox', supportsDetection: true };
+    }
+    else if (userAgent.includes('safari')) {
+        return { browser: 'Safari', supportsDetection: true };
+    }
+    else if (userAgent.includes('edge')) {
+        return { browser: 'Edge', supportsDetection: true };
+    }
+    return { browser: 'Unknown', supportsDetection: false };
+}
+/**
+ * Main incognito detection function
+ */
+async function detectIncognitoMode() {
+    detectBrowserSpecificPatterns();
+    // Run all detection methods in parallel
+    const [localStorage, sessionStorage, indexedDB, openDatabase, permissions, quotaManagement, filesystem, cookiesEnabled, cacheDetection] = await Promise.all([
+        testLocalStorage(),
+        testSessionStorage(),
+        testIndexedDB(),
+        testOpenDatabase(),
+        testPermissions(),
+        testQuotaManagement(),
+        testFilesystem(),
+        testCookiesEnabled(),
+        testCacheDetection()
+    ]);
+    const detectionMethods = {
+        localStorage,
+        sessionStorage,
+        indexedDB,
+        openDatabase,
+        permissions,
+        quotaManagement,
+        filesystem,
+        cookiesEnabled,
+        cacheDetection,
+        canvasConsistency: { detected: false, confidence: 0, method: 'not_implemented' },
+        webglConsistency: { detected: false, confidence: 0, method: 'not_implemented' },
+        timingDifferences: { detected: false, confidence: 0, method: 'not_implemented' }
+    };
+    // Calculate overall confidence
+    const detections = Object.values(detectionMethods).filter(d => d.detected);
+    const totalConfidence = detections.reduce((sum, d) => sum + d.confidence, 0);
+    const averageConfidence = detections.length > 0 ? totalConfidence / detections.length : 0;
+    // Determine if incognito mode is detected
+    const isIncognito = detections.length >= 2 || // Multiple methods detected
+        detections.some(d => d.confidence >= 80); // High confidence detection
+    const confidence = Math.min(averageConfidence, 95); // Cap at 95%
+    return {
+        isIncognito,
+        confidence: Math.round(confidence),
+        detectionMethods: Object.keys(detectionMethods).filter(key => detectionMethods[key]?.detected),
+        details: {
+            localStorage: localStorage?.detected ?? false,
+            sessionStorage: sessionStorage?.detected ?? false,
+            indexedDB: indexedDB?.detected ?? false,
+            cookiesEnabled: cookiesEnabled?.detected ?? false,
+            quota: quotaManagement?.detected ? 0 : null,
+            permissions: permissions?.details || {}
+        }
+    };
+}
+/**
+ * Quick incognito detection (less comprehensive but faster)
+ */
+async function quickIncognitoDetection() {
+    try {
+        // Test the most reliable indicators quickly
+        const [localStorage, indexedDB] = await Promise.all([
+            testLocalStorage(),
+            testIndexedDB()
+        ]);
+        return localStorage.detected || indexedDB.detected;
+    }
+    catch {
+        return false;
+    }
+}
+
+/**
+ * Enhanced User Agent Parser
+ * Based on FingerprintJS browser detection with advanced engine and version parsing
+ */
+/**
+ * Browser engine detection (based on FingerprintJS)
+ */
+function isChromium() {
+    try {
+        return typeof window.chrome === 'object' &&
+            window.chrome !== null &&
+            typeof window.chrome.runtime === 'object';
+    }
+    catch {
+        return false;
+    }
+}
+function isWebKit() {
+    return navigator.userAgent.includes('WebKit') &&
+        !navigator.userAgent.includes('Chrome');
+}
+function isGecko() {
+    return navigator.userAgent.includes('Gecko') &&
+        !navigator.userAgent.includes('Chrome');
+}
+function isSamsungInternet() {
+    return navigator.userAgent.includes('SamsungBrowser') ||
+        navigator.userAgent.includes('Samsung Internet');
+}
+function isIPad() {
+    // iPad detection (iOS 13+ shows as desktop Safari)
+    return navigator.userAgent.includes('iPad') ||
+        (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
+}
+function isAndroid() {
+    return navigator.userAgent.includes('Android');
+}
+/**
+ * Extract browser version from user agent
+ */
+function extractVersion(userAgent, pattern) {
+    const match = userAgent.match(pattern);
+    return match ? (match[1] || 'Unknown') : 'Unknown';
+}
+/**
+ * Detect browser name and version
+ */
+function detectBrowser(userAgent) {
+    const ua = userAgent.toLowerCase();
+    // Edge (Chromium-based)
+    if (ua.includes('edg/')) {
+        const version = extractVersion(userAgent, /edg\/([0-9.]+)/i);
+        return {
+            name: 'Edge',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'chromium'
+        };
+    }
+    // Edge Legacy
+    if (ua.includes('edge/')) {
+        const version = extractVersion(userAgent, /edge\/([0-9.]+)/i);
+        return {
+            name: 'Edge Legacy',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'edgehtml'
+        };
+    }
+    // Brave Browser (check before Chrome)
+    if (ua.includes('brave/') || navigator.brave) {
+        const version = extractVersion(userAgent, /chrome\/([0-9.]+)/i);
+        return {
+            name: 'Brave',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'chromium'
+        };
+    }
+    // Samsung Internet
+    if (isSamsungInternet()) {
+        const version = extractVersion(userAgent, /samsungbrowser\/([0-9.]+)/i);
+        return {
+            name: 'Samsung Internet',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'chromium'
+        };
+    }
+    // Chrome (check after other Chromium browsers)
+    if (ua.includes('chrome/') && !ua.includes('edg')) {
+        const version = extractVersion(userAgent, /chrome\/([0-9.]+)/i);
+        return {
+            name: 'Chrome',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'chromium'
+        };
+    }
+    // Firefox
+    if (ua.includes('firefox/')) {
+        const version = extractVersion(userAgent, /firefox\/([0-9.]+)/i);
+        return {
+            name: 'Firefox',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'gecko'
+        };
+    }
+    // Safari (check after Chrome to avoid false positives)
+    if (ua.includes('safari/') && !ua.includes('chrome')) {
+        const version = extractVersion(userAgent, /version\/([0-9.]+)/i);
+        return {
+            name: 'Safari',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'webkit'
+        };
+    }
+    // Opera (modern versions)
+    if (ua.includes('opr/') || ua.includes('opera/')) {
+        const version = extractVersion(userAgent, /(?:opr|opera)\/([0-9.]+)/i);
+        return {
+            name: 'Opera',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: isChromium() ? 'chromium' : 'unknown'
+        };
+    }
+    // Vivaldi
+    if (ua.includes('vivaldi/')) {
+        const version = extractVersion(userAgent, /vivaldi\/([0-9.]+)/i);
+        return {
+            name: 'Vivaldi',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'chromium'
+        };
+    }
+    // Yandex Browser
+    if (ua.includes('yabrowser/')) {
+        const version = extractVersion(userAgent, /yabrowser\/([0-9.]+)/i);
+        return {
+            name: 'Yandex Browser',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'chromium'
+        };
+    }
+    // Internet Explorer
+    if (ua.includes('msie') || ua.includes('trident/')) {
+        const version = extractVersion(userAgent, /(?:msie |rv:)([0-9.]+)/i);
+        return {
+            name: 'Internet Explorer',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'trident'
+        };
+    }
+    // UC Browser
+    if (ua.includes('ucbrowser/')) {
+        const version = extractVersion(userAgent, /ucbrowser\/([0-9.]+)/i);
+        return {
+            name: 'UC Browser',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'chromium'
+        };
+    }
+    // QQ Browser
+    if (ua.includes('qqbrowser/')) {
+        const version = extractVersion(userAgent, /qqbrowser\/([0-9.]+)/i);
+        return {
+            name: 'QQ Browser',
+            version,
+            major: version.split('.')[0] || 'Unknown',
+            engine: 'chromium'
+        };
+    }
+    // Unknown browser
+    return {
+        name: 'Unknown',
+        version: 'Unknown',
+        major: 'Unknown',
+        engine: 'unknown'
+    };
+}
+/**
+ * Detect operating system
+ */
+function detectOS(userAgent) {
+    const ua = userAgent.toLowerCase();
+    // Windows
+    if (ua.includes('windows nt')) {
+        const version = extractVersion(userAgent, /windows nt ([0-9.]+)/i);
+        let osName = 'Windows';
+        // Map NT versions to friendly names
+        switch (version) {
+            case '10.0':
+                osName = 'Windows 10/11';
+                break;
+            case '6.3':
+                osName = 'Windows 8.1';
+                break;
+            case '6.2':
+                osName = 'Windows 8';
+                break;
+            case '6.1':
+                osName = 'Windows 7';
+                break;
+            case '6.0':
+                osName = 'Windows Vista';
+                break;
+            case '5.1':
+                osName = 'Windows XP';
+                break;
+            default: osName = 'Windows';
+        }
+        return {
+            name: osName,
+            version,
+            family: 'windows'
+        };
+    }
+    // macOS / Mac OS X
+    if (ua.includes('mac os x') || ua.includes('macos')) {
+        const version = extractVersion(userAgent, /mac os x ([0-9._]+)/i);
+        return {
+            name: 'macOS',
+            version: version.replace(/_/g, '.'),
+            family: 'macos'
+        };
+    }
+    // iOS
+    if (ua.includes('iphone') || ua.includes('ipad') || ua.includes('ipod') || isIPad()) {
+        const version = extractVersion(userAgent, /os ([0-9._]+)/i);
+        return {
+            name: 'iOS',
+            version: version.replace(/_/g, '.'),
+            family: 'ios'
+        };
+    }
+    // Android
+    if (isAndroid()) {
+        const version = extractVersion(userAgent, /android ([0-9.]+)/i);
+        return {
+            name: 'Android',
+            version,
+            family: 'android'
+        };
+    }
+    // Linux
+    if (ua.includes('linux')) {
+        return {
+            name: 'Linux',
+            version: 'Unknown',
+            family: 'linux'
+        };
+    }
+    // Chrome OS
+    if (ua.includes('cros')) {
+        const version = extractVersion(userAgent, /cros [a-z0-9_]+ ([0-9.]+)/i);
+        return {
+            name: 'Chrome OS',
+            version,
+            family: 'linux'
+        };
+    }
+    // FreeBSD
+    if (ua.includes('freebsd')) {
+        return {
+            name: 'FreeBSD',
+            version: 'Unknown',
+            family: 'unix'
+        };
+    }
+    // Unknown OS
+    return {
+        name: 'Unknown',
+        version: 'Unknown',
+        family: 'unknown'
+    };
+}
+/**
+ * Detect device type
+ */
+function detectDevice(userAgent) {
+    const ua = userAgent.toLowerCase();
+    // Tablet detection
+    if (ua.includes('tablet') || isIPad()) {
+        if (isIPad()) {
+            return { type: 'tablet', vendor: 'Apple', model: 'iPad' };
+        }
+        if (ua.includes('kindle')) {
+            return { type: 'tablet', vendor: 'Amazon', model: 'Kindle' };
+        }
+        return { type: 'tablet' };
+    }
+    // Mobile detection
+    if (ua.includes('mobile') ||
+        ua.includes('iphone') ||
+        ua.includes('ipod') ||
+        isAndroid()) {
+        if (ua.includes('iphone')) {
+            return { type: 'mobile', vendor: 'Apple', model: 'iPhone' };
+        }
+        if (ua.includes('ipod')) {
+            return { type: 'mobile', vendor: 'Apple', model: 'iPod' };
+        }
+        if (isAndroid() && ua.includes('mobile')) {
+            return { type: 'mobile', vendor: 'Android' };
+        }
+        return { type: 'mobile' };
+    }
+    // Desktop (default)
+    return { type: 'desktop' };
+}
+/**
+ * Check for suspicious patterns in user agent
+ */
+function analyzeSuspiciousPatterns(userAgent) {
+    const patterns = [];
+    let category = 'legitimate';
+    // Bot patterns
+    const botKeywords = [
+        'bot', 'crawler', 'spider', 'scraper', 'automation',
+        'headless', 'phantom', 'selenium', 'webdriver',
+        'google', 'bing', 'yahoo', 'baidu', 'yandex',
+        'facebook', 'twitter', 'linkedin', 'whatsapp'
+    ];
+    for (const keyword of botKeywords) {
+        if (userAgent.toLowerCase().includes(keyword)) {
+            patterns.push(keyword);
+            if (['bot', 'crawler', 'spider', 'scraper'].some(k => keyword.includes(k))) {
+                category = 'crawler';
+            }
+            else if (['selenium', 'webdriver', 'automation'].some(k => keyword.includes(k))) {
+                category = 'automation';
+            }
+            else if (['headless', 'phantom'].some(k => keyword.includes(k))) {
+                category = 'headless';
+            }
+        }
+    }
+    // Suspicious patterns
+    if (userAgent.length < 10) {
+        patterns.push('too_short');
+    }
+    if (!userAgent || userAgent === 'Mozilla/5.0') {
+        patterns.push('generic_mozilla');
+    }
+    const isBot = patterns.length > 0;
+    return { isBot, patterns, category };
+}
+/**
+ * Enhanced user agent analysis
+ */
+function analyzeUserAgent(userAgent) {
+    const ua = userAgent || navigator.userAgent || '';
+    const browser = detectBrowser(ua);
+    const os = detectOS(ua);
+    const device = detectDevice(ua);
+    const suspicious = analyzeSuspiciousPatterns(ua);
+    return {
+        browser: {
+            name: browser.name,
+            version: browser.version,
+            major: browser.major,
+            engine: browser.engine
+        },
+        os: {
+            name: os.name,
+            version: os.version,
+            family: os.family
+        },
+        device: {
+            type: device.type,
+            vendor: device.vendor,
+            model: device.model
+        },
+        suspicious: {
+            isBot: suspicious.isBot,
+            patterns: suspicious.patterns,
+            category: suspicious.category
+        },
+        isMobile: device.type === 'mobile',
+        isTablet: device.type === 'tablet',
+        isDesktop: device.type === 'desktop',
+        isBot: suspicious.isBot,
+        raw: ua
+    };
+}
+/**
+ * Get browser engine type
+ */
+function getBrowserEngine() {
+    if (isChromium())
+        return 'chromium';
+    if (isWebKit())
+        return 'webkit';
+    if (isGecko())
+        return 'gecko';
+    const ua = navigator.userAgent.toLowerCase();
+    if (ua.includes('trident'))
+        return 'trident';
+    return 'unknown';
+}
+/**
+ * Check if running on mobile device
+ */
+function isMobile() {
+    return detectDevice(navigator.userAgent).type === 'mobile';
+}
+/**
+ * Check if running on tablet
+ */
+function isTablet() {
+    return detectDevice(navigator.userAgent).type === 'tablet';
+}
+/**
+ * Check if running on desktop
+ */
+function isDesktop() {
+    return detectDevice(navigator.userAgent).type === 'desktop';
+}
+
+exports.RabbitTrackerSDK = RabbitTrackerSDK;
+exports.analyzeUserAgent = analyzeUserAgent;
+exports.clearFingerprintCache = clearFingerprintCache;
+exports.collectFingerprint = collectFingerprint;
+exports.default = RabbitTrackerSDK;
+exports.detectBot = detectBot;
+exports.detectIncognitoMode = detectIncognitoMode;
+exports.generateVisitorId = generateVisitorId;
+exports.generateVisitorIdFromFingerprint = generateVisitorIdFromFingerprint;
+exports.getAvailableComponents = getAvailableComponents;
+exports.getBrowserEngine = getBrowserEngine;
+exports.getCompleteFingerprint = getCompleteFingerprint;
+exports.getLightweightFingerprint = getLightweightFingerprint;
+exports.hash32 = hash32;
+exports.hashFingerprint = hashFingerprint;
+exports.isAndroid = isAndroid;
+exports.isChromium = isChromium;
+exports.isDesktop = isDesktop;
+exports.isFingerprintingAvailable = isFingerprintingAvailable;
+exports.isGecko = isGecko;
+exports.isIPad = isIPad;
+exports.isMobile = isMobile;
+exports.isSamsungInternet = isSamsungInternet;
+exports.isTablet = isTablet;
+exports.isWebKit = isWebKit;
+exports.quickBotDetection = quickBotDetection;
+exports.quickIncognitoDetection = quickIncognitoDetection;
+exports.x64hash128 = x64hash128;
+//# sourceMappingURL=index.js.map