@datalyr/web 1.0.0

package/dist/datalyr.cjs.js

@@ -0,0 +1,2835 @@
+/**
+ * @datalyr/web v1.0.0
+ * Datalyr Web SDK - Modern attribution tracking for web applications
+ * (c) 2025 Datalyr Inc.
+ * Released under the MIT License
+ */
+'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;
+}
+
+module.exports = datalyr;
+//# sourceMappingURL=datalyr.cjs.js.map