@dotcms/events 0.0.0-stage → 26.10.5-1-alpha.0

package/index.esm.js

@@ -0,0 +1,3672 @@
+import { getUVEState } from '@dotcms/uve';
+import { E as EXPERIMENT_ATTRIBUTE, V as VARIANT_ATTRIBUTE, D as DEFAULT_VARIANT, R as REVEAL_STYLE_ID, a as DECISION_TIMEOUT_MS, b as VARIANT_QUERY_PARAM, Q as QUIET_MS, I as IS_USER_INCLUDED_REQUEST_TIMEOUT_MS, c as IS_USER_INCLUDED_PATH, S as STORAGE_KEYS, O as ONE_DAY_MS, d as decideVariant, B as BOOT_STATE_KEY, e as DEFAULT_ASSIGNMENT_TIMEOUT_MS } from './decision.esm.js';
+import onRouteChange from '@analytics/router-utils';
+import smartQueue from '@analytics/queue-utils';
+
+/*! *****************************************************************************
+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 */
+
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+/*
+ * Constants of the click tracker.
+ */
+/**
+ * Event type for content clicks
+ * Must match DotCMSPredefinedEventType.CONTENT_CLICK
+ */
+const CLICK_EVENT_TYPE = 'content_click';
+/**
+ * Default debounce time in milliseconds for clicks
+ */
+const DEFAULT_CLICK_THROTTLE_MS = 300;
+/**
+ * CSS selector for clickable elements to track
+ * Only clicks on <a> and <button> elements are tracked
+ */
+const CLICKABLE_ELEMENTS_SELECTOR = 'a, button';
+
+/*
+ * Constants the content trackers share: how contentlets are found, and the rescan event.
+ */
+/**
+ * Default debounce time in milliseconds for MutationObserver
+ */
+const CONTENTLET_OBSERVER_DEBOUNCE_MS = 250;
+/**
+ * CSS class selector for contentlet elements
+ *
+ * @important This constant is intentionally duplicated in @dotcms/react SDK
+ * (core-web/libs/sdk/react/src/lib/next/components/Contentlet/Contentlet.tsx), whose renderers
+ * print the class, and dotCMS prints it on traditional pages too. Both constants MUST have the
+ * same value ('dotcms-contentlet') for content tracking to find React-rendered contentlets.
+ *
+ * This duplication is intentional to keep the SDKs independent:
+ * - @dotcms/events works without React
+ * - @dotcms/react works without events
+ * - When both are used together, they must share the same class name
+ *
+ * If you need to change this value, you MUST update it in both locations:
+ * 1. This file (@dotcms/events)
+ * 2. Contentlet.tsx in @dotcms/react
+ *
+ * @see core-web/libs/sdk/react/src/lib/next/components/Contentlet/Contentlet.tsx
+ */
+const CONTENTLET_CLASS = 'dotcms-contentlet';
+/**
+ * Attribute that carries a contentlet's identifier (`dataset['dotIdentifier']`). The page
+ * renderers print it only once analytics is active, after hydration, so it can land after
+ * the contentlet itself.
+ */
+const CONTENTLET_IDENTIFIER_ATTRIBUTE = 'data-dot-identifier';
+/**
+ * Window event that asks the content trackers to scan for contentlets again. Sent when
+ * contentlets that were hidden become visible, which changes no DOM node the trackers watch
+ * (an experiment's rows are revealed through a style rule).
+ */
+const CONTENTLET_RESCAN_EVENT = 'dotcms:events:rescan';
+
+/** The window property that traditional pages and plain scripts reach `dotEvents` through. */
+const EVENTS_WINDOW_KEY = 'dotEvents';
+/**
+ * The Analytics.js name of the sender plugin. The enricher keys its hooks with it
+ * (`page:<name>`, `track:<name>`), so they run for the sender's calls only.
+ */
+const SENDER_PLUGIN_NAME = 'dot-events-sender';
+// Analytics endpoint for sending events to server
+const ANALYTICS_ENDPOINT = '/api/v1/analytics/content/event';
+/**
+ * The event types dotCMS accepts, each with its own schema. It rejects any other type, so the
+ * SDK sends no custom events.
+ */
+const DotCMSPredefinedEventType = {
+    PAGEVIEW: 'pageview',
+    CONTENT_IMPRESSION: 'content_impression',
+    CONTENT_CLICK: 'content_click',
+    CONVERSION: 'conversion'
+};
+/**
+ * Expected UTM parameter keys for campaign tracking
+ */
+const EXPECTED_UTM_KEYS = [
+    'utm_source',
+    'utm_medium',
+    'utm_campaign',
+    'utm_term',
+    'utm_content'
+];
+/**
+ * Session configuration constants
+ */
+const DEFAULT_SESSION_TIMEOUT_MINUTES = 30;
+/**
+ * Session storage key for session ID
+ */
+const SESSION_STORAGE_KEY = 'dot_events_session_id';
+/**
+ * User ID configuration constants
+ */
+const USER_ID_KEY = 'dot_events_user_id';
+/**
+ * Default queue configuration batch size
+ */
+const DEFAULT_QUEUE_CONFIG_BATCH_SIZE = 15;
+/**
+ * Default queue configuration flush interval
+ */
+const DEFAULT_QUEUE_CONFIG_FLUSH_INTERVAL = 5000;
+/**
+ * Activity tracking configuration
+ * Events used to detect user activity for session management
+ * - click: Detects real user interaction with minimal performance impact
+ * - visibilitychange: Handled separately to detect tab changes
+ */
+const ACTIVITY_EVENTS = ['click'];
+/**
+ * Default queue configuration for event batching
+ */
+const DEFAULT_QUEUE_CONFIG = {
+    eventBatchSize: DEFAULT_QUEUE_CONFIG_BATCH_SIZE, // Max events per batch - auto-sends when reached
+    flushInterval: DEFAULT_QUEUE_CONFIG_FLUSH_INTERVAL // Time between flushes - sends whatever is queued
+};
+/**
+ * Default properties that Analytics.js adds automatically
+ * These should be filtered out to only keep user-provided properties
+ */
+const ANALYTICS_JS_DEFAULT_PROPERTIES = [
+    'title',
+    'url',
+    'path',
+    'hash',
+    'search',
+    'width',
+    'height',
+    'referrer'
+];
+/**
+ * Window flag that says the SDK is active on the page. Not this package's name to change:
+ * `@dotcms/uve/internal` declares it too (`ANALYTICS_ACTIVE_WINDOW_KEY`), and the React, Vue
+ * and Angular SDKs read it to print the contentlet attributes impressions and clicks need.
+ */
+const ANALYTICS_WINDOWS_ACTIVE_KEY = '__dotAnalyticsActive__';
+/**
+ * Window event sent once the SDK is active, so the renderers that read
+ * `ANALYTICS_WINDOWS_ACTIVE_KEY` render again. Shared with `@dotcms/uve/internal`
+ * (`ANALYTICS_READY_EVENT`) like that flag.
+ */
+const ANALYTICS_READY_EVENT = 'dotcms:analytics:ready';
+/**
+ * Queue persistence configuration constants
+ * Used for storing events in sessionStorage for traditional page navigations
+ */
+/**
+ * Session storage key for persistent tab ID
+ * This ID remains constant across page navigations within the same browser tab
+ */
+const TAB_ID_STORAGE_KEY = 'dot_events_tab_id';
+/**
+ * Prefix for queue storage key in sessionStorage
+ * Full key format: dot_events_queue_{tabId}
+ */
+const QUEUE_STORAGE_KEY_PREFIX = 'dot_events_queue';
+/**
+ * Maximum age in milliseconds for persisted events
+ * Events older than this will be discarded (24 hours)
+ */
+const MAX_EVENT_AGE_MS = 24 * 60 * 60 * 1000;
+
+var _DotLogger_packageName, _DotLogger_context, _DotLogger_minLevel;
+/**
+ * Priority map for log level comparisons
+ * Lower numbers = more verbose, higher numbers = less verbose
+ */
+const LOG_LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+};
+/**
+ * Custom logger for DotCMS SDK
+ * Provides structured logging with context identification and configurable log level filtering
+ *
+ * @example
+ * ```typescript
+ * const logger = new DotLogger('events', 'Impression', 'info');
+ * logger.debug('This will not show'); // Below threshold
+ * logger.info('Tracker initialized'); // Shows
+ * logger.error('Failed to track'); // Shows
+ * ```
+ */
+class DotLogger {
+    constructor(packageName, context, minLevel = 'warn') {
+        _DotLogger_packageName.set(this, void 0);
+        _DotLogger_context.set(this, void 0);
+        _DotLogger_minLevel.set(this, void 0);
+        __classPrivateFieldSet(this, _DotLogger_packageName, packageName, "f");
+        __classPrivateFieldSet(this, _DotLogger_context, context, "f");
+        __classPrivateFieldSet(this, _DotLogger_minLevel, minLevel, "f");
+    }
+    /**
+     * Creates the formatted prefix for log messages
+     * Format: [dotCMS packageName | Context] [LEVEL]
+     */
+    getPrefix(level) {
+        return `[dotCMS ${__classPrivateFieldGet(this, _DotLogger_packageName, "f")} | ${__classPrivateFieldGet(this, _DotLogger_context, "f")}] [${level.toUpperCase()}]`;
+    }
+    /**
+     * Checks if a log level should be displayed based on the minimum threshold
+     */
+    shouldLog(level) {
+        return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[__classPrivateFieldGet(this, _DotLogger_minLevel, "f")];
+    }
+    /**
+     * Log a DEBUG level message
+     * Used for detailed debugging information
+     */
+    debug(...args) {
+        if (this.shouldLog('debug')) {
+            // eslint-disable-next-line no-console
+            console.log(this.getPrefix('debug'), ...args);
+        }
+    }
+    /**
+     * Log an INFO level message
+     * Used for general informational messages
+     */
+    info(...args) {
+        if (this.shouldLog('info')) {
+            // eslint-disable-next-line no-console
+            console.info(this.getPrefix('info'), ...args);
+        }
+    }
+    /**
+     * Log a WARN level message
+     * Used for warning messages that don't prevent operation
+     */
+    warn(...args) {
+        if (this.shouldLog('warn')) {
+            console.warn(this.getPrefix('warn'), ...args);
+        }
+    }
+    /**
+     * Log an ERROR level message
+     * Always logs regardless of threshold for critical errors
+     */
+    error(...args) {
+        console.error(this.getPrefix('error'), ...args);
+    }
+    /**
+     * Create a console group for organizing related log messages
+     * Respects the minimum log level threshold
+     */
+    group(label) {
+        if (this.shouldLog('debug')) {
+            // eslint-disable-next-line no-console
+            console.group(`${this.getPrefix('debug')} ${label}`);
+        }
+    }
+    /**
+     * End the current console group
+     * Respects the minimum log level threshold
+     */
+    groupEnd() {
+        if (this.shouldLog('debug')) {
+            // eslint-disable-next-line no-console
+            console.groupEnd();
+        }
+    }
+    /**
+     * Start a timer with the given label
+     * Useful for performance measurements
+     */
+    time(label) {
+        if (this.shouldLog('debug')) {
+            // eslint-disable-next-line no-console
+            console.time(`${this.getPrefix('debug')} ${label}`);
+        }
+    }
+    /**
+     * End a timer and log the elapsed time
+     * Useful for performance measurements
+     */
+    timeEnd(label) {
+        if (this.shouldLog('debug')) {
+            // eslint-disable-next-line no-console
+            console.timeEnd(`${this.getPrefix('debug')} ${label}`);
+        }
+    }
+    /**
+     * Log a message (alias for info)
+     * Provided for backward compatibility
+     */
+    log(...args) {
+        this.info(...args);
+    }
+}
+_DotLogger_packageName = new WeakMap(), _DotLogger_context = new WeakMap(), _DotLogger_minLevel = new WeakMap();
+
+var _DotCMSActivityTracker_activityListeners, _DotCMSActivityTracker_inactivityTimer, _DotCMSActivityTracker_isThrottled, _DotCMSActivityTracker_config;
+/** Session activity is recorded at most once a second */
+const ACTIVITY_THROTTLE_MS = 1000;
+/**
+ * Activity tracking for the events pipeline.
+ * Handles user activity monitoring, session management, and inactivity detection.
+ * Singleton pattern since we only handle one site at a time.
+ */
+class DotCMSActivityTracker {
+    constructor() {
+        _DotCMSActivityTracker_activityListeners.set(this, []);
+        _DotCMSActivityTracker_inactivityTimer.set(this, null);
+        _DotCMSActivityTracker_isThrottled.set(this, false);
+        _DotCMSActivityTracker_config.set(this, null);
+    }
+    /**
+     * Updates activity timestamp (throttled for performance)
+     */
+    updateActivityTime() {
+        // Reset inactivity timer
+        if (__classPrivateFieldGet(this, _DotCMSActivityTracker_inactivityTimer, "f")) {
+            clearTimeout(__classPrivateFieldGet(this, _DotCMSActivityTracker_inactivityTimer, "f"));
+        }
+        __classPrivateFieldSet(this, _DotCMSActivityTracker_inactivityTimer, setTimeout(() => {
+            // User became inactive - handle session timeout
+            if (__classPrivateFieldGet(this, _DotCMSActivityTracker_config, "f")?.debug) {
+                console.warn('[dotCMS events] User became inactive after timeout');
+            }
+            // Timer has fired, set to null to indicate no active timer
+            __classPrivateFieldSet(this, _DotCMSActivityTracker_inactivityTimer, null, "f");
+        }, DEFAULT_SESSION_TIMEOUT_MINUTES * 60 * 1000), "f");
+    }
+    /**
+     * Updates session activity with throttling
+     */
+    updateSessionActivity() {
+        if (__classPrivateFieldGet(this, _DotCMSActivityTracker_isThrottled, "f"))
+            return;
+        __classPrivateFieldSet(this, _DotCMSActivityTracker_isThrottled, true, "f");
+        this.updateActivityTime();
+        setTimeout(() => {
+            __classPrivateFieldSet(this, _DotCMSActivityTracker_isThrottled, false, "f");
+        }, ACTIVITY_THROTTLE_MS);
+    }
+    /**
+     * Initializes activity tracking with event listeners
+     */
+    initialize(config) {
+        this.cleanup();
+        __classPrivateFieldSet(this, _DotCMSActivityTracker_config, config, "f");
+        // Early return if window is not available (SSR/build time)
+        if (typeof window === 'undefined') {
+            return;
+        }
+        const throttledHandler = () => this.updateSessionActivity();
+        // Add activity event listeners
+        ACTIVITY_EVENTS.forEach((eventType) => {
+            window.addEventListener(eventType, throttledHandler, { passive: true });
+            __classPrivateFieldGet(this, _DotCMSActivityTracker_activityListeners, "f").push(() => window.removeEventListener(eventType, throttledHandler));
+        });
+        // Handle visibility changes for mobile/background scenarios
+        const handleVisibilityChange = () => {
+            if (document.visibilityState === 'visible') {
+                this.updateSessionActivity();
+                if (config.debug) {
+                    console.warn('[dotCMS events] User returned to tab, session reactivated');
+                }
+            }
+        };
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        __classPrivateFieldGet(this, _DotCMSActivityTracker_activityListeners, "f").push(() => document.removeEventListener('visibilitychange', handleVisibilityChange));
+        // Initialize activity time
+        this.updateActivityTime();
+        if (config.debug) {
+            console.warn('[dotCMS events] Activity tracking initialized');
+        }
+    }
+    /**
+     * Cleans up all activity tracking listeners
+     */
+    cleanup() {
+        __classPrivateFieldGet(this, _DotCMSActivityTracker_activityListeners, "f").forEach((cleanup) => cleanup());
+        __classPrivateFieldSet(this, _DotCMSActivityTracker_activityListeners, [], "f");
+        if (__classPrivateFieldGet(this, _DotCMSActivityTracker_inactivityTimer, "f")) {
+            clearTimeout(__classPrivateFieldGet(this, _DotCMSActivityTracker_inactivityTimer, "f"));
+            __classPrivateFieldSet(this, _DotCMSActivityTracker_inactivityTimer, null, "f");
+        }
+        __classPrivateFieldSet(this, _DotCMSActivityTracker_config, null, "f");
+    }
+}
+_DotCMSActivityTracker_activityListeners = new WeakMap(), _DotCMSActivityTracker_inactivityTimer = new WeakMap(), _DotCMSActivityTracker_isThrottled = new WeakMap(), _DotCMSActivityTracker_config = new WeakMap();
+// Create singleton instance
+const activityTracker = new DotCMSActivityTracker();
+/**
+ * Updates session activity with throttling
+ */
+const updateSessionActivity = () => {
+    activityTracker.updateSessionActivity();
+};
+/**
+ * Initializes activity tracking
+ */
+const initializeActivityTracking = (config) => {
+    activityTracker.initialize(config);
+};
+/**
+ * Cleans up activity tracking listeners and resets analytics state
+ */
+const cleanupActivityTracking = () => {
+    activityTracker.cleanup();
+    // Reset analytics state and cleanup window properties
+    if (typeof window !== 'undefined') {
+        window[ANALYTICS_WINDOWS_ACTIVE_KEY] = false;
+        // Dispatch cleanup event to notify any subscribers
+        window.dispatchEvent(new CustomEvent('dotcms:events:cleanup'));
+    }
+};
+
+// Performance cache for static browser data that rarely changes
+let staticBrowserData = null;
+// UTM parameters cache to avoid repetitive URL parsing
+let utmCache = null;
+/**
+ * Generates a random ID from the current time and Math.random: unique enough for session and
+ * user ids, but not cryptographically secure.
+ * @internal This function is for internal use only and should not be used outside of the SDK.
+ * @param prefix - The prefix for the generated ID
+ * @returns A unique ID string with the given prefix
+ */
+const generateSecureId = (prefix) => {
+    const timestamp = Date.now();
+    const randomPart = Math.random().toString(36).substr(2, 9);
+    const extraRandom = Math.random().toString(36).substr(2, 9);
+    return `${prefix}_${timestamp}_${randomPart}${extraRandom}`;
+};
+/**
+ * Safe localStorage wrapper with error handling.
+ * @internal This is for internal use only.
+ */
+const safeLocalStorage = {
+    getItem: (key) => {
+        try {
+            return localStorage.getItem(key);
+        }
+        catch {
+            return null;
+        }
+    },
+    setItem: (key, value) => {
+        try {
+            localStorage.setItem(key, value);
+        }
+        catch (e) {
+            console.warn(`[dotCMS events] Could not save ${key} to localStorage`);
+            throw e;
+        }
+    }
+};
+/**
+ * Safe sessionStorage wrapper with error handling
+ */
+const safeSessionStorage = {
+    getItem: (key) => {
+        try {
+            return sessionStorage.getItem(key);
+        }
+        catch {
+            return null;
+        }
+    },
+    setItem: (key, value) => {
+        try {
+            sessionStorage.setItem(key, value);
+        }
+        catch (e) {
+            console.warn(`[dotCMS events] Could not save ${key} to sessionStorage`);
+            throw e;
+        }
+    },
+    removeItem: (key) => {
+        try {
+            sessionStorage.removeItem(key);
+        }
+        catch {
+            console.warn(`[dotCMS events] Could not remove ${key} from sessionStorage`);
+        }
+    }
+};
+/**
+ * Gets or generates a user ID from localStorage.
+ * @internal This function is for internal use only.
+ * @returns The user ID string
+ */
+const getUserId = () => {
+    let userId = safeLocalStorage.getItem(USER_ID_KEY);
+    if (!userId) {
+        userId = generateSecureId('user');
+        try {
+            safeLocalStorage.setItem(USER_ID_KEY, userId);
+        }
+        catch {
+            // Ignore storage errors for user ID (ephemeral user)
+        }
+    }
+    return userId;
+};
+/**
+ * Checks if a new day has started since session creation
+ */
+const hasPassedMidnight = (sessionStartTime) => {
+    const sessionStart = new Date(sessionStartTime);
+    const now = new Date();
+    const sessionStartUTC = new Date(sessionStart.getUTCFullYear(), sessionStart.getUTCMonth(), sessionStart.getUTCDate());
+    const nowUTC = new Date(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+    return sessionStartUTC.getTime() !== nowUTC.getTime();
+};
+/**
+ * Gets session ID with comprehensive lifecycle management.
+ * Returns existing valid session ID or creates a new one if needed.
+ * @internal This function is for internal use only.
+ *
+ * Session validation criteria:
+ * 1. User is still active (< 30 min inactivity)
+ * 2. Session hasn't passed midnight (UTC)
+ *
+ * @returns The session ID string
+ */
+const getSessionId = () => {
+    const now = Date.now();
+    // Early return if window is not available (SSR/build time)
+    if (typeof window === 'undefined') {
+        return generateSecureId('session_fallback');
+    }
+    try {
+        const sessionData = sessionStorage.getItem(SESSION_STORAGE_KEY);
+        if (sessionData) {
+            const { sessionId, startTime, lastActivity } = JSON.parse(sessionData);
+            // Check if session is still valid
+            const hasNotPassedMidnight = !hasPassedMidnight(startTime);
+            const hasRecentActivity = now - lastActivity < DEFAULT_SESSION_TIMEOUT_MINUTES * 60 * 1000;
+            if (hasNotPassedMidnight && hasRecentActivity) {
+                // Update last activity time
+                sessionStorage.setItem(SESSION_STORAGE_KEY, JSON.stringify({
+                    sessionId,
+                    startTime,
+                    lastActivity: now
+                }));
+                return sessionId;
+            }
+        }
+        // Create new session
+        const newSessionId = generateSecureId('session');
+        const sessionDataToStore = {
+            sessionId: newSessionId,
+            startTime: now,
+            lastActivity: now
+        };
+        sessionStorage.setItem(SESSION_STORAGE_KEY, JSON.stringify(sessionDataToStore));
+        return newSessionId;
+    }
+    catch {
+        // Fallback to simple session ID if storage fails
+        return generateSecureId('session_fallback');
+    }
+};
+/**
+ * Gets analytics context with user and session identification.
+ * Used by the identity plugin to inject context into analytics events.
+ *
+ * @param config - The analytics configuration object
+ * @returns The analytics context with site_auth, session_id, user_id and device
+ */
+const getEventContext = (config) => {
+    const sessionId = getSessionId();
+    const userId = getUserId();
+    const device = getDeviceDataForContext();
+    return {
+        site_auth: config.siteAuth,
+        session_id: sessionId,
+        user_id: userId,
+        device
+    };
+};
+/**
+ * Gets static browser data (cached for performance)
+ */
+const getStaticBrowserData = () => {
+    if (staticBrowserData) {
+        return staticBrowserData;
+    }
+    staticBrowserData = {
+        user_language: navigator.language,
+        doc_encoding: document.characterSet || document.charset,
+        screen_resolution: typeof screen !== 'undefined' && screen.width && screen.height
+            ? `${screen.width}x${screen.height}`
+            : ''
+    };
+    return staticBrowserData;
+};
+/**
+ * Gets current device data for analytics.
+ * Combines static browser data with dynamic viewport information.
+ * Used by the identity plugin to inject device data into context.
+ *
+ * @returns Device data with screen resolution, language, and viewport dimensions
+ */
+const getDeviceDataForContext = () => {
+    const staticData = getStaticBrowserData();
+    const viewportWidth = window.innerWidth || document.documentElement.clientWidth || 0;
+    const viewportHeight = window.innerHeight || document.documentElement.clientHeight || 0;
+    return {
+        screen_resolution: staticData.screen_resolution ?? '',
+        language: staticData.user_language ?? '',
+        viewport_width: String(viewportWidth),
+        viewport_height: String(viewportHeight)
+    };
+};
+/**
+ * Extracts and transforms UTM parameters from the URL - cached for performance.
+ * Returns UTM data in DotCMS format (without 'utm_' prefix).
+ * @internal This function is for internal use only.
+ * @param location - The Location object to extract UTM parameters from
+ * @returns DotCMSEventUtmData object with transformed UTM parameters (source, medium, campaign, etc.)
+ */
+const extractUTMParameters = (location) => {
+    const search = location.search;
+    // Return cached result if search hasn't changed
+    if (utmCache && utmCache.search === search) {
+        return utmCache.params;
+    }
+    const urlParams = new URLSearchParams(search);
+    const utmData = {};
+    EXPECTED_UTM_KEYS.forEach((key) => {
+        const value = urlParams.get(key);
+        if (value) {
+            // Transform utm_source -> source, utm_medium -> medium, etc.
+            const cleanKey = key.replace('utm_', '');
+            utmData[cleanKey] = value;
+        }
+    });
+    // Cache the result
+    utmCache = { search, params: utmData };
+    return utmData;
+};
+/**
+ * Gets timezone offset in the format +HH:mm or -HH:mm
+ */
+const getTimezoneOffset = () => {
+    try {
+        const offset = new Date().getTimezoneOffset();
+        const sign = offset > 0 ? '-' : '+';
+        const absOffset = Math.abs(offset);
+        const hours = Math.floor(absOffset / 60);
+        const minutes = absOffset % 60;
+        return `${sign}${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}`;
+    }
+    catch {
+        return '+00:00';
+    }
+};
+/**
+ * Gets local time in ISO format without milliseconds.
+ * Used by enricher plugins to add local_time to events.
+ *
+ * @returns Local time string in ISO 8601 format with timezone offset (e.g., "2024-01-01T12:00:00-05:00")
+ */
+const getLocalTime = () => {
+    try {
+        const now = new Date();
+        const timezoneOffset = getTimezoneOffset();
+        // Format: YYYY-MM-DDTHH:mm:ss+HH:mm (without milliseconds)
+        const year = now.getFullYear();
+        const month = (now.getMonth() + 1).toString().padStart(2, '0');
+        const day = now.getDate().toString().padStart(2, '0');
+        const hours = now.getHours().toString().padStart(2, '0');
+        const minutes = now.getMinutes().toString().padStart(2, '0');
+        const seconds = now.getSeconds().toString().padStart(2, '0');
+        return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}${timezoneOffset}`;
+    }
+    catch {
+        return new Date().toISOString();
+    }
+};
+/**
+ * Optimized payload enrichment using existing analytics.js data.
+ * Filters out Analytics.js default properties and only keeps user-provided properties in custom.
+ * Used by the enricher plugin to transform Analytics.js payload into DotCMS event format.
+ *
+ * @param payload - The Analytics.js payload with context already injected by identity plugin
+ * @param location - The Location object to extract page data from (defaults to window.location)
+ * @returns Enriched payload with page, UTM, custom data, and local_time (device is in context)
+ */
+const enrichPagePayloadOptimized = (payload, location = typeof window !== 'undefined' ? window.location : {}) => {
+    const local_time = getLocalTime();
+    const staticData = getStaticBrowserData();
+    // Extract data from analytics.js payload
+    const { properties } = payload;
+    // Filter out Analytics.js default properties to get only user-provided properties
+    const userProvidedProperties = {};
+    Object.keys(properties).forEach((key) => {
+        if (!ANALYTICS_JS_DEFAULT_PROPERTIES.includes(key)) {
+            userProvidedProperties[key] = properties[key];
+        }
+    });
+    // TODO: Fix this when we detect the locale_id of the page in not server side
+    const locale_id = payload.context?.device?.language?.toLowerCase() ?? '';
+    const pageData = {
+        url: location.href,
+        doc_encoding: staticData.doc_encoding,
+        doc_hash: location.hash,
+        doc_protocol: location.protocol,
+        doc_search: location.search,
+        doc_host: location.hostname,
+        doc_path: location.pathname,
+        title: properties['title'] ?? document?.title,
+        locale_id
+    };
+    // Extract UTM parameters from the current URL (already transformed to DotCMS format)
+    const utmData = extractUTMParameters(location);
+    return {
+        ...payload,
+        page: pageData,
+        ...(Object.keys(utmData).length > 0 && { utm: utmData }),
+        // Only include custom if there are user-provided properties
+        ...(Object.keys(userProvidedProperties).length > 0 && { custom: userProvidedProperties }),
+        local_time
+    };
+};
+/**
+ * Checks if code is running in a browser environment
+ * @returns true if window and document are available
+ */
+const isBrowser$1 = () => {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+};
+/**
+ * Runs a callback when the browser discards the page. A page it keeps in the back/forward
+ * cache (`pagehide` with `persisted`) comes back as it was when the visitor returns, with its
+ * listeners and observers, so it is left alone. `beforeunload` is not used: it fires before the
+ * page goes into that cache too.
+ *
+ * @param discarded - Called on the `pagehide` that discards the page
+ */
+const onPageDiscard = (discarded) => {
+    window.addEventListener('pagehide', (event) => {
+        if (!event.persisted) {
+            discarded();
+        }
+    });
+};
+/**
+ * Creates a logger with plugin-specific prefix and configurable log level
+ * @param pluginName - Name of the plugin (e.g., 'Click', 'Impression')
+ * @param config - Analytics configuration with debug flag and optional logLevel
+ * @returns DotLogger instance with configured log level
+ */
+const createPluginLogger = (pluginName, config) => {
+    // Use explicit logLevel if provided, otherwise fall back to debug flag
+    const level = config.logLevel ?? (config.debug ? 'debug' : 'warn');
+    return new DotLogger('events', pluginName, level);
+};
+
+/*
+ * Helpers of the content trackers: they find contentlets in the DOM, read their data, watch
+ * for new ones and decide which trackers run.
+ */
+/**
+ * Creates a throttled version of a callback function
+ * Ensures the callback is executed at most once every `limitMs` milliseconds
+ * @param callback - The function to throttle
+ * @param limitMs - The time limit in milliseconds
+ * @param options - `trailing`: instead of dropping the calls made inside the window, run the
+ * last one when the window ends
+ * @returns A throttled function
+ */
+function createThrottle(callback, limitMs, options = {}) {
+    let lastRun = 0;
+    let trailingTimer = null;
+    return (...args) => {
+        const now = Date.now();
+        const wait = limitMs - (now - lastRun);
+        if (wait <= 0) {
+            callback(...args);
+            lastRun = now;
+            return;
+        }
+        if (options.trailing && trailingTimer === null) {
+            trailingTimer = setTimeout(() => {
+                trailingTimer = null;
+                lastRun = Date.now();
+                callback(...args);
+            }, wait);
+        }
+    };
+}
+/**
+ * Extracts the contentlet identifier from a DOM element
+ * @param element - The HTML element containing data attributes
+ * @returns The contentlet identifier or null if not found
+ */
+function extractContentletIdentifier(element) {
+    return element.dataset['dotIdentifier'] || null;
+}
+/**
+ * Extracts all contentlet data from a DOM element's data attributes
+ * @param element - The HTML element containing data attributes
+ * @returns Complete contentlet data object
+ */
+function extractContentletData(element) {
+    return {
+        identifier: element.dataset['dotIdentifier'] || '',
+        inode: element.dataset['dotInode'] || '',
+        contentType: element.dataset['dotType'] || '',
+        title: element.dataset['dotTitle'] || '',
+        baseType: element.dataset['dotBasetype'] || ''
+    };
+}
+/**
+ * Initial scan delay for DOM readiness
+ * Allows React/Next.js to finish rendering before scanning for contentlets
+ */
+const INITIAL_SCAN_DELAY_MS = 100;
+/**
+ * Finds all contentlet elements in the DOM
+ * @returns Array of contentlet HTMLElements
+ */
+const findContentlets = () => {
+    return Array.from(document.querySelectorAll(`.${CONTENTLET_CLASS}`));
+};
+/**
+ * Creates a MutationObserver that watches for contentlet changes in the DOM
+ * @param callback - Function to call when mutations are detected
+ * @param debounceMs - Debounce time in milliseconds (default: 250ms)
+ * @param options - `identifiers`: also call back when a contentlet receives its
+ * `data-dot-identifier`. The renderers print it after hydration, usually within
+ * milliseconds of the contentlet itself, so calls inside the window are not dropped: the
+ * last one runs when it ends.
+ * @returns Configured and active MutationObserver
+ */
+const createContentletObserver = (callback, debounceMs = CONTENTLET_OBSERVER_DEBOUNCE_MS, options = {}) => {
+    const watchIdentifiers = options.identifiers === true;
+    const throttledCallback = createThrottle(callback, debounceMs, { trailing: watchIdentifiers });
+    const isContentlet = (node) => node.nodeType === Node.ELEMENT_NODE &&
+        node.classList?.contains(CONTENTLET_CLASS) === true;
+    const observer = new MutationObserver((mutations) => {
+        // This reduces observer callback executions by ~90% on dynamic sites
+        const hasRelevantChanges = mutations.some((mutation) => {
+            // Only the identifier attribute is observed, so any attribute change counts
+            // when it lands on a contentlet
+            if (mutation.type === 'attributes') {
+                return isContentlet(mutation.target);
+            }
+            // Skip if no nodes were added or removed
+            if (mutation.addedNodes.length === 0 && mutation.removedNodes.length === 0) {
+                return false;
+            }
+            // Check if any added/removed nodes are or contain contentlets
+            const nodes = [
+                ...Array.from(mutation.addedNodes),
+                ...Array.from(mutation.removedNodes)
+            ];
+            return nodes.some((node) => {
+                // Only check element nodes
+                if (node.nodeType !== Node.ELEMENT_NODE) {
+                    return false;
+                }
+                const element = node;
+                // Check if node itself is a contentlet
+                if (element.classList?.contains(CONTENTLET_CLASS)) {
+                    return true;
+                }
+                // Check if node contains contentlets
+                return element.querySelector?.(`.${CONTENTLET_CLASS}`) !== null;
+            });
+        });
+        // Only invoke callback if relevant changes detected
+        if (hasRelevantChanges) {
+            throttledCallback();
+        }
+    });
+    const observeOptions = {
+        childList: true,
+        subtree: true,
+        characterData: false,
+        ...(watchIdentifiers
+            ? { attributes: true, attributeFilter: [CONTENTLET_IDENTIFIER_ATTRIBUTE] }
+            : { attributes: false })
+    };
+    // Handle case where document.body might not be available yet if script is in <head>
+    const target = document.body || document.documentElement;
+    if (target) {
+        observer.observe(target, observeOptions);
+    }
+    else {
+        // Fallback: wait for DOMContentLoaded if everything is null (rare)
+        window.addEventListener('DOMContentLoaded', () => {
+            if (document.body) {
+                observer.observe(document.body, observeOptions);
+            }
+        });
+    }
+    return observer;
+};
+/**
+ * Cleans up a content tracker when the browser discards the page. A page kept in the
+ * back/forward cache keeps its tracker, which works again when the visitor goes back to it.
+ * @param cleanup - Function to call when the page is discarded
+ */
+const setupPluginCleanup = (cleanup) => {
+    if (!isBrowser$1())
+        return;
+    onPageDiscard(cleanup);
+};
+/**
+ * Gets enhanced tracking plugins based on configuration
+ * Returns content impression and click tracking plugins if enabled
+ * @param config - Analytics configuration
+ * @param impressionPlugin - Impression tracking plugin factory
+ * @param clickPlugin - Click tracking plugin factory
+ * @returns Array of enabled tracking plugins
+ */
+const getEnhancedTrackingPlugins = (config, impressionPlugin, clickPlugin) => {
+    return [
+        config.impressions && impressionPlugin(config),
+        config.clicks && clickPlugin(config)
+    ].filter(Boolean);
+};
+
+/**
+ * Where a contentlet sits in the viewport, which both content trackers measure.
+ * Pure functions without class dependencies for better testability and reusability
+ */
+/**
+ * Calculates the visibility ratio of an element in the viewport
+ * @param element - The HTML element to check
+ * @returns A number between 0 and 1 representing the visible percentage
+ */
+function calculateElementVisibilityRatio(element) {
+    const rect = element.getBoundingClientRect();
+    const viewHeight = window.innerHeight || document.documentElement.clientHeight;
+    const viewWidth = window.innerWidth || document.documentElement.clientWidth;
+    const visibleHeight = Math.min(rect.bottom, viewHeight) - Math.max(rect.top, 0);
+    const visibleWidth = Math.min(rect.right, viewWidth) - Math.max(rect.left, 0);
+    if (visibleHeight <= 0 || visibleWidth <= 0) {
+        return 0;
+    }
+    const visibleArea = visibleHeight * visibleWidth;
+    const totalArea = rect.height * rect.width;
+    return totalArea > 0 ? visibleArea / totalArea : 0;
+}
+/**
+ * Calculates the offset percentage of an element from the top of the viewport
+ * @param element - The HTML element to check
+ * @returns Percentage value (can be negative if above viewport)
+ */
+function calculateViewportOffset(element) {
+    const rect = element.getBoundingClientRect();
+    const viewportHeight = window.innerHeight || document.documentElement.clientHeight;
+    const offsetPercentage = (rect.top / viewportHeight) * 100;
+    return Math.round(offsetPercentage * 100) / 100;
+}
+/**
+ * Gets comprehensive viewport metrics for an element
+ * @param element - The HTML element to analyze
+ * @returns Object containing offset percentage and visibility ratio
+ */
+function getViewportMetrics(element) {
+    const visibilityRatio = calculateElementVisibilityRatio(element);
+    const offsetPercentage = calculateViewportOffset(element);
+    return {
+        offsetPercentage,
+        visibilityRatio
+    };
+}
+
+/**
+ * Handles click events on elements within a contentlet.
+ * The tracker passes the contentlet the click landed in: the innermost one around the clicked
+ * link or button.
+ *
+ * @param event - The mouse event
+ * @param contentletElement - The contentlet container element
+ * @param trackCallback - Callback to execute if the click is valid
+ * @param logger - Logger instance for debug messages
+ */
+const handleContentletClick = (event, contentletElement, trackCallback, logger) => {
+    const target = event.target;
+    logger.debug('Click detected on:', target);
+    // 1. Find clickable element (a or button) within the event path
+    const clickableElement = target.closest(CLICKABLE_ELEMENTS_SELECTOR);
+    if (!clickableElement) {
+        logger.debug('No <a> or <button> found in click path');
+        return;
+    }
+    // 2. Verify clickable is actually inside this contentlet (safety check)
+    if (!contentletElement.contains(clickableElement)) {
+        logger.debug('Click was outside contentlet boundary');
+        return;
+    }
+    logger.debug('Found clickable element:', clickableElement);
+    // 3. Extract and validate contentlet data
+    const contentletData = extractContentletData(contentletElement);
+    if (!contentletData.identifier) {
+        logger.debug('Contentlet has no identifier');
+        return;
+    }
+    logger.debug('Contentlet data:', contentletData);
+    // 4. Build payload with metadata
+    const viewportMetrics = getViewportMetrics(contentletElement);
+    // Extract attributes from the clickable element
+    // Filter out: analytics attributes, and already-captured properties (class, id, href)
+    // Format as 'key:value' strings (e.g., ['data-category:val', 'data-campaign:val2'])
+    const attributes = [];
+    for (const attr of clickableElement.attributes) {
+        if (!attr.name.startsWith('data-dot-analytics') &&
+            attr.name !== 'class' &&
+            attr.name !== 'id' &&
+            attr.name !== 'href') {
+            attributes.push(`${attr.name}:${attr.value}`);
+        }
+    }
+    // The contentlet's position among the page's contentlets, read when it is clicked: one
+    // query per click, and the position stays right as contentlets are added or moved
+    const domIndex = findContentlets().indexOf(contentletElement);
+    const payload = {
+        content: {
+            identifier: contentletData.identifier,
+            inode: contentletData.inode,
+            title: contentletData.title,
+            content_type: contentletData.contentType
+        },
+        position: {
+            viewport_offset_pct: viewportMetrics.offsetPercentage,
+            dom_index: domIndex
+        },
+        element: {
+            text: (clickableElement.innerText || clickableElement.textContent || '')
+                .trim()
+                .substring(0, 100), // Limit length
+            type: clickableElement.tagName.toLowerCase(),
+            id: clickableElement.id || '', // Required by backend, empty string if not present
+            class: clickableElement.className || '', // Required by backend, empty string if not present
+            href: clickableElement.getAttribute('href') || '', // Path as written in HTML (relative), empty string for buttons
+            attributes: attributes // Additional attributes (data-*, aria-*, target, etc.)
+        }
+    };
+    trackCallback(CLICK_EVENT_TYPE, payload);
+};
+
+var _DotCMSClickTracker_lastClickAt, _DotCMSClickTracker_logger, _DotCMSClickTracker_subscribers, _DotCMSClickTracker_listening, _DotCMSClickTracker_handleClick;
+/**
+ * Tracks clicks on the links and buttons inside contentlets, through one click listener on the
+ * document, in the capture phase. A click finds its contentlet with `closest`, so:
+ * - nothing scans or observes the page, and a contentlet added at any time counts;
+ * - an app's `stopPropagation()` cannot hide a click from the tracker;
+ * - a click inside nested contentlets counts once, for the innermost;
+ * - clicks on the same contentlet within 300 ms count once.
+ *
+ * @example
+ * ```typescript
+ * const tracker = new DotCMSClickTracker(config);
+ * const subscription = tracker.onClick((eventName, payload) => {
+ *   console.log('Click detected:', payload);
+ * });
+ * tracker.initialize();
+ * // Later: subscription.unsubscribe();
+ * ```
+ */
+class DotCMSClickTracker {
+    constructor(config) {
+        // When each contentlet was last clicked: a click on one never throttles another
+        _DotCMSClickTracker_lastClickAt.set(this, new WeakMap());
+        _DotCMSClickTracker_logger.set(this, void 0);
+        _DotCMSClickTracker_subscribers.set(this, new Set());
+        _DotCMSClickTracker_listening.set(this, false);
+        /** Reports a click on a link or button inside a contentlet, throttled per contentlet */
+        _DotCMSClickTracker_handleClick.set(this, (event) => {
+            const target = event.target;
+            if (!(target instanceof Element)) {
+                return;
+            }
+            const contentlet = target
+                .closest(CLICKABLE_ELEMENTS_SELECTOR)
+                ?.closest(`.${CONTENTLET_CLASS}`);
+            if (!contentlet) {
+                return;
+            }
+            handleContentletClick(event, contentlet, (eventName, payload) => {
+                const now = Date.now();
+                if (now - (__classPrivateFieldGet(this, _DotCMSClickTracker_lastClickAt, "f").get(contentlet) ?? 0) < DEFAULT_CLICK_THROTTLE_MS) {
+                    return;
+                }
+                __classPrivateFieldGet(this, _DotCMSClickTracker_lastClickAt, "f").set(contentlet, now);
+                __classPrivateFieldGet(this, _DotCMSClickTracker_subscribers, "f").forEach((callback) => callback(eventName, payload));
+                __classPrivateFieldGet(this, _DotCMSClickTracker_logger, "f").info(`Fired click event for ${payload.content.identifier}`, payload);
+            }, __classPrivateFieldGet(this, _DotCMSClickTracker_logger, "f"));
+        });
+        __classPrivateFieldSet(this, _DotCMSClickTracker_logger, createPluginLogger('Click', config), "f");
+    }
+    /**
+     * Subscribe to click events
+     * @param callback - Function called when click is detected
+     * @returns Subscription object with unsubscribe method
+     */
+    onClick(callback) {
+        __classPrivateFieldGet(this, _DotCMSClickTracker_subscribers, "f").add(callback);
+        return {
+            unsubscribe: () => {
+                __classPrivateFieldGet(this, _DotCMSClickTracker_subscribers, "f").delete(callback);
+            }
+        };
+    }
+    /** Starts listening for clicks; without a document, as on the server, it does nothing */
+    initialize() {
+        if (!isBrowser$1()) {
+            __classPrivateFieldGet(this, _DotCMSClickTracker_logger, "f").warn('No document, skipping');
+            return;
+        }
+        if (__classPrivateFieldGet(this, _DotCMSClickTracker_listening, "f")) {
+            return;
+        }
+        document.addEventListener('click', __classPrivateFieldGet(this, _DotCMSClickTracker_handleClick, "f"), true);
+        __classPrivateFieldSet(this, _DotCMSClickTracker_listening, true, "f");
+        __classPrivateFieldGet(this, _DotCMSClickTracker_logger, "f").info('Plugin initialized');
+    }
+    /**
+     * Stops listening for clicks. Should be called when the plugin is disabled or the page is
+     * discarded.
+     */
+    cleanup() {
+        if (__classPrivateFieldGet(this, _DotCMSClickTracker_listening, "f")) {
+            document.removeEventListener('click', __classPrivateFieldGet(this, _DotCMSClickTracker_handleClick, "f"), true);
+            __classPrivateFieldSet(this, _DotCMSClickTracker_listening, false, "f");
+        }
+        __classPrivateFieldGet(this, _DotCMSClickTracker_logger, "f").info('Click tracking cleaned up');
+    }
+}
+_DotCMSClickTracker_lastClickAt = new WeakMap(), _DotCMSClickTracker_logger = new WeakMap(), _DotCMSClickTracker_subscribers = new WeakMap(), _DotCMSClickTracker_listening = new WeakMap(), _DotCMSClickTracker_handleClick = new WeakMap();
+
+/**
+ * Clicks plugin of the events pipeline.
+ * Handles automatic tracking of clicks on content elements.
+ *
+ * This plugin initializes the click tracker which:
+ * - Listens for clicks once, on the document, in the capture phase
+ * - Reports clicks on <a> or <button> elements inside a contentlet, the innermost one
+ * - Extracts contentlet data, its position when clicked, and element metadata
+ * - Throttles clicks per contentlet to prevent duplicates
+ * - Fires 'content_click' events via subscription callback
+ *
+ * Note: This plugin is only registered if config.clicks is enabled.
+ * See getEnhancedTrackingPlugins() for conditional loading logic.
+ *
+ * @param {PipelineConfig} config - Configuration with clicks settings
+ * @returns {Object} Plugin object with lifecycle methods
+ */
+const clicksPlugin = (config) => {
+    let clickTracker = null;
+    let subscription = null;
+    const logger = createPluginLogger('Click', config);
+    return {
+        name: 'dot-events-clicks',
+        /**
+         * Initialize click tracking
+         * Called when Analytics.js initializes the plugin with instance context
+         * @param instance - Analytics.js instance with track method
+         */
+        initialize: ({ instance }) => {
+            // Create and initialize tracker
+            clickTracker = new DotCMSClickTracker(config);
+            // Subscribe to click events
+            subscription = clickTracker.onClick((eventName, payload) => {
+                instance.track(eventName, payload);
+            });
+            // Start tracking
+            clickTracker.initialize();
+            logger.info('Click tracking plugin initialized');
+            return Promise.resolve();
+        },
+        /**
+         * Setup cleanup handlers when plugin is loaded
+         * Called after Analytics.js completes plugin loading
+         */
+        loaded: () => {
+            if (isBrowser$1() && clickTracker) {
+                const cleanup = () => {
+                    if (subscription) {
+                        subscription.unsubscribe();
+                        subscription = null;
+                    }
+                    if (clickTracker) {
+                        clickTracker.cleanup();
+                        clickTracker = null;
+                        logger.info('Click tracking cleaned up on page unload');
+                    }
+                };
+                // Cleanup on page unload
+                setupPluginCleanup(cleanup);
+            }
+            return true;
+        }
+    };
+};
+
+const MARK_SELECTOR = `[${EXPERIMENT_ATTRIBUTE}]`;
+const revealedRules = new Set();
+// Where the browser has adopted style sheets, reveals go to one: a change through the CSSOM,
+// which no Content-Security-Policy blocks, unlike a style element the script creates.
+let revealSheet;
+/**
+ * Tells whether an element is on screen as far as React is concerned: not inside a route that
+ * Activity keeps in the page with `display: none`, nor inside the hidden container where a
+ * Suspense boundary's content waits while it streams in.
+ *
+ * @param element - The element
+ * @returns False when an ancestor keeps it out of view
+ */
+const isRendered = (element) => {
+    for (let node = element; node; node = node.parentElement) {
+        if (node.hidden || node.style.display === 'none') {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Reads the experiments the current page renders, from their marks: each experiment and
+ * rendered variant once, in document order.
+ *
+ * @returns The experiments and the variants the server rendered
+ */
+const readPageExperiments = () => {
+    const marks = new Map();
+    document.querySelectorAll(MARK_SELECTOR).forEach((element) => {
+        const experimentId = element.getAttribute(EXPERIMENT_ATTRIBUTE);
+        if (!experimentId || !isRendered(element)) {
+            return;
+        }
+        const variant = element.getAttribute(VARIANT_ATTRIBUTE) || DEFAULT_VARIANT;
+        marks.set(`${experimentId}\n${variant}`, { experimentId, variant });
+    });
+    return Array.from(marks.values());
+};
+/**
+ * Calls back when marks are inserted or rewritten, so the engine decides content that arrives
+ * after its first decision: Suspense content that streams in, or a route that changes only its
+ * query and keeps its elements.
+ *
+ * @param changed - Called once per batch of DOM changes that touches a mark
+ * @returns Stops observing
+ */
+const observeMarks = (changed) => {
+    const touchesMark = (record) => record.type === 'attributes' ||
+        Array.from(record.addedNodes).some((node) => node instanceof Element &&
+            (node.matches(MARK_SELECTOR) || !!node.querySelector(MARK_SELECTOR)));
+    const observer = new MutationObserver((records) => {
+        if (records.some(touchesMark)) {
+            changed();
+        }
+    });
+    observer.observe(document.documentElement, {
+        childList: true,
+        subtree: true,
+        attributeFilter: [EXPERIMENT_ATTRIBUTE, VARIANT_ATTRIBUTE]
+    });
+    return () => observer.disconnect();
+};
+/**
+ * Adds a reveal rule: to the adopted style sheet where the browser has them, or else to a
+ * style element in the head.
+ *
+ * @param rule - The rule
+ */
+const addRevealRule = (rule) => {
+    if ('adoptedStyleSheets' in document) {
+        try {
+            revealSheet ?? (revealSheet = new CSSStyleSheet());
+            if (!document.adoptedStyleSheets.includes(revealSheet)) {
+                document.adoptedStyleSheets = [...document.adoptedStyleSheets, revealSheet];
+            }
+            revealSheet.insertRule(rule, revealSheet.cssRules.length);
+            return;
+        }
+        catch {
+            // A style element instead
+        }
+    }
+    let style = document.getElementById(REVEAL_STYLE_ID);
+    if (!style) {
+        style = document.createElement('style');
+        style.id = REVEAL_STYLE_ID;
+        document.head.appendChild(style);
+    }
+    style.appendChild(document.createTextNode(rule));
+};
+/**
+ * Shows rows the renderer hid. With an id and a variant, only that experiment's rows rendered
+ * with that variant, so a route kept in the page with another render stays hidden; without an
+ * id, all of them (engine off, inside UVE).
+ *
+ * The rule beats the renderer's hiding rule through `:root` and `!important`, whatever the
+ * order of the two in the document.
+ *
+ * @param experimentId - The experiment whose rows to show
+ * @param variant - The variant they were rendered with
+ */
+const revealRows = (experimentId, variant) => {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    const selector = experimentId
+        ? `[${EXPERIMENT_ATTRIBUTE}="${CSS.escape(experimentId)}"]` +
+            (variant ? `[${VARIANT_ATTRIBUTE}="${CSS.escape(variant)}"]` : '')
+        : MARK_SELECTOR;
+    const rule = `:root ${selector}{visibility:visible !important;animation:none !important}`;
+    if (revealedRules.has(rule)) {
+        return;
+    }
+    revealedRules.add(rule);
+    addRevealRule(rule);
+    // The rows show through a style rule, which no tracker's DOM observer notices, and the
+    // impression tracker skipped them while they were hidden.
+    window.dispatchEvent(new CustomEvent(CONTENTLET_RESCAN_EVENT));
+};
+/** The style element that hides the contentlet wrappers while a new visitor is decided. */
+const CONTENTLET_HIDING_STYLE_ID = 'dotcms-experiment-contentlets';
+/**
+ * Hides the contentlet wrappers dotCMS prints on the pages it renders: they hold what a variant
+ * changes. Like the markup's rule, it shows them on its own after `DECISION_TIMEOUT_MS`.
+ */
+const hideContentlets = () => {
+    if (document.getElementById(CONTENTLET_HIDING_STYLE_ID)) {
+        return;
+    }
+    const style = document.createElement('style');
+    style.id = CONTENTLET_HIDING_STYLE_ID;
+    style.textContent =
+        `.${CONTENTLET_CLASS}{visibility:hidden;animation:dotcms-experiment-timeout 0s linear ${DECISION_TIMEOUT_MS / 1000}s forwards}` +
+            '@keyframes dotcms-experiment-timeout{to{visibility:visible}}';
+    document.head.appendChild(style);
+};
+/**
+ * Shows the contentlet wrappers `hideContentlets` hid, and asks the impression tracker to scan
+ * again for them.
+ */
+const revealContentlets = () => {
+    const style = document.getElementById(CONTENTLET_HIDING_STYLE_ID);
+    if (!style) {
+        return;
+    }
+    style.remove();
+    window.dispatchEvent(new CustomEvent(CONTENTLET_RESCAN_EVENT));
+};
+/**
+ * The variant a page dotCMS rendered shows: the one its contentlet wrappers carry in
+ * `data-dot-variant`, or, when the variant changes none of them (or the wrappers are not
+ * parsed yet), the one its URL asks for. dotCMS renders the variant `variantName` names.
+ *
+ * @param href - The page's URL
+ * @returns The rendered variant
+ */
+const readRenderedVariant = (href) => {
+    const wrapped = Array.from(document.querySelectorAll(`.${CONTENTLET_CLASS}[${VARIANT_ATTRIBUTE}]`))
+        .map((wrapper) => wrapper.getAttribute(VARIANT_ATTRIBUTE))
+        .find((variant) => !!variant && variant !== DEFAULT_VARIANT);
+    return wrapped ?? new URL(href).searchParams.get(VARIANT_QUERY_PARAM) ?? DEFAULT_VARIANT;
+};
+/**
+ * Holds the page's new `fetch` calls, except `keepalive` ones (an analytics flush), for
+ * `QUIET_MS`. A page being replaced runs until the variant's document arrives, and a hydrated
+ * app goes on prefetching its links; held, they do not compete with the variant's server render.
+ * A held call never settles, and after `QUIET_MS` only new calls go out.
+ */
+const holdRequests = () => {
+    const send = window.fetch;
+    window.fetch = (input, init) => init?.keepalive ? send.call(window, input, init) : new Promise(() => undefined);
+    setTimeout(() => {
+        window.fetch = send;
+    }, QUIET_MS);
+};
+/**
+ * Replaces the page with a variant's URL: stops its loading, navigates, and holds its new
+ * requests, as the boot script does when it decides from storage.
+ *
+ * @param url - The variant's URL
+ */
+const leavePageFor = (url) => {
+    window.stop();
+    window.location.replace(url);
+    holdRequests();
+};
+
+const asStringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+const toEntity = (raw) => {
+    const entity = (raw ?? {});
+    return {
+        experiments: Array.isArray(entity['experiments'])
+            ? entity['experiments']
+            : [],
+        includedExperimentIds: asStringArray(entity['includedExperimentIds']),
+        excludedExperimentIds: asStringArray(entity['excludedExperimentIds']),
+        excludedExperimentIdsEnded: asStringArray(entity['excludedExperimentIdsEnded'])
+    };
+};
+/**
+ * Asks dotCMS which running experiments the visitor is in.
+ *
+ * @param dotcmsUrl - The dotCMS origin, without a trailing slash
+ * @param exclude - Experiments already evaluated, so the server skips them
+ * @returns `ok` with the entity, `disabled` on a 403 (Experiments off), or `failed`
+ */
+const fetchIsUserIncluded = async (dotcmsUrl, exclude) => {
+    const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+    const timer = setTimeout(() => controller?.abort(), IS_USER_INCLUDED_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(`${dotcmsUrl}${IS_USER_INCLUDED_PATH}`, {
+            method: 'POST',
+            headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+            body: JSON.stringify({ exclude }),
+            signal: controller?.signal ?? null
+        });
+        if (response.status === 403) {
+            return { status: 'disabled' };
+        }
+        if (!response.ok) {
+            return { status: 'failed', httpStatus: response.status };
+        }
+        const json = (await response.json());
+        return { status: 'ok', entity: toEntity(json?.entity) };
+    }
+    catch {
+        return { status: 'failed' };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+
+const storageOf = (kind) => {
+    try {
+        return kind === 'local' ? window.localStorage : window.sessionStorage;
+    }
+    catch {
+        return null;
+    }
+};
+const read = (kind, key) => {
+    try {
+        const raw = storageOf(kind)?.getItem(key);
+        return raw ? JSON.parse(raw) : null;
+    }
+    catch {
+        return null;
+    }
+};
+const write = (kind, key, value) => {
+    try {
+        storageOf(kind)?.setItem(key, JSON.stringify(value));
+    }
+    catch {
+        // Storage can be full or blocked; the engine keeps working in memory.
+    }
+};
+/**
+ * Loads the stored assignments, without the ones whose look-back window has passed.
+ *
+ * @returns The assignments, or null when there are none
+ */
+const loadAssignments = () => {
+    const stored = read('local', STORAGE_KEYS.assignments);
+    if (!stored || !Array.isArray(stored.experiments)) {
+        return null;
+    }
+    const now = Date.now();
+    return {
+        fetchedAt: stored.fetchedAt ?? 0,
+        experiments: stored.experiments.filter((experiment) => experiment.expiresAt > now),
+        evaluatedIds: Array.isArray(stored.evaluatedIds) ? stored.evaluatedIds : []
+    };
+};
+/**
+ * Merges an `isUserIncluded` answer into the stored assignments and saves them.
+ * Ended experiments drop out; every evaluated experiment is remembered, so a visitor
+ * left out by traffic allocation is not evaluated again.
+ *
+ * @param entity - The response entity
+ * @param previous - What was stored before the request
+ * @returns The assignments now stored
+ */
+const saveAssignments = (entity, previous) => {
+    const now = Date.now();
+    const ended = new Set(entity.excludedExperimentIdsEnded);
+    const byId = new Map((previous?.experiments ?? [])
+        .filter((experiment) => !ended.has(experiment.id) && experiment.expiresAt > now)
+        .map((experiment) => [experiment.id, experiment]));
+    entity.experiments.forEach((experiment) => {
+        byId.set(experiment.id, {
+            ...experiment,
+            expiresAt: now + (experiment.lookBackWindow?.expireMillis || ONE_DAY_MS)
+        });
+    });
+    const evaluated = new Set([
+        ...(previous?.evaluatedIds ?? []),
+        ...entity.includedExperimentIds,
+        ...entity.excludedExperimentIds,
+        ...entity.experiments.map((experiment) => experiment.id)
+    ]);
+    ended.forEach((id) => evaluated.delete(id));
+    const next = {
+        fetchedAt: now,
+        experiments: [...byId.values()],
+        evaluatedIds: [...evaluated]
+    };
+    write('local', STORAGE_KEYS.assignments, next);
+    return next;
+};
+/**
+ * Tells whether this tab should ask `isUserIncluded`: once per tab session, when nothing
+ * is stored, or when the stored answer is older than a day.
+ *
+ * @param stored - The current assignments
+ * @returns True when a request is due
+ */
+const isCheckDue = (stored) => {
+    const checkedThisTab = read('session', STORAGE_KEYS.checkedThisTab) === true;
+    return !checkedThisTab || !stored || Date.now() - stored.fetchedAt > ONE_DAY_MS;
+};
+/** Records that this tab asked `isUserIncluded`. */
+const markCheckedThisTab = () => write('session', STORAGE_KEYS.checkedThisTab, true);
+/** Tells whether the site answered 403 in the last day. */
+const isDisabledForNow = () => (read('local', STORAGE_KEYS.disabledUntil) ?? 0) > Date.now();
+/** Remembers a 403 for a day, so sites without Experiments stop paying for the call. */
+const disableForADay = () => write('local', STORAGE_KEYS.disabledUntil, Date.now() + ONE_DAY_MS);
+/**
+ * Returns the experiments the visitor reached in this analytics session. A new session
+ * starts empty.
+ *
+ * @param sessionId - The analytics session id
+ * @returns The cumulative `context.experiments`
+ */
+const getSessionExperiments = (sessionId) => {
+    const stored = read('session', STORAGE_KEYS.sessionExperiments);
+    return stored && stored.sessionId === sessionId ? stored.experiments : [];
+};
+/**
+ * Adds an experiment to the session's `context.experiments`, replacing an older entry
+ * for the same experiment.
+ *
+ * @param sessionId - The analytics session id
+ * @param entry - The experiment the visitor reached
+ */
+const joinSessionExperiment = (sessionId, entry) => {
+    const others = getSessionExperiments(sessionId).filter((experiment) => experiment.id !== entry.id);
+    write('session', STORAGE_KEYS.sessionExperiments, {
+        sessionId,
+        experiments: [...others, entry]
+    });
+};
+/**
+ * Removes ended experiments from the session's `context.experiments`.
+ *
+ * @param endedIds - Ids `isUserIncluded` reported as ended
+ */
+const leaveEndedExperiments = (endedIds) => {
+    if (endedIds.length === 0) {
+        return;
+    }
+    const stored = read('session', STORAGE_KEYS.sessionExperiments);
+    if (!stored) {
+        return;
+    }
+    const ended = new Set(endedIds);
+    write('session', STORAGE_KEYS.sessionExperiments, {
+        sessionId: stored.sessionId,
+        experiments: stored.experiments.filter((experiment) => !ended.has(experiment.id))
+    });
+};
+
+/**
+ * Calls back on every navigation inside the page, an SPA route change, that changes the path
+ * or the query. It listens to the browser's Navigation API, which reports every History change,
+ * back and forward included, without patching `history`. Where the browser has none, it falls
+ * back to `@analytics/router-utils`, which reports path changes only.
+ *
+ * @param navigated - Called once the URL has changed
+ * @returns Stops the calls. router-utils has no way to detach, so in the fallback its listener
+ * stays and only stops calling back
+ */
+const onNavigation = (navigated) => {
+    const navigation = window.navigation;
+    if (!navigation) {
+        let active = true;
+        onRouteChange(() => {
+            if (active) {
+                navigated();
+            }
+        });
+        return () => {
+            active = false;
+        };
+    }
+    const pageOf = () => `${window.location.pathname}${window.location.search}`;
+    let current = pageOf();
+    const listener = () => {
+        const next = pageOf();
+        // Routers also save their own state on the URL they are on
+        if (next !== current) {
+            current = next;
+            navigated();
+        }
+    };
+    navigation.addEventListener('currententrychange', listener);
+    return () => navigation.removeEventListener('currententrychange', listener);
+};
+/**
+ * Calls back each time the browser restores the page from its back/forward cache (`pageshow`
+ * with `persisted`). The page comes back as the visitor left it, its scripts still running, so
+ * nothing that runs on a load runs again, and onNavigation reports nothing: the visitor is
+ * back on the same page, not on another route.
+ *
+ * @param restored - Called on each restore
+ * @returns Stops the calls
+ */
+const onPageRestore = (restored) => {
+    const listener = (event) => {
+        if (event.persisted) {
+            restored();
+        }
+    };
+    window.addEventListener('pageshow', listener);
+    return () => window.removeEventListener('pageshow', listener);
+};
+
+/**
+ * Tells whether a URL rule from `isUserIncluded` matches a URL.
+ *
+ * @param pattern - The rule, a regular expression in a string
+ * @param href - The URL
+ * @returns False when the rule is missing or is not a valid expression
+ */
+const matchesRule = (pattern, href) => {
+    if (!pattern) {
+        return false;
+    }
+    // dotCMS writes the rules for a lowercase address and its own experiments script tests
+    // them that way: the part before the query in lowercase, the query as it is
+    const query = href.indexOf('?');
+    const url = query < 0 ? href.toLowerCase() : href.slice(0, query).toLowerCase() + href.slice(query);
+    try {
+        return new RegExp(pattern).test(url);
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * The warning for a route that renders another variant than the one its URL asks for.
+ *
+ * @param mark - The experiment and the variant the server rendered
+ * @param variant - The variant the URL asks for
+ * @returns The message
+ */
+const routeIgnoresVariantMessage = (mark, variant) => `this URL asks for ${variant} of experiment ${mark.experimentId}, but the server rendered ${mark.variant}. ` +
+    'The route does not pass variantName to its page request, so the page is shown as it is and the visit is not counted in the experiment.';
+/**
+ * The page a URL shows: its path and query, which the route renders. The hash changes nothing.
+ *
+ * @param href - The URL
+ * @returns The path and the query
+ */
+const pageOf = (href) => {
+    const url = new URL(href);
+    return url.pathname + url.search;
+};
+/**
+ * The URL the page's boot script is replacing the page with, if it is.
+ *
+ * @returns The variant's URL, or undefined when the script did not redirect
+ */
+const bootRedirect = () => {
+    const state = window[BOOT_STATE_KEY];
+    return state && typeof state.redirectedTo === 'string'
+        ? state.redirectedTo
+        : undefined;
+};
+/**
+ * Creates the engine that assigns the visitor, holds and releases pageviews, redirects to
+ * the assigned variant and fills `context.experiments`.
+ *
+ * @param options - dotCMS origin, the assignment timeout and a logger
+ * @returns The engine
+ */
+const createExperimentsEngine = ({ dotcmsUrl, timeoutMs, log, warn, onError, navigate = leavePageFor, pages = 'markup' }) => {
+    let assignments = loadAssignments();
+    let disabled = isDisabledForNow();
+    let inflight = null;
+    // URLs already warned about, so a page warns once however many pageviews it sends
+    const warnedUrls = new Set();
+    // The variant's URL, when prepare replaced the page
+    let preparedRedirect;
+    // One decision per page visit and rendered experiment, shared by decide and the mark observer
+    const decisions = new Map();
+    let stopObserving;
+    // Navigations inside the page so far. A visit is the page plus this count: a visitor who
+    // leaves and comes back during a wait starts a new visit, decided and counted on its own
+    let navigations = 0;
+    // The visit whose page runs an experiment the visitor is in: only its events carry them
+    let visitInExperiment;
+    // The hiding rule shows the content after DECISION_TIMEOUT_MS on its own: a longer wait
+    // would show the original, then replace it with the variant
+    const waitMs = Math.min(timeoutMs, DECISION_TIMEOUT_MS);
+    if (timeoutMs > DECISION_TIMEOUT_MS) {
+        warn(`experiments.timeout is ${timeoutMs} ms; the page waits ${DECISION_TIMEOUT_MS} ms at most, as long as the experiment's content stays hidden`);
+    }
+    const stopCountingNavigations = pages === 'markup'
+        ? onNavigation(() => {
+            navigations += 1;
+        })
+        : undefined;
+    const findAssignment = (experimentId) => assignments?.experiments.find((experiment) => experiment.id === experimentId);
+    /**
+     * Warns when an experiment the visitor is in runs on the current URL, by its URL rule,
+     * while nothing on the page carries experiment marks: the experiment would never show.
+     */
+    const warnIfUnmarked = () => {
+        const href = window.location.href;
+        const experiment = assignments?.experiments.find((candidate) => matchesRule(candidate.regexs?.isExperimentPage, href));
+        if (!experiment || warnedUrls.has(href)) {
+            return;
+        }
+        warnedUrls.add(href);
+        warn(`experiment "${experiment.name}" (${experiment.id}) runs on this page, but nothing on it carries the experiment's marks. ` +
+            'Wrap the content the experiment varies in DotCMSExperiment (@dotcms/events/react), or print experimentMarkup (@dotcms/events/markup): ' +
+            'until then the visitor sees the original and the experiment records nothing.');
+    };
+    const check = (force = false) => {
+        if (disabled) {
+            return Promise.resolve();
+        }
+        if (inflight) {
+            return inflight;
+        }
+        if (!force && !isCheckDue(assignments)) {
+            return Promise.resolve();
+        }
+        log('asking isUserIncluded');
+        inflight = fetchIsUserIncluded(dotcmsUrl, assignments?.evaluatedIds ?? [])
+            .then((result) => {
+            if (result.status === 'disabled') {
+                disabled = true;
+                disableForADay();
+                log('isUserIncluded answered 403: experiments off for a day');
+                onError?.({
+                    code: 'EXPERIMENTS',
+                    status: 403,
+                    message: 'isUserIncluded answered 403: experiments are off for the site, for a day'
+                });
+                return;
+            }
+            if (result.status === 'failed') {
+                log('isUserIncluded failed; keeping the stored assignments');
+                onError?.({
+                    code: 'EXPERIMENTS',
+                    ...(result.httpStatus !== undefined && { status: result.httpStatus }),
+                    message: 'isUserIncluded failed: the stored assignments stay'
+                });
+                return;
+            }
+            assignments = saveAssignments(result.entity, assignments);
+            leaveEndedExperiments(result.entity.excludedExperimentIdsEnded);
+            markCheckedThisTab();
+            log('assignments', assignments.experiments.map((experiment) => `${experiment.id}: ${experiment.variant.name}`));
+        })
+            .finally(() => {
+            inflight = null;
+        });
+        return inflight;
+    };
+    /** The stored experiment whose `isExperimentPage` rule matches the current URL. */
+    const experimentOnThisPage = () => assignments?.experiments.find((experiment) => experiment.expiresAt > Date.now() &&
+        matchesRule(experiment.regexs?.isExperimentPage, window.location.href));
+    const decisionFor = (mark, href = window.location.href) => decideVariant({
+        experimentId: mark.experimentId,
+        rendered: mark.variant,
+        href,
+        stored: assignments,
+        disabled,
+        now: Date.now(),
+        param: VARIANT_QUERY_PARAM,
+        defaultVariant: DEFAULT_VARIANT
+    });
+    const waitForAnswer = () => Promise.race([
+        check(true).then(() => 'answered'),
+        new Promise((resolve) => setTimeout(() => resolve('timeout'), waitMs))
+    ]);
+    /**
+     * The mark of a page dotCMS rendered: its experiment from the URL rule, and the variant its
+     * contentlet wrappers carry. On a first visit nothing stored has the rule yet, so it waits
+     * for `isUserIncluded`, up to the timeout, with the contentlets hidden.
+     *
+     * @returns The mark, or null when no experiment runs on the page for this visitor
+     */
+    const contentletsMark = async () => {
+        if (disabled) {
+            return null;
+        }
+        if (!assignments && (await waitForAnswer()) === 'timeout') {
+            log('the assignment timed out; showing the page without the experiment');
+            return null;
+        }
+        const experiment = experimentOnThisPage();
+        return experiment
+            ? { experimentId: experiment.id, variant: readRenderedVariant(window.location.href) }
+            : null;
+    };
+    /**
+     * Decides one experiment the page renders: shows it, or leaves for the assigned variant.
+     *
+     * @param mark - The experiment and the variant the server rendered
+     * @param href - The page's URL when its decision started
+     * @param reveal - Shows what the page hid while it waited
+     * @returns How it ended; `left` when the visitor went to another page during the wait
+     */
+    const decideMark = async (mark, href, reveal) => {
+        // The same decision the boot script makes while the HTML is parsed
+        let decision = decisionFor(mark, href);
+        const visit = navigations;
+        if (decision.kind === 'unknown') {
+            log(`holding the pageview for ${mark.experimentId}`);
+            const outcome = await waitForAnswer();
+            // A click during the wait, even one that comes back: the next page is decided on
+            // its own, and this visit neither redirects to a variant of another URL nor counts
+            if (navigations !== visit || pageOf(window.location.href) !== pageOf(href)) {
+                log(`left ${pageOf(href)} while ${mark.experimentId} was decided`);
+                return 'left';
+            }
+            if (outcome === 'timeout') {
+                log('the assignment timed out; showing the page without the experiment');
+                reveal();
+                return 'shown';
+            }
+            decision = decisionFor(mark, href);
+        }
+        switch (decision.kind) {
+            case 'redirect':
+                log(`rendered ${mark.variant}, assigned ${decision.variant}: ${decision.url}`);
+                navigate(decision.url);
+                return 'redirected';
+            case 'assigned': {
+                const assigned = findAssignment(mark.experimentId);
+                if (assigned) {
+                    joinSessionExperiment(getSessionId(), {
+                        id: assigned.id,
+                        running_id: assigned.runningId,
+                        variant: assigned.variant.name
+                    });
+                    visitInExperiment = visit;
+                }
+                log(`showing ${decision.variant} of ${mark.experimentId}`);
+                break;
+            }
+            case 'ignored':
+                warn(routeIgnoresVariantMessage(mark, decision.variant));
+                break;
+            default:
+                log(`not in ${mark.experimentId}; showing the page`);
+        }
+        reveal();
+        return 'shown';
+    };
+    /**
+     * Decides a marked experiment once per page, whoever asks first: decide, for the pageview,
+     * or the observer, for marks that arrive later.
+     *
+     * @param mark - The experiment and the variant the server rendered
+     * @param href - The page's URL
+     * @returns How the decision ended
+     */
+    const decideOnce = (mark, href) => {
+        const key = `${navigations}\n${pageOf(href)}\n${mark.experimentId}\n${mark.variant}`;
+        let outcome = decisions.get(key);
+        if (!outcome) {
+            outcome = decideMark(mark, href, () => revealRows(mark.experimentId, mark.variant));
+            decisions.set(key, outcome);
+            // A visit left mid-decision is never asked for again: its key has an older count
+            void outcome.then((result) => {
+                if (result === 'left') {
+                    decisions.delete(key);
+                }
+            });
+        }
+        return outcome;
+    };
+    /**
+     * Decides every experiment the page renders, in document order; the first redirect wins.
+     *
+     * @param marks - The page's marks
+     * @param href - The page's URL
+     * @returns The page's decision
+     */
+    const decideMarks = async (marks, href) => {
+        for (const mark of marks) {
+            const outcome = await decideOnce(mark, href);
+            if (outcome === 'redirected') {
+                return { redirected: true };
+            }
+            if (outcome === 'left') {
+                return { redirected: false, left: true };
+            }
+        }
+        return { redirected: false };
+    };
+    /**
+     * Waits for the marks of a page whose experiment runs on its URL, by the stored rule, while
+     * the page has none yet: content behind Suspense streams in after the page loads, and after
+     * a route change.
+     *
+     * @returns The marks, or none after the timeout
+     */
+    const waitForMarks = () => new Promise((resolve) => {
+        let stop = () => undefined;
+        const timer = setTimeout(() => {
+            stop();
+            resolve([]);
+        }, waitMs);
+        stop = observeMarks(() => {
+            const marks = readPageExperiments();
+            if (marks.length) {
+                clearTimeout(timer);
+                stop();
+                resolve(marks);
+            }
+        });
+    });
+    /**
+     * From the first decision on, decides the marks that arrive later, as soon as they are in
+     * the page: streamed content, or a route rendered after its pageview.
+     */
+    const watchLateMarks = () => {
+        stopObserving ?? (stopObserving = observeMarks(() => {
+            const href = window.location.href;
+            readPageExperiments().forEach((mark) => void decideOnce(mark, href));
+        }));
+    };
+    return {
+        prepare: () => {
+            if (pages !== 'contentlets' || disabled) {
+                return false;
+            }
+            const experiment = experimentOnThisPage();
+            if (!experiment) {
+                // A first visit: nothing stored says whether this page runs an experiment
+                if (!assignments) {
+                    hideContentlets();
+                }
+                return false;
+            }
+            // The body is not parsed yet: the URL says which variant dotCMS renders
+            const decision = decisionFor({
+                experimentId: experiment.id,
+                variant: readRenderedVariant(window.location.href)
+            });
+            if (decision.kind !== 'redirect') {
+                return false;
+            }
+            log(`replacing the page with ${decision.variant} of ${experiment.id}: ${decision.url}`);
+            preparedRedirect = decision.url;
+            navigate(decision.url);
+            return true;
+        },
+        start: () => {
+            void check();
+        },
+        decide: async () => {
+            // The boot script decided from storage while the HTML was parsed
+            const redirectedTo = preparedRedirect ?? bootRedirect();
+            if (redirectedTo) {
+                log(`the page script is replacing the page: ${redirectedTo}`);
+                return { redirected: true };
+            }
+            const href = window.location.href;
+            const visit = navigations;
+            let marks = readPageExperiments();
+            if (pages === 'markup') {
+                watchLateMarks();
+                // The page runs an experiment by its URL rule, but its marks are not in yet
+                if (!marks.length && !disabled && experimentOnThisPage()) {
+                    marks = await waitForMarks();
+                    if (navigations !== visit || pageOf(window.location.href) !== pageOf(href)) {
+                        return { redirected: false, left: true };
+                    }
+                    if (!marks.length) {
+                        warnIfUnmarked();
+                    }
+                }
+                return decideMarks(marks, href);
+            }
+            // A traditional page that prints the experiment markup is decided by it
+            if (marks.length) {
+                return decideMarks(marks, href);
+            }
+            const mark = await contentletsMark();
+            if (!mark) {
+                revealContentlets();
+                return { redirected: false };
+            }
+            const outcome = await decideMark(mark, href, revealContentlets);
+            if (outcome === 'left') {
+                return { redirected: false, left: true };
+            }
+            return { redirected: outcome === 'redirected' };
+        },
+        contextExperiments: (sessionId) => visitInExperiment === navigations ? getSessionExperiments(sessionId) : [],
+        stop: () => {
+            stopObserving?.();
+            stopObserving = undefined;
+            stopCountingNavigations?.();
+        }
+    };
+};
+
+/**
+ * Analytics.js plugin that adds the session's `context.experiments` to every event sent from
+ * a page that runs an experiment the visitor is in. The engine's `isUserIncluded` check starts
+ * in `init`, before Analytics.js loads.
+ *
+ * It must come right after the identity plugin, which creates `context`.
+ *
+ * @param engine - The experiments engine
+ * @returns The plugin
+ */
+const experimentsPlugin = (engine) => {
+    const withExperiments = ({ payload }) => {
+        const context = payload?.context;
+        if (!context?.session_id) {
+            return payload;
+        }
+        const experiments = engine.contextExperiments(context.session_id);
+        if (experiments.length === 0) {
+            return payload;
+        }
+        return { ...payload, context: { ...context, experiments } };
+    };
+    return {
+        name: 'dot-events-experiments',
+        pageStart: withExperiments,
+        trackStart: withExperiments,
+        loaded: () => true
+    };
+};
+
+/*
+ * Constants of the impression tracker.
+ */
+/**
+ * Impression tracking configuration constants
+ */
+/**
+ * Default minimum percentage of element that must be visible (0.0 to 1.0)
+ */
+const DEFAULT_IMPRESSION_VISIBILITY_THRESHOLD = 0.5;
+/**
+ * Default minimum time in milliseconds element must be visible
+ */
+const DEFAULT_IMPRESSION_DWELL_MS = 750;
+/**
+ * Default maximum number of elements to track (performance limit)
+ */
+const DEFAULT_IMPRESSION_MAX_NODES = 100;
+/**
+ * Default impression tracking configuration
+ */
+const DEFAULT_IMPRESSION_CONFIG = {
+    visibilityThreshold: DEFAULT_IMPRESSION_VISIBILITY_THRESHOLD,
+    dwellMs: DEFAULT_IMPRESSION_DWELL_MS,
+    maxNodes: DEFAULT_IMPRESSION_MAX_NODES
+};
+/**
+ * Event type for content impressions
+ * Must match DotCMSPredefinedEventType.CONTENT_IMPRESSION
+ */
+const IMPRESSION_EVENT_TYPE = 'content_impression';
+
+/**
+ * Utility functions for impression tracking
+ */
+/**
+ * Checks if an element meets a specific visibility threshold
+ * @param element - The HTML element to check
+ * @param threshold - The required visibility ratio (0.0 to 1.0)
+ * @returns True if the element meets or exceeds the threshold
+ */
+function isElementMeetingVisibilityThreshold(element, threshold) {
+    const visibilityRatio = calculateElementVisibilityRatio(element);
+    return visibilityRatio >= threshold;
+}
+
+var _DotCMSImpressionTracker_observer, _DotCMSImpressionTracker_mutationObserver, _DotCMSImpressionTracker_elementImpressionStates, _DotCMSImpressionTracker_sessionTrackedImpressions, _DotCMSImpressionTracker_impressionConfig, _DotCMSImpressionTracker_stopWatchingNavigations, _DotCMSImpressionTracker_stopWatchingRestores, _DotCMSImpressionTracker_subscribers, _DotCMSImpressionTracker_logger, _DotCMSImpressionTracker_handleRescan;
+/**
+ * Tracks content impressions using IntersectionObserver and dwell time.
+ * Emits events through subscriptions when impressions are detected.
+ */
+class DotCMSImpressionTracker {
+    constructor(config) {
+        _DotCMSImpressionTracker_observer.set(this, null);
+        _DotCMSImpressionTracker_mutationObserver.set(this, null);
+        _DotCMSImpressionTracker_elementImpressionStates.set(this, new Map());
+        _DotCMSImpressionTracker_sessionTrackedImpressions.set(this, new Set());
+        _DotCMSImpressionTracker_impressionConfig.set(this, void 0);
+        _DotCMSImpressionTracker_stopWatchingNavigations.set(this, null);
+        _DotCMSImpressionTracker_stopWatchingRestores.set(this, null);
+        _DotCMSImpressionTracker_subscribers.set(this, new Set());
+        _DotCMSImpressionTracker_logger.set(this, void 0);
+        /** Scans again on CONTENTLET_RESCAN_EVENT, sent when hidden contentlets are shown */
+        _DotCMSImpressionTracker_handleRescan.set(this, () => {
+            __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").debug('Rescan requested');
+            this.findAndObserveContentletElements();
+        });
+        __classPrivateFieldSet(this, _DotCMSImpressionTracker_logger, createPluginLogger('Impression', config), "f");
+        __classPrivateFieldSet(this, _DotCMSImpressionTracker_impressionConfig, this.resolveImpressionConfig(config.impressions), "f");
+    }
+    /**
+     * Subscribe to impression events
+     * @param callback - Function called when impression is detected
+     * @returns Subscription object with unsubscribe method
+     */
+    onImpression(callback) {
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_subscribers, "f").add(callback);
+        return {
+            unsubscribe: () => {
+                __classPrivateFieldGet(this, _DotCMSImpressionTracker_subscribers, "f").delete(callback);
+            }
+        };
+    }
+    /** Notifies all subscribers of an impression */
+    notifySubscribers(eventName, payload) {
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_subscribers, "f").forEach((callback) => {
+            try {
+                callback(eventName, payload);
+            }
+            catch (error) {
+                __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").error('Error in impression subscriber:', error);
+            }
+        });
+    }
+    /**
+     * Merges user config with defaults. IntersectionObserver throws on a visibility threshold
+     * outside 0 to 1, so one outside that range is clamped to it, with a warning
+     */
+    resolveImpressionConfig(userConfig) {
+        // If boolean/undefined, use defaults
+        if (typeof userConfig !== 'object' || userConfig === null) {
+            return { ...DEFAULT_IMPRESSION_CONFIG };
+        }
+        // Merge user config with defaults
+        const merged = { ...DEFAULT_IMPRESSION_CONFIG, ...userConfig };
+        const requested = merged.visibilityThreshold;
+        const visibilityThreshold = Number.isFinite(requested)
+            ? Math.min(1, Math.max(0, requested))
+            : DEFAULT_IMPRESSION_CONFIG.visibilityThreshold;
+        if (visibilityThreshold !== requested) {
+            __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").warn(`visibilityThreshold must be between 0 and 1, got ${requested}: using ${visibilityThreshold}`);
+        }
+        return { ...merged, visibilityThreshold };
+    }
+    /** Initializes tracking: sets up observers, finds contentlets, handles visibility/navigation */
+    initialize() {
+        // Early return if SSR
+        if (!isBrowser$1()) {
+            return;
+        }
+        // Setup IntersectionObserver
+        this.initializeIntersectionObserver();
+        // Wait for DOM to be ready before scanning
+        // The delay allows React/Next.js to finish initial rendering
+        // before searching for contentlet elements
+        if (typeof window !== 'undefined') {
+            setTimeout(() => {
+                __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").debug('Running initial scan after timeout...');
+                // Find and observe contentlet elements
+                this.findAndObserveContentletElements();
+            }, INITIAL_SCAN_DELAY_MS);
+        }
+        // Setup mutation observer for dynamic content
+        this.initializeDynamicContentDetector();
+        // Scan again when hidden contentlets are shown without a DOM mutation
+        window.addEventListener(CONTENTLET_RESCAN_EVENT, __classPrivateFieldGet(this, _DotCMSImpressionTracker_handleRescan, "f"));
+        // Listen for visibility changes to pause/resume tracking
+        this.initializePageVisibilityHandler();
+        // Listen for page navigation to reset tracking
+        this.initializePageNavigationHandler();
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").info('Impression tracking initialized with config:', __classPrivateFieldGet(this, _DotCMSImpressionTracker_impressionConfig, "f"));
+    }
+    /** Sets up IntersectionObserver with configured visibility threshold */
+    initializeIntersectionObserver() {
+        const options = {
+            root: null, // Use viewport as root
+            rootMargin: '0px',
+            threshold: __classPrivateFieldGet(this, _DotCMSImpressionTracker_impressionConfig, "f").visibilityThreshold
+        };
+        __classPrivateFieldSet(this, _DotCMSImpressionTracker_observer, new IntersectionObserver((entries) => {
+            this.processIntersectionChanges(entries);
+        }, options), "f");
+    }
+    /** Finds contentlets in DOM, validates them, and starts observing (respects maxNodes limit) */
+    findAndObserveContentletElements() {
+        if (!__classPrivateFieldGet(this, _DotCMSImpressionTracker_observer, "f"))
+            return;
+        const contentlets = findContentlets();
+        if (contentlets.length === 0) {
+            __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").warn('No contentlets found to track');
+            return;
+        }
+        // Limit to maxNodes for performance
+        const maxNodesToTrack = Math.min(contentlets.length, __classPrivateFieldGet(this, _DotCMSImpressionTracker_impressionConfig, "f").maxNodes);
+        let observedCount = 0;
+        for (let i = 0; i < maxNodesToTrack; i++) {
+            const element = contentlets[i];
+            if (!element) {
+                continue;
+            }
+            const identifier = extractContentletIdentifier(element);
+            if (identifier) {
+                // Skip elements that shouldn't be tracked
+                const skipReason = this.shouldSkipElement(element);
+                if (skipReason) {
+                    __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").debug(`Skipping element ${identifier} (${skipReason})`);
+                    continue;
+                }
+                // Only observe and initialize if this is a new element
+                if (!__classPrivateFieldGet(this, _DotCMSImpressionTracker_elementImpressionStates, "f").has(identifier)) {
+                    if (!element.dataset['dotDomIndex']) {
+                        element.dataset['dotDomIndex'] = String(i);
+                    }
+                    __classPrivateFieldGet(this, _DotCMSImpressionTracker_observer, "f").observe(element);
+                    __classPrivateFieldGet(this, _DotCMSImpressionTracker_elementImpressionStates, "f").set(identifier, {
+                        timer: null,
+                        visibleSince: null,
+                        tracked: this.hasBeenTrackedInSession(identifier),
+                        element
+                    });
+                    observedCount++;
+                }
+            }
+        }
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").info(`Observing ${observedCount} contentlets`);
+        if (contentlets.length > maxNodesToTrack) {
+            __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").warn(`${contentlets.length - maxNodesToTrack} contentlets not tracked (maxNodes limit: ${__classPrivateFieldGet(this, _DotCMSImpressionTracker_impressionConfig, "f").maxNodes})`);
+        }
+    }
+    /**
+     * Watches for contentlets added to the DOM, and for contentlets receiving their
+     * identifier, which the renderers print after hydration (throttled for performance)
+     */
+    initializeDynamicContentDetector() {
+        if (!isBrowser$1()) {
+            return;
+        }
+        __classPrivateFieldSet(this, _DotCMSImpressionTracker_mutationObserver, createContentletObserver(() => {
+            this.findAndObserveContentletElements();
+        }, CONTENTLET_OBSERVER_DEBOUNCE_MS, { identifiers: true }), "f");
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").info('MutationObserver enabled for dynamic content detection');
+    }
+    /** Cancels all timers when page is hidden (prevents false impressions) */
+    initializePageVisibilityHandler() {
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden') {
+                // Page is hidden, cancel all timers
+                __classPrivateFieldGet(this, _DotCMSImpressionTracker_elementImpressionStates, "f").forEach((state) => {
+                    if (state.timer !== null) {
+                        window.clearTimeout(state.timer);
+                        state.timer = null;
+                        state.visibleSince = null;
+                    }
+                });
+                __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").warn('Page hidden, all impression timers cancelled');
+            }
+        });
+    }
+    /**
+     * Resets tracking when the visitor goes to another page, or comes back to this one from the
+     * back/forward cache. It listens through onNavigation: the browser's Navigation API where
+     * there is one, which needs no patch of `history`
+     */
+    initializePageNavigationHandler() {
+        __classPrivateFieldSet(this, _DotCMSImpressionTracker_stopWatchingNavigations, onNavigation(() => {
+            __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").warn(`Navigation detected (${window.location.pathname}), resetting impression tracking`);
+            this.forgetPageImpressions();
+        }), "f");
+        // A restored page is seen again, and counts again, as after a load. Its DOM is the one
+        // the visitor left, so nothing else scans it: observed again from scratch, the observer
+        // reports what is in view
+        __classPrivateFieldSet(this, _DotCMSImpressionTracker_stopWatchingRestores, onPageRestore(() => {
+            __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").info('Page restored from the back/forward cache, counting impressions again');
+            this.forgetPageImpressions();
+            __classPrivateFieldGet(this, _DotCMSImpressionTracker_observer, "f")?.disconnect();
+            this.findAndObserveContentletElements();
+        }), "f");
+    }
+    /** Forgets the page's impressions, timers and elements, so the next view counts its own */
+    forgetPageImpressions() {
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_sessionTrackedImpressions, "f").clear();
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_elementImpressionStates, "f").forEach((state) => {
+            if (state.timer !== null) {
+                window.clearTimeout(state.timer);
+                state.timer = null;
+                state.visibleSince = null;
+            }
+        });
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_elementImpressionStates, "f").clear();
+    }
+    /** Handles visibility changes: starts timer on enter, cancels on exit */
+    processIntersectionChanges(entries) {
+        // Ignore if page is not visible
+        if (document.visibilityState !== 'visible') {
+            return;
+        }
+        entries.forEach((entry) => {
+            const element = entry.target;
+            const identifier = extractContentletIdentifier(element);
+            if (!identifier)
+                return;
+            if (entry.isIntersecting) {
+                // Element is visible, start tracking
+                this.startImpressionDwellTimer(identifier, element);
+            }
+            else {
+                // Element is not visible, cancel tracking
+                this.cancelImpressionDwellTimer(identifier);
+            }
+        });
+    }
+    /** Starts dwell timer; fires impression if element still visible when timer expires */
+    startImpressionDwellTimer(identifier, element) {
+        const state = __classPrivateFieldGet(this, _DotCMSImpressionTracker_elementImpressionStates, "f").get(identifier);
+        if (!state)
+            return;
+        // Already tracked, skip
+        if (state.tracked || this.hasBeenTrackedInSession(identifier)) {
+            return;
+        }
+        // Timer already running, skip
+        if (state.timer !== null) {
+            return;
+        }
+        // Page not visible, skip
+        if (document.visibilityState !== 'visible') {
+            return;
+        }
+        // Start timer
+        state.visibleSince = Date.now();
+        state.element = element;
+        state.timer = window.setTimeout(() => {
+            // Verify element is still visible before firing (post-dwell check)
+            if (this.isElementStillVisible(element)) {
+                this.trackAndSendImpression(identifier, element);
+            }
+            else {
+                __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").warn(`Dwell timer expired for ${identifier} but element no longer visible, skipping impression`);
+                // Clear state since we're not tracking
+                state.timer = null;
+                state.visibleSince = null;
+            }
+        }, __classPrivateFieldGet(this, _DotCMSImpressionTracker_impressionConfig, "f").dwellMs);
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").debug(`Started dwell timer for ${identifier} (${__classPrivateFieldGet(this, _DotCMSImpressionTracker_impressionConfig, "f").dwellMs}ms)`);
+    }
+    /** Cancels active dwell timer (element left viewport before dwell time) */
+    cancelImpressionDwellTimer(identifier) {
+        const state = __classPrivateFieldGet(this, _DotCMSImpressionTracker_elementImpressionStates, "f").get(identifier);
+        if (!state || state.timer === null)
+            return;
+        window.clearTimeout(state.timer);
+        state.timer = null;
+        state.visibleSince = null;
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").debug(`Cancelled dwell timer for ${identifier}`);
+    }
+    /** Fires impression event with content & position data (page data added by enricher plugin) */
+    trackAndSendImpression(identifier, element) {
+        const state = __classPrivateFieldGet(this, _DotCMSImpressionTracker_elementImpressionStates, "f").get(identifier);
+        if (!state)
+            return;
+        // Calculate actual dwell time
+        const dwellTime = state.visibleSince ? Date.now() - state.visibleSince : 0;
+        // Extract contentlet data using utility
+        const contentletData = extractContentletData(element);
+        // Calculate viewport metrics using utility
+        const viewportMetrics = getViewportMetrics(element);
+        // Read cached DOM index instead of expensive query
+        // Falls back to -1 if not cached (should never happen in normal flow)
+        const domIndex = parseInt(element.dataset['dotDomIndex'] || '-1', 10);
+        // Build impression payload (enricher plugin adds page data automatically)
+        const impressionPayload = {
+            content: {
+                identifier: contentletData.identifier,
+                inode: contentletData.inode,
+                title: contentletData.title,
+                content_type: contentletData.contentType
+            },
+            position: {
+                viewport_offset_pct: viewportMetrics.offsetPercentage,
+                dom_index: domIndex
+            }
+        };
+        // Notify subscribers (plugin will call analytics.track)
+        this.notifySubscribers(IMPRESSION_EVENT_TYPE, impressionPayload);
+        // Mark as tracked in session
+        this.markImpressionAsTracked(identifier);
+        // Clear state
+        state.timer = null;
+        state.visibleSince = null;
+        state.tracked = true;
+        // Stop observing this element (no longer needed)
+        if (__classPrivateFieldGet(this, _DotCMSImpressionTracker_observer, "f")) {
+            __classPrivateFieldGet(this, _DotCMSImpressionTracker_observer, "f").unobserve(element);
+        }
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").info(`Fired impression for ${identifier} (dwell: ${dwellTime}ms) - element unobserved`, contentletData);
+    }
+    /** Returns skip reason if element is hidden/too small, null if trackable */
+    shouldSkipElement(element) {
+        const rect = element.getBoundingClientRect();
+        const styles = window.getComputedStyle(element);
+        // Check for zero dimensions (empty/collapsed elements)
+        if (rect.height === 0 || rect.width === 0) {
+            return `zero dimensions: ${rect.width}x${rect.height}`;
+        }
+        // Check for very small elements (likely tracking pixels or artifacts)
+        const MIN_SIZE = 10; // pixels
+        if (rect.height < MIN_SIZE || rect.width < MIN_SIZE) {
+            return `too small: ${rect.width}x${rect.height} (minimum: ${MIN_SIZE}px)`;
+        }
+        // Check for hidden elements (visibility: hidden)
+        if (styles.visibility === 'hidden') {
+            return 'visibility: hidden';
+        }
+        // Check for transparent elements (opacity: 0)
+        if (parseFloat(styles.opacity) === 0) {
+            return 'opacity: 0';
+        }
+        // Check for elements with display: none
+        if (styles.display === 'none') {
+            return 'display: none';
+        }
+        // Element passes all checks
+        return null;
+    }
+    /** Post-dwell check: verifies element still meets visibility threshold */
+    isElementStillVisible(element) {
+        // Check page visibility first
+        if (document.visibilityState !== 'visible') {
+            return false;
+        }
+        // Check if element meets visibility threshold using utility
+        return isElementMeetingVisibilityThreshold(element, __classPrivateFieldGet(this, _DotCMSImpressionTracker_impressionConfig, "f").visibilityThreshold);
+    }
+    /** Checks if impression already fired in current page session */
+    hasBeenTrackedInSession(identifier) {
+        return __classPrivateFieldGet(this, _DotCMSImpressionTracker_sessionTrackedImpressions, "f").has(identifier);
+    }
+    /** Marks impression as tracked (prevents duplicates in same page session) */
+    markImpressionAsTracked(identifier) {
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_sessionTrackedImpressions, "f").add(identifier);
+    }
+    /** Cleanup: disconnects observers, clears timers and state */
+    cleanup() {
+        // Disconnect intersection observer
+        if (__classPrivateFieldGet(this, _DotCMSImpressionTracker_observer, "f")) {
+            __classPrivateFieldGet(this, _DotCMSImpressionTracker_observer, "f").disconnect();
+            __classPrivateFieldSet(this, _DotCMSImpressionTracker_observer, null, "f");
+        }
+        // Disconnect mutation observer
+        if (__classPrivateFieldGet(this, _DotCMSImpressionTracker_mutationObserver, "f")) {
+            __classPrivateFieldGet(this, _DotCMSImpressionTracker_mutationObserver, "f").disconnect();
+            __classPrivateFieldSet(this, _DotCMSImpressionTracker_mutationObserver, null, "f");
+        }
+        window.removeEventListener(CONTENTLET_RESCAN_EVENT, __classPrivateFieldGet(this, _DotCMSImpressionTracker_handleRescan, "f"));
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_stopWatchingNavigations, "f")?.call(this);
+        __classPrivateFieldSet(this, _DotCMSImpressionTracker_stopWatchingNavigations, null, "f");
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_stopWatchingRestores, "f")?.call(this);
+        __classPrivateFieldSet(this, _DotCMSImpressionTracker_stopWatchingRestores, null, "f");
+        // Clear all active dwell timers
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_elementImpressionStates, "f").forEach((state) => {
+            if (state.timer !== null) {
+                window.clearTimeout(state.timer);
+            }
+        });
+        // Clear all state
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_elementImpressionStates, "f").clear();
+        // Clear all subscribers
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_subscribers, "f").clear();
+        __classPrivateFieldGet(this, _DotCMSImpressionTracker_logger, "f").info('Impression tracking cleaned up');
+    }
+}
+_DotCMSImpressionTracker_observer = new WeakMap(), _DotCMSImpressionTracker_mutationObserver = new WeakMap(), _DotCMSImpressionTracker_elementImpressionStates = new WeakMap(), _DotCMSImpressionTracker_sessionTrackedImpressions = new WeakMap(), _DotCMSImpressionTracker_impressionConfig = new WeakMap(), _DotCMSImpressionTracker_stopWatchingNavigations = new WeakMap(), _DotCMSImpressionTracker_stopWatchingRestores = new WeakMap(), _DotCMSImpressionTracker_subscribers = new WeakMap(), _DotCMSImpressionTracker_logger = new WeakMap(), _DotCMSImpressionTracker_handleRescan = new WeakMap();
+
+/**
+ * Impressions plugin of the events pipeline.
+ * Handles automatic tracking of content visibility and impressions.
+ *
+ * This plugin initializes the impression tracker which:
+ * - Uses IntersectionObserver to detect when contentlets are visible
+ * - Tracks dwell time (how long elements are visible)
+ * - Fires 'content-impression' events via instance.track()
+ * - Deduplicates impressions per session
+ *
+ * Analytics.js runs the plugins in the order events.ts registers them: identity, experiments,
+ * impressions, clicks, enricher, sender. This one hooks into no event: its tracker fires
+ * events through instance.track(), which runs them through the other plugins like any event.
+ *
+ * Note: This plugin is only registered if config.impressions is enabled.
+ * See getEnhancedTrackingPlugins() for conditional loading logic.
+ *
+ * @param {PipelineConfig} config - Configuration with impressions settings
+ * @returns {Object} Plugin object with lifecycle methods
+ */
+const impressionsPlugin = (config) => {
+    let impressionTracker = null;
+    let subscription = null;
+    const logger = createPluginLogger('Impression', config);
+    return {
+        name: 'dot-events-impressions',
+        /**
+         * Initialize impression tracking
+         * Called when Analytics.js initializes the plugin with instance context
+         * @param instance - Analytics.js instance with track method
+         */
+        initialize: ({ instance }) => {
+            // Only initialize if impressions are enabled
+            if (!config.impressions) {
+                logger.info('Impression tracking disabled (config.impressions not set)');
+                return Promise.resolve();
+            }
+            // Create and initialize tracker
+            impressionTracker = new DotCMSImpressionTracker(config);
+            impressionTracker.initialize();
+            // Subscribe to impression events and call analytics track
+            subscription = impressionTracker.onImpression((eventName, payload) => {
+                instance.track(eventName, payload);
+            });
+            logger.info('Impression tracking plugin initialized');
+            return Promise.resolve();
+        },
+        /**
+         * Setup cleanup handlers when plugin is loaded
+         * Called after Analytics.js completes plugin loading
+         */
+        loaded: () => {
+            // Only setup cleanup if tracker was initialized
+            if (isBrowser$1() && impressionTracker) {
+                const cleanup = () => {
+                    // Unsubscribe before cleanup
+                    if (subscription) {
+                        subscription.unsubscribe();
+                        subscription = null;
+                    }
+                    if (impressionTracker) {
+                        impressionTracker.cleanup();
+                        impressionTracker = null;
+                        logger.info('Impression tracking cleaned up on page unload');
+                    }
+                };
+                // Cleanup on page unload
+                setupPluginCleanup(cleanup);
+            }
+            return true;
+        }
+    };
+};
+
+/**
+ * Plugin that enriches the analytics payload data with page, UTM, and custom data.
+ * Uses Analytics.js lifecycle events to inject enriched data before the main plugin processes it.
+ *
+ * The identity plugin, registered first, injects context: { session_id, site_auth, user_id, device }.
+ * This plugin, registered after the experiments, impressions and clicks plugins, adds page, UTM
+ * and custom data. The sender, registered last, structures the events and sends them.
+ *
+ * This plugin is ONLY responsible for data enrichment - NOT for event structuring or business logic.
+ */
+const enricherPlugin = () => {
+    return {
+        name: 'dot-events-enricher',
+        /**
+         * PAGE VIEW ENRICHMENT - Runs after identity context injection
+         * Returns enriched payload with page, utm, and custom data added
+         * @returns {EnrichedAnalyticsPayload} Enriched payload ready for event creation
+         */
+        [`page:${SENDER_PLUGIN_NAME}`]: ({ payload }) => {
+            const enrichedData = enrichPagePayloadOptimized(payload);
+            if (!enrichedData.page) {
+                throw new Error('[dotCMS events] Missing required page data');
+            }
+            return enrichedData;
+        },
+        /**
+         * TRACK EVENT ENRICHMENT - Runs after identity context injection
+         * Adds page data and timestamp for predefined content events.
+         * For custom events, only adds timestamp.
+         *
+         * @returns {EnrichedTrackPayload} Enriched payload ready for event structuring
+         */
+        [`track:${SENDER_PLUGIN_NAME}`]: ({ payload }) => {
+            const { event } = payload;
+            const local_time = getLocalTime();
+            // For content_impression, content_click, and conversion events, add page data
+            if (event === DotCMSPredefinedEventType.CONTENT_IMPRESSION ||
+                event === DotCMSPredefinedEventType.CONTENT_CLICK ||
+                event === DotCMSPredefinedEventType.CONVERSION) {
+                return {
+                    ...payload,
+                    page: {
+                        title: document.title,
+                        url: window.location.href
+                    },
+                    local_time
+                };
+            }
+            // For custom events, just add local_time
+            return {
+                ...payload,
+                local_time
+            };
+        }
+    };
+};
+
+/**
+ * Identity plugin of the events pipeline.
+ * Handles user ID generation, session management, and activity tracking.
+ * This plugin provides consistent identity context across all analytics events.
+ *
+ * It runs first: events.ts registers identity, experiments, impressions, clicks, enricher and
+ * sender, in that order, and each plugin reads what the ones before it wrote.
+ *
+ * @param {PipelineConfig} config - Configuration object containing server URL, site key, and debug settings
+ * @returns {Object} Plugin object with methods for initialization and event processing
+ */
+const identityPlugin = (config) => {
+    return {
+        name: 'dot-events-identity',
+        /**
+         * Initialize the identity plugin
+         * Sets up activity tracking for session management
+         */
+        initialize: () => {
+            initializeActivityTracking(config);
+            return Promise.resolve();
+        },
+        /**
+         * Inject identity context into page events and updates session activity for session management
+         * This runs BEFORE the enricher plugin
+         */
+        pageStart: ({ payload }) => {
+            updateSessionActivity();
+            const context = getEventContext(config);
+            return {
+                ...payload,
+                context
+            };
+        },
+        /**
+         * Inject identity context into track events and updates session activity for session management
+         * This runs BEFORE the enricher plugin
+         */
+        trackStart: ({ payload }) => {
+            updateSessionActivity();
+            const context = getEventContext(config);
+            return {
+                ...payload,
+                context
+            };
+        },
+        /**
+         * Cleans up activity tracking when the browser discards the page. A page kept in the
+         * back/forward cache keeps it, and keeps `__dotAnalyticsActive__` set, so the
+         * renderers still print the contentlet attributes once the visitor goes back to it.
+         */
+        loaded: () => {
+            if (typeof window !== 'undefined') {
+                onPageDiscard(cleanupActivityTracking);
+            }
+            return true;
+        }
+    };
+};
+
+/**
+ * Hands a failure to the configured handler. A handler that throws must not break the page.
+ *
+ * @param config - The analytics configuration
+ * @param error - The failure
+ */
+const notify = (config, error) => {
+    try {
+        config.onError?.(error);
+    }
+    catch {
+        // The app's handler failed; the events pipeline carries on
+    }
+};
+/**
+ * Reads the response body, when it is JSON.
+ *
+ * @param response - The events response
+ * @returns The body, or null
+ */
+const readBody = async (response) => {
+    try {
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Reports what dotCMS answered to an events request: an error status, or an accepted request
+ * whose body says some events failed.
+ *
+ * @param response - The events response
+ * @param body - Its body, when JSON
+ * @param config - The analytics configuration
+ * @param events - How many events the request carried
+ */
+const reportResponse = (response, body, config, events) => {
+    const errors = body?.entity?.errors;
+    const failed = body?.entity?.failed ?? 0;
+    if (response.ok && failed === 0) {
+        return;
+    }
+    const reason = errors?.[0]?.message ?? body?.message ?? (response.statusText || 'Unknown Error');
+    notify(config, {
+        code: 'REJECTED',
+        message: response.ok
+            ? `${failed} of ${events} event(s) failed: ${reason}`
+            : `HTTP ${response.status}: ${reason}`,
+        status: response.status,
+        detail: errors ?? body,
+        events
+    });
+};
+/**
+ * Send analytics events to the server using fetch API
+ * @param payload - The event payload data
+ * @param config - The analytics configuration
+ * @param keepalive - Use keepalive mode for page unload scenarios (default: false)
+ * @returns A promise that resolves when the request is complete
+ */
+const sendEvents = async (payload, config, keepalive = false) => {
+    const logger = createPluginLogger('HTTP', config);
+    const endpoint = `${config.server}${ANALYTICS_ENDPOINT}`;
+    const body = JSON.stringify(payload);
+    logger.info(`Sending ${payload.events.length} event(s)${keepalive ? ' (keepalive)' : ''}`, {
+        payload
+    });
+    try {
+        const fetchOptions = {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body
+        };
+        // Only add keepalive-specific options when keepalive is true
+        if (keepalive) {
+            fetchOptions.keepalive = true;
+            fetchOptions.credentials = 'omit'; // Required for keepalive requests
+            // Fire and forget - don't await response with keepalive
+            // The browser will send the request even if the page unloads
+            fetch(endpoint, fetchOptions)
+                .then(async (response) => {
+                reportResponse(response, await readBody(response), config, payload.events.length);
+            })
+                .catch((err) => {
+                logger.error('Keepalive request failed (browser may have ignored it):', err);
+                notify(config, {
+                    code: 'NETWORK',
+                    message: String(err),
+                    events: payload.events.length
+                });
+            });
+            // We can't know if it succeeded, but for keepalive=true contexts we usually assume "sent"
+            // or we return false since we can't confirm.
+            // However, the caller usually ignores the return value for keepalive.
+            return true;
+        }
+        // Normal request - await and check response
+        const response = await fetch(endpoint, fetchOptions);
+        if (!response.ok) {
+            // Always log the HTTP status code
+            const statusText = response.statusText || 'Unknown Error';
+            const baseErrorMessage = `HTTP ${response.status}: ${statusText}`;
+            const errorData = await readBody(response);
+            if (errorData?.message) {
+                logger.warn(`${errorData.message} (${baseErrorMessage})`);
+            }
+            else if (errorData) {
+                // JSON parsed successfully but no message property
+                logger.warn(`${baseErrorMessage} - No error message in response`);
+            }
+            else {
+                logger.warn(`${baseErrorMessage} - Failed to parse error response`);
+            }
+            reportResponse(response, errorData, config, payload.events.length);
+            return false;
+        }
+        // Accepted: dotCMS may still have failed some of the events
+        reportResponse(response, await readBody(response), config, payload.events.length);
+        return true;
+    }
+    catch (error) {
+        logger.error('Error sending event:', error);
+        notify(config, { code: 'NETWORK', message: String(error), events: payload.events.length });
+        return false;
+    }
+};
+
+/**
+ * What sets two events' contexts apart: the site, the session, the visitor and the
+ * experiments. The device alone does not, since the viewport changes between events, as it
+ * does when a phone's address bar hides on scroll.
+ *
+ * @param context - An event's context
+ * @returns A key that is equal for contexts that can share a request
+ */
+const contextKey = ({ site_auth, session_id, user_id, experiments }) => JSON.stringify([site_auth, session_id, user_id, experiments ?? []]);
+/**
+ * Groups events into request bodies, in order: consecutive events whose contexts share a key
+ * go out together, with the latest of their contexts. Events of a page that runs an
+ * experiment and of one that does not never share a context.
+ *
+ * @param items - Events with the context each was created with
+ * @returns One request body per run of events
+ */
+const toRequestBodies = (items) => {
+    const bodies = [];
+    let lastKey;
+    items.forEach(({ event, context }) => {
+        const key = contextKey(context);
+        const last = bodies[bodies.length - 1];
+        if (last && key === lastKey) {
+            last.events.push(event);
+            last.context = context;
+        }
+        else {
+            bodies.push({ context, events: [event] });
+            lastKey = key;
+        }
+    });
+    return bodies;
+};
+/**
+ * Creates a queue manager for batching analytics events.
+ * Uses factory function pattern consistent with the plugin architecture.
+ */
+const createEventQueue = (config) => {
+    const logger = createPluginLogger('Queue', config);
+    let eventQueue = null;
+    // The context each queued event was created with
+    let contextOf = new WeakMap();
+    /**
+     * Whether to use keepalive mode for sending events
+     * true for page unload (visibilitychange, pagehide), false for normal sends
+     */
+    let keepalive = false;
+    /**
+     * Track if we're in a SPA navigation to avoid unnecessary flushes
+     */
+    let isSPANavigation = false;
+    let currentPath = typeof window !== 'undefined' ? window.location.pathname : '';
+    /**
+     * Unique identifier for this browser tab
+     * Used to prevent race conditions when multiple tabs write to sessionStorage
+     */
+    let tabId = '';
+    /**
+     * Parallel array to track events, with their contexts, for persistence
+     * smartQueue doesn't expose its internal array, so we maintain a copy
+     */
+    let eventsForPersistence = [];
+    // Merge user config with defaults (allows partial configuration)
+    // After merge, queueConfig always has all required values
+    const queueConfig = {
+        ...DEFAULT_QUEUE_CONFIG,
+        ...(typeof config.queue === 'object' ? config.queue : {})
+    };
+    /**
+     * Get storage key for this tab's queue
+     */
+    const getStorageKey = () => {
+        return `${QUEUE_STORAGE_KEY_PREFIX}_${tabId}`;
+    };
+    /**
+     * Validate persisted queue structure
+     * @param data - Data from sessionStorage
+     * @returns Validated queue or null if invalid
+     */
+    const validatePersistedQueue = (data) => {
+        const q = data;
+        if (!q || typeof q !== 'object' || Array.isArray(q)) {
+            return null;
+        }
+        // Validate minimal structural requirements
+        if (typeof q.tabId !== 'string' ||
+            typeof q.timestamp !== 'number' ||
+            !Number.isFinite(q.timestamp) ||
+            !Array.isArray(q.events)) {
+            logger.warn('Invalid persisted queue: structural mismatch');
+            return null;
+        }
+        // Validate minimal event structure: each event with its context
+        const validEvents = q.events.filter((item) => item &&
+            typeof item === 'object' &&
+            item.event &&
+            typeof item.event === 'object' &&
+            'event_type' in item.event &&
+            item.context &&
+            typeof item.context === 'object');
+        return {
+            tabId: q.tabId,
+            timestamp: q.timestamp,
+            events: validEvents
+        };
+    };
+    /**
+     * Load events from sessionStorage
+     * @returns Persisted queue or null if not found/invalid
+     */
+    const loadFromStorage = () => {
+        try {
+            const key = getStorageKey();
+            const stored = safeSessionStorage.getItem(key);
+            if (!stored) {
+                logger.debug('No persisted queue found');
+                return null;
+            }
+            const parsed = JSON.parse(stored);
+            const validated = validatePersistedQueue(parsed);
+            if (!validated) {
+                // Clear invalid storage
+                safeSessionStorage.removeItem(key);
+                return null;
+            }
+            // Check if events are too old (24 hours)
+            const age = Date.now() - validated.timestamp;
+            if (age > MAX_EVENT_AGE_MS) {
+                logger.warn(`Persisted events too old (${Math.round(age / 1000 / 60 / 60)}h), discarding`);
+                safeSessionStorage.removeItem(key);
+                return null;
+            }
+            logger.info(`Loaded ${validated.events.length} persisted event(s) from storage (age: ${Math.round(age / 1000)}s)`);
+            return validated;
+        }
+        catch (error) {
+            logger.error('Failed to load persisted queue', error);
+            // Clear corrupted storage
+            safeSessionStorage.removeItem(getStorageKey());
+            return null;
+        }
+    };
+    /**
+     * Persist current queue to sessionStorage
+     */
+    const persistToStorage = () => {
+        if (eventsForPersistence.length === 0) {
+            return;
+        }
+        try {
+            const key = getStorageKey();
+            const queueData = {
+                tabId,
+                timestamp: Date.now(),
+                events: eventsForPersistence
+            };
+            safeSessionStorage.setItem(key, JSON.stringify(queueData));
+            logger.debug(`Persisted ${eventsForPersistence.length} event(s) to storage`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'QuotaExceededError') {
+                logger.warn('sessionStorage quota exceeded, continuing without persistence');
+            }
+            else {
+                logger.error('Failed to persist queue', error);
+            }
+        }
+    };
+    /**
+     * Clear persisted queue from sessionStorage
+     */
+    const clearStorage = () => {
+        try {
+            const key = getStorageKey();
+            safeSessionStorage.removeItem(key);
+            logger.debug('Persisted queue cleared from storage');
+        }
+        catch (error) {
+            logger.error('Failed to clear persisted queue', error);
+        }
+    };
+    /**
+     * Sends events right away, outside the batches. Used for the events an earlier page
+     * persisted, which go out when this page loads (that caller passes useKeepalive false),
+     * each with the context it was created with.
+     * @param events - Events to send, with their contexts
+     * @param useKeepalive - Whether to send with keepalive
+     * @returns Promise<boolean> - true if every request succeeded
+     */
+    const sendImmediately = async (events, useKeepalive = true) => {
+        if (events.length === 0) {
+            return true;
+        }
+        logger.info(`Sending ${events.length} persisted event(s) immediately`);
+        const sent = await Promise.all(toRequestBodies(events).map((payload) => sendEvents(payload, config, useKeepalive)));
+        return sent.every(Boolean);
+    };
+    /**
+     * Send batch of events to server
+     * Called by smartQueue - uses keepalive mode when flushing on page unload
+     * @param events - The batch of events to send
+     * @param _rest - Remaining events in queue (unused, required by smartQueue API)
+     */
+    const sendBatch = (events, _rest) => {
+        const batch = events.flatMap((event) => {
+            const context = contextOf.get(event);
+            return context ? [{ event, context }] : [];
+        });
+        if (batch.length === 0)
+            return;
+        logger.debug(`Sending batch of ${events.length} event(s)`, {
+            events,
+            keepalive
+        });
+        // Send events (fire-and-forget with keepalive): one request per context in the batch
+        toRequestBodies(batch).forEach((payload) => sendEvents(payload, config, keepalive));
+        // Remove sent events from parallel tracking array
+        eventsForPersistence = eventsForPersistence.filter((queued) => !events.some((sent) => sent === queued.event));
+        // Always update storage after dispatching the send — even for keepalive flushes.
+        // Note: sendEvents is fire-and-forget (the returned promise is not awaited),
+        // so this runs regardless of whether the HTTP request succeeds.
+        // sessionStorage writes are synchronous and complete before page unload,
+        // so the persistence state stays consistent. Previously, keepalive flushes
+        // skipped the storage update, which caused the next page load to re-send
+        // the same events from persistence, producing duplicates.
+        if (eventsForPersistence.length === 0) {
+            clearStorage();
+        }
+        else {
+            persistToStorage();
+        }
+    };
+    /**
+     * Flush remaining events when page becomes hidden or unloads
+     * Enables keepalive mode and triggers smartQueue to flush ALL events
+     */
+    const flushRemaining = () => {
+        if (!eventQueue || eventQueue.size() === 0 || eventsForPersistence.length === 0)
+            return;
+        logger.info(`Flushing ${eventQueue.size()} events (page hidden/unload)`);
+        // Use keepalive mode for reliable delivery during page unload
+        keepalive = true;
+        // Flush all events - flush(true) makes smartQueue recursively batch until empty
+        eventQueue.flush(true);
+    };
+    /**
+     * Handle visibility change - flush when page becomes hidden
+     * This is more reliable than beforeunload/unload, especially on mobile
+     *
+     * IMPORTANT: We skip flush if this is a SPA navigation (client-side routing)
+     * Only flush on real tab changes or browser close
+     */
+    const handleVisibilityChange = () => {
+        logger.debug('handleVisibilityChange', document.visibilityState);
+        if (document.visibilityState === 'hidden') {
+            // Don't flush if this is just a SPA navigation
+            if (isSPANavigation) {
+                logger.debug('Skipping flush (SPA navigation detected), persisting to storage');
+                // For SPA navigation, persist events without flushing
+                // Events stay in memory and are preserved across client-side routing
+                persistToStorage();
+                return;
+            }
+            // Real visibility change (tab switch, browser close, etc.)
+            flushRemaining();
+        }
+        else if (document.visibilityState === 'visible') {
+            // Reset SPA navigation flag when page becomes visible again
+            isSPANavigation = false;
+        }
+    };
+    return {
+        /**
+         * Initialize the queue with smart batching
+         */
+        initialize: () => {
+            // 1. Load or generate persistent tab ID
+            // Tab ID must remain constant across page navigations within the same browser tab
+            if (typeof window !== 'undefined') {
+                // Try to load existing tab ID from sessionStorage
+                const storedTabId = safeSessionStorage.getItem(TAB_ID_STORAGE_KEY);
+                if (storedTabId) {
+                    // Reuse existing tab ID from previous page
+                    tabId = storedTabId;
+                    logger.debug(`Reusing Tab ID: ${tabId}`);
+                }
+                else {
+                    // Generate new tab ID (Robust check for crypto.randomUUID)
+                    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+                        tabId = crypto.randomUUID();
+                    }
+                    else {
+                        // Fallback for non-secure contexts or older browsers/environments
+                        tabId = generateSecureId('tab');
+                        logger.debug('crypto.randomUUID not available, using fallback generator');
+                    }
+                    try {
+                        safeSessionStorage.setItem(TAB_ID_STORAGE_KEY, tabId);
+                    }
+                    catch {
+                        // Ignore storage error for tab ID, will just generate a new one on next load
+                    }
+                    logger.debug(`Generated new Tab ID: ${tabId}`);
+                }
+            }
+            // 2. Load persisted events from previous page (if any)
+            const persisted = loadFromStorage();
+            if (persisted && persisted.events.length > 0) {
+                // Send persisted events immediately WITHOUT keepalive (to confirm success)
+                // This ensures events from previous page navigation are sent reliably
+                sendImmediately(persisted.events, false).then((success) => {
+                    if (success) {
+                        // Clear storage ONLY after successful transmission
+                        clearStorage();
+                    }
+                    else {
+                        logger.warn('Failed to send persisted events, keeping in storage for next retry');
+                    }
+                });
+            }
+            // 3. Initialize smartQueue for new events
+            eventQueue = smartQueue((items, rest) => {
+                sendBatch(items);
+            }, {
+                max: queueConfig.eventBatchSize,
+                interval: queueConfig.flushInterval,
+                throttle: false // Always false - enables both batch size and interval triggers
+            });
+            // 4. Setup page visibility and unload listeners
+            // visibilitychange is more reliable than beforeunload, especially on mobile
+            if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+                document.addEventListener('visibilitychange', handleVisibilityChange);
+                // pagehide as fallback for browsers without bfcache or older browsers
+                window.addEventListener('pagehide', flushRemaining);
+                // Detect SPA navigations using @analytics/router-utils
+                // Handles Next.js, React Router, Vue Router, etc.
+                onRouteChange((newPath) => {
+                    isSPANavigation = true;
+                    currentPath = newPath;
+                    logger.debug(`SPA navigation detected (${currentPath})`);
+                    // Reset flag after a short delay (SPA navigation is done)
+                    setTimeout(() => {
+                        isSPANavigation = false;
+                    }, 100);
+                });
+            }
+        },
+        /**
+         * Add event to queue
+         * smartQueue handles all batching logic automatically:
+         * - Sends immediately when eventBatchSize reached (with throttle: false)
+         * - Sends pending events every flushInterval
+         */
+        enqueue: (event, context) => {
+            if (!eventQueue)
+                return;
+            // Each event goes out with the context it was created with
+            contextOf.set(event, context);
+            // Add to parallel tracking array for persistence
+            eventsForPersistence.push({ event, context });
+            // Calculate predicted size before push to show correct order in logs
+            const predictedSize = eventQueue.size() + 1;
+            const maxSize = queueConfig.eventBatchSize;
+            const willBeFull = predictedSize >= maxSize;
+            logger.debug(`Event added. Queue size: ${predictedSize}/${maxSize}${willBeFull ? ' (full, sending...)' : ''}`, { eventType: event.event_type, event });
+            // Push triggers sendBatch callback if queue is full (throttle: false)
+            eventQueue.push(event);
+            // Persist to sessionStorage after enqueue
+            persistToStorage();
+        },
+        /**
+         * Get queue size for debugging
+         * Returns the number of events in smartQueue
+         */
+        size: () => eventQueue?.size() ?? 0,
+        /**
+         * Clean up queue resources
+         * Flushes remaining events and cleans up listeners
+         *
+         * IMPORTANT: Does NOT clear sessionStorage
+         * - Storage is updated when sendBatch dispatches a batch, whether or not its request
+         *   succeeds, and in initialize()
+         * - This allows events to persist across traditional page navigations
+         */
+        cleanup: () => {
+            // Flush remaining events with keepalive
+            flushRemaining();
+            // Remove event listeners
+            if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+                document.removeEventListener('visibilitychange', handleVisibilityChange);
+                window.removeEventListener('pagehide', flushRemaining);
+            }
+            // Clean up memory only (not sessionStorage)
+            eventQueue = null;
+            contextOf = new WeakMap();
+            keepalive = false;
+            eventsForPersistence = [];
+        }
+    };
+};
+
+/**
+ * Analytics plugin for tracking page views and custom events in DotCMS applications.
+ * This plugin handles:
+ * 1. Event structuring (deciding between predefined and custom events)
+ * 2. Building complete request bodies
+ * 3. Sending analytics data to the DotCMS server
+ * 4. Managing initialization and queue management
+ *
+ * The enricher plugin runs BEFORE this plugin and adds page/utm/custom data.
+ * This plugin receives enriched payloads and structures them into proper events.
+ *
+ * @param {PipelineConfig} config - Configuration object containing API key, server URL,
+ *                                     debug mode, auto page view settings, and queue config
+ * @returns {Object} Plugin object with methods for initialization and event tracking
+ */
+const senderPlugin = (config) => {
+    let isInitialized = false;
+    // Queue is enabled if queue is not explicitly false
+    const enableQueue = config.queue !== false;
+    let queue = null;
+    /**
+     * Dispatches event to queue or directly to server
+     */
+    const dispatchEvent = (requestBody) => {
+        const event = requestBody.events[0];
+        const context = requestBody.context;
+        // Use queue or send directly
+        if (enableQueue && queue) {
+            if (event) {
+                queue.enqueue(event, context);
+            }
+        }
+        else {
+            // Direct send without queue (when queue === false)
+            sendEvents(requestBody, config);
+        }
+    };
+    return {
+        name: SENDER_PLUGIN_NAME,
+        config,
+        /**
+         * Initialize the plugin with optional queue management
+         */
+        initialize: () => {
+            isInitialized = true;
+            // Initialize queue if enabled (queue is undefined or an object)
+            if (enableQueue) {
+                queue = createEventQueue(config);
+                queue.initialize();
+            }
+            return Promise.resolve();
+        },
+        /**
+         * Track a page view event
+         * Receives enriched payload from the enricher plugin and structures it into a pageview event
+         */
+        page: ({ payload }) => {
+            if (!isInitialized) {
+                throw new Error('[dotCMS events] Plugin not initialized');
+            }
+            const { context, page, utm, custom, local_time } = payload;
+            if (!page) {
+                throw new Error('[dotCMS events] Missing required page data');
+            }
+            const requestBody = {
+                context,
+                events: [
+                    {
+                        event_type: DotCMSPredefinedEventType.PAGEVIEW,
+                        local_time,
+                        data: {
+                            page,
+                            ...(utm && { utm }),
+                            ...(custom && { custom })
+                        }
+                    }
+                ]
+            };
+            dispatchEvent(requestBody);
+        },
+        /**
+         * Builds a content impression, content click or conversion from the enriched payload.
+         *
+         * - content_impression → extracts from properties, combines with enriched page data
+         * - content_click → extracts from properties, combines with enriched page data
+         * - conversion → its name and the page
+         *
+         * Those, with pageviews, are the only event types dotCMS accepts.
+         */
+        track: ({ payload }) => {
+            if (!isInitialized) {
+                throw new Error('[dotCMS events] Plugin not initialized');
+            }
+            const { event, properties, context, local_time } = payload;
+            let analyticsEvent;
+            // One case per event type dotCMS accepts
+            switch (event) {
+                case DotCMSPredefinedEventType.CONTENT_IMPRESSION: {
+                    // Extract impression data from properties (sent by tracker)
+                    const impressionPayload = properties;
+                    const { content, position } = impressionPayload;
+                    const { page } = payload; // Added by enricher
+                    if (!content || !position || !page) {
+                        throw new Error('[dotCMS events] Missing required impression data');
+                    }
+                    analyticsEvent = {
+                        event_type: DotCMSPredefinedEventType.CONTENT_IMPRESSION,
+                        local_time,
+                        data: {
+                            content,
+                            position,
+                            page
+                        }
+                    };
+                    break;
+                }
+                case DotCMSPredefinedEventType.CONTENT_CLICK: {
+                    // Extract click data from properties (sent by click plugin)
+                    const clickPayload = properties;
+                    const { content, position, element } = clickPayload;
+                    const { page } = payload; // Added by enricher
+                    if (!content || !position || !element || !page) {
+                        throw new Error('[dotCMS events] Missing required click data');
+                    }
+                    analyticsEvent = {
+                        event_type: DotCMSPredefinedEventType.CONTENT_CLICK,
+                        local_time,
+                        data: {
+                            content,
+                            position,
+                            element,
+                            page
+                        }
+                    };
+                    break;
+                }
+                case DotCMSPredefinedEventType.CONVERSION: {
+                    // Extract conversion data from properties (sent by user)
+                    const { name } = properties;
+                    const { page } = payload; // Added by enricher
+                    if (!name || !page) {
+                        throw new Error('[dotCMS events] Missing required conversion data');
+                    }
+                    analyticsEvent = {
+                        event_type: DotCMSPredefinedEventType.CONVERSION,
+                        local_time,
+                        data: {
+                            conversion: { name },
+                            page
+                        }
+                    };
+                    break;
+                }
+                default:
+                    // Only the SDK calls track, with the types above
+                    throw new Error(`[dotCMS events] ${event} is not an event type dotCMS accepts`);
+            }
+            const requestBody = {
+                context,
+                events: [analyticsEvent]
+            };
+            dispatchEvent(requestBody);
+        },
+        /**
+         * Check if the plugin is loaded
+         */
+        loaded: () => isInitialized
+    };
+};
+
+/** Calls made before `init`, replayed once it runs. Capped so a missing `init` can't grow it. */
+const MAX_PENDING_CALLS = 50;
+/**
+ * A storage that lives as long as the page. Analytics.js persists an anonymous id that nothing
+ * here reads, and its default storage falls back to a cookie when localStorage is
+ * unavailable: with this one, nothing it keeps reaches localStorage, sessionStorage or a
+ * cookie.
+ *
+ * @returns The storage
+ */
+const createMemoryStorage = () => {
+    const values = new Map();
+    return {
+        getItem: (key) => values.get(key),
+        setItem: (key, value) => void values.set(key, value),
+        removeItem: (key) => void values.delete(key)
+    };
+};
+let instance = null;
+let engine = null;
+let activeConfigKey = null;
+let lastPageKey = null;
+let debug = false;
+const pendingCalls = [];
+const isBrowser = () => typeof window !== 'undefined' && typeof document !== 'undefined';
+const log = (...args) => {
+    if (debug) {
+        // eslint-disable-next-line no-console
+        console.info('[dotCMS events]', ...args);
+    }
+};
+let onErrorHandler;
+/**
+ * Hands a failure to the app's `onError`. A handler that throws must not break the page.
+ *
+ * @param error - The failure
+ */
+const reportError = (error) => {
+    try {
+        onErrorHandler?.(error);
+    }
+    catch {
+        // The app's handler failed; events carry on
+    }
+};
+/** Reports a setup mistake in the page, only in debug like `log`. */
+const warn = (message) => {
+    if (debug) {
+        console.warn(`[dotCMS events] ${message}`);
+    }
+};
+const defer = (call) => {
+    if (pendingCalls.length < MAX_PENDING_CALLS) {
+        pendingCalls.push(call);
+    }
+};
+// Optional settings pass through only when set, so the core applies its own defaults.
+const toAnalyticsConfig = (config) => ({
+    server: config.dotcmsUrl.replace(/\/+$/, ''),
+    siteAuth: config.siteAuth,
+    debug: Boolean(config.debug),
+    autoPageView: config.autoPageView !== false,
+    ...(config.logLevel !== undefined && { logLevel: config.logLevel }),
+    ...(config.queue !== undefined && { queue: config.queue }),
+    ...(config.impressions !== undefined && { impressions: config.impressions }),
+    ...(config.clicks !== undefined && { clicks: config.clicks }),
+    onError: reportError
+});
+const assignmentTimeout = (config) => typeof config.experiments === 'object' && typeof config.experiments.timeout === 'number'
+    ? config.experiments.timeout
+    : DEFAULT_ASSIGNMENT_TIMEOUT_MS;
+const nextFrame = () => new Promise((resolve) => requestAnimationFrame(() => resolve()));
+/**
+ * Sends a pageview, after the experiments engine decides the page. When the engine
+ * redirects, the pageview is dropped: the variant's page sends its own.
+ */
+const sendPageView = async (data) => {
+    if (!instance) {
+        return;
+    }
+    if (engine) {
+        const { redirected, left } = await engine.decide();
+        if (redirected) {
+            log('pageview dropped: redirecting to the assigned variant');
+            return;
+        }
+        // Sent now, it would carry the URL of the page the visitor went to
+        if (left) {
+            log('pageview dropped: the visitor left the page while it was decided');
+            return;
+        }
+    }
+    instance.page(data);
+};
+const trackAutomaticPageView = async () => {
+    const pageKey = `${window.location.pathname}${window.location.search}`;
+    if (pageKey === lastPageKey) {
+        return;
+    }
+    lastPageKey = pageKey;
+    await sendPageView({});
+};
+const startAutomaticPageViews = () => {
+    const first = () => void trackAutomaticPageView();
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', first, { once: true });
+    }
+    else {
+        first();
+    }
+    // Wait two frames after a navigation, so the new route's rows are in the DOM.
+    onNavigation(() => {
+        void nextFrame()
+            .then(nextFrame)
+            .then(() => trackAutomaticPageView());
+    });
+    // A page restored from the back/forward cache keeps the URL already counted, but the
+    // visitor sees it again: it counts, as it does when the browser loads it again instead
+    onPageRestore(() => void sendPageView({}));
+};
+/**
+ * Starts the SDK: what `dotEvents.init` does, with how the pages mark their experiment. Apps call
+ * `dotEvents.init`, for pages that print the experiment markup; the script dotCMS injects into
+ * traditional pages calls this with `contentlets`, since those pages carry dotCMS's contentlet
+ * wrappers instead. Not exported by the package.
+ *
+ * @param config - The app's config
+ * @param pages - How the pages mark what their experiment varies
+ */
+const initEvents = (config, pages) => {
+    if (!isBrowser()) {
+        return;
+    }
+    const configKey = `${config?.dotcmsUrl}|${config?.siteAuth}`;
+    // Claimed as soon as init starts: Analytics.js loads after this call returns
+    if (activeConfigKey) {
+        if (configKey !== activeConfigKey) {
+            console.warn('[dotCMS events] init was called again with another config; ignored');
+        }
+        return;
+    }
+    debug = Boolean(config?.debug);
+    onErrorHandler = config?.onError;
+    if (!config?.dotcmsUrl || !config?.siteAuth) {
+        console.error('[dotCMS events] init needs dotcmsUrl and siteAuth');
+        return;
+    }
+    if (getUVEState()) {
+        // Inside the editor nothing is tracked, and nothing may stay hidden.
+        revealRows();
+        window[ANALYTICS_WINDOWS_ACTIVE_KEY] = false;
+        log('inside UVE: events off');
+        return;
+    }
+    activeConfigKey = configKey;
+    const analyticsConfig = toAnalyticsConfig(config);
+    const experimentsOn = config.experiments !== false;
+    engine = experimentsOn
+        ? createExperimentsEngine({
+            dotcmsUrl: analyticsConfig.server,
+            timeoutMs: assignmentTimeout(config),
+            log,
+            warn,
+            onError: reportError,
+            pages
+        })
+        : null;
+    if (engine) {
+        // On pages dotCMS renders, a returning visitor is decided now, while the head is parsed.
+        // Otherwise a new visitor's isUserIncluded leaves now, while Analytics.js loads.
+        if (!engine.prepare()) {
+            engine.start();
+        }
+    }
+    else {
+        revealRows();
+    }
+    // The page renderers print contentlet attributes while analytics is active, so they
+    // learn it now, before they hydrate, and never render twice.
+    window[ANALYTICS_WINDOWS_ACTIVE_KEY] = true;
+    window.dispatchEvent(new CustomEvent(ANALYTICS_READY_EVENT));
+    // Traditional pages and plain scripts reach the same object as window.dotEvents.
+    const globalScope = window;
+    if (!globalScope[EVENTS_WINDOW_KEY]) {
+        globalScope[EVENTS_WINDOW_KEY] = dotEvents;
+    }
+    // Analytics.js reads the time zone when its module is evaluated: loading it here keeps
+    // that work, and the module's, out of the task that starts the app. Calls wait in
+    // pendingCalls meanwhile.
+    void import('analytics')
+        .then(({ Analytics }) => {
+        const plugins = [
+            identityPlugin(analyticsConfig),
+            ...(engine ? [experimentsPlugin(engine)] : []),
+            ...getEnhancedTrackingPlugins(analyticsConfig, impressionsPlugin, clicksPlugin),
+            enricherPlugin(),
+            senderPlugin(analyticsConfig)
+        ];
+        // Analytics.js reads `storage` from its config, though its types leave it out
+        const analyticsJsConfig = {
+            app: 'dotEvents',
+            debug: analyticsConfig.debug,
+            plugins,
+            storage: createMemoryStorage()
+        };
+        instance = Analytics(analyticsJsConfig);
+        log('ready', {
+            experiments: experimentsOn,
+            autoPageView: analyticsConfig.autoPageView
+        });
+        pendingCalls.splice(0).forEach((call) => call());
+        if (analyticsConfig.autoPageView) {
+            startAutomaticPageViews();
+        }
+    })
+        .catch((error) => {
+        console.error('[dotCMS events] Analytics.js failed to load; no events are sent', error);
+    });
+};
+/**
+ * The events SDK. There is one object per page: every import gets the same instance,
+ * configured by the one `init` call.
+ */
+const dotEvents = {
+    init(config) {
+        initEvents(config, 'markup');
+    },
+    conversion(name) {
+        if (!isBrowser()) {
+            return;
+        }
+        if (!name || name.trim() === '') {
+            console.warn('[dotCMS events] a conversion needs a name');
+            return;
+        }
+        if (!instance) {
+            defer(() => dotEvents.conversion(name));
+            return;
+        }
+        instance.track(DotCMSPredefinedEventType.CONVERSION, { name });
+    },
+    pageView(data = {}) {
+        if (!isBrowser()) {
+            return;
+        }
+        if (!instance) {
+            defer(() => dotEvents.pageView(data));
+            return;
+        }
+        void sendPageView(data);
+    }
+};
+
+export { dotEvents };