@journium/js 1.1.0 → 1.2.0

package/dist/journium.js

@@ -0,0 +1,1892 @@
+/* Journium Analytics SDK - Browser CDN Build */
+(function (exports) {
+    'use strict';
+
+    /**
+     * uuidv7: A JavaScript implementation of UUID version 7
+     *
+     * Copyright 2021-2024 LiosK
+     *
+     * @license Apache-2.0
+     * @packageDocumentation
+     */
+    const DIGITS = "0123456789abcdef";
+    /** Represents a UUID as a 16-byte byte array. */
+    class UUID {
+        /** @param bytes - The 16-byte byte array representation. */
+        constructor(bytes) {
+            this.bytes = bytes;
+        }
+        /**
+         * Creates an object from the internal representation, a 16-byte byte array
+         * containing the binary UUID representation in the big-endian byte order.
+         *
+         * This method does NOT shallow-copy the argument, and thus the created object
+         * holds the reference to the underlying buffer.
+         *
+         * @throws TypeError if the length of the argument is not 16.
+         */
+        static ofInner(bytes) {
+            if (bytes.length !== 16) {
+                throw new TypeError("not 128-bit length");
+            }
+            else {
+                return new UUID(bytes);
+            }
+        }
+        /**
+         * Builds a byte array from UUIDv7 field values.
+         *
+         * @param unixTsMs - A 48-bit `unix_ts_ms` field value.
+         * @param randA - A 12-bit `rand_a` field value.
+         * @param randBHi - The higher 30 bits of 62-bit `rand_b` field value.
+         * @param randBLo - The lower 32 bits of 62-bit `rand_b` field value.
+         * @throws RangeError if any field value is out of the specified range.
+         */
+        static fromFieldsV7(unixTsMs, randA, randBHi, randBLo) {
+            if (!Number.isInteger(unixTsMs) ||
+                !Number.isInteger(randA) ||
+                !Number.isInteger(randBHi) ||
+                !Number.isInteger(randBLo) ||
+                unixTsMs < 0 ||
+                randA < 0 ||
+                randBHi < 0 ||
+                randBLo < 0 ||
+                unixTsMs > 281474976710655 ||
+                randA > 0xfff ||
+                randBHi > 1073741823 ||
+                randBLo > 4294967295) {
+                throw new RangeError("invalid field value");
+            }
+            const bytes = new Uint8Array(16);
+            bytes[0] = unixTsMs / 2 ** 40;
+            bytes[1] = unixTsMs / 2 ** 32;
+            bytes[2] = unixTsMs / 2 ** 24;
+            bytes[3] = unixTsMs / 2 ** 16;
+            bytes[4] = unixTsMs / 2 ** 8;
+            bytes[5] = unixTsMs;
+            bytes[6] = 0x70 | (randA >>> 8);
+            bytes[7] = randA;
+            bytes[8] = 0x80 | (randBHi >>> 24);
+            bytes[9] = randBHi >>> 16;
+            bytes[10] = randBHi >>> 8;
+            bytes[11] = randBHi;
+            bytes[12] = randBLo >>> 24;
+            bytes[13] = randBLo >>> 16;
+            bytes[14] = randBLo >>> 8;
+            bytes[15] = randBLo;
+            return new UUID(bytes);
+        }
+        /**
+         * Builds a byte array from a string representation.
+         *
+         * This method accepts the following formats:
+         *
+         * - 32-digit hexadecimal format without hyphens: `0189dcd553117d408db09496a2eef37b`
+         * - 8-4-4-4-12 hyphenated format: `0189dcd5-5311-7d40-8db0-9496a2eef37b`
+         * - Hyphenated format with surrounding braces: `{0189dcd5-5311-7d40-8db0-9496a2eef37b}`
+         * - RFC 9562 URN format: `urn:uuid:0189dcd5-5311-7d40-8db0-9496a2eef37b`
+         *
+         * Leading and trailing whitespaces represents an error.
+         *
+         * @throws SyntaxError if the argument could not parse as a valid UUID string.
+         */
+        static parse(uuid) {
+            var _a, _b, _c, _d;
+            let hex = undefined;
+            switch (uuid.length) {
+                case 32:
+                    hex = (_a = /^[0-9a-f]{32}$/i.exec(uuid)) === null || _a === void 0 ? void 0 : _a[0];
+                    break;
+                case 36:
+                    hex =
+                        (_b = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i
+                            .exec(uuid)) === null || _b === void 0 ? void 0 : _b.slice(1, 6).join("");
+                    break;
+                case 38:
+                    hex =
+                        (_c = /^\{([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})\}$/i
+                            .exec(uuid)) === null || _c === void 0 ? void 0 : _c.slice(1, 6).join("");
+                    break;
+                case 45:
+                    hex =
+                        (_d = /^urn:uuid:([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i
+                            .exec(uuid)) === null || _d === void 0 ? void 0 : _d.slice(1, 6).join("");
+                    break;
+            }
+            if (hex) {
+                const inner = new Uint8Array(16);
+                for (let i = 0; i < 16; i += 4) {
+                    const n = parseInt(hex.substring(2 * i, 2 * i + 8), 16);
+                    inner[i + 0] = n >>> 24;
+                    inner[i + 1] = n >>> 16;
+                    inner[i + 2] = n >>> 8;
+                    inner[i + 3] = n;
+                }
+                return new UUID(inner);
+            }
+            else {
+                throw new SyntaxError("could not parse UUID string");
+            }
+        }
+        /**
+         * @returns The 8-4-4-4-12 canonical hexadecimal string representation
+         * (`0189dcd5-5311-7d40-8db0-9496a2eef37b`).
+         */
+        toString() {
+            let text = "";
+            for (let i = 0; i < this.bytes.length; i++) {
+                text += DIGITS.charAt(this.bytes[i] >>> 4);
+                text += DIGITS.charAt(this.bytes[i] & 0xf);
+                if (i === 3 || i === 5 || i === 7 || i === 9) {
+                    text += "-";
+                }
+            }
+            return text;
+        }
+        /**
+         * @returns The 32-digit hexadecimal representation without hyphens
+         * (`0189dcd553117d408db09496a2eef37b`).
+         */
+        toHex() {
+            let text = "";
+            for (let i = 0; i < this.bytes.length; i++) {
+                text += DIGITS.charAt(this.bytes[i] >>> 4);
+                text += DIGITS.charAt(this.bytes[i] & 0xf);
+            }
+            return text;
+        }
+        /** @returns The 8-4-4-4-12 canonical hexadecimal string representation. */
+        toJSON() {
+            return this.toString();
+        }
+        /**
+         * Reports the variant field value of the UUID or, if appropriate, "NIL" or
+         * "MAX".
+         *
+         * For convenience, this method reports "NIL" or "MAX" if `this` represents
+         * the Nil or Max UUID, although the Nil and Max UUIDs are technically
+         * subsumed under the variants `0b0` and `0b111`, respectively.
+         */
+        getVariant() {
+            const n = this.bytes[8] >>> 4;
+            if (n < 0) {
+                throw new Error("unreachable");
+            }
+            else if (n <= 0b0111) {
+                return this.bytes.every((e) => e === 0) ? "NIL" : "VAR_0";
+            }
+            else if (n <= 0b1011) {
+                return "VAR_10";
+            }
+            else if (n <= 0b1101) {
+                return "VAR_110";
+            }
+            else if (n <= 0b1111) {
+                return this.bytes.every((e) => e === 0xff) ? "MAX" : "VAR_RESERVED";
+            }
+            else {
+                throw new Error("unreachable");
+            }
+        }
+        /**
+         * Returns the version field value of the UUID or `undefined` if the UUID does
+         * not have the variant field value of `0b10`.
+         */
+        getVersion() {
+            return this.getVariant() === "VAR_10" ? this.bytes[6] >>> 4 : undefined;
+        }
+        /** Creates an object from `this`. */
+        clone() {
+            return new UUID(this.bytes.slice(0));
+        }
+        /** Returns true if `this` is equivalent to `other`. */
+        equals(other) {
+            return this.compareTo(other) === 0;
+        }
+        /**
+         * Returns a negative integer, zero, or positive integer if `this` is less
+         * than, equal to, or greater than `other`, respectively.
+         */
+        compareTo(other) {
+            for (let i = 0; i < 16; i++) {
+                const diff = this.bytes[i] - other.bytes[i];
+                if (diff !== 0) {
+                    return Math.sign(diff);
+                }
+            }
+            return 0;
+        }
+    }
+    /**
+     * Encapsulates the monotonic counter state.
+     *
+     * This class provides APIs to utilize a separate counter state from that of the
+     * global generator used by {@link uuidv7} and {@link uuidv7obj}. In addition to
+     * the default {@link generate} method, this class has {@link generateOrAbort}
+     * that is useful to absolutely guarantee the monotonically increasing order of
+     * generated UUIDs. See their respective documentation for details.
+     */
+    class V7Generator {
+        /**
+         * Creates a generator object with the default random number generator, or
+         * with the specified one if passed as an argument. The specified random
+         * number generator should be cryptographically strong and securely seeded.
+         */
+        constructor(randomNumberGenerator) {
+            this.timestamp = 0;
+            this.counter = 0;
+            this.random = randomNumberGenerator !== null && randomNumberGenerator !== void 0 ? randomNumberGenerator : getDefaultRandom();
+        }
+        /**
+         * Generates a new UUIDv7 object from the current timestamp, or resets the
+         * generator upon significant timestamp rollback.
+         *
+         * This method returns a monotonically increasing UUID by reusing the previous
+         * timestamp even if the up-to-date timestamp is smaller than the immediately
+         * preceding UUID's. However, when such a clock rollback is considered
+         * significant (i.e., by more than ten seconds), this method resets the
+         * generator and returns a new UUID based on the given timestamp, breaking the
+         * increasing order of UUIDs.
+         *
+         * See {@link generateOrAbort} for the other mode of generation and
+         * {@link generateOrResetCore} for the low-level primitive.
+         */
+        generate() {
+            return this.generateOrResetCore(Date.now(), 10000);
+        }
+        /**
+         * Generates a new UUIDv7 object from the current timestamp, or returns
+         * `undefined` upon significant timestamp rollback.
+         *
+         * This method returns a monotonically increasing UUID by reusing the previous
+         * timestamp even if the up-to-date timestamp is smaller than the immediately
+         * preceding UUID's. However, when such a clock rollback is considered
+         * significant (i.e., by more than ten seconds), this method aborts and
+         * returns `undefined` immediately.
+         *
+         * See {@link generate} for the other mode of generation and
+         * {@link generateOrAbortCore} for the low-level primitive.
+         */
+        generateOrAbort() {
+            return this.generateOrAbortCore(Date.now(), 10000);
+        }
+        /**
+         * Generates a new UUIDv7 object from the `unixTsMs` passed, or resets the
+         * generator upon significant timestamp rollback.
+         *
+         * This method is equivalent to {@link generate} except that it takes a custom
+         * timestamp and clock rollback allowance.
+         *
+         * @param rollbackAllowance - The amount of `unixTsMs` rollback that is
+         * considered significant. A suggested value is `10_000` (milliseconds).
+         * @throws RangeError if `unixTsMs` is not a 48-bit positive integer.
+         */
+        generateOrResetCore(unixTsMs, rollbackAllowance) {
+            let value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
+            if (value === undefined) {
+                // reset state and resume
+                this.timestamp = 0;
+                value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
+            }
+            return value;
+        }
+        /**
+         * Generates a new UUIDv7 object from the `unixTsMs` passed, or returns
+         * `undefined` upon significant timestamp rollback.
+         *
+         * This method is equivalent to {@link generateOrAbort} except that it takes a
+         * custom timestamp and clock rollback allowance.
+         *
+         * @param rollbackAllowance - The amount of `unixTsMs` rollback that is
+         * considered significant. A suggested value is `10_000` (milliseconds).
+         * @throws RangeError if `unixTsMs` is not a 48-bit positive integer.
+         */
+        generateOrAbortCore(unixTsMs, rollbackAllowance) {
+            const MAX_COUNTER = 4398046511103;
+            if (!Number.isInteger(unixTsMs) ||
+                unixTsMs < 1 ||
+                unixTsMs > 281474976710655) {
+                throw new RangeError("`unixTsMs` must be a 48-bit positive integer");
+            }
+            else if (rollbackAllowance < 0 || rollbackAllowance > 281474976710655) {
+                throw new RangeError("`rollbackAllowance` out of reasonable range");
+            }
+            if (unixTsMs > this.timestamp) {
+                this.timestamp = unixTsMs;
+                this.resetCounter();
+            }
+            else if (unixTsMs + rollbackAllowance >= this.timestamp) {
+                // go on with previous timestamp if new one is not much smaller
+                this.counter++;
+                if (this.counter > MAX_COUNTER) {
+                    // increment timestamp at counter overflow
+                    this.timestamp++;
+                    this.resetCounter();
+                }
+            }
+            else {
+                // abort if clock went backwards to unbearable extent
+                return undefined;
+            }
+            return UUID.fromFieldsV7(this.timestamp, Math.trunc(this.counter / 2 ** 30), this.counter & (2 ** 30 - 1), this.random.nextUint32());
+        }
+        /** Initializes the counter at a 42-bit random integer. */
+        resetCounter() {
+            this.counter =
+                this.random.nextUint32() * 0x400 + (this.random.nextUint32() & 0x3ff);
+        }
+        /**
+         * Generates a new UUIDv4 object utilizing the random number generator inside.
+         *
+         * @internal
+         */
+        generateV4() {
+            const bytes = new Uint8Array(Uint32Array.of(this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32()).buffer);
+            bytes[6] = 0x40 | (bytes[6] >>> 4);
+            bytes[8] = 0x80 | (bytes[8] >>> 2);
+            return UUID.ofInner(bytes);
+        }
+    }
+    /** Returns the default random number generator available in the environment. */
+    const getDefaultRandom = () => {
+        // detect Web Crypto API
+        if (typeof crypto !== "undefined" &&
+            typeof crypto.getRandomValues !== "undefined") {
+            return new BufferedCryptoRandom();
+        }
+        else {
+            // fall back on Math.random() unless the flag is set to true
+            if (typeof UUIDV7_DENY_WEAK_RNG !== "undefined" && UUIDV7_DENY_WEAK_RNG) {
+                throw new Error("no cryptographically strong RNG available");
+            }
+            return {
+                nextUint32: () => Math.trunc(Math.random() * 65536) * 65536 +
+                    Math.trunc(Math.random() * 65536),
+            };
+        }
+    };
+    /**
+     * Wraps `crypto.getRandomValues()` to enable buffering; this uses a small
+     * buffer by default to avoid both unbearable throughput decline in some
+     * environments and the waste of time and space for unused values.
+     */
+    class BufferedCryptoRandom {
+        constructor() {
+            this.buffer = new Uint32Array(8);
+            this.cursor = 0xffff;
+        }
+        nextUint32() {
+            if (this.cursor >= this.buffer.length) {
+                crypto.getRandomValues(this.buffer);
+                this.cursor = 0;
+            }
+            return this.buffer[this.cursor++];
+        }
+    }
+    let defaultGenerator;
+    /**
+     * Generates a UUIDv7 string.
+     *
+     * @returns The 8-4-4-4-12 canonical hexadecimal string representation
+     * ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx").
+     */
+    const uuidv7 = () => uuidv7obj().toString();
+    /** Generates a UUIDv7 object. */
+    const uuidv7obj = () => (defaultGenerator || (defaultGenerator = new V7Generator())).generate();
+    const generateUuidv7 = () => {
+        return uuidv7();
+    };
+    const getCurrentTimestamp = () => {
+        return new Date().toISOString();
+    };
+    const getCurrentUrl = () => {
+        if (typeof window !== 'undefined') {
+            return window.location.href;
+        }
+        return '';
+    };
+    const getPageTitle = () => {
+        if (typeof document !== 'undefined') {
+            return document.title;
+        }
+        return '';
+    };
+    const getReferrer = () => {
+        if (typeof document !== 'undefined') {
+            return document.referrer;
+        }
+        return '';
+    };
+    const isBrowser = () => {
+        return typeof window !== 'undefined';
+    };
+    const isNode = () => {
+        var _a;
+        return typeof process !== 'undefined' && !!((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node);
+    };
+    const fetchRemoteOptions = async (apiHost, publishableKey, fetchFn) => {
+        const endpoint = '/v1/configs';
+        const url = `${apiHost}${endpoint}?ingestion_key=${encodeURIComponent(publishableKey)}`;
+        try {
+            let fetch = fetchFn;
+            if (!fetch) {
+                if (isNode()) {
+                    // For Node.js environments, expect fetch to be passed in
+                    throw new Error('Fetch function must be provided in Node.js environment');
+                }
+                else {
+                    // Use native fetch in browser
+                    fetch = window.fetch;
+                }
+            }
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            // if (!response.ok) {
+            //   throw new Error(`Options fetch failed: ${response.status} ${response.statusText}`);
+            // }
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            console.warn('Failed to fetch remote options:', error);
+            return null;
+        }
+    };
+    const mergeOptions = (localOptions, remoteOptions) => {
+        if (!remoteOptions && !localOptions) {
+            return {};
+        }
+        if (!remoteOptions) {
+            return localOptions;
+        }
+        if (!localOptions) {
+            return remoteOptions;
+        }
+        // Deep merge local options into remote options
+        // Local options takes precedence over remote options
+        const merged = { ...remoteOptions };
+        // Handle primitive values
+        Object.keys(localOptions).forEach(key => {
+            const localValue = localOptions[key];
+            if (localValue !== undefined && localValue !== null) {
+                if (typeof localValue === 'object' && !Array.isArray(localValue)) {
+                    // Deep merge objects - local options overrides remote
+                    merged[key] = {
+                        ...(merged[key] || {}),
+                        ...localValue
+                    };
+                }
+                else {
+                    // Override primitive values and arrays with local options
+                    merged[key] = localValue;
+                }
+            }
+        });
+        return merged;
+    };
+
+    const DEFAULT_SESSION_TIMEOUT = 30 * 60 * 1000; // 30 minutes in ms
+    class BrowserIdentityManager {
+        constructor(sessionTimeout, publishableKey) {
+            this.identity = null;
+            this.sessionTimeout = DEFAULT_SESSION_TIMEOUT;
+            if (sessionTimeout) {
+                this.sessionTimeout = sessionTimeout;
+            }
+            // Generate storage key with publishableKey pattern: jrnm_<publishableKey>_journium
+            this.storageKey = publishableKey ? `jrnm_${publishableKey}_journium` : '__journium_identity';
+            this.loadOrCreateIdentity();
+        }
+        loadOrCreateIdentity() {
+            if (!this.isBrowser())
+                return;
+            try {
+                const stored = localStorage.getItem(this.storageKey);
+                if (stored) {
+                    const parsedIdentity = JSON.parse(stored);
+                    // Check if session is expired
+                    const now = Date.now();
+                    const sessionAge = now - parsedIdentity.session_timestamp;
+                    if (sessionAge > this.sessionTimeout) {
+                        // Session expired, create new session but keep device and distinct IDs
+                        this.identity = {
+                            distinct_id: parsedIdentity.distinct_id,
+                            $device_id: parsedIdentity.$device_id,
+                            $session_id: generateUuidv7(),
+                            session_timestamp: now,
+                            $user_state: parsedIdentity.$user_state || 'anonymous',
+                        };
+                    }
+                    else {
+                        // Session still valid
+                        this.identity = parsedIdentity;
+                        // Ensure $user_state exists for backward compatibility
+                        if (!this.identity.$user_state) {
+                            this.identity.$user_state = 'anonymous';
+                        }
+                    }
+                }
+                else {
+                    // First time, create all new IDs
+                    const newId = generateUuidv7();
+                    this.identity = {
+                        distinct_id: newId,
+                        $device_id: newId,
+                        $session_id: newId,
+                        session_timestamp: Date.now(),
+                        $user_state: 'anonymous',
+                    };
+                }
+                // Save to localStorage
+                this.saveIdentity();
+            }
+            catch (error) {
+                console.warn('Journium: Failed to load/create identity:', error);
+                // Fallback: create temporary identity without localStorage
+                const newId = generateUuidv7();
+                this.identity = {
+                    distinct_id: newId,
+                    $device_id: newId,
+                    $session_id: newId,
+                    session_timestamp: Date.now(),
+                    $user_state: 'anonymous',
+                };
+            }
+        }
+        saveIdentity() {
+            if (!this.isBrowser() || !this.identity)
+                return;
+            try {
+                localStorage.setItem(this.storageKey, JSON.stringify(this.identity));
+            }
+            catch (error) {
+                console.warn('Journium: Failed to save identity to localStorage:', error);
+            }
+        }
+        isBrowser() {
+            return typeof window !== 'undefined' && typeof localStorage !== 'undefined';
+        }
+        getIdentity() {
+            return this.identity;
+        }
+        updateSessionTimeout(timeoutMs) {
+            this.sessionTimeout = timeoutMs;
+        }
+        refreshSession() {
+            if (!this.identity)
+                return;
+            this.identity = {
+                ...this.identity,
+                $session_id: generateUuidv7(),
+                session_timestamp: Date.now(),
+            };
+            this.saveIdentity();
+        }
+        identify(distinctId, _attributes = {}) {
+            if (!this.identity)
+                return { previousDistinctId: null };
+            const previousDistinctId = this.identity.distinct_id;
+            // Update the distinct ID and mark user as identified
+            this.identity = {
+                ...this.identity,
+                distinct_id: distinctId,
+                $user_state: 'identified',
+            };
+            this.saveIdentity();
+            return { previousDistinctId };
+        }
+        reset() {
+            if (!this.identity)
+                return;
+            // Generate new distinct ID but keep device ID
+            this.identity = {
+                ...this.identity,
+                distinct_id: generateUuidv7(),
+                $user_state: 'anonymous',
+            };
+            this.saveIdentity();
+        }
+        getUserAgentInfo() {
+            if (!this.isBrowser()) {
+                return {
+                    $raw_user_agent: '',
+                    $browser: 'Unknown',
+                    $os: 'Unknown',
+                    $device_type: 'Unknown',
+                };
+            }
+            const userAgent = navigator.userAgent;
+            return {
+                $raw_user_agent: userAgent,
+                $browser: this.parseBrowser(userAgent),
+                $os: this.parseOS(userAgent),
+                $device_type: this.parseDeviceType(userAgent),
+            };
+        }
+        parseBrowser(userAgent) {
+            if (userAgent.includes('Chrome') && !userAgent.includes('Edg'))
+                return 'Chrome';
+            if (userAgent.includes('Firefox'))
+                return 'Firefox';
+            if (userAgent.includes('Safari') && !userAgent.includes('Chrome'))
+                return 'Safari';
+            if (userAgent.includes('Edg'))
+                return 'Edge';
+            if (userAgent.includes('Opera') || userAgent.includes('OPR'))
+                return 'Opera';
+            return 'Unknown';
+        }
+        parseOS(userAgent) {
+            if (userAgent.includes('Windows'))
+                return 'Windows';
+            if (userAgent.includes('Macintosh') || userAgent.includes('Mac OS'))
+                return 'Mac OS';
+            if (userAgent.includes('Linux'))
+                return 'Linux';
+            if (userAgent.includes('Android'))
+                return 'Android';
+            if (userAgent.includes('iPhone') || userAgent.includes('iPad'))
+                return 'iOS';
+            return 'Unknown';
+        }
+        parseDeviceType(userAgent) {
+            if (userAgent.includes('Mobile') || userAgent.includes('Android') || userAgent.includes('iPhone')) {
+                return 'Mobile';
+            }
+            if (userAgent.includes('iPad') || userAgent.includes('Tablet')) {
+                return 'Tablet';
+            }
+            return 'Desktop';
+        }
+    }
+
+    class Logger {
+        static setDebug(enabled) {
+            this.isDebugEnabled = enabled;
+        }
+        static isDebug() {
+            return this.isDebugEnabled;
+        }
+        static log(...args) {
+            if (this.isDebugEnabled) {
+                console.log(...args);
+            }
+        }
+        static warn(...args) {
+            if (this.isDebugEnabled) {
+                console.warn(...args);
+            }
+        }
+        static error(...args) {
+            if (this.isDebugEnabled) {
+                console.error(...args);
+            }
+        }
+        static info(...args) {
+            if (this.isDebugEnabled) {
+                console.info(...args);
+            }
+        }
+    }
+    Logger.isDebugEnabled = false;
+
+    class JourniumClient {
+        constructor(config) {
+            var _a, _b, _c, _d;
+            this.queue = [];
+            this.stagedEvents = [];
+            this.flushTimer = null;
+            this.remoteOptionsRefreshTimer = null;
+            this.isRefreshing = false;
+            this.lastRemoteOptions = null;
+            this.initializationComplete = false;
+            this.initializationFailed = false;
+            this.optionsChangeCallbacks = new Set();
+            // Validate required configuration
+            if (!config.publishableKey || config.publishableKey.trim() === '') {
+                // Reject initialization with clear error
+                const errorMsg = 'Journium: publishableKey is required but not provided or is empty. SDK cannot be initialized.';
+                Logger.setDebug(true);
+                Logger.error(errorMsg);
+                throw new Error(errorMsg);
+            }
+            // Set default apiHost if not provided
+            this.config = {
+                ...config,
+                apiHost: config.apiHost || 'https://events.journium.app'
+            };
+            // Generate storage key for options caching
+            this.optionsStorageKey = `jrnm_${config.publishableKey}_options`;
+            // Initialize with minimal defaults for identity manager
+            const fallbackSessionTimeout = 30 * 60 * 1000; // 30 minutes
+            this.effectiveOptions = {}; // Will be set after remote config
+            // Initialize Logger with local debug setting or false
+            Logger.setDebug((_b = (_a = this.config.options) === null || _a === void 0 ? void 0 : _a.debug) !== null && _b !== void 0 ? _b : false);
+            // Initialize identity manager with fallback timeout
+            this.identityManager = new BrowserIdentityManager((_d = (_c = this.config.options) === null || _c === void 0 ? void 0 : _c.sessionTimeout) !== null && _d !== void 0 ? _d : fallbackSessionTimeout, this.config.publishableKey);
+            // Initialize asynchronously - wait for remote config first
+            this.initializeAsync();
+        }
+        loadCachedOptions() {
+            if (typeof window === 'undefined' || !window.localStorage) {
+                return null;
+            }
+            try {
+                const cached = window.localStorage.getItem(this.optionsStorageKey);
+                return cached ? JSON.parse(cached) : null;
+            }
+            catch (error) {
+                Logger.warn('Journium: Failed to load cached config:', error);
+                return null;
+            }
+        }
+        saveCachedOptions(options) {
+            if (typeof window === 'undefined' || !window.localStorage) {
+                return;
+            }
+            try {
+                window.localStorage.setItem(this.optionsStorageKey, JSON.stringify(options));
+            }
+            catch (error) {
+                Logger.warn('Journium: Failed to save config to cache:', error);
+            }
+        }
+        async initializeAsync() {
+            try {
+                Logger.log('Journium: Starting initialization - fetching fresh remote config...');
+                const remoteOptions = await this.fetchRemoteOptionsWithRetry();
+                if (!remoteOptions) {
+                    Logger.error('Journium: Initialization failed - no remote config available');
+                    this.initializationFailed = true;
+                    return;
+                }
+                this.applyRemoteOptions(remoteOptions);
+                Logger.log('Journium: Effective options after init:', this.effectiveOptions);
+                this.initializationComplete = true;
+                this.initializationFailed = false;
+                this.processStagedEvents();
+                if (this.effectiveOptions.flushInterval && this.effectiveOptions.flushInterval > 0) {
+                    this.startFlushTimer();
+                }
+                this.startRemoteOptionsRefreshTimer();
+                Logger.log('Journium: Initialization complete');
+                this.notifyOptionsChange();
+            }
+            catch (error) {
+                Logger.error('Journium: Initialization failed:', error);
+                this.initializationFailed = true;
+                this.initializationComplete = false;
+            }
+        }
+        async fetchRemoteOptionsWithRetry() {
+            const maxRetries = 2;
+            const timeoutMs = 15000; // 15 seconds
+            for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                try {
+                    Logger.log(`Journium: Fetching remote config (attempt ${attempt}/${maxRetries})...`);
+                    // Create timeout promise
+                    const timeoutPromise = new Promise((_, reject) => {
+                        setTimeout(() => reject(new Error('Timeout')), timeoutMs);
+                    });
+                    // Race fetch against timeout
+                    const fetchPromise = fetchRemoteOptions(this.config.apiHost, this.config.publishableKey);
+                    const remoteOptionsResponse = await Promise.race([fetchPromise, timeoutPromise]);
+                    if (remoteOptionsResponse && remoteOptionsResponse.status === 'success') {
+                        Logger.log('Journium: Successfully fetched fresh remote config:', remoteOptionsResponse.config);
+                        return remoteOptionsResponse.config || null;
+                    }
+                    else if (remoteOptionsResponse && remoteOptionsResponse.status === 'error' && remoteOptionsResponse.errorCode === 'J_ERR_TENANT_NOT_FOUND') {
+                        Logger.error('Journium: Invalid publishableKey is being used.');
+                        return null;
+                    }
+                    {
+                        throw new Error('Remote config fetch unsuccessful');
+                    }
+                }
+                catch (error) {
+                    Logger.warn(`Journium: Remote config fetch attempt ${attempt} failed:`, error);
+                    if (attempt === maxRetries) {
+                        Logger.warn('Journium: All remote config fetch attempts failed, falling back to cached config');
+                        return null;
+                    }
+                    // Wait 1 second before retry (except on last attempt)
+                    if (attempt < maxRetries) {
+                        await new Promise(resolve => setTimeout(resolve, 1000));
+                    }
+                }
+            }
+            return null;
+        }
+        /**
+         * Register a callback to be notified when effective options change (e.g., when remote options are fetched)
+         */
+        onOptionsChange(callback) {
+            this.optionsChangeCallbacks.add(callback);
+            // Return unsubscribe function
+            return () => {
+                this.optionsChangeCallbacks.delete(callback);
+            };
+        }
+        notifyOptionsChange() {
+            this.optionsChangeCallbacks.forEach(callback => {
+                try {
+                    callback(this.effectiveOptions);
+                }
+                catch (error) {
+                    Logger.warn('Journium: Error in options change callback:', error);
+                }
+            });
+        }
+        processStagedEvents() {
+            if (this.stagedEvents.length === 0)
+                return;
+            if (this.ingestionPaused) {
+                Logger.warn(`Journium: Ingestion is paused — discarding ${this.stagedEvents.length} staged events`);
+                this.stagedEvents = [];
+                return;
+            }
+            Logger.log(`Journium: Processing ${this.stagedEvents.length} staged events`);
+            for (const stagedEvent of this.stagedEvents) {
+                this.queue.push({
+                    ...stagedEvent,
+                    properties: this.buildIdentityProperties(stagedEvent.properties),
+                });
+            }
+            this.stagedEvents = [];
+            Logger.log('Journium: Staged events processed and moved to main queue');
+            if (this.queue.length >= this.effectiveOptions.flushAt) {
+                this.flush();
+            }
+        }
+        startFlushTimer() {
+            if (this.flushTimer) {
+                clearInterval(this.flushTimer);
+            }
+            this.flushTimer = setInterval(() => {
+                this.flush();
+            }, this.effectiveOptions.flushInterval);
+        }
+        startRemoteOptionsRefreshTimer() {
+            // Clear any existing timer to prevent duplicate intervals
+            if (this.remoteOptionsRefreshTimer) {
+                clearInterval(this.remoteOptionsRefreshTimer);
+                this.remoteOptionsRefreshTimer = null;
+            }
+            this.remoteOptionsRefreshTimer = setInterval(() => {
+                this.refreshRemoteOptions();
+            }, JourniumClient.REMOTE_OPTIONS_REFRESH_INTERVAL);
+            Logger.log(`Journium: Scheduling remote options refresh every ${JourniumClient.REMOTE_OPTIONS_REFRESH_INTERVAL}ms`);
+        }
+        async refreshRemoteOptions() {
+            if (this.isRefreshing) {
+                Logger.log('Journium: Remote options refresh already in progress, skipping');
+                return;
+            }
+            this.isRefreshing = true;
+            Logger.log('Journium: Periodic remote options refresh triggered');
+            try {
+                const remoteOptions = await this.fetchRemoteOptionsWithRetry();
+                if (!remoteOptions) {
+                    Logger.warn('Journium: Periodic remote options refresh failed, keeping current options');
+                    return;
+                }
+                const prevRemoteSnapshot = JSON.stringify(this.lastRemoteOptions);
+                const prevFlushInterval = this.effectiveOptions.flushInterval;
+                this.applyRemoteOptions(remoteOptions);
+                if (prevRemoteSnapshot === JSON.stringify(this.lastRemoteOptions)) {
+                    Logger.log('Journium: Remote options unchanged after refresh, no update needed');
+                    return;
+                }
+                Logger.log('Journium: Remote options updated after refresh:', this.effectiveOptions);
+                if (this.effectiveOptions.flushInterval !== prevFlushInterval) {
+                    if (this.effectiveOptions.flushInterval && this.effectiveOptions.flushInterval > 0) {
+                        this.startFlushTimer();
+                    }
+                    else if (this.flushTimer) {
+                        clearInterval(this.flushTimer);
+                        this.flushTimer = null;
+                    }
+                }
+                this.notifyOptionsChange();
+            }
+            catch (error) {
+                Logger.error('Journium: Periodic remote options refresh encountered an error:', error);
+            }
+            finally {
+                this.isRefreshing = false;
+            }
+        }
+        applyRemoteOptions(remoteOptions) {
+            var _a;
+            this.lastRemoteOptions = remoteOptions;
+            this.effectiveOptions = this.config.options
+                ? mergeOptions(this.config.options, remoteOptions)
+                : remoteOptions;
+            this.saveCachedOptions(remoteOptions);
+            if (this.effectiveOptions.sessionTimeout) {
+                this.identityManager.updateSessionTimeout(this.effectiveOptions.sessionTimeout);
+            }
+            Logger.setDebug((_a = this.effectiveOptions.debug) !== null && _a !== void 0 ? _a : false);
+        }
+        buildIdentityProperties(userProperties = {}) {
+            const identity = this.identityManager.getIdentity();
+            const userAgentInfo = this.identityManager.getUserAgentInfo();
+            return {
+                $device_id: identity === null || identity === void 0 ? void 0 : identity.$device_id,
+                distinct_id: identity === null || identity === void 0 ? void 0 : identity.distinct_id,
+                $session_id: identity === null || identity === void 0 ? void 0 : identity.$session_id,
+                $is_identified: (identity === null || identity === void 0 ? void 0 : identity.$user_state) === 'identified',
+                $current_url: typeof window !== 'undefined' ? window.location.href : '',
+                $pathname: typeof window !== 'undefined' ? window.location.pathname : '',
+                ...userAgentInfo,
+                $lib_version: '0.1.0', // TODO: Get from package.json
+                $platform: 'web',
+                ...userProperties,
+            };
+        }
+        async sendEvents(events) {
+            if (!events.length)
+                return;
+            try {
+                const response = await fetch(`${this.config.apiHost}/v1/ingest_event`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.config.publishableKey}`,
+                    },
+                    body: JSON.stringify({
+                        events,
+                    }),
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                Logger.log('Journium: Successfully sent events', events);
+            }
+            catch (error) {
+                Logger.error('Journium: Failed to send events', error);
+                throw error;
+            }
+        }
+        identify(distinctId, attributes = {}) {
+            // Don't identify if initialization failed
+            if (this.initializationFailed) {
+                Logger.warn('Journium: identify() call rejected - initialization failed');
+                return;
+            }
+            // Call identify on identity manager to get previous distinct ID
+            const { previousDistinctId } = this.identityManager.identify(distinctId, attributes);
+            // Track $identify event with previous distinct ID
+            const identifyProperties = {
+                ...attributes,
+                $anon_distinct_id: previousDistinctId,
+            };
+            this.track('$identify', identifyProperties);
+            Logger.log('Journium: User identified', { distinctId, attributes, previousDistinctId });
+        }
+        reset() {
+            // Don't reset if initialization failed
+            if (this.initializationFailed) {
+                Logger.warn('Journium: reset() call rejected - initialization failed');
+                return;
+            }
+            // Reset identity in identity manager
+            this.identityManager.reset();
+            Logger.log('Journium: User identity reset');
+        }
+        track(event, properties = {}) {
+            // Create minimal event without identity properties (will be added later if staging)
+            const journiumEvent = {
+                uuid: generateUuidv7(),
+                ingestion_key: this.config.publishableKey,
+                client_timestamp: getCurrentTimestamp(),
+                event,
+                properties: { ...properties }, // Only user properties for now
+            };
+            if (!this.initializationComplete) {
+                if (this.initializationFailed) {
+                    Logger.warn('Journium: track() call rejected - initialization failed');
+                    return;
+                }
+                this.stagedEvents.push(journiumEvent);
+                Logger.log('Journium: Event staged during initialization', journiumEvent);
+                return;
+            }
+            if (this.ingestionPaused) {
+                Logger.warn('Journium: Ingestion is paused — event dropped:', journiumEvent.event);
+                return;
+            }
+            const eventWithIdentity = {
+                ...journiumEvent,
+                properties: this.buildIdentityProperties(properties),
+            };
+            this.queue.push(eventWithIdentity);
+            Logger.log('Journium: Event tracked', eventWithIdentity);
+            if (this.effectiveOptions.flushAt && this.queue.length >= this.effectiveOptions.flushAt) {
+                this.flush();
+            }
+        }
+        async flush() {
+            // Don't flush if initialization failed
+            if (this.initializationFailed) {
+                Logger.warn('Journium: flush() call rejected - initialization failed');
+                return;
+            }
+            if (this.queue.length === 0)
+                return;
+            const events = [...this.queue];
+            this.queue = [];
+            try {
+                await this.sendEvents(events);
+            }
+            catch (error) {
+                this.queue.unshift(...events);
+                throw error;
+            }
+        }
+        destroy() {
+            if (this.flushTimer) {
+                clearInterval(this.flushTimer);
+                this.flushTimer = null;
+            }
+            if (this.remoteOptionsRefreshTimer) {
+                clearInterval(this.remoteOptionsRefreshTimer);
+                this.remoteOptionsRefreshTimer = null;
+            }
+            this.flush();
+        }
+        getEffectiveOptions() {
+            return this.effectiveOptions;
+        }
+        get ingestionPaused() {
+            return this.effectiveOptions['ingestionPaused'] === true;
+        }
+    }
+    JourniumClient.REMOTE_OPTIONS_REFRESH_INTERVAL = 15 * 60 * 1000; // 15 minutes
+
+    class PageviewTracker {
+        constructor(client) {
+            this.lastUrl = '';
+            this.originalPushState = null;
+            this.originalReplaceState = null;
+            this.popStateHandler = null;
+            this.client = client;
+        }
+        capturePageview(customProperties = {}) {
+            const currentUrl = getCurrentUrl();
+            const url = new URL(currentUrl);
+            const properties = {
+                $current_url: currentUrl,
+                $host: url.host,
+                $pathname: url.pathname,
+                $search: url.search,
+                $title: getPageTitle(),
+                $referrer: getReferrer(),
+                ...customProperties,
+            };
+            this.client.track('$pageview', properties);
+            this.lastUrl = currentUrl;
+        }
+        /**
+         * Start automatic autocapture for pageviews
+         * @param captureInitialPageview - whether to fire a $pageview immediately on start (default: true).
+         *   Pass false when restarting after a remote options update to avoid a spurious pageview.
+         */
+        startAutoPageviewTracking(captureInitialPageview = true) {
+            if (captureInitialPageview) {
+                this.capturePageview();
+            }
+            if (typeof window !== 'undefined') {
+                // Store original methods for cleanup
+                this.originalPushState = window.history.pushState;
+                this.originalReplaceState = window.history.replaceState;
+                window.history.pushState = (...args) => {
+                    this.originalPushState.apply(window.history, args);
+                    setTimeout(() => this.capturePageview(), 0);
+                };
+                window.history.replaceState = (...args) => {
+                    this.originalReplaceState.apply(window.history, args);
+                    setTimeout(() => this.capturePageview(), 0);
+                };
+                this.popStateHandler = () => {
+                    setTimeout(() => this.capturePageview(), 0);
+                };
+                window.addEventListener('popstate', this.popStateHandler);
+            }
+        }
+        /**
+         * Stop automatic autocapture for pageviews
+         * @returns void
+         */
+        stopAutocapture() {
+            if (typeof window !== 'undefined') {
+                // Restore original methods
+                if (this.originalPushState) {
+                    window.history.pushState = this.originalPushState;
+                    this.originalPushState = null;
+                }
+                if (this.originalReplaceState) {
+                    window.history.replaceState = this.originalReplaceState;
+                    this.originalReplaceState = null;
+                }
+                if (this.popStateHandler) {
+                    window.removeEventListener('popstate', this.popStateHandler);
+                    this.popStateHandler = null;
+                }
+            }
+        }
+    }
+
+    /**
+     * AutocaptureTracker is responsible for tracking user interactions and capturing them as events.
+     */
+    class AutocaptureTracker {
+        constructor(client, options = {}) {
+            this.listeners = new Map();
+            this.isActive = false;
+            this.client = client;
+            this.options = {
+                captureClicks: true,
+                captureFormSubmits: true,
+                captureFormChanges: true,
+                captureTextSelection: false,
+                ignoreClasses: ['journium-ignore'],
+                ignoreElements: ['script', 'style', 'noscript'],
+                captureContentText: true,
+                ...options,
+            };
+        }
+        /**
+         * Update autocapture options and restart if currently active
+         */
+        updateOptions(options) {
+            const wasActive = this.isActive;
+            // Stop if currently active
+            if (wasActive) {
+                this.stop();
+            }
+            // Update options
+            this.options = {
+                captureClicks: true,
+                captureFormSubmits: true,
+                captureFormChanges: true,
+                captureTextSelection: false,
+                ignoreClasses: ['journium-ignore'],
+                ignoreElements: ['script', 'style', 'noscript'],
+                captureContentText: true,
+                ...options,
+            };
+            // Restart if it was active before
+            if (wasActive) {
+                this.start();
+            }
+        }
+        start() {
+            if (!isBrowser() || this.isActive) {
+                return;
+            }
+            this.isActive = true;
+            if (this.options.captureClicks) {
+                this.addClickListener();
+            }
+            if (this.options.captureFormSubmits) {
+                this.addFormSubmitListener();
+            }
+            if (this.options.captureFormChanges) {
+                this.addFormChangeListener();
+            }
+            if (this.options.captureTextSelection) {
+                this.addTextSelectionListener();
+            }
+        }
+        stop() {
+            if (!isBrowser() || !this.isActive) {
+                return;
+            }
+            this.isActive = false;
+            this.listeners.forEach((listener, event) => {
+                document.removeEventListener(event, listener, true);
+            });
+            this.listeners.clear();
+        }
+        addClickListener() {
+            const clickListener = (event) => {
+                const target = event.target;
+                if (this.shouldIgnoreElement(target)) {
+                    return;
+                }
+                const properties = this.getElementProperties(target, 'click');
+                this.client.track('$autocapture', {
+                    $event_type: 'click',
+                    ...properties,
+                });
+            };
+            document.addEventListener('click', clickListener, true);
+            this.listeners.set('click', clickListener);
+        }
+        addFormSubmitListener() {
+            const submitListener = (event) => {
+                const target = event.target;
+                if (this.shouldIgnoreElement(target)) {
+                    return;
+                }
+                const properties = this.getFormProperties(target, 'submit');
+                this.client.track('$autocapture', {
+                    $event_type: 'submit',
+                    ...properties,
+                });
+            };
+            document.addEventListener('submit', submitListener, true);
+            this.listeners.set('submit', submitListener);
+        }
+        addFormChangeListener() {
+            const changeListener = (event) => {
+                const target = event.target;
+                if (this.shouldIgnoreElement(target) || !this.isFormElement(target)) {
+                    return;
+                }
+                const properties = this.getInputProperties(target, 'change');
+                this.client.track('$autocapture', {
+                    $event_type: 'change',
+                    ...properties,
+                });
+            };
+            document.addEventListener('change', changeListener, true);
+            this.listeners.set('change', changeListener);
+        }
+        addTextSelectionListener() {
+            const selectionListener = () => {
+                const selection = window.getSelection();
+                if (!selection || selection.toString().trim().length === 0) {
+                    return;
+                }
+                const selectedText = selection.toString().trim();
+                if (selectedText.length < 3) { // Ignore very short selections
+                    return;
+                }
+                this.client.track('$autocapture', {
+                    $event_type: 'text_selection',
+                    $selected_text: selectedText.substring(0, 200), // Limit text length
+                    $selection_length: selectedText.length,
+                });
+            };
+            document.addEventListener('mouseup', selectionListener);
+            this.listeners.set('mouseup', selectionListener);
+        }
+        shouldIgnoreElement(element) {
+            var _a, _b, _c;
+            if (!element || !element.tagName) {
+                return true;
+            }
+            // Check if element should be ignored by tag name
+            if ((_a = this.options.ignoreElements) === null || _a === void 0 ? void 0 : _a.includes(element.tagName.toLowerCase())) {
+                return true;
+            }
+            // Check if element has ignore classes
+            if ((_b = this.options.ignoreClasses) === null || _b === void 0 ? void 0 : _b.some(cls => element.classList.contains(cls))) {
+                return true;
+            }
+            // Check parent elements for ignore classes
+            let parent = element.parentElement;
+            while (parent) {
+                if ((_c = this.options.ignoreClasses) === null || _c === void 0 ? void 0 : _c.some(cls => parent.classList.contains(cls))) {
+                    return true;
+                }
+                parent = parent.parentElement;
+            }
+            return false;
+        }
+        isFormElement(element) {
+            const formElements = ['input', 'select', 'textarea'];
+            return formElements.includes(element.tagName.toLowerCase());
+        }
+        getElementProperties(element, eventType) {
+            const properties = {
+                $element_tag: element.tagName.toLowerCase(),
+                $element_type: this.getElementType(element),
+            };
+            // Element identifiers
+            if (element.id) {
+                properties.$element_id = element.id;
+            }
+            if (element.className) {
+                properties.$element_classes = Array.from(element.classList);
+            }
+            // Element attributes
+            const relevantAttributes = ['name', 'role', 'aria-label', 'data-testid', 'data-track'];
+            relevantAttributes.forEach(attr => {
+                const value = element.getAttribute(attr);
+                if (value) {
+                    properties[`$element_${attr.replace('-', '_')}`] = value;
+                }
+            });
+            // Element content
+            if (this.options.captureContentText) {
+                const text = this.getElementText(element);
+                if (text) {
+                    properties.$element_text = text.substring(0, 200); // Limit text length
+                }
+            }
+            // Elements chain data
+            const elementsChain = this.getElementsChain(element);
+            properties.$elements_chain = elementsChain.chain;
+            properties.$elements_chain_href = elementsChain.href;
+            properties.$elements_chain_elements = elementsChain.elements;
+            properties.$elements_chain_texts = elementsChain.texts;
+            properties.$elements_chain_ids = elementsChain.ids;
+            // Position information
+            const rect = element.getBoundingClientRect();
+            properties.$element_position = {
+                x: Math.round(rect.left),
+                y: Math.round(rect.top),
+                width: Math.round(rect.width),
+                height: Math.round(rect.height),
+            };
+            // Parent information
+            if (element.parentElement) {
+                properties.$parent_tag = element.parentElement.tagName.toLowerCase();
+                if (element.parentElement.id) {
+                    properties.$parent_id = element.parentElement.id;
+                }
+            }
+            // URL information
+            properties.$current_url = window.location.href;
+            properties.$host = window.location.host;
+            properties.$pathname = window.location.pathname;
+            return properties;
+        }
+        getFormProperties(form, eventType) {
+            const properties = this.getElementProperties(form, eventType);
+            // Form-specific properties
+            properties.$form_method = form.method || 'get';
+            properties.$form_action = form.action || '';
+            // Count form elements
+            const inputs = form.querySelectorAll('input, select, textarea');
+            properties.$form_elements_count = inputs.length;
+            // Form element types
+            const elementTypes = {};
+            inputs.forEach(input => {
+                const type = this.getElementType(input);
+                elementTypes[type] = (elementTypes[type] || 0) + 1;
+            });
+            properties.$form_element_types = elementTypes;
+            return properties;
+        }
+        getInputProperties(input, eventType) {
+            const properties = this.getElementProperties(input, eventType);
+            // Input-specific properties
+            properties.$input_type = input.type || 'text';
+            if (input.name) {
+                properties.$input_name = input.name;
+            }
+            if (input.placeholder) {
+                properties.$input_placeholder = input.placeholder;
+            }
+            // Value information (be careful with sensitive data)
+            if (this.isSafeInputType(input.type)) {
+                if (input.type === 'checkbox' || input.type === 'radio') {
+                    properties.$input_checked = input.checked;
+                }
+                else if (input.value) {
+                    // For safe inputs, capture value length and basic characteristics
+                    properties.$input_value_length = input.value.length;
+                    properties.$input_has_value = input.value.length > 0;
+                    // For select elements, capture the selected value
+                    if (input.tagName.toLowerCase() === 'select') {
+                        properties.$input_selected_value = input.value;
+                    }
+                }
+            }
+            // Form context
+            const form = input.closest('form');
+            if (form && form.id) {
+                properties.$form_id = form.id;
+            }
+            return properties;
+        }
+        getElementType(element) {
+            const tag = element.tagName.toLowerCase();
+            if (tag === 'input') {
+                return element.type || 'text';
+            }
+            if (tag === 'button') {
+                return element.type || 'button';
+            }
+            return tag;
+        }
+        getElementText(element) {
+            var _a, _b;
+            // For buttons and links, get the visible text
+            if (['button', 'a'].includes(element.tagName.toLowerCase())) {
+                return ((_a = element.textContent) === null || _a === void 0 ? void 0 : _a.trim()) || '';
+            }
+            // For inputs, get placeholder or label
+            if (element.tagName.toLowerCase() === 'input') {
+                const input = element;
+                return input.placeholder || input.value || '';
+            }
+            // For other elements, get text content but limit it
+            const text = ((_b = element.textContent) === null || _b === void 0 ? void 0 : _b.trim()) || '';
+            return text.length > 50 ? text.substring(0, 47) + '...' : text;
+        }
+        getElementsChain(element) {
+            var _a;
+            const elements = [];
+            const texts = [];
+            const ids = [];
+            let href = '';
+            let current = element;
+            while (current && current !== document.body) {
+                // Element selector
+                let selector = current.tagName.toLowerCase();
+                // Add ID if present
+                if (current.id) {
+                    selector += `#${current.id}`;
+                    ids.push(current.id);
+                }
+                else {
+                    ids.push('');
+                }
+                // Add classes if present
+                if (current.className && typeof current.className === 'string') {
+                    const classes = current.className.trim().split(/\s+/).slice(0, 3); // Limit to first 3 classes
+                    if (classes.length > 0 && classes[0] !== '') {
+                        selector += '.' + classes.join('.');
+                    }
+                }
+                // Add nth-child if no ID (to make selector more specific)
+                if (!current.id && current.parentElement) {
+                    const siblings = Array.from(current.parentElement.children)
+                        .filter(child => child.tagName === current.tagName);
+                    if (siblings.length > 1) {
+                        const index = siblings.indexOf(current) + 1;
+                        selector += `:nth-child(${index})`;
+                    }
+                }
+                elements.push(selector);
+                // Extract text content
+                let text = '';
+                if (current.tagName.toLowerCase() === 'a') {
+                    text = ((_a = current.textContent) === null || _a === void 0 ? void 0 : _a.trim()) || '';
+                    // Capture href for links
+                    if (!href && current.getAttribute('href')) {
+                        href = current.getAttribute('href') || '';
+                    }
+                }
+                else if (['button', 'span', 'div'].includes(current.tagName.toLowerCase())) {
+                    // For buttons and text elements, get direct text content (not including children)
+                    const directText = Array.from(current.childNodes)
+                        .filter(node => node.nodeType === Node.TEXT_NODE)
+                        .map(node => { var _a; return (_a = node.textContent) === null || _a === void 0 ? void 0 : _a.trim(); })
+                        .join(' ')
+                        .trim();
+                    text = directText || '';
+                }
+                else if (current.tagName.toLowerCase() === 'input') {
+                    const input = current;
+                    text = input.placeholder || input.value || '';
+                }
+                // Limit text length and clean it
+                text = text.substring(0, 100).replace(/\s+/g, ' ').trim();
+                texts.push(text);
+                current = current.parentElement;
+            }
+            // Build the chain string (reverse order so it goes from parent to child)
+            const chain = elements.reverse().join(' > ');
+            return {
+                chain,
+                href,
+                elements: elements,
+                texts: texts.reverse(),
+                ids: ids.reverse()
+            };
+        }
+        isSafeInputType(type) {
+            // Don't capture values for sensitive input types
+            const sensitiveTypes = ['password', 'email', 'tel', 'credit-card-number'];
+            return !sensitiveTypes.includes(type.toLowerCase());
+        }
+    }
+
+    class JourniumAnalytics {
+        constructor(config) {
+            this.autocaptureStarted = false;
+            this.config = config;
+            this.client = new JourniumClient(config);
+            this.pageviewTracker = new PageviewTracker(this.client);
+            // Initialize autocapture tracker with effective options (may include cached remote options)
+            // This ensures we use the correct initial state even if cached remote options exist
+            const initialEffectiveOptions = this.client.getEffectiveOptions();
+            const initialAutocaptureOptions = this.resolveAutocaptureOptions(initialEffectiveOptions.autocapture);
+            this.autocaptureTracker = new AutocaptureTracker(this.client, initialAutocaptureOptions);
+            // Listen for options changes (e.g., when fresh remote options are fetched)
+            this.unsubscribeOptionsChange = this.client.onOptionsChange((effectiveOptions) => {
+                this.handleOptionsChange(effectiveOptions);
+            });
+            // Start automatic autocapture immediately if initial options support it
+            // This handles cached remote options or local options with autocapture enabled
+            this.startAutocaptureIfEnabled(initialEffectiveOptions);
+        }
+        resolveAutocaptureOptions(autocapture) {
+            if (autocapture === false) {
+                return {
+                    captureClicks: false,
+                    captureFormSubmits: false,
+                    captureFormChanges: false,
+                    captureTextSelection: false,
+                };
+            }
+            if (autocapture === true || autocapture === undefined) {
+                return {}; // Use default configuration (enabled by default)
+            }
+            return autocapture;
+        }
+        track(event, properties) {
+            this.client.track(event, properties);
+        }
+        identify(distinctId, attributes) {
+            this.client.identify(distinctId, attributes);
+        }
+        reset() {
+            this.client.reset();
+        }
+        capturePageview(properties) {
+            this.pageviewTracker.capturePageview(properties);
+        }
+        startAutocapture() {
+            // Always check effective options (which may include remote options)
+            const effectiveOptions = this.client.getEffectiveOptions();
+            // Only enable if effectiveOptions are loaded and autoTrackPageviews is not explicitly false
+            const autoTrackPageviews = effectiveOptions && Object.keys(effectiveOptions).length > 0
+                ? effectiveOptions.autoTrackPageviews !== false
+                : false;
+            const autocaptureEnabled = effectiveOptions && Object.keys(effectiveOptions).length > 0
+                ? effectiveOptions.autocapture !== false
+                : false;
+            // Update autocapture tracker options if they've changed
+            const autocaptureOptions = this.resolveAutocaptureOptions(effectiveOptions.autocapture);
+            this.autocaptureTracker.updateOptions(autocaptureOptions);
+            if (autoTrackPageviews) {
+                this.pageviewTracker.startAutoPageviewTracking();
+            }
+            if (autocaptureEnabled) {
+                this.autocaptureTracker.start();
+            }
+            this.autocaptureStarted = true;
+        }
+        stopAutocapture() {
+            this.pageviewTracker.stopAutocapture();
+            this.autocaptureTracker.stop();
+            this.autocaptureStarted = false;
+        }
+        /**
+         * Automatically start autocapture if enabled in options
+         * Handles both initial options and empty options during remote-first initialization
+         */
+        startAutocaptureIfEnabled(effectiveOptions) {
+            // Skip if autocapture was already started manually
+            if (this.autocaptureStarted) {
+                return;
+            }
+            // During remote-first initialization, effective options might be empty initially
+            // Only auto-start if we have actual options loaded, not empty options
+            const hasActualOptions = effectiveOptions && Object.keys(effectiveOptions).length > 0;
+            if (hasActualOptions) {
+                // Use same logic as manual startAutocapture() but only start automatically
+                const autoTrackPageviews = effectiveOptions.autoTrackPageviews !== false;
+                const autocaptureEnabled = effectiveOptions.autocapture !== false;
+                // Update autocapture tracker options
+                const autocaptureOptions = this.resolveAutocaptureOptions(effectiveOptions.autocapture);
+                this.autocaptureTracker.updateOptions(autocaptureOptions);
+                if (autoTrackPageviews) {
+                    this.pageviewTracker.startAutoPageviewTracking();
+                }
+                if (autocaptureEnabled) {
+                    this.autocaptureTracker.start();
+                }
+                if (autoTrackPageviews || autocaptureEnabled) {
+                    this.autocaptureStarted = true;
+                }
+            }
+            // If options are empty (during initialization), wait for options change callback
+        }
+        /**
+         * Handle effective options change (e.g., when remote options are fetched)
+         */
+        handleOptionsChange(effectiveOptions) {
+            // If autocapture was never started before, this is the initial options application
+            // (async init completed) — treat it like a page load and capture a pageview.
+            // If it was already started, this is a periodic remote options update — only
+            // re-register listeners without emitting a spurious pageview.
+            const isFirstStart = !this.autocaptureStarted;
+            if (this.autocaptureStarted) {
+                this.pageviewTracker.stopAutocapture();
+                this.autocaptureTracker.stop();
+                this.autocaptureStarted = false;
+            }
+            const autoTrackPageviews = effectiveOptions.autoTrackPageviews !== false;
+            const autocaptureEnabled = effectiveOptions.autocapture !== false;
+            const autocaptureOptions = this.resolveAutocaptureOptions(effectiveOptions.autocapture);
+            this.autocaptureTracker.updateOptions(autocaptureOptions);
+            if (autoTrackPageviews) {
+                this.pageviewTracker.startAutoPageviewTracking(isFirstStart);
+            }
+            if (autocaptureEnabled) {
+                this.autocaptureTracker.start();
+            }
+            this.autocaptureStarted = autoTrackPageviews || autocaptureEnabled;
+        }
+        async flush() {
+            return this.client.flush();
+        }
+        getEffectiveOptions() {
+            return this.client.getEffectiveOptions();
+        }
+        /**
+         * Register a callback to be notified when effective options change
+         */
+        onOptionsChange(callback) {
+            return this.client.onOptionsChange(callback);
+        }
+        destroy() {
+            this.pageviewTracker.stopAutocapture();
+            this.autocaptureTracker.stop();
+            if (this.unsubscribeOptionsChange) {
+                this.unsubscribeOptionsChange();
+            }
+            this.client.destroy();
+        }
+    }
+    const init = (config) => {
+        return new JourniumAnalytics(config);
+    };
+
+    /**
+     * CDN Entry Point for Journium Analytics
+     * This file provides global browser integration for script snippet usage
+     * Features: auto method stubbing, error handling, improved queue processing
+     */
+    // Available public methods for auto-stubbing
+    const STUBBED_METHODS = [
+        'track', 'identify', 'reset', 'capturePageview', 'startAutocapture',
+        'stopAutocapture', 'flush', 'getEffectiveOptions', 'onOptionsChange', 'destroy'
+    ];
+    /**
+     * Enhanced queue processing with better error handling and edge cases
+     */
+    function processQueuedCalls(instance, queue) {
+        if (!Array.isArray(queue) || queue.length === 0) {
+            return;
+        }
+        const processedCount = { success: 0, error: 0, skipped: 0 };
+        queue.forEach(([method, ...args], index) => {
+            try {
+                // Validate method call structure
+                if (typeof method !== 'string') {
+                    console.warn(`Journium: Invalid method call at index ${index}:`, method);
+                    processedCount.skipped++;
+                    return;
+                }
+                // Check if method exists and is callable
+                if (method in instance && typeof instance[method] === 'function') {
+                    // Handle async methods properly
+                    const result = instance[method](...args);
+                    // If it's a promise, handle potential rejections
+                    if (result && typeof result.catch === 'function') {
+                        result.catch((error) => {
+                            console.warn(`Journium: Async method '${method}' failed:`, error);
+                        });
+                    }
+                    processedCount.success++;
+                }
+                else {
+                    console.warn(`Journium: Unknown method '${method}' called from queue`);
+                    processedCount.skipped++;
+                }
+            }
+            catch (error) {
+                console.warn(`Journium: Error executing queued method '${method}':`, error);
+                processedCount.error++;
+            }
+        });
+        // Log summary for debugging
+        if (processedCount.success > 0 || processedCount.error > 0) {
+            console.log(`Journium: Processed ${processedCount.success} calls, ${processedCount.error} errors, ${processedCount.skipped} skipped`);
+        }
+    }
+    /**
+     * Dynamically stub all available methods
+     */
+    function createMethodStubs(target, queueTarget = []) {
+        STUBBED_METHODS.forEach(method => {
+            target[method] = function (...args) {
+                queueTarget.push([method, ...args]);
+                return target; // Enable method chaining
+            };
+        });
+    }
+    /**
+     * Dynamically bind all available methods from instance to target
+     */
+    function bindInstanceMethods(instance, target) {
+        STUBBED_METHODS.forEach(method => {
+            if (method in instance && typeof instance[method] === 'function') {
+                target[method] = instance[method].bind(instance);
+            }
+        });
+    }
+    /**
+     * Create fallback object when initialization fails
+     */
+    function createFallbackObject(error) {
+        const fallbackQueue = [];
+        const fallback = {
+            init: (config, instanceName) => {
+                console.warn('Journium: Fallback mode - init calls will be queued');
+                fallbackQueue.push(['init', config, instanceName]);
+                return {};
+            },
+            _error: error || null,
+            _fallback: true
+        };
+        // Create method stubs that queue calls
+        createMethodStubs(fallback, fallbackQueue);
+        return fallback;
+    }
+    /**
+     * Create the global journium object with enhanced error handling
+     */
+    function createGlobalJournium() {
+        let defaultInstance = null;
+        const globalJournium = {
+            init: (config, instanceName) => {
+                try {
+                    // Validate config object
+                    if (!config || typeof config !== 'object') {
+                        throw new Error('Config object is required');
+                    }
+                    if (!config.publishableKey) {
+                        throw new Error('publishableKey is required in config');
+                    }
+                    // Build the config for the init function with proper structure
+                    const initConfig = {
+                        publishableKey: config.publishableKey
+                    };
+                    // Add apiHost if provided
+                    if (config.apiHost) {
+                        initConfig.apiHost = config.apiHost;
+                    }
+                    // Add options as nested object if provided
+                    if (config.options && typeof config.options === 'object') {
+                        initConfig.options = config.options;
+                    }
+                    // Create the instance using the merged config
+                    const instance = init(initConfig);
+                    if (instanceName) {
+                        // Multi-instance: store as journium[instanceName]
+                        globalJournium[instanceName] = instance;
+                        return instance;
+                    }
+                    else {
+                        // Single instance: dynamically bind all methods
+                        defaultInstance = instance;
+                        bindInstanceMethods(instance, globalJournium);
+                        return instance;
+                    }
+                }
+                catch (error) {
+                    console.error('Journium: Failed to initialize:', error);
+                    // Return fallback object that queues method calls
+                    const fallback = createFallbackObject(error);
+                    Object.assign(globalJournium, fallback);
+                    return {};
+                }
+            }
+        };
+        return globalJournium;
+    }
+    /**
+     * Initialize from snippet with comprehensive error handling and retry logic
+     */
+    function initializeFromSnippet() {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        const snippet = window.journium;
+        let globalJournium = createGlobalJournium();
+        try {
+            if (snippet && snippet._i) {
+                // Extract snippet initialization parameters
+                const [config, instanceName] = snippet._i;
+                const queuedCalls = snippet._q || [];
+                // Validate config object structure
+                if (!config || typeof config !== 'object') {
+                    throw new Error('Invalid or missing config object');
+                }
+                if (!config.publishableKey) {
+                    throw new Error('publishableKey is required in config');
+                }
+                // Initialize the instance with timeout protection
+                const instance = globalJournium.init(config, instanceName);
+                // Process queued method calls
+                if (queuedCalls.length > 0) {
+                    // Always use the instance for processing queued calls
+                    setTimeout(() => processQueuedCalls(instance, queuedCalls), 0);
+                }
+                // Preserve snippet metadata
+                globalJournium.__JV = snippet.__JV;
+                globalJournium._q = [];
+                globalJournium._i = snippet._i;
+                globalJournium._error = null;
+            }
+            else if (snippet && snippet._q) {
+                // Handle case where queue exists but no initialization
+                console.warn('Journium: Found queued calls but no initialization data');
+                globalJournium._q = snippet._q;
+            }
+        }
+        catch (error) {
+            console.error('Journium: Critical initialization failure:', error);
+            // Create fallback with error tracking
+            globalJournium = createFallbackObject(error);
+            // Preserve original queue for potential retry
+            if (snippet && snippet._q) {
+                globalJournium._q = snippet._q;
+            }
+            // Enable retry mechanism
+            globalJournium._retry = true;
+        }
+        finally {
+            // Always replace window.journium, even in failure cases
+            window.journium = globalJournium;
+            // Set up retry mechanism if needed
+            if (globalJournium._retry && !globalJournium._error) {
+                setTimeout(() => {
+                    if (window.journium && window.journium._retry) {
+                        console.log('Journium: Attempting retry...');
+                        initializeFromSnippet();
+                    }
+                }, 2000);
+            }
+        }
+    }
+    // Auto-initialize when script loads
+    if (typeof window !== 'undefined') {
+        initializeFromSnippet();
+    }
+    var cdn = { init };
+
+    exports.default = cdn;
+    exports.init = init;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+    return exports;
+
+})({});
+//# sourceMappingURL=journium.js.map