@datalyr/web 1.0.0

package/dist/datalyr.js

@@ -0,0 +1,2838 @@
+/**
+ * @datalyr/web v1.0.0
+ * Datalyr Web SDK - Modern attribution tracking for web applications
+ * (c) 2025 Datalyr Inc.
+ * Released under the MIT License
+ */
+var Datalyr = (function () {
+    'use strict';
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    /**
+     * Storage Module
+     * Safe storage wrapper with fallbacks for Safari private mode
+     */
+    class SafeStorage {
+        constructor(storage) {
+            this.memory = new Map();
+            this.prefix = '__dl_';
+            // Test if storage is available
+            try {
+                const testKey = '__dl_test__' + Math.random();
+                storage.setItem(testKey, '1');
+                storage.removeItem(testKey);
+                this.storage = storage;
+            }
+            catch (_a) {
+                // Storage not available (Safari private mode, etc.)
+                this.storage = null;
+                console.warn('[Datalyr] Storage not available, using memory fallback');
+            }
+        }
+        get(key, defaultValue = null) {
+            const fullKey = this.prefix + key;
+            try {
+                if (this.storage) {
+                    const value = this.storage.getItem(fullKey);
+                    if (value === null)
+                        return defaultValue;
+                    // Try to parse JSON
+                    try {
+                        return JSON.parse(value);
+                    }
+                    catch (_a) {
+                        return value;
+                    }
+                }
+                else {
+                    const value = this.memory.get(fullKey);
+                    if (value === undefined)
+                        return defaultValue;
+                    try {
+                        return JSON.parse(value);
+                    }
+                    catch (_b) {
+                        return value;
+                    }
+                }
+            }
+            catch (_c) {
+                return defaultValue;
+            }
+        }
+        set(key, value) {
+            const fullKey = this.prefix + key;
+            const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+            try {
+                if (this.storage) {
+                    this.storage.setItem(fullKey, stringValue);
+                    return true;
+                }
+                else {
+                    this.memory.set(fullKey, stringValue);
+                    return true;
+                }
+            }
+            catch (e) {
+                // Quota exceeded or other error
+                console.warn('[Datalyr] Failed to store:', key, e);
+                // Try memory fallback
+                this.memory.set(fullKey, stringValue);
+                return false;
+            }
+        }
+        remove(key) {
+            const fullKey = this.prefix + key;
+            try {
+                if (this.storage) {
+                    this.storage.removeItem(fullKey);
+                    return true;
+                }
+                else {
+                    this.memory.delete(fullKey);
+                    return true;
+                }
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+        keys() {
+            try {
+                if (this.storage) {
+                    const keys = [];
+                    for (let i = 0; i < this.storage.length; i++) {
+                        const key = this.storage.key(i);
+                        if (key && key.startsWith(this.prefix)) {
+                            keys.push(key.slice(this.prefix.length));
+                        }
+                    }
+                    return keys;
+                }
+                else {
+                    return Array.from(this.memory.keys())
+                        .filter(k => k.startsWith(this.prefix))
+                        .map(k => k.slice(this.prefix.length));
+                }
+            }
+            catch (_a) {
+                return [];
+            }
+        }
+    }
+    // Cookie operations
+    class CookieStorage {
+        constructor(options = {}) {
+            this.domain = options.domain || 'auto';
+            this.maxAge = options.maxAge || 365;
+            this.sameSite = options.sameSite || 'Lax';
+            this.secure = options.secure || 'auto';
+        }
+        get(name) {
+            var _a;
+            const value = `; ${document.cookie}`;
+            const parts = value.split(`; ${name}=`);
+            if (parts.length === 2) {
+                return ((_a = parts.pop()) === null || _a === void 0 ? void 0 : _a.split(';').shift()) || null;
+            }
+            return null;
+        }
+        set(name, value, days) {
+            try {
+                const maxAge = (days || this.maxAge) * 86400; // Convert to seconds
+                const secure = this.secure === 'auto'
+                    ? location.protocol === 'https:'
+                    : this.secure;
+                let domain = '';
+                if (this.domain === 'auto') {
+                    // Auto-detect domain for cross-subdomain tracking
+                    domain = this.getAutoDomain();
+                }
+                else if (this.domain) {
+                    domain = `;domain=${this.domain}`;
+                }
+                const cookie = [
+                    `${name}=${encodeURIComponent(value)}`,
+                    `max-age=${maxAge}`,
+                    'path=/',
+                    `SameSite=${this.sameSite}`,
+                    secure ? 'Secure' : '',
+                    domain
+                ].filter(Boolean).join(';');
+                document.cookie = cookie;
+                return true;
+            }
+            catch (e) {
+                console.warn('[Datalyr] Failed to set cookie:', name, e);
+                return false;
+            }
+        }
+        remove(name) {
+            try {
+                // Try to remove with various domain settings
+                const domains = ['', location.hostname];
+                // Add parent domain variations
+                const parts = location.hostname.split('.');
+                if (parts.length > 2) {
+                    domains.push(`.${parts.slice(-2).join('.')}`);
+                    domains.push(`.${location.hostname}`);
+                }
+                domains.forEach(domain => {
+                    const domainStr = domain ? `;domain=${domain}` : '';
+                    document.cookie = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/${domainStr}`;
+                });
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+        /**
+         * Auto-detect the best domain for cross-subdomain tracking
+         */
+        getAutoDomain() {
+            const hostname = location.hostname;
+            // Don't set domain for localhost or IP addresses
+            if (hostname === 'localhost' || /^[\d.]+$/.test(hostname) || /^\[[\d:]+\]$/.test(hostname)) {
+                return '';
+            }
+            // Try setting cookie at different domain levels to find the highest allowed
+            const parts = hostname.split('.');
+            // Start from the root domain and work up
+            for (let i = parts.length - 2; i >= 0; i--) {
+                const testDomain = '.' + parts.slice(i).join('.');
+                const testName = '__dl_test_' + Math.random();
+                // Try to set a test cookie
+                document.cookie = `${testName}=1;domain=${testDomain};path=/`;
+                // Check if it was set successfully
+                if (document.cookie.indexOf(testName) !== -1) {
+                    // Remove test cookie
+                    document.cookie = `${testName}=;expires=Thu, 01 Jan 1970 00:00:00 GMT;domain=${testDomain};path=/`;
+                    return `;domain=${testDomain}`;
+                }
+            }
+            // If nothing worked, don't set domain (will default to current subdomain)
+            return '';
+        }
+    }
+    // Export singleton instances for storage
+    const storage = new SafeStorage(window.localStorage);
+    new SafeStorage(window.sessionStorage);
+    // Default cookie instance for backwards compatibility
+    const cookies = new CookieStorage();
+
+    /**
+     * Utility Functions
+     */
+    /**
+     * Generate UUID v4
+     */
+    function generateUUID() {
+        // Use crypto.randomUUID if available
+        if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+            return crypto.randomUUID();
+        }
+        // Fallback implementation
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            const r = Math.random() * 16 | 0;
+            const v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+    /**
+     * Get all URL query parameters
+     */
+    function getAllQueryParams(search = window.location.search) {
+        const params = {};
+        try {
+            if ('URLSearchParams' in window) {
+                const searchParams = new URLSearchParams(search);
+                searchParams.forEach((value, key) => {
+                    params[key] = value;
+                });
+                return params;
+            }
+        }
+        catch (_a) { }
+        // Manual fallback
+        const query = (search || '').replace(/^\?/, '').split('&');
+        for (const part of query) {
+            const [key, value = ''] = part.split('=');
+            try {
+                const decodedKey = decodeURIComponent((key || '').replace(/\+/g, ' '));
+                const decodedValue = decodeURIComponent((value || '').replace(/\+/g, ' '));
+                if (decodedKey) {
+                    params[decodedKey] = decodedValue;
+                }
+            }
+            catch (_b) {
+                // Ignore bad encoding
+            }
+        }
+        return params;
+    }
+    /**
+     * Sanitize event data (remove sensitive keys, DOM elements, functions)
+     */
+    function sanitizeEventData(data, maxDepth = 5, currentDepth = 0) {
+        if (currentDepth >= maxDepth)
+            return '[Max depth reached]';
+        if (data === null || data === undefined)
+            return data;
+        // Remove DOM elements and functions
+        if ((typeof Element !== 'undefined' && data instanceof Element) ||
+            (typeof Document !== 'undefined' && data instanceof Document) ||
+            typeof data === 'function') {
+            return '[Removed]';
+        }
+        // Handle arrays
+        if (Array.isArray(data)) {
+            return data.map(item => sanitizeEventData(item, maxDepth, currentDepth + 1));
+        }
+        // Handle objects
+        if (typeof data === 'object') {
+            const sanitized = {};
+            const sensitiveKeys = /pass|pwd|token|secret|auth|bearer|session|cookie|signature|api[-_]?key|private[-_]?key|access[-_]?token|refresh[-_]?token/i;
+            for (const key in data) {
+                if (Object.prototype.hasOwnProperty.call(data, key)) {
+                    // Skip sensitive keys
+                    if (sensitiveKeys.test(key)) {
+                        continue;
+                    }
+                    // Sanitize value recursively
+                    sanitized[key] = sanitizeEventData(data[key], maxDepth, currentDepth + 1);
+                }
+            }
+            return sanitized;
+        }
+        // Handle strings
+        if (typeof data === 'string') {
+            // Truncate very long strings
+            if (data.length > 1000) {
+                return data.slice(0, 1000) + '...[truncated]';
+            }
+            // Remove potential JWT tokens or API keys
+            if (data.match(/^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+$/) || // JWT
+                data.match(/^[a-f0-9]{32,}$/i)) { // Hex tokens
+                return '[Redacted]';
+            }
+            return data;
+        }
+        return data;
+    }
+    /**
+     * Deep merge objects
+     */
+    function deepMerge(target, ...sources) {
+        if (!sources.length)
+            return target;
+        const source = sources.shift();
+        if (isObject(target) && isObject(source)) {
+            for (const key in source) {
+                if (isObject(source[key])) {
+                    if (!target[key])
+                        Object.assign(target, { [key]: {} });
+                    deepMerge(target[key], source[key]);
+                }
+                else {
+                    Object.assign(target, { [key]: source[key] });
+                }
+            }
+        }
+        return deepMerge(target, ...sources);
+    }
+    function isObject(item) {
+        return item && typeof item === 'object' && !Array.isArray(item);
+    }
+    /**
+     * Calculate retry delay with exponential backoff and jitter
+     */
+    function calculateRetryDelay(attempt, baseDelay = 1000) {
+        const maxDelay = 30000; // 30 seconds max
+        const jitter = Math.random() * 0.1; // 10% jitter
+        return Math.min(baseDelay * Math.pow(2, attempt) * (1 + jitter), maxDelay);
+    }
+    /**
+     * Check if browser Do Not Track is enabled
+     */
+    function isDoNotTrackEnabled() {
+        return navigator.doNotTrack === '1' ||
+            window.doNotTrack === '1' ||
+            navigator.doNotTrack === 'yes';
+    }
+    /**
+     * Check if Global Privacy Control is enabled
+     */
+    function isGlobalPrivacyControlEnabled() {
+        return navigator.globalPrivacyControl === true ||
+            window.globalPrivacyControl === true;
+    }
+    /**
+     * Get referrer data
+     */
+    function getReferrerData() {
+        const referrer = document.referrer;
+        if (!referrer)
+            return {};
+        try {
+            const url = new URL(referrer);
+            return {
+                referrer,
+                referrer_host: url.hostname,
+                referrer_path: url.pathname,
+                referrer_search: url.search,
+                referrer_source: detectReferrerSource(url.hostname)
+            };
+        }
+        catch (_a) {
+            return { referrer };
+        }
+    }
+    /**
+     * Detect referrer source
+     */
+    function detectReferrerSource(hostname) {
+        const sources = {
+            google: ['google.com', 'google.'],
+            facebook: ['facebook.com', 'fb.com'],
+            twitter: ['twitter.com', 't.co', 'x.com'],
+            linkedin: ['linkedin.com', 'lnkd.in'],
+            instagram: ['instagram.com'],
+            youtube: ['youtube.com', 'youtu.be'],
+            tiktok: ['tiktok.com'],
+            reddit: ['reddit.com'],
+            pinterest: ['pinterest.com'],
+            bing: ['bing.com'],
+            yahoo: ['yahoo.com'],
+            duckduckgo: ['duckduckgo.com'],
+            baidu: ['baidu.com']
+        };
+        for (const [source, domains] of Object.entries(sources)) {
+            if (domains.some(domain => hostname.includes(domain))) {
+                return source;
+            }
+        }
+        return 'other';
+    }
+
+    /**
+     * Identity Management Module
+     * Handles anonymous_id, user_id, and identity resolution
+     */
+    class IdentityManager {
+        constructor() {
+            this.userId = null;
+            this.sessionId = null;
+            this.anonymousId = this.getOrCreateAnonymousId();
+            this.userId = this.getStoredUserId();
+        }
+        /**
+         * Get or create anonymous ID (device/browser identifier)
+         */
+        getOrCreateAnonymousId() {
+            let anonymousId = storage.get('dl_anonymous_id');
+            if (!anonymousId) {
+                anonymousId = `anon_${generateUUID()}`;
+                storage.set('dl_anonymous_id', anonymousId);
+            }
+            return anonymousId;
+        }
+        /**
+         * Get stored user ID from previous session
+         */
+        getStoredUserId() {
+            return storage.get('dl_user_id');
+        }
+        /**
+         * Get the anonymous ID
+         */
+        getAnonymousId() {
+            return this.anonymousId;
+        }
+        /**
+         * Get the user ID (if identified)
+         */
+        getUserId() {
+            return this.userId;
+        }
+        /**
+         * Get the distinct ID (primary identifier)
+         * Returns user_id if identified, otherwise anonymous_id
+         */
+        getDistinctId() {
+            return this.userId || this.anonymousId;
+        }
+        /**
+         * Get canonical ID (alias for distinct_id)
+         */
+        getCanonicalId() {
+            return this.getDistinctId();
+        }
+        /**
+         * Set the session ID
+         */
+        setSessionId(sessionId) {
+            this.sessionId = sessionId;
+        }
+        /**
+         * Get the session ID
+         */
+        getSessionId() {
+            return this.sessionId;
+        }
+        /**
+         * Identify a user
+         * Links anonymous_id to user_id
+         */
+        identify(userId, traits = {}) {
+            if (!userId) {
+                console.warn('[Datalyr] identify() called without userId');
+                return {};
+            }
+            const previousUserId = this.userId;
+            this.userId = userId;
+            // Persist for future sessions
+            storage.set('dl_user_id', userId);
+            // Return identity link data (will be sent as $identify event)
+            return {
+                anonymous_id: this.anonymousId,
+                user_id: userId,
+                previous_id: previousUserId,
+                traits: traits,
+                identified_at: new Date().toISOString(),
+                resolution_method: 'identify_call'
+            };
+        }
+        /**
+         * Alias one ID to another
+         */
+        alias(userId, previousId) {
+            const aliasData = {
+                userId,
+                previousId: previousId || this.anonymousId,
+                aliased_at: new Date().toISOString()
+            };
+            // Update current user ID if aliasing to current anonymous ID
+            if (!previousId || previousId === this.anonymousId) {
+                this.userId = userId;
+                storage.set('dl_user_id', userId);
+            }
+            return aliasData;
+        }
+        /**
+         * Reset the current user (on logout)
+         * Clears user_id but keeps anonymous_id
+         */
+        reset() {
+            this.userId = null;
+            storage.remove('dl_user_id');
+            storage.remove('dl_user_traits');
+            // Generate new anonymous ID for privacy
+            this.anonymousId = `anon_${generateUUID()}`;
+            storage.set('dl_anonymous_id', this.anonymousId);
+        }
+        /**
+         * Get all identity fields for event payload
+         */
+        getIdentityFields() {
+            return {
+                // Modern fields
+                distinct_id: this.getDistinctId(),
+                anonymous_id: this.anonymousId,
+                user_id: this.userId,
+                // Legacy compatibility
+                visitor_id: this.anonymousId,
+                visitorId: this.anonymousId,
+                canonical_id: this.getCanonicalId(),
+                // Session
+                session_id: this.sessionId,
+                sessionId: this.sessionId,
+                // Identity resolution
+                resolution_method: 'browser_sdk',
+                resolution_confidence: 1.0
+            };
+        }
+    }
+
+    /**
+     * Session Management Module
+     */
+    class SessionManager {
+        constructor(timeout = 30 * 60 * 1000) {
+            this.sessionId = null;
+            this.sessionData = null;
+            this.lastActivity = Date.now();
+            this.SESSION_KEY = 'dl_session_data';
+            this.activityCheckInterval = null;
+            this.activityListeners = [];
+            this.sessionTimeout = timeout;
+            this.initSession();
+            this.setupActivityMonitor();
+        }
+        /**
+         * Initialize or restore session
+         */
+        initSession() {
+            const storedSession = storage.get(this.SESSION_KEY);
+            const now = Date.now();
+            if (storedSession && this.isSessionValid(storedSession, now)) {
+                // Restore existing session
+                this.sessionData = storedSession;
+                this.sessionId = storedSession.id;
+                this.lastActivity = now;
+            }
+            else {
+                // Create new session
+                this.createNewSession();
+            }
+        }
+        /**
+         * Check if session is still valid
+         */
+        isSessionValid(session, now) {
+            const timeSinceActivity = now - session.lastActivity;
+            return timeSinceActivity < this.sessionTimeout && session.isActive;
+        }
+        /**
+         * Create a new session
+         */
+        createNewSession() {
+            const now = Date.now();
+            this.sessionId = `sess_${generateUUID()}`;
+            this.sessionData = {
+                id: this.sessionId,
+                startTime: now,
+                lastActivity: now,
+                pageViews: 0,
+                events: 0,
+                duration: 0,
+                isActive: true
+            };
+            this.incrementSessionCount();
+            this.saveSession();
+            return this.sessionId;
+        }
+        /**
+         * Get current session ID
+         */
+        getSessionId() {
+            if (!this.sessionId || !this.isSessionActive()) {
+                this.createNewSession();
+            }
+            return this.sessionId;
+        }
+        /**
+         * Get session data
+         */
+        getSessionData() {
+            return this.sessionData;
+        }
+        /**
+         * Update session activity
+         */
+        updateActivity(eventType) {
+            const now = Date.now();
+            // Check if we need a new session
+            if (!this.sessionData || !this.isSessionValid(this.sessionData, now)) {
+                this.createNewSession();
+                return;
+            }
+            this.lastActivity = now;
+            this.sessionData.lastActivity = now;
+            this.sessionData.duration = now - this.sessionData.startTime;
+            // Update counters
+            if (eventType === 'pageview' || eventType === 'page_view') {
+                this.sessionData.pageViews++;
+            }
+            this.sessionData.events++;
+            this.saveSession();
+        }
+        /**
+         * Check if session is active
+         */
+        isSessionActive() {
+            if (!this.sessionData)
+                return false;
+            const now = Date.now();
+            return this.isSessionValid(this.sessionData, now);
+        }
+        /**
+         * End the current session
+         */
+        endSession() {
+            if (this.sessionData) {
+                this.sessionData.isActive = false;
+                this.saveSession();
+            }
+            this.sessionId = null;
+            this.sessionData = null;
+        }
+        /**
+         * Save session to storage
+         */
+        saveSession() {
+            if (this.sessionData) {
+                storage.set(this.SESSION_KEY, this.sessionData);
+            }
+        }
+        /**
+         * Get session timeout
+         */
+        getTimeout() {
+            return this.sessionTimeout;
+        }
+        /**
+         * Set session timeout
+         */
+        setTimeout(timeout) {
+            this.sessionTimeout = timeout;
+        }
+        /**
+         * Store session attribution
+         */
+        storeAttribution(attribution) {
+            const key = `dl_session_${this.sessionId}_attribution`;
+            storage.set(key, Object.assign(Object.assign({}, attribution), { sessionId: this.sessionId, timestamp: Date.now() }));
+        }
+        /**
+         * Get session attribution
+         */
+        getAttribution() {
+            if (!this.sessionId)
+                return null;
+            const key = `dl_session_${this.sessionId}_attribution`;
+            return storage.get(key);
+        }
+        /**
+         * Get session metrics
+         */
+        getMetrics() {
+            if (!this.sessionData)
+                return {};
+            return {
+                session_id: this.sessionId,
+                session_duration: this.sessionData.duration,
+                session_page_views: this.sessionData.pageViews,
+                session_events: this.sessionData.events,
+                session_start: this.sessionData.startTime,
+                time_since_session_start: Date.now() - this.sessionData.startTime
+            };
+        }
+        /**
+         * Setup activity monitor for automatic session timeout
+         */
+        setupActivityMonitor() {
+            // Monitor user activity
+            const activityEvents = ['mousedown', 'keydown', 'scroll', 'touchstart'];
+            const handleActivity = () => {
+                const now = Date.now();
+                if (this.sessionData && now - this.lastActivity > 1000) { // Debounce 1 second
+                    this.updateActivity();
+                }
+            };
+            activityEvents.forEach(event => {
+                window.addEventListener(event, handleActivity, { passive: true, capture: true });
+                this.activityListeners.push({ event, handler: handleActivity });
+            });
+            // Check for session timeout periodically
+            this.activityCheckInterval = setInterval(() => {
+                if (this.sessionData && !this.isSessionActive()) {
+                    this.createNewSession();
+                }
+            }, 60000); // Check every minute
+        }
+        /**
+         * Cleanup listeners and timers
+         */
+        destroy() {
+            // Remove activity listeners
+            this.activityListeners.forEach(({ event, handler }) => {
+                window.removeEventListener(event, handler);
+            });
+            this.activityListeners = [];
+            // Clear interval
+            if (this.activityCheckInterval) {
+                clearInterval(this.activityCheckInterval);
+                this.activityCheckInterval = null;
+            }
+        }
+        /**
+         * Get session number (count of sessions)
+         */
+        getSessionNumber() {
+            const count = storage.get('dl_session_count', 0);
+            return count + 1;
+        }
+        /**
+         * Increment session count
+         */
+        incrementSessionCount() {
+            const count = storage.get('dl_session_count', 0);
+            storage.set('dl_session_count', count + 1);
+        }
+    }
+
+    /**
+     * Attribution Tracking Module
+     * Handles UTM parameters, click IDs, and customer journey
+     */
+    class AttributionManager {
+        constructor(options = {}) {
+            this.UTM_PARAMS = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content'];
+            this.CLICK_IDS = ['fbclid', 'gclid', 'ttclid', 'msclkid', 'twclid', 'li_fat_id', 'sclid', 'dclid', 'epik'];
+            this.attributionWindow = options.attributionWindow || 30 * 24 * 60 * 60 * 1000; // 30 days
+            this.trackedParams = options.trackedParams || [];
+        }
+        /**
+         * Capture current attribution from URL
+         */
+        captureAttribution() {
+            const params = getAllQueryParams();
+            const attribution = {
+                timestamp: Date.now()
+            };
+            // Capture UTM parameters
+            for (const utm of this.UTM_PARAMS) {
+                const value = params[utm];
+                if (value) {
+                    const key = utm.replace('utm_', '');
+                    attribution[key] = value;
+                }
+            }
+            // Capture click IDs
+            for (const clickId of this.CLICK_IDS) {
+                const value = params[clickId];
+                if (value) {
+                    attribution.clickId = value;
+                    attribution.clickIdType = clickId;
+                    break; // Use first found click ID
+                }
+            }
+            // Capture custom tracked parameters
+            for (const param of this.trackedParams) {
+                const value = params[param];
+                if (value) {
+                    attribution[param] = value;
+                }
+            }
+            // Capture referrer
+            if (document.referrer) {
+                attribution.referrer = document.referrer;
+                attribution.referrerHost = this.extractHostname(document.referrer);
+            }
+            // Capture landing page
+            attribution.landingPage = window.location.href;
+            attribution.landingPath = window.location.pathname;
+            // Determine source if not explicitly set
+            if (!attribution.source) {
+                attribution.source = this.determineSource(attribution);
+            }
+            // Determine medium if not explicitly set
+            if (!attribution.medium) {
+                attribution.medium = this.determineMedium(attribution);
+            }
+            return attribution;
+        }
+        /**
+         * Store first touch attribution
+         */
+        storeFirstTouch(attribution) {
+            const existing = storage.get('dl_first_touch');
+            if (!existing) {
+                storage.set('dl_first_touch', Object.assign(Object.assign({}, attribution), { timestamp: Date.now() }));
+            }
+        }
+        /**
+         * Get first touch attribution
+         */
+        getFirstTouch() {
+            return storage.get('dl_first_touch');
+        }
+        /**
+         * Store last touch attribution
+         */
+        storeLastTouch(attribution) {
+            storage.set('dl_last_touch', Object.assign(Object.assign({}, attribution), { timestamp: Date.now() }));
+        }
+        /**
+         * Get last touch attribution
+         */
+        getLastTouch() {
+            return storage.get('dl_last_touch');
+        }
+        /**
+         * Add touchpoint to customer journey
+         */
+        addTouchpoint(sessionId, attribution) {
+            const journey = this.getJourney();
+            const touchpoint = {
+                timestamp: Date.now(),
+                sessionId,
+                source: attribution.source,
+                medium: attribution.medium,
+                campaign: attribution.campaign
+            };
+            journey.push(touchpoint);
+            // Keep last 30 touchpoints
+            if (journey.length > 30) {
+                journey.shift();
+            }
+            storage.set('dl_journey', journey);
+        }
+        /**
+         * Get customer journey
+         */
+        getJourney() {
+            return storage.get('dl_journey', []);
+        }
+        /**
+         * Get attribution data for event
+         */
+        getAttributionData() {
+            const firstTouch = this.getFirstTouch();
+            const lastTouch = this.getLastTouch();
+            const journey = this.getJourney();
+            const current = this.captureAttribution();
+            // Update first/last touch if needed
+            if (!firstTouch && Object.keys(current).length > 1) {
+                this.storeFirstTouch(current);
+            }
+            if (Object.keys(current).length > 1) {
+                this.storeLastTouch(current);
+            }
+            return Object.assign(Object.assign({}, current), { 
+                // First touch (with snake_case aliases)
+                first_touch_source: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.source, first_touch_medium: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.medium, first_touch_campaign: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.campaign, first_touch_timestamp: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.timestamp, firstTouchSource: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.source, firstTouchMedium: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.medium, firstTouchCampaign: firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.campaign, 
+                // Last touch (with snake_case aliases)
+                last_touch_source: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.source, last_touch_medium: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.medium, last_touch_campaign: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.campaign, last_touch_timestamp: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.timestamp, lastTouchSource: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.source, lastTouchMedium: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.medium, lastTouchCampaign: lastTouch === null || lastTouch === void 0 ? void 0 : lastTouch.campaign, 
+                // Journey metrics
+                touchpoint_count: journey.length, touchpointCount: journey.length, days_since_first_touch: (firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.timestamp)
+                    ? Math.floor((Date.now() - firstTouch.timestamp) / 86400000)
+                    : 0, daysSinceFirstTouch: (firstTouch === null || firstTouch === void 0 ? void 0 : firstTouch.timestamp)
+                    ? Math.floor((Date.now() - firstTouch.timestamp) / 86400000)
+                    : 0 });
+        }
+        /**
+         * Determine source from attribution data
+         */
+        determineSource(attribution) {
+            // If we have a click ID, determine source from that
+            if (attribution.clickIdType) {
+                const clickIdSources = {
+                    fbclid: 'facebook',
+                    gclid: 'google',
+                    ttclid: 'tiktok',
+                    msclkid: 'bing',
+                    twclid: 'twitter',
+                    li_fat_id: 'linkedin',
+                    sclid: 'snapchat',
+                    dclid: 'doubleclick',
+                    epik: 'pinterest'
+                };
+                return clickIdSources[attribution.clickIdType] || 'paid';
+            }
+            // Check referrer
+            if (attribution.referrerHost) {
+                const host = attribution.referrerHost.toLowerCase();
+                // Social sources
+                if (host.includes('facebook.com') || host.includes('fb.com'))
+                    return 'facebook';
+                if (host.includes('twitter.com') || host.includes('t.co') || host.includes('x.com'))
+                    return 'twitter';
+                if (host.includes('linkedin.com') || host.includes('lnkd.in'))
+                    return 'linkedin';
+                if (host.includes('instagram.com'))
+                    return 'instagram';
+                if (host.includes('youtube.com') || host.includes('youtu.be'))
+                    return 'youtube';
+                if (host.includes('tiktok.com'))
+                    return 'tiktok';
+                if (host.includes('reddit.com'))
+                    return 'reddit';
+                if (host.includes('pinterest.com'))
+                    return 'pinterest';
+                // Search engines
+                if (host.includes('google.'))
+                    return 'google';
+                if (host.includes('bing.com'))
+                    return 'bing';
+                if (host.includes('yahoo.com'))
+                    return 'yahoo';
+                if (host.includes('duckduckgo.com'))
+                    return 'duckduckgo';
+                if (host.includes('baidu.com'))
+                    return 'baidu';
+                return 'referral';
+            }
+            return 'direct';
+        }
+        /**
+         * Determine medium from attribution data
+         */
+        determineMedium(attribution) {
+            // If we have a click ID, it's paid
+            if (attribution.clickId) {
+                return 'cpc'; // Cost per click
+            }
+            // Check source
+            const source = attribution.source;
+            if (!source || source === 'direct') {
+                return 'none';
+            }
+            // Social sources typically organic unless paid
+            const socialSources = ['facebook', 'twitter', 'linkedin', 'instagram', 'youtube', 'tiktok', 'reddit', 'pinterest'];
+            if (socialSources.includes(source)) {
+                return 'social';
+            }
+            // Search engines
+            const searchSources = ['google', 'bing', 'yahoo', 'duckduckgo', 'baidu'];
+            if (searchSources.includes(source)) {
+                return 'organic';
+            }
+            return 'referral';
+        }
+        /**
+         * Extract hostname from URL
+         */
+        extractHostname(url) {
+            try {
+                return new URL(url).hostname;
+            }
+            catch (_a) {
+                return '';
+            }
+        }
+        /**
+         * Check if attribution has expired
+         */
+        isAttributionExpired(attribution) {
+            if (!attribution.timestamp)
+                return true;
+            return Date.now() - attribution.timestamp > this.attributionWindow;
+        }
+        /**
+         * Clear expired attribution
+         */
+        clearExpiredAttribution() {
+            const firstTouch = this.getFirstTouch();
+            const lastTouch = this.getLastTouch();
+            if (firstTouch && this.isAttributionExpired(firstTouch)) {
+                storage.remove('dl_first_touch');
+            }
+            if (lastTouch && this.isAttributionExpired(lastTouch)) {
+                storage.remove('dl_last_touch');
+            }
+        }
+    }
+
+    /**
+     * Event Queue and Batching Module
+     */
+    // Default critical events that bypass batching
+    const DEFAULT_CRITICAL_EVENTS = ['purchase', 'signup', 'subscribe', 'lead', 'conversion'];
+    // Default high priority events that use faster batching
+    const DEFAULT_HIGH_PRIORITY_EVENTS = ['add_to_cart', 'begin_checkout', 'view_item', 'search'];
+    class EventQueue {
+        constructor(config) {
+            this.queue = [];
+            this.offlineQueue = [];
+            this.batchTimer = null;
+            this.periodicFlushInterval = null;
+            this.flushPromise = null;
+            this.recentEventIds = new Set();
+            this.MAX_RECENT_EVENT_IDS = 1000;
+            this.OFFLINE_QUEUE_KEY = 'dl_offline_queue';
+            this.currentEndpointIndex = 0;
+            this.config = {
+                batchSize: config.batchSize || 10,
+                flushInterval: config.flushInterval || 5000,
+                maxRetries: config.maxRetries || 5,
+                retryDelay: config.retryDelay || 1000,
+                endpoint: config.endpoint || 'https://ingest.datalyr.com',
+                fallbackEndpoints: config.fallbackEndpoints || [],
+                workspaceId: config.workspaceId,
+                debug: config.debug || false,
+                criticalEvents: config.criticalEvents || DEFAULT_CRITICAL_EVENTS,
+                highPriorityEvents: config.highPriorityEvents || DEFAULT_HIGH_PRIORITY_EVENTS,
+                maxOfflineQueueSize: config.maxOfflineQueueSize || 100
+            };
+            this.networkStatus = {
+                isOnline: navigator.onLine !== false,
+                lastOfflineAt: null,
+                lastOnlineAt: null
+            };
+            this.loadOfflineQueue();
+            this.setupNetworkListeners();
+            this.startPeriodicFlush();
+        }
+        /**
+         * Add event to queue
+         */
+        enqueue(event) {
+            const eventName = event.eventName;
+            // Check for duplicates (within 500ms window)
+            if (this.isDuplicateEvent(event)) {
+                this.log('Duplicate event suppressed:', eventName);
+                return;
+            }
+            // Critical events bypass queue
+            if (this.config.criticalEvents.includes(eventName)) {
+                this.log('Critical event, sending immediately:', eventName);
+                this.sendBatch([event]);
+                return;
+            }
+            // Add to queue
+            this.queue.push(event);
+            this.log('Event queued:', eventName);
+            // Check if we should flush
+            if (this.shouldFlush(eventName)) {
+                this.flush();
+            }
+        }
+        /**
+         * Check if event is duplicate
+         */
+        isDuplicateEvent(event) {
+            const eventId = event.eventId;
+            if (this.recentEventIds.has(eventId)) {
+                return true;
+            }
+            this.recentEventIds.add(eventId);
+            // Clean up old event IDs
+            if (this.recentEventIds.size > this.MAX_RECENT_EVENT_IDS) {
+                const toDelete = this.recentEventIds.size - this.MAX_RECENT_EVENT_IDS;
+                const iterator = this.recentEventIds.values();
+                for (let i = 0; i < toDelete; i++) {
+                    this.recentEventIds.delete(iterator.next().value);
+                }
+            }
+            return false;
+        }
+        /**
+         * Check if we should flush the queue
+         */
+        shouldFlush(eventName) {
+            // Check queue size
+            if (this.queue.length >= this.config.batchSize) {
+                return true;
+            }
+            // Check for high priority events
+            if (eventName && this.config.highPriorityEvents.includes(eventName)) {
+                // Use faster flush for high priority
+                if (this.batchTimer) {
+                    clearTimeout(this.batchTimer);
+                }
+                this.batchTimer = setTimeout(() => this.flush(), 1000);
+                return false;
+            }
+            // Set normal batch timer if not already set
+            if (!this.batchTimer) {
+                this.batchTimer = setTimeout(() => this.flush(), this.config.flushInterval);
+            }
+            return false;
+        }
+        /**
+         * Flush the queue
+         */
+        flush() {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Prevent concurrent flushes
+                if (this.flushPromise) {
+                    return this.flushPromise;
+                }
+                this.flushPromise = this._flush();
+                yield this.flushPromise;
+                this.flushPromise = null;
+            });
+        }
+        /**
+         * Internal flush implementation
+         */
+        _flush() {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Clear timer
+                if (this.batchTimer) {
+                    clearTimeout(this.batchTimer);
+                    this.batchTimer = null;
+                }
+                // Check if we have events
+                if (this.queue.length === 0) {
+                    return;
+                }
+                // Check network status
+                if (!this.networkStatus.isOnline) {
+                    this.log('Network offline, queuing events');
+                    this.moveToOfflineQueue();
+                    return;
+                }
+                // Get events to send
+                const events = this.queue.splice(0, this.config.batchSize);
+                try {
+                    yield this.sendBatch(events);
+                }
+                catch (error) {
+                    this.log('Failed to send batch:', error);
+                    // Move to offline queue for retry
+                    this.offlineQueue.push(...events);
+                    this.saveOfflineQueue();
+                }
+            });
+        }
+        /**
+         * Send batch of events
+         */
+        sendBatch(events_1) {
+            return __awaiter(this, arguments, void 0, function* (events, retries = 0, endpointIndex = 0) {
+                const batchPayload = {
+                    events,
+                    batchId: generateUUID(),
+                    timestamp: new Date().toISOString()
+                };
+                // Get current endpoint (main or fallback)
+                const endpoints = [this.config.endpoint, ...this.config.fallbackEndpoints];
+                const currentEndpoint = endpoints[endpointIndex] || this.config.endpoint;
+                try {
+                    const response = yield fetch(currentEndpoint, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'X-Batch-Size': events.length.toString()
+                        },
+                        body: JSON.stringify(batchPayload),
+                        keepalive: true
+                    });
+                    if (!response.ok) {
+                        // Handle rate limiting
+                        if (response.status === 429) {
+                            const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
+                            this.log(`Rate limited, retrying after ${retryAfter}s`);
+                            setTimeout(() => {
+                                this.queue.unshift(...events);
+                            }, retryAfter * 1000);
+                            return;
+                        }
+                        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                    }
+                    this.log(`Batch sent successfully to ${currentEndpoint}: ${events.length} events`);
+                    this.currentEndpointIndex = 0; // Reset to primary on success
+                }
+                catch (error) {
+                    // Try next fallback endpoint if available
+                    if (endpointIndex < endpoints.length - 1) {
+                        this.log(`Failed on ${currentEndpoint}, trying fallback ${endpointIndex + 1}`);
+                        return this.sendBatch(events, 0, endpointIndex + 1);
+                    }
+                    // Retry with exponential backoff on current endpoint
+                    if (retries < this.config.maxRetries) {
+                        const delay = calculateRetryDelay(retries, this.config.retryDelay);
+                        this.log(`Retrying batch in ${delay}ms (attempt ${retries + 1}/${this.config.maxRetries})`);
+                        yield new Promise(resolve => setTimeout(resolve, delay));
+                        return this.sendBatch(events, retries + 1, endpointIndex);
+                    }
+                    throw error;
+                }
+            });
+        }
+        /**
+         * Setup network status listeners
+         */
+        setupNetworkListeners() {
+            window.addEventListener('online', () => {
+                this.networkStatus.isOnline = true;
+                this.networkStatus.lastOnlineAt = Date.now();
+                this.log('Network connection restored');
+                // Process offline queue
+                setTimeout(() => this.processOfflineQueue(), 1000);
+            });
+            window.addEventListener('offline', () => {
+                this.networkStatus.isOnline = false;
+                this.networkStatus.lastOfflineAt = Date.now();
+                this.log('Network connection lost');
+            });
+        }
+        /**
+         * Start periodic flush timer
+         */
+        startPeriodicFlush() {
+            this.periodicFlushInterval = setInterval(() => {
+                if (this.queue.length > 0) {
+                    this.flush();
+                }
+            }, this.config.flushInterval);
+        }
+        /**
+         * Stop periodic flush timer
+         */
+        stopPeriodicFlush() {
+            if (this.periodicFlushInterval) {
+                clearInterval(this.periodicFlushInterval);
+                this.periodicFlushInterval = null;
+            }
+        }
+        /**
+         * Move events to offline queue
+         */
+        moveToOfflineQueue() {
+            this.offlineQueue.push(...this.queue);
+            this.queue = [];
+            this.saveOfflineQueue();
+        }
+        /**
+         * Load offline queue from storage
+         */
+        loadOfflineQueue() {
+            const stored = storage.get(this.OFFLINE_QUEUE_KEY, []);
+            if (Array.isArray(stored)) {
+                this.offlineQueue = stored;
+                this.log(`Loaded ${this.offlineQueue.length} offline events`);
+            }
+        }
+        /**
+         * Save offline queue to storage
+         */
+        saveOfflineQueue() {
+            // Keep max events based on config
+            const toSave = this.offlineQueue.slice(-this.config.maxOfflineQueueSize);
+            storage.set(this.OFFLINE_QUEUE_KEY, toSave);
+        }
+        /**
+         * Process offline queue
+         */
+        processOfflineQueue() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.offlineQueue.length === 0)
+                    return;
+                this.log(`Processing ${this.offlineQueue.length} offline events`);
+                while (this.offlineQueue.length > 0) {
+                    const batch = this.offlineQueue.splice(0, this.config.batchSize);
+                    try {
+                        yield this.sendBatch(batch);
+                        this.saveOfflineQueue();
+                    }
+                    catch (error) {
+                        this.log('Failed to send offline batch:', error);
+                        // Put back in queue
+                        this.offlineQueue.unshift(...batch);
+                        this.saveOfflineQueue();
+                        break;
+                    }
+                }
+                if (this.offlineQueue.length === 0) {
+                    storage.remove(this.OFFLINE_QUEUE_KEY);
+                }
+            });
+        }
+        /**
+         * Get queue size
+         */
+        getQueueSize() {
+            return this.queue.length;
+        }
+        /**
+         * Get offline queue size
+         */
+        getOfflineQueueSize() {
+            return this.offlineQueue.length;
+        }
+        /**
+         * Get network status
+         */
+        getNetworkStatus() {
+            return Object.assign({}, this.networkStatus);
+        }
+        /**
+         * Force flush (for page unload)
+         */
+        forceFlush() {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Try sendBeacon first for reliability
+                if (navigator.sendBeacon && this.queue.length > 0) {
+                    const batchPayload = {
+                        events: this.queue,
+                        batchId: generateUUID(),
+                        timestamp: new Date().toISOString()
+                    };
+                    const blob = new Blob([JSON.stringify(batchPayload)], {
+                        type: 'application/json'
+                    });
+                    const success = navigator.sendBeacon(this.config.endpoint, blob);
+                    if (success) {
+                        this.log('Events sent via sendBeacon');
+                        this.queue = [];
+                        return;
+                    }
+                }
+                // Fallback to regular flush
+                yield this.flush();
+            });
+        }
+        /**
+         * Clear queue
+         */
+        clear() {
+            this.queue = [];
+            if (this.batchTimer) {
+                clearTimeout(this.batchTimer);
+                this.batchTimer = null;
+            }
+        }
+        /**
+         * Debug logging
+         */
+        log(...args) {
+            if (this.config.debug) {
+                console.log('[Datalyr Queue]', ...args);
+            }
+        }
+        /**
+         * Cleanup resources
+         */
+        destroy() {
+            this.stopPeriodicFlush();
+            if (this.batchTimer) {
+                clearTimeout(this.batchTimer);
+                this.batchTimer = null;
+            }
+            // Save any remaining events to offline queue
+            if (this.queue.length > 0) {
+                this.moveToOfflineQueue();
+            }
+        }
+    }
+
+    /**
+     * Fingerprint Collection Module
+     * Collects device fingerprint data for identification
+     * Privacy-conscious: respects privacy mode settings
+     */
+    class FingerprintCollector {
+        constructor(options = {}) {
+            this.heavyFingerprintDone = false;
+            this.fingerprintCache = {};
+            this.privacyMode = options.privacyMode || 'standard';
+            this.enableFingerprinting = options.enableFingerprinting !== false;
+        }
+        /**
+         * Collect fingerprint data
+         * Returns minimal data in strict mode, full data in standard mode
+         */
+        collect() {
+            // Strict privacy mode - minimal fingerprinting only
+            if (this.privacyMode === 'strict' || !this.enableFingerprinting) {
+                return this.collectMinimal();
+            }
+            // Standard mode - collect more data
+            return this.collectStandard();
+        }
+        /**
+         * Collect minimal fingerprint data (privacy-friendly)
+         */
+        collectMinimal() {
+            return {
+                timezone: this.getTimezone(),
+                language: navigator.language || null,
+                platform: navigator.platform || null,
+                canvasEnabled: false,
+                localStorageAvailable: this.testStorage('localStorage'),
+                sessionStorageAvailable: this.testStorage('sessionStorage')
+            };
+        }
+        /**
+         * Collect standard fingerprint data
+         */
+        collectStandard() {
+            const fingerprint = {};
+            try {
+                // Basic browser data
+                fingerprint.userAgent = navigator.userAgent || null;
+                // User-Agent Client Hints (modern browsers)
+                if ('userAgentData' in navigator) {
+                    const uaData = navigator.userAgentData;
+                    fingerprint.userAgentData = {
+                        brands: uaData.brands || [],
+                        mobile: uaData.mobile || false,
+                        platform: uaData.platform || null
+                    };
+                }
+                // Language settings
+                fingerprint.language = navigator.language || null;
+                fingerprint.languages = navigator.languages ?
+                    navigator.languages.slice(0, 2) : null; // Limit to 2 for privacy
+                // Platform and browser features
+                fingerprint.platform = navigator.platform || null;
+                fingerprint.cookieEnabled = navigator.cookieEnabled || null;
+                fingerprint.doNotTrack = navigator.doNotTrack || null;
+                // Hardware (coarsened for privacy)
+                fingerprint.hardwareConcurrency = this.coarsenHardwareConcurrency();
+                fingerprint.deviceMemory = this.coarsenDeviceMemory();
+                fingerprint.maxTouchPoints = navigator.maxTouchPoints > 0 ? 'touch' : 'no-touch';
+                // Screen (coarsened)
+                fingerprint.screenResolution = this.getScreenResolution();
+                fingerprint.colorDepth = screen.colorDepth || null;
+                fingerprint.pixelRatio = this.coarsenPixelRatio();
+                // Timezone
+                fingerprint.timezone = this.getTimezone();
+                fingerprint.timezoneOffset = this.coarsenTimezoneOffset();
+                // Canvas fingerprinting disabled for privacy
+                fingerprint.canvasEnabled = false;
+                // Plugins count only (not details for privacy)
+                fingerprint.pluginsCount = navigator.plugins ? navigator.plugins.length : null;
+                // Storage availability
+                fingerprint.localStorageAvailable = this.testStorage('localStorage');
+                fingerprint.sessionStorageAvailable = this.testStorage('sessionStorage');
+                fingerprint.indexedDBAvailable = this.testIndexedDB();
+                // Add cached heavy fingerprint data if available
+                if (this.heavyFingerprintDone) {
+                    Object.assign(fingerprint, this.fingerprintCache);
+                }
+            }
+            catch (e) {
+                console.warn('[Datalyr] Error collecting fingerprint:', e);
+            }
+            return fingerprint;
+        }
+        /**
+         * Collect heavy fingerprint data (WebGL, Audio)
+         * Called lazily on first event to improve page load performance
+         */
+        collectHeavyFingerprint() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.heavyFingerprintDone || this.privacyMode === 'strict') {
+                    return;
+                }
+                try {
+                    // WebGL fingerprinting
+                    const webglData = this.getWebGLFingerprint();
+                    if (webglData) {
+                        this.fingerprintCache.webglVendor = webglData.vendor;
+                        this.fingerprintCache.webglRenderer = webglData.renderer;
+                    }
+                    // Audio fingerprinting
+                    const audioData = yield this.getAudioFingerprint();
+                    if (audioData) {
+                        this.fingerprintCache.audioSampleRate = audioData.sampleRate;
+                        this.fingerprintCache.audioState = audioData.state;
+                        this.fingerprintCache.audioMaxChannels = audioData.maxChannels;
+                    }
+                    this.heavyFingerprintDone = true;
+                }
+                catch (e) {
+                    console.warn('[Datalyr] Heavy fingerprinting failed:', e);
+                }
+            });
+        }
+        /**
+         * Get WebGL fingerprint
+         */
+        getWebGLFingerprint() {
+            try {
+                const canvas = document.createElement('canvas');
+                const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+                if (!gl)
+                    return null;
+                const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
+                if (!debugInfo) {
+                    return {
+                        vendor: gl.getParameter(gl.VENDOR) || 'unknown',
+                        renderer: gl.getParameter(gl.RENDERER) || 'unknown'
+                    };
+                }
+                return {
+                    vendor: gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) || 'unknown',
+                    renderer: gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || 'unknown'
+                };
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        /**
+         * Get audio fingerprint
+         */
+        getAudioFingerprint() {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                try {
+                    const AudioContext = window.AudioContext || window.webkitAudioContext;
+                    if (!AudioContext)
+                        return null;
+                    const audioCtx = new AudioContext();
+                    const result = {
+                        sampleRate: audioCtx.sampleRate || null,
+                        state: audioCtx.state || null,
+                        maxChannels: ((_a = audioCtx.destination) === null || _a === void 0 ? void 0 : _a.maxChannelCount) || null
+                    };
+                    // Close context to free resources
+                    if (audioCtx.close) {
+                        yield audioCtx.close();
+                    }
+                    return result;
+                }
+                catch (_b) {
+                    return null;
+                }
+            });
+        }
+        /**
+         * Get timezone
+         */
+        getTimezone() {
+            try {
+                return Intl.DateTimeFormat().resolvedOptions().timeZone || null;
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        /**
+         * Get screen resolution (coarsened)
+         */
+        getScreenResolution() {
+            try {
+                const width = Math.round(screen.width / 100) * 100;
+                const height = Math.round(screen.height / 100) * 100;
+                return `${width}x${height}`;
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        /**
+         * Coarsen hardware concurrency for privacy
+         */
+        coarsenHardwareConcurrency() {
+            try {
+                const cores = navigator.hardwareConcurrency;
+                if (!cores)
+                    return null;
+                return cores > 8 ? '8+' : cores;
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        /**
+         * Coarsen device memory for privacy
+         */
+        coarsenDeviceMemory() {
+            try {
+                const memory = navigator.deviceMemory;
+                if (!memory)
+                    return null;
+                return memory > 4 ? '4+' : memory;
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        /**
+         * Coarsen pixel ratio for privacy
+         */
+        coarsenPixelRatio() {
+            try {
+                const ratio = window.devicePixelRatio;
+                if (!ratio)
+                    return null;
+                // Round to common values
+                if (ratio <= 1)
+                    return '1';
+                if (ratio <= 1.5)
+                    return '1.5';
+                if (ratio <= 2)
+                    return '2';
+                if (ratio <= 3)
+                    return '3';
+                return '3+';
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        /**
+         * Coarsen timezone offset for privacy
+         */
+        coarsenTimezoneOffset() {
+            try {
+                const offset = new Date().getTimezoneOffset();
+                // Round to nearest 30 minutes
+                return Math.round(offset / 30) * 30;
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        /**
+         * Test if storage is available
+         */
+        testStorage(type) {
+            try {
+                const storage = window[type];
+                const testKey = '__dl_test__';
+                storage.setItem(testKey, '1');
+                storage.removeItem(testKey);
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+        /**
+         * Test if IndexedDB is available
+         */
+        testIndexedDB() {
+            try {
+                return !!window.indexedDB;
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+        /**
+         * Generate fingerprint hash
+         */
+        generateHash(data) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // Sort keys for consistent hashing
+                    const sortedData = Object.keys(data)
+                        .sort()
+                        .reduce((obj, key) => {
+                        obj[key] = data[key];
+                        return obj;
+                    }, {});
+                    const str = JSON.stringify(sortedData);
+                    // Use Web Crypto API if available
+                    if (window.crypto && window.crypto.subtle) {
+                        const encoder = new TextEncoder();
+                        const data = encoder.encode(str);
+                        const hashBuffer = yield crypto.subtle.digest('SHA-256', data);
+                        const hashArray = Array.from(new Uint8Array(hashBuffer));
+                        return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+                    }
+                    // Fallback to simple hash
+                    let hash = 0;
+                    for (let i = 0; i < str.length; i++) {
+                        const char = str.charCodeAt(i);
+                        hash = ((hash << 5) - hash) + char;
+                        hash = hash & hash; // Convert to 32bit integer
+                    }
+                    return Math.abs(hash).toString(16);
+                }
+                catch (_a) {
+                    return '';
+                }
+            });
+        }
+    }
+
+    /**
+     * Container Script Manager
+     * Loads and manages third-party tracking scripts and pixels
+     */
+    class ContainerManager {
+        constructor(options) {
+            this.scripts = [];
+            this.loadedScripts = new Set();
+            this.sessionLoadedScripts = new Set();
+            this.pixels = null;
+            this.initialized = false;
+            this.workspaceId = options.workspaceId;
+            // Container scripts always use the app endpoint, not ingest
+            this.endpoint = this.extractAppEndpoint(options.endpoint);
+            this.debug = options.debug || false;
+            // Load session scripts from storage
+            const sessionScripts = storage.get('dl_session_scripts', []);
+            this.sessionLoadedScripts = new Set(sessionScripts);
+        }
+        /**
+         * Initialize container and load scripts
+         */
+        init() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.initialized)
+                    return;
+                try {
+                    // Fetch container configuration
+                    const response = yield fetch(`${this.endpoint}/container-scripts`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'X-Container-Version': '1.0'
+                        },
+                        body: JSON.stringify({
+                            workspaceId: this.workspaceId
+                        })
+                    });
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch container scripts: ${response.status}`);
+                    }
+                    const data = yield response.json();
+                    // Store scripts and pixels
+                    this.scripts = data.scripts || [];
+                    this.pixels = data.pixels || null;
+                    // Initialize pixels if configured
+                    if (this.pixels) {
+                        this.initializePixels();
+                    }
+                    // Load scripts based on trigger
+                    this.loadScriptsByTrigger('page_load');
+                    // Setup DOM ready listener
+                    if (document.readyState === 'loading') {
+                        document.addEventListener('DOMContentLoaded', () => {
+                            this.loadScriptsByTrigger('dom_ready');
+                        });
+                    }
+                    else {
+                        this.loadScriptsByTrigger('dom_ready');
+                    }
+                    // Setup window load listener
+                    window.addEventListener('load', () => {
+                        this.loadScriptsByTrigger('window_load');
+                    });
+                    this.initialized = true;
+                    this.log('Container manager initialized with', this.scripts.length, 'scripts');
+                }
+                catch (error) {
+                    this.log('Error initializing container:', error);
+                }
+            });
+        }
+        /**
+         * Load scripts by trigger type
+         */
+        loadScriptsByTrigger(trigger) {
+            const scriptsToLoad = this.scripts.filter(script => script.enabled &&
+                script.trigger === trigger &&
+                this.shouldLoadScript(script));
+            scriptsToLoad.forEach(script => this.loadScript(script));
+        }
+        /**
+         * Check if script should be loaded based on frequency and conditions
+         */
+        shouldLoadScript(script) {
+            // Check frequency
+            if (script.frequency === 'once_per_page' && this.loadedScripts.has(script.id)) {
+                return false;
+            }
+            if (script.frequency === 'once_per_session' && this.sessionLoadedScripts.has(script.id)) {
+                return false;
+            }
+            // Check conditions
+            if (script.conditions && script.conditions.length > 0) {
+                return this.evaluateConditions(script.conditions);
+            }
+            return true;
+        }
+        /**
+         * Evaluate script conditions
+         */
+        evaluateConditions(conditions) {
+            return conditions.every(condition => {
+                try {
+                    const { type, operator, value } = condition;
+                    switch (type) {
+                        case 'url_path':
+                            return this.evaluateStringCondition(window.location.pathname, operator, value);
+                        case 'url_host':
+                            return this.evaluateStringCondition(window.location.hostname, operator, value);
+                        case 'url_parameter':
+                            const params = new URLSearchParams(window.location.search);
+                            return this.evaluateStringCondition(params.get(condition.parameter) || '', operator, value);
+                        case 'referrer':
+                            return this.evaluateStringCondition(document.referrer, operator, value);
+                        case 'device_type':
+                            const isMobile = /Mobile|Android|iPhone|iPad/i.test(navigator.userAgent);
+                            return this.evaluateStringCondition(isMobile ? 'mobile' : 'desktop', operator, value);
+                        default:
+                            return true;
+                    }
+                }
+                catch (_a) {
+                    return false;
+                }
+            });
+        }
+        /**
+         * Evaluate string condition
+         */
+        evaluateStringCondition(actual, operator, expected) {
+            switch (operator) {
+                case 'equals':
+                    return actual === expected;
+                case 'not_equals':
+                    return actual !== expected;
+                case 'contains':
+                    return actual.includes(expected);
+                case 'not_contains':
+                    return !actual.includes(expected);
+                case 'starts_with':
+                    return actual.startsWith(expected);
+                case 'ends_with':
+                    return actual.endsWith(expected);
+                case 'matches_regex':
+                    try {
+                        return new RegExp(expected).test(actual);
+                    }
+                    catch (_a) {
+                        return false;
+                    }
+                default:
+                    return false;
+            }
+        }
+        /**
+         * Load a single script
+         */
+        loadScript(script) {
+            try {
+                switch (script.type) {
+                    case 'inline':
+                        this.loadInlineScript(script);
+                        break;
+                    case 'external':
+                        this.loadExternalScript(script);
+                        break;
+                    case 'pixel':
+                        this.loadPixel(script);
+                        break;
+                }
+                // Mark as loaded
+                this.loadedScripts.add(script.id);
+                // Update session scripts if needed
+                if (script.frequency === 'once_per_session') {
+                    this.sessionLoadedScripts.add(script.id);
+                    storage.set('dl_session_scripts', Array.from(this.sessionLoadedScripts));
+                }
+                this.log('Loaded script:', script.name);
+            }
+            catch (error) {
+                this.log('Error loading script:', script.name, error);
+            }
+        }
+        /**
+         * Load inline JavaScript
+         */
+        loadInlineScript(script) {
+            // Basic XSS protection - ensure content doesn't contain obvious malicious patterns
+            if (this.containsMaliciousPatterns(script.content)) {
+                this.log('Blocked potentially malicious inline script:', script.id);
+                return;
+            }
+            const scriptElement = document.createElement('script');
+            scriptElement.textContent = script.content;
+            scriptElement.dataset.datalyrScript = script.id;
+            scriptElement.setAttribute('data-nonce', this.generateNonce());
+            document.head.appendChild(scriptElement);
+        }
+        /**
+         * Load external JavaScript
+         */
+        loadExternalScript(script) {
+            // Validate URL before loading
+            if (!this.isValidScriptUrl(script.content)) {
+                this.log('Blocked invalid script URL:', script.content);
+                return;
+            }
+            const scriptElement = document.createElement('script');
+            scriptElement.src = script.content;
+            scriptElement.dataset.datalyrScript = script.id;
+            // Apply settings
+            if (script.settings) {
+                if (script.settings.async !== false)
+                    scriptElement.async = true;
+                if (script.settings.defer)
+                    scriptElement.defer = true;
+                if (script.settings.integrity)
+                    scriptElement.integrity = script.settings.integrity;
+                if (script.settings.crossorigin)
+                    scriptElement.crossOrigin = script.settings.crossorigin;
+            }
+            else {
+                // Default to async for better performance
+                scriptElement.async = true;
+            }
+            document.head.appendChild(scriptElement);
+        }
+        /**
+         * Load tracking pixel
+         */
+        loadPixel(script) {
+            const img = new Image();
+            img.src = script.content;
+            img.style.display = 'none';
+            img.dataset.datalyrPixel = script.id;
+            document.body.appendChild(img);
+        }
+        /**
+         * Initialize third-party pixels (Meta, Google, TikTok)
+         */
+        initializePixels() {
+            var _a, _b, _c;
+            if (!this.pixels)
+                return;
+            // Initialize Meta Pixel
+            if (((_a = this.pixels.meta) === null || _a === void 0 ? void 0 : _a.enabled) && this.pixels.meta.pixel_id) {
+                this.initializeMetaPixel(this.pixels.meta);
+            }
+            // Initialize Google Tag
+            if (((_b = this.pixels.google) === null || _b === void 0 ? void 0 : _b.enabled) && this.pixels.google.tag_id) {
+                this.initializeGoogleTag(this.pixels.google);
+            }
+            // Initialize TikTok Pixel
+            if (((_c = this.pixels.tiktok) === null || _c === void 0 ? void 0 : _c.enabled) && this.pixels.tiktok.pixel_id) {
+                this.initializeTikTokPixel(this.pixels.tiktok);
+            }
+        }
+        /**
+         * Initialize Meta (Facebook) Pixel
+         */
+        initializeMetaPixel(config) {
+            try {
+                // Load Meta Pixel script
+                (function (f, b, e, v, n, t, s) {
+                    if (f.fbq)
+                        return;
+                    n = f.fbq = function () {
+                        n.callMethod ? n.callMethod.apply(n, arguments) : n.queue.push(arguments);
+                    };
+                    if (!f._fbq)
+                        f._fbq = n;
+                    n.push = n;
+                    n.loaded = !0;
+                    n.version = '2.0';
+                    n.queue = [];
+                    t = b.createElement(e);
+                    t.async = !0;
+                    t.src = v;
+                    s = b.getElementsByTagName(e)[0];
+                    s.parentNode.insertBefore(t, s);
+                })(window, document, 'script', 'https://connect.facebook.net/en_US/fbevents.js');
+                // Initialize pixel
+                window.fbq('init', config.pixel_id);
+                window.fbq('track', 'PageView');
+                this.log('Meta Pixel initialized:', config.pixel_id);
+            }
+            catch (error) {
+                this.log('Error initializing Meta Pixel:', error);
+            }
+        }
+        /**
+         * Initialize Google Tag
+         */
+        initializeGoogleTag(config) {
+            try {
+                // Load Google Tag script
+                const script = document.createElement('script');
+                script.async = true;
+                script.src = `https://www.googletagmanager.com/gtag/js?id=${config.tag_id}`;
+                document.head.appendChild(script);
+                // Initialize gtag
+                window.dataLayer = window.dataLayer || [];
+                function gtag() {
+                    window.dataLayer.push(arguments);
+                }
+                window.gtag = gtag;
+                gtag('js', new Date());
+                gtag('config', config.tag_id, {
+                    allow_enhanced_conversions: config.enhanced_conversions !== false
+                });
+                this.log('Google Tag initialized:', config.tag_id);
+            }
+            catch (error) {
+                this.log('Error initializing Google Tag:', error);
+            }
+        }
+        /**
+         * Initialize TikTok Pixel
+         */
+        initializeTikTokPixel(config) {
+            try {
+                // Load TikTok Pixel script
+                (function (w, d, t) {
+                    w.TiktokAnalyticsObject = t;
+                    var ttq = w[t] = w[t] || [];
+                    ttq.methods = ['page', 'track', 'identify', 'instances', 'debug', 'on', 'off', 'once', 'ready', 'alias', 'group', 'enableCookie', 'disableCookie'];
+                    ttq.setAndDefer = function (t, e) {
+                        t[e] = function () {
+                            t.push([e].concat(Array.prototype.slice.call(arguments, 0)));
+                        };
+                    };
+                    for (var i = 0; i < ttq.methods.length; i++)
+                        ttq.setAndDefer(ttq, ttq.methods[i]);
+                    ttq.instance = function (t) {
+                        for (var e = ttq._i[t] || [], n = 0; n < ttq.methods.length; n++)
+                            ttq.setAndDefer(e, ttq.methods[n]);
+                        return e;
+                    };
+                    ttq.load = function (e, n) {
+                        var i = 'https://analytics.tiktok.com/i18n/pixel/events.js';
+                        ttq._i = ttq._i || {};
+                        ttq._i[e] = [];
+                        ttq._o = ttq._o || {};
+                        ttq._o[e] = n || {};
+                        var o = document.createElement('script');
+                        o.type = 'text/javascript';
+                        o.async = true;
+                        o.src = i + '?sdkid=' + e + '&lib=' + t;
+                        var a = document.getElementsByTagName('script')[0];
+                        a.parentNode.insertBefore(o, a);
+                    };
+                })(window, document, 'ttq');
+                // Initialize pixel
+                window.ttq.load(config.pixel_id);
+                window.ttq.page();
+                this.log('TikTok Pixel initialized:', config.pixel_id);
+            }
+            catch (error) {
+                this.log('Error initializing TikTok Pixel:', error);
+            }
+        }
+        /**
+         * Track event to all initialized pixels
+         */
+        trackToPixels(eventName, properties = {}) {
+            var _a, _b, _c, _d, _e, _f;
+            // Track to Meta Pixel
+            if (((_b = (_a = this.pixels) === null || _a === void 0 ? void 0 : _a.meta) === null || _b === void 0 ? void 0 : _b.enabled) && window.fbq) {
+                try {
+                    window.fbq('track', eventName, properties);
+                }
+                catch (error) {
+                    this.log('Error tracking Meta Pixel event:', error);
+                }
+            }
+            // Track to Google Tag
+            if (((_d = (_c = this.pixels) === null || _c === void 0 ? void 0 : _c.google) === null || _d === void 0 ? void 0 : _d.enabled) && window.gtag) {
+                try {
+                    window.gtag('event', eventName, properties);
+                }
+                catch (error) {
+                    this.log('Error tracking Google Tag event:', error);
+                }
+            }
+            // Track to TikTok Pixel
+            if (((_f = (_e = this.pixels) === null || _e === void 0 ? void 0 : _e.tiktok) === null || _f === void 0 ? void 0 : _f.enabled) && window.ttq) {
+                try {
+                    // Map common events to TikTok names
+                    const tiktokEventMap = {
+                        'Purchase': 'CompletePayment',
+                        'AddToCart': 'AddToCart',
+                        'InitiateCheckout': 'InitiateCheckout',
+                        'ViewContent': 'ViewContent',
+                        'Search': 'Search',
+                        'Lead': 'SubmitForm'
+                    };
+                    const tiktokEvent = tiktokEventMap[eventName] || eventName;
+                    window.ttq.track(tiktokEvent, properties);
+                }
+                catch (error) {
+                    this.log('Error tracking TikTok Pixel event:', error);
+                }
+            }
+        }
+        /**
+         * Manually trigger a custom script
+         */
+        triggerCustomScript(scriptId) {
+            const script = this.scripts.find(s => s.id === scriptId && s.trigger === 'custom');
+            if (script && this.shouldLoadScript(script)) {
+                this.loadScript(script);
+            }
+        }
+        /**
+         * Get loaded scripts
+         */
+        getLoadedScripts() {
+            return Array.from(this.loadedScripts);
+        }
+        /**
+         * Extract app endpoint from ingest endpoint
+         */
+        extractAppEndpoint(endpoint) {
+            if (!endpoint) {
+                return 'https://app.datalyr.com';
+            }
+            // If it's already an app endpoint, use it
+            if (endpoint.includes('app.datalyr.com')) {
+                return endpoint;
+            }
+            // Convert ingest endpoint to app endpoint
+            if (endpoint.includes('ingest.datalyr.com')) {
+                return 'https://app.datalyr.com';
+            }
+            // For local development
+            if (endpoint.includes('localhost') || endpoint.includes('127.0.0.1')) {
+                // Assume app is on port 3000 if ingest is on 3001
+                return endpoint.replace(':3001', ':3000').replace('/ingest', '');
+            }
+            // For custom endpoints, try to extract the base domain
+            try {
+                const url = new URL(endpoint);
+                return `${url.protocol}//${url.hostname}${url.port ? ':' + url.port : ''}`;
+            }
+            catch (_a) {
+                return 'https://app.datalyr.com';
+            }
+        }
+        /**
+         * Check for malicious patterns in inline scripts
+         */
+        containsMaliciousPatterns(content) {
+            // Basic patterns that might indicate malicious content
+            const dangerousPatterns = [
+                /<script[^>]*>/gi, // Script tags within content
+                /document\.cookie/gi, // Direct cookie access
+                /eval\s*\(/gi, // eval usage
+                /Function\s*\(/gi, // Function constructor
+                /innerHTML\s*=/gi, // Direct innerHTML assignment
+                /document\.write/gi, // document.write usage
+            ];
+            return dangerousPatterns.some(pattern => pattern.test(content));
+        }
+        /**
+         * Validate script URL
+         */
+        isValidScriptUrl(url) {
+            try {
+                const parsed = new URL(url);
+                // Only allow HTTPS in production (allow HTTP for localhost)
+                if (parsed.protocol !== 'https:' && !parsed.hostname.includes('localhost')) {
+                    return false;
+                }
+                // Block data: and javascript: protocols
+                if (['data:', 'javascript:', 'file:'].includes(parsed.protocol)) {
+                    return false;
+                }
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+        /**
+         * Generate a nonce for CSP
+         */
+        generateNonce() {
+            const array = new Uint8Array(16);
+            crypto.getRandomValues(array);
+            return btoa(String.fromCharCode(...array));
+        }
+        /**
+         * Debug logging
+         */
+        log(...args) {
+            if (this.debug) {
+                console.log('[Datalyr Container]', ...args);
+            }
+        }
+    }
+
+    /**
+     * Datalyr Web SDK
+     * Modern attribution tracking for web applications
+     */
+    class Datalyr {
+        constructor() {
+            this.superProperties = {};
+            this.userProperties = {};
+            this.optedOut = false;
+            this.initialized = false;
+            this.errors = [];
+            this.MAX_ERRORS = 50;
+            this.heavyFingerprintCollected = false;
+            // Check for opt-out cookie on instantiation using default cookie instance
+            this.optedOut = cookies.get('__dl_opt_out') === 'true';
+        }
+        /**
+         * Initialize the SDK
+         */
+        init(config) {
+            if (this.initialized) {
+                console.warn('[Datalyr] SDK already initialized');
+                return;
+            }
+            // Validate config
+            if (!config.workspaceId) {
+                throw new Error('[Datalyr] workspaceId is required');
+            }
+            // Set default config values
+            this.config = Object.assign({ endpoint: 'https://ingest.datalyr.com', debug: false, batchSize: 10, flushInterval: 5000, flushAt: 10, criticalEvents: undefined, highPriorityEvents: undefined, sessionTimeout: 30 * 60 * 1000, trackSessions: true, attributionWindow: 30 * 24 * 60 * 60 * 1000, trackedParams: [], respectDoNotTrack: false, respectGlobalPrivacyControl: true, privacyMode: 'standard', cookieDomain: 'auto', cookieExpires: 365, secureCookie: 'auto', sameSite: 'Lax', cookiePrefix: '__dl_', enablePerformanceTracking: true, enableFingerprinting: true, maxRetries: 5, retryDelay: 1000, maxOfflineQueueSize: 100, trackSPA: true, trackPageViews: true, fallbackEndpoints: [], plugins: [] }, config);
+            // Initialize cookie storage with config
+            this.cookies = new CookieStorage({
+                domain: this.config.cookieDomain,
+                maxAge: this.config.cookieExpires,
+                sameSite: this.config.sameSite,
+                secure: this.config.secureCookie
+            });
+            // Initialize modules
+            this.identity = new IdentityManager();
+            this.session = new SessionManager(this.config.sessionTimeout);
+            this.attribution = new AttributionManager({
+                attributionWindow: this.config.attributionWindow,
+                trackedParams: this.config.trackedParams
+            });
+            this.queue = new EventQueue(this.config);
+            this.fingerprint = new FingerprintCollector({
+                privacyMode: this.config.privacyMode,
+                enableFingerprinting: this.config.enableFingerprinting
+            });
+            // Set session ID in identity manager
+            const sessionId = this.session.getSessionId();
+            this.identity.setSessionId(sessionId);
+            // Load stored user properties
+            this.userProperties = storage.get('dl_user_traits', {});
+            // Setup SPA tracking if enabled
+            if (this.config.trackSPA) {
+                this.setupSPATracking();
+            }
+            // Initialize container manager if enabled
+            if (this.config.enableContainer !== false) {
+                this.container = new ContainerManager({
+                    workspaceId: this.config.workspaceId,
+                    endpoint: this.config.endpoint,
+                    debug: this.config.debug
+                });
+                // Initialize container asynchronously
+                this.container.init().catch(error => {
+                    this.log('Container initialization failed:', error);
+                });
+            }
+            // Track initial page view if enabled
+            if (this.config.trackPageViews) {
+                this.page();
+            }
+            // Setup page unload handler
+            this.setupUnloadHandler();
+            // Initialize plugins
+            if (this.config.plugins) {
+                for (const plugin of this.config.plugins) {
+                    try {
+                        plugin.initialize(this);
+                        this.log(`Plugin initialized: ${plugin.name}`);
+                    }
+                    catch (error) {
+                        this.trackError(error, { plugin: plugin.name });
+                    }
+                }
+            }
+            this.initialized = true;
+            this.log('SDK initialized');
+        }
+        /**
+         * Track an event
+         */
+        track(eventName, properties = {}) {
+            if (!this.shouldTrack())
+                return;
+            try {
+                // Collect heavy fingerprint on first event (lazy loading)
+                if (!this.heavyFingerprintCollected && this.config.enableFingerprinting) {
+                    this.heavyFingerprintCollected = true;
+                    this.fingerprint.collectHeavyFingerprint().catch(err => {
+                        this.log('Heavy fingerprint collection failed:', err);
+                    });
+                }
+                // Update session activity
+                this.session.updateActivity(eventName);
+                // Create event payload
+                const payload = this.createEventPayload(eventName, properties);
+                // Queue event
+                this.queue.enqueue(payload);
+                // Track to third-party pixels if container is initialized
+                if (this.container) {
+                    this.container.trackToPixels(eventName, properties);
+                }
+                // Call plugin handlers
+                if (this.config.plugins) {
+                    for (const plugin of this.config.plugins) {
+                        if (plugin.track) {
+                            try {
+                                plugin.track(eventName, properties);
+                            }
+                            catch (error) {
+                                this.trackError(error, { plugin: plugin.name, event: eventName });
+                            }
+                        }
+                    }
+                }
+                this.log('Event tracked:', eventName);
+            }
+            catch (error) {
+                this.trackError(error, { event: eventName });
+            }
+        }
+        /**
+         * Identify a user
+         */
+        identify(userId, traits = {}) {
+            if (!this.shouldTrack())
+                return;
+            if (!userId) {
+                console.warn('[Datalyr] identify() called without userId');
+                return;
+            }
+            try {
+                // Update identity
+                const identityLink = this.identity.identify(userId, traits);
+                // Store user properties
+                this.userProperties = Object.assign(Object.assign({}, this.userProperties), traits);
+                storage.set('dl_user_traits', this.userProperties);
+                // Track $identify event
+                this.track('$identify', Object.assign(Object.assign({}, identityLink), { traits }));
+                // Call plugin handlers
+                if (this.config.plugins) {
+                    for (const plugin of this.config.plugins) {
+                        if (plugin.identify) {
+                            try {
+                                plugin.identify(userId, traits);
+                            }
+                            catch (error) {
+                                this.trackError(error, { plugin: plugin.name });
+                            }
+                        }
+                    }
+                }
+                this.log('User identified:', userId);
+            }
+            catch (error) {
+                this.trackError(error, { userId });
+            }
+        }
+        /**
+         * Track a page view
+         */
+        page(properties = {}) {
+            if (!this.shouldTrack())
+                return;
+            const pageData = Object.assign({ title: document.title, url: window.location.href, path: window.location.pathname, search: window.location.search, referrer: document.referrer }, properties);
+            // Add referrer data
+            const referrerData = getReferrerData();
+            Object.assign(pageData, referrerData);
+            // Add performance metrics if enabled
+            if (this.config.enablePerformanceTracking) {
+                const metrics = this.getPerformanceMetrics();
+                if (metrics) {
+                    pageData.performance = metrics;
+                }
+            }
+            this.track('pageview', pageData);
+            // Call plugin handlers
+            if (this.config.plugins) {
+                for (const plugin of this.config.plugins) {
+                    if (plugin.page) {
+                        try {
+                            plugin.page(pageData);
+                        }
+                        catch (error) {
+                            this.trackError(error, { plugin: plugin.name });
+                        }
+                    }
+                }
+            }
+        }
+        /**
+         * Track a screen view (for SPAs)
+         */
+        screen(screenName, properties = {}) {
+            this.track('screen_view', Object.assign({ screen_name: screenName }, properties));
+        }
+        /**
+         * Associate user with a group/account
+         */
+        group(groupId, traits = {}) {
+            this.track('$group', {
+                group_id: groupId,
+                traits
+            });
+        }
+        /**
+         * Alias one ID to another
+         */
+        alias(userId, previousId) {
+            const aliasData = this.identity.alias(userId, previousId);
+            this.track('$alias', aliasData);
+        }
+        /**
+         * Reset the current user
+         */
+        reset() {
+            this.identity.reset();
+            this.userProperties = {};
+            storage.remove('dl_user_traits');
+            this.session.createNewSession();
+            this.log('User reset');
+        }
+        /**
+         * Get the current anonymous ID
+         */
+        getAnonymousId() {
+            return this.identity.getAnonymousId();
+        }
+        /**
+         * Get the current user ID
+         */
+        getUserId() {
+            return this.identity.getUserId();
+        }
+        /**
+         * Get the distinct ID
+         */
+        getDistinctId() {
+            return this.identity.getDistinctId();
+        }
+        /**
+         * Get the current session ID
+         */
+        getSessionId() {
+            return this.session.getSessionId();
+        }
+        /**
+         * Start a new session manually
+         */
+        startNewSession() {
+            const sessionId = this.session.createNewSession();
+            this.identity.setSessionId(sessionId);
+            return sessionId;
+        }
+        /**
+         * Get session data
+         */
+        getSessionData() {
+            return this.session.getSessionData();
+        }
+        /**
+         * Get current attribution data
+         */
+        getAttribution() {
+            return this.attribution.captureAttribution();
+        }
+        /**
+         * Get customer journey
+         */
+        getJourney() {
+            return this.attribution.getJourney();
+        }
+        /**
+         * Set attribution manually
+         */
+        setAttribution(attribution) {
+            const current = this.attribution.captureAttribution();
+            const merged = Object.assign(Object.assign({}, current), attribution);
+            this.session.storeAttribution(merged);
+        }
+        /**
+         * Opt out of tracking
+         */
+        optOut() {
+            this.optedOut = true;
+            cookies.set('__dl_opt_out', 'true', this.config.cookieExpires);
+            this.queue.clear();
+            this.log('User opted out');
+        }
+        /**
+         * Opt in to tracking
+         */
+        optIn() {
+            this.optedOut = false;
+            cookies.set('__dl_opt_out', 'false', this.config.cookieExpires);
+            this.log('User opted in');
+        }
+        /**
+         * Check if user has opted out
+         */
+        isOptedOut() {
+            return this.optedOut;
+        }
+        /**
+         * Set consent preferences
+         */
+        setConsent(consent) {
+            storage.set('dl_consent', consent);
+            this.log('Consent updated:', consent);
+        }
+        /**
+         * Manually flush the event queue
+         */
+        flush() {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.queue.flush();
+            });
+        }
+        /**
+         * Set super properties
+         */
+        setSuperProperties(properties) {
+            this.superProperties = Object.assign(Object.assign({}, this.superProperties), properties);
+            this.log('Super properties set:', properties);
+        }
+        /**
+         * Unset a super property
+         */
+        unsetSuperProperty(propertyName) {
+            delete this.superProperties[propertyName];
+            this.log('Super property unset:', propertyName);
+        }
+        /**
+         * Get super properties
+         */
+        getSuperProperties() {
+            return Object.assign({}, this.superProperties);
+        }
+        /**
+         * Create event payload
+         */
+        createEventPayload(eventName, properties) {
+            // Sanitize and merge properties
+            const sanitizedProperties = sanitizeEventData(properties);
+            const eventData = deepMerge({}, this.superProperties, sanitizedProperties);
+            // Add attribution data
+            const attributionData = this.attribution.getAttributionData();
+            Object.assign(eventData, attributionData);
+            // Add session metrics
+            const sessionMetrics = this.session.getMetrics();
+            Object.assign(eventData, sessionMetrics);
+            // Add fingerprint data if enabled
+            if (this.config.enableFingerprinting) {
+                const fingerprintData = this.fingerprint.collect();
+                Object.assign(eventData, {
+                    fingerprint: fingerprintData,
+                    device_fingerprint: fingerprintData // Snake case alias
+                });
+            }
+            // Add browser context
+            Object.assign(eventData, {
+                url: window.location.href,
+                path: window.location.pathname,
+                referrer: document.referrer,
+                title: document.title,
+                screen_width: screen.width,
+                screen_height: screen.height,
+                viewport_width: window.innerWidth,
+                viewport_height: window.innerHeight
+            });
+            // Create payload with both camelCase and snake_case fields
+            const identityFields = this.identity.getIdentityFields();
+            const eventId = generateUUID();
+            const payload = Object.assign(Object.assign({ 
+                // Required fields
+                workspaceId: this.config.workspaceId, workspace_id: this.config.workspaceId, eventId: eventId, event_id: eventId, // Snake case alias (same ID)
+                eventName, event_name: eventName, // Snake case alias
+                eventData, event_data: eventData, source: 'web', timestamp: new Date().toISOString() }, identityFields), { 
+                // SDK metadata
+                sdk_version: '1.0.0', sdk_name: 'datalyr-web-sdk' });
+            return payload;
+        }
+        /**
+         * Check if we should track
+         */
+        shouldTrack() {
+            // Check opt-out
+            if (this.optedOut) {
+                return false;
+            }
+            // Check Do Not Track
+            if (this.config.respectDoNotTrack && isDoNotTrackEnabled()) {
+                return false;
+            }
+            // Check Global Privacy Control
+            if (this.config.respectGlobalPrivacyControl && isGlobalPrivacyControlEnabled()) {
+                return false;
+            }
+            return true;
+        }
+        /**
+         * Setup SPA tracking
+         */
+        setupSPATracking() {
+            // Store original methods
+            const originalPushState = history.pushState;
+            const originalReplaceState = history.replaceState;
+            const self = this;
+            // Override pushState
+            history.pushState = function (...args) {
+                originalPushState.apply(history, args);
+                setTimeout(() => {
+                    self.page();
+                }, 0);
+            };
+            // Override replaceState
+            history.replaceState = function (...args) {
+                originalReplaceState.apply(history, args);
+                setTimeout(() => {
+                    self.page();
+                }, 0);
+            };
+            // Listen for popstate
+            window.addEventListener('popstate', () => {
+                setTimeout(() => {
+                    this.page();
+                }, 0);
+            });
+            // Listen for hashchange
+            window.addEventListener('hashchange', () => {
+                this.page();
+            });
+        }
+        /**
+         * Setup page unload handler
+         */
+        setupUnloadHandler() {
+            // Use both events for maximum compatibility
+            const handleUnload = () => {
+                this.queue.forceFlush();
+            };
+            window.addEventListener('beforeunload', handleUnload);
+            window.addEventListener('pagehide', handleUnload);
+            window.addEventListener('visibilitychange', () => {
+                if (document.visibilityState === 'hidden') {
+                    handleUnload();
+                }
+            });
+        }
+        /**
+         * Get performance metrics
+         */
+        getPerformanceMetrics() {
+            if (!this.config.enablePerformanceTracking)
+                return null;
+            const metrics = {};
+            try {
+                // Try Navigation Timing v2
+                if (performance && typeof performance.getEntriesByType === 'function') {
+                    const entries = performance.getEntriesByType('navigation');
+                    const nav = entries && entries[0];
+                    if (nav) {
+                        metrics.pageLoadTime = Math.round(nav.loadEventEnd);
+                        metrics.domReadyTime = Math.round(nav.domContentLoadedEventEnd);
+                        metrics.firstByteTime = Math.round(nav.responseStart);
+                        metrics.dnsTime = Math.round(nav.domainLookupEnd - nav.domainLookupStart);
+                        metrics.tcpTime = Math.round(nav.connectEnd - nav.connectStart);
+                        metrics.requestTime = Math.round(nav.responseEnd - nav.requestStart);
+                        metrics.timeOnPage = Math.round(performance.now());
+                    }
+                }
+            }
+            catch (error) {
+                this.trackError(error, { context: 'performance_metrics' });
+            }
+            return Object.keys(metrics).length > 0 ? metrics : null;
+        }
+        /**
+         * Track error
+         */
+        trackError(error, context) {
+            const errorInfo = {
+                message: error.message || String(error),
+                stack: error.stack,
+                context,
+                timestamp: new Date().toISOString(),
+                url: window.location.href
+            };
+            this.errors.push(errorInfo);
+            // Keep only recent errors
+            if (this.errors.length > this.MAX_ERRORS) {
+                this.errors = this.errors.slice(-this.MAX_ERRORS);
+            }
+            if (this.config.debug) {
+                console.error('[Datalyr Error]', errorInfo);
+            }
+        }
+        /**
+         * Get errors
+         */
+        getErrors() {
+            return [...this.errors];
+        }
+        /**
+         * Get network status
+         */
+        getNetworkStatus() {
+            return this.queue.getNetworkStatus();
+        }
+        /**
+         * Load a container script by ID
+         */
+        loadScript(scriptId) {
+            if (this.container) {
+                this.container.triggerCustomScript(scriptId);
+            }
+        }
+        /**
+         * Get loaded container scripts
+         */
+        getLoadedScripts() {
+            if (this.container) {
+                return this.container.getLoadedScripts();
+            }
+            return [];
+        }
+        /**
+         * Debug logging
+         */
+        log(...args) {
+            if (this.config.debug) {
+                console.log('[Datalyr]', ...args);
+            }
+        }
+        /**
+         * Destroy the SDK instance and cleanup resources
+         */
+        destroy() {
+            // Clean up queue
+            if (this.queue) {
+                this.queue.destroy();
+            }
+            // Clean up session
+            if (this.session) {
+                this.session.destroy();
+            }
+            // Clear any remaining data
+            this.superProperties = {};
+            this.userProperties = {};
+            this.errors = [];
+            this.initialized = false;
+            this.log('SDK destroyed');
+        }
+    }
+    // Create singleton instance
+    const datalyr = new Datalyr();
+    // Expose global API
+    if (typeof window !== 'undefined') {
+        window.datalyr = datalyr;
+    }
+
+    return datalyr;
+
+})();
+//# sourceMappingURL=datalyr.js.map