@error-explorer/browser 1.1.1

package/dist/error-explorer.cjs.js

@@ -0,0 +1,2818 @@
+/**
+ * @error-explorer/browser v1.0.0
+ * Error Explorer SDK for Browser
+ * https://github.com/error-explorer/error-explorer-sdks
+ * (c) 2026 Error Explorer
+ * Released under the MIT License
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const DEFAULT_ENDPOINT = 'https://error-explorer.com/api/v1/webhook';
+const DEFAULT_CONFIG = {
+    environment: 'production',
+    release: '',
+    autoCapture: {
+        errors: true,
+        unhandledRejections: true,
+        console: true,
+    },
+    breadcrumbs: {
+        enabled: true,
+        maxBreadcrumbs: 20,
+        clicks: true,
+        navigation: true,
+        fetch: true,
+        xhr: true,
+        console: true,
+        inputs: false,
+    },
+    denyUrls: [],
+    allowUrls: [],
+    ignoreErrors: [],
+    maxRetries: 3,
+    timeout: 5000,
+    offline: true,
+    debug: false,
+};
+/**
+ * Parse DSN to extract token and endpoint
+ * DSN format: https://{token}@{host}/api/v1/webhook
+ */
+function parseDsn(dsn) {
+    try {
+        const url = new URL(dsn);
+        const token = url.username;
+        if (!token) {
+            return null;
+        }
+        // Remove username from URL to get endpoint
+        url.username = '';
+        const endpoint = url.toString();
+        return { token, endpoint };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build endpoint URL from token
+ */
+function buildEndpoint(token, baseEndpoint) {
+    // If endpoint already contains token placeholder, replace it
+    if (baseEndpoint.includes('{token}')) {
+        return baseEndpoint.replace('{token}', token);
+    }
+    // Otherwise append token to endpoint
+    const separator = baseEndpoint.endsWith('/') ? '' : '/';
+    return `${baseEndpoint}${separator}${token}`;
+}
+/**
+ * Validate and resolve configuration
+ */
+function resolveConfig(options) {
+    let token;
+    let endpoint;
+    // Parse DSN if provided
+    if (options.dsn) {
+        const parsed = parseDsn(options.dsn);
+        if (!parsed) {
+            throw new Error('[ErrorExplorer] Invalid DSN format');
+        }
+        token = parsed.token;
+        endpoint = parsed.endpoint;
+    }
+    else if (options.token) {
+        token = options.token;
+        endpoint = buildEndpoint(token, options.endpoint ?? DEFAULT_ENDPOINT);
+    }
+    else {
+        throw new Error('[ErrorExplorer] Either token or dsn is required');
+    }
+    // Validate token format
+    if (!token.startsWith('ee_')) {
+        console.warn('[ErrorExplorer] Token should start with "ee_"');
+    }
+    return {
+        token,
+        endpoint,
+        environment: options.environment ?? DEFAULT_CONFIG.environment,
+        release: options.release ?? DEFAULT_CONFIG.release,
+        project: options.project,
+        autoCapture: {
+            ...DEFAULT_CONFIG.autoCapture,
+            ...options.autoCapture,
+        },
+        breadcrumbs: {
+            ...DEFAULT_CONFIG.breadcrumbs,
+            ...options.breadcrumbs,
+        },
+        beforeSend: options.beforeSend,
+        denyUrls: options.denyUrls ?? DEFAULT_CONFIG.denyUrls,
+        allowUrls: options.allowUrls ?? DEFAULT_CONFIG.allowUrls,
+        ignoreErrors: options.ignoreErrors ?? DEFAULT_CONFIG.ignoreErrors,
+        maxRetries: options.maxRetries ?? DEFAULT_CONFIG.maxRetries,
+        timeout: options.timeout ?? DEFAULT_CONFIG.timeout,
+        offline: options.offline ?? DEFAULT_CONFIG.offline,
+        debug: options.debug ?? DEFAULT_CONFIG.debug,
+        hmacSecret: options.hmacSecret,
+    };
+}
+/**
+ * Check if URL matches any pattern in list
+ */
+function matchesPattern(url, patterns) {
+    return patterns.some((pattern) => {
+        if (typeof pattern === 'string') {
+            return url.includes(pattern);
+        }
+        return pattern.test(url);
+    });
+}
+
+/**
+ * Parse a stack trace string into structured frames
+ */
+function parseStackTrace(stack) {
+    if (!stack) {
+        return [];
+    }
+    const lines = stack.split('\n');
+    const frames = [];
+    for (const line of lines) {
+        const frame = parseStackLine(line);
+        if (frame) {
+            frames.push(frame);
+        }
+    }
+    return frames;
+}
+/**
+ * Parse a single stack trace line
+ * Handles Chrome/V8, Firefox, and Safari formats
+ */
+function parseStackLine(line) {
+    const trimmed = line.trim();
+    // Skip empty lines and "Error:" header
+    if (!trimmed || trimmed.startsWith('Error:') || trimmed === 'Error') {
+        return null;
+    }
+    // Chrome/V8 format: "    at functionName (filename:line:col)"
+    // or "    at filename:line:col"
+    const chromeMatch = trimmed.match(/^\s*at\s+(?:(.+?)\s+\()?(?:(.+?):(\d+):(\d+)|(.+?):(\d+)|(.+?))\)?$/);
+    if (chromeMatch) {
+        const [, func, file1, line1, col1, file2, line2, file3] = chromeMatch;
+        return {
+            function: func || '<anonymous>',
+            filename: file1 || file2 || file3,
+            lineno: line1 ? parseInt(line1, 10) : line2 ? parseInt(line2, 10) : undefined,
+            colno: col1 ? parseInt(col1, 10) : undefined,
+            in_app: isInApp(file1 || file2 || file3),
+        };
+    }
+    // Firefox format: "functionName@filename:line:col"
+    const firefoxMatch = trimmed.match(/^(.+?)@(.+?):(\d+):(\d+)$/);
+    if (firefoxMatch) {
+        const [, func, file, line, col] = firefoxMatch;
+        return {
+            function: func || '<anonymous>',
+            filename: file,
+            lineno: parseInt(line ?? '0', 10),
+            colno: parseInt(col ?? '0', 10),
+            in_app: isInApp(file),
+        };
+    }
+    // Safari format: "functionName@filename:line:col" or just "filename:line:col"
+    const safariMatch = trimmed.match(/^(?:(.+?)@)?(.+?):(\d+)(?::(\d+))?$/);
+    if (safariMatch) {
+        const [, func, file, line, col] = safariMatch;
+        return {
+            function: func || '<anonymous>',
+            filename: file,
+            lineno: parseInt(line ?? '0', 10),
+            colno: col ? parseInt(col, 10) : undefined,
+            in_app: isInApp(file),
+        };
+    }
+    // If no format matches, return a basic frame
+    if (trimmed.length > 0) {
+        return {
+            function: trimmed,
+            in_app: false,
+        };
+    }
+    return null;
+}
+/**
+ * Check if a filename is "in app" (not from node_modules, CDN, or browser internals)
+ */
+function isInApp(filename) {
+    if (!filename) {
+        return false;
+    }
+    // Browser internal
+    if (filename.startsWith('<')) {
+        return false;
+    }
+    // Native code
+    if (filename === '[native code]' || filename.includes('native code')) {
+        return false;
+    }
+    // Node modules
+    if (filename.includes('node_modules')) {
+        return false;
+    }
+    // CDN or external
+    const externalPatterns = [
+        /cdn\./i,
+        /unpkg\.com/i,
+        /jsdelivr\.net/i,
+        /cdnjs\.cloudflare\.com/i,
+        /googleapis\.com/i,
+        /gstatic\.com/i,
+    ];
+    for (const pattern of externalPatterns) {
+        if (pattern.test(filename)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Get error name from an Error object or unknown value
+ */
+function getErrorName(error) {
+    if (error instanceof Error) {
+        return error.name || 'Error';
+    }
+    if (typeof error === 'object' && error !== null) {
+        const obj = error;
+        if (typeof obj['name'] === 'string') {
+            return obj['name'];
+        }
+    }
+    return 'Error';
+}
+/**
+ * Get error message from an Error object or unknown value
+ */
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (typeof error === 'object' && error !== null) {
+        const obj = error;
+        if (typeof obj['message'] === 'string') {
+            return obj['message'];
+        }
+    }
+    try {
+        return String(error);
+    }
+    catch {
+        return 'Unknown error';
+    }
+}
+/**
+ * Get stack trace from an Error object or unknown value
+ */
+function getErrorStack(error) {
+    if (error instanceof Error) {
+        return error.stack;
+    }
+    if (typeof error === 'object' && error !== null) {
+        const obj = error;
+        if (typeof obj['stack'] === 'string') {
+            return obj['stack'];
+        }
+    }
+    return undefined;
+}
+
+/**
+ * Generate a UUID v4
+ * Uses crypto.randomUUID() if available, falls back to custom implementation
+ */
+function generateUuid() {
+    // Use native crypto.randomUUID if available (modern browsers)
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    // Fallback for older browsers
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Generate a short ID (for session, etc.)
+ */
+function generateShortId() {
+    return generateUuid().replace(/-/g, '').substring(0, 16);
+}
+
+/**
+ * Manages breadcrumbs - a trail of events leading up to an error
+ */
+class BreadcrumbManager {
+    constructor(config) {
+        this.breadcrumbs = [];
+        this.maxBreadcrumbs = config.breadcrumbs.maxBreadcrumbs;
+    }
+    /**
+     * Add a breadcrumb
+     */
+    add(breadcrumb) {
+        const internal = {
+            ...breadcrumb,
+            timestamp: breadcrumb.timestamp ?? Date.now(),
+        };
+        this.breadcrumbs.push(internal);
+        // FIFO: keep only the last N breadcrumbs
+        while (this.breadcrumbs.length > this.maxBreadcrumbs) {
+            this.breadcrumbs.shift();
+        }
+    }
+    /**
+     * Get all breadcrumbs
+     */
+    getAll() {
+        return [...this.breadcrumbs];
+    }
+    /**
+     * Clear all breadcrumbs
+     */
+    clear() {
+        this.breadcrumbs = [];
+    }
+    /**
+     * Get the number of breadcrumbs
+     */
+    get count() {
+        return this.breadcrumbs.length;
+    }
+}
+// Singleton instance
+let instance$f = null;
+/**
+ * Get the singleton BreadcrumbManager instance
+ */
+function getBreadcrumbManager() {
+    return instance$f;
+}
+/**
+ * Initialize the singleton BreadcrumbManager
+ */
+function initBreadcrumbManager(config) {
+    instance$f = new BreadcrumbManager(config);
+    return instance$f;
+}
+/**
+ * Reset the singleton (for testing)
+ */
+function resetBreadcrumbManager() {
+    instance$f = null;
+}
+
+/**
+ * Maximum depth for object serialization
+ */
+const MAX_DEPTH = 10;
+/**
+ * Maximum string length
+ */
+const MAX_STRING_LENGTH = 1000;
+/**
+ * Maximum array length
+ */
+const MAX_ARRAY_LENGTH = 100;
+/**
+ * Safely serialize a value for JSON, handling circular references and depth limits
+ */
+function safeSerialize(value, depth = 0) {
+    // Handle primitives
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return truncateString(value, MAX_STRING_LENGTH);
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (typeof value === 'symbol') {
+        return value.toString();
+    }
+    if (typeof value === 'function') {
+        return `[Function: ${value.name || 'anonymous'}]`;
+    }
+    // Depth limit reached
+    if (depth >= MAX_DEPTH) {
+        return '[Max depth reached]';
+    }
+    // Handle Error objects
+    if (value instanceof Error) {
+        return {
+            name: value.name,
+            message: value.message,
+            stack: value.stack,
+        };
+    }
+    // Handle Date objects
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    // Handle RegExp
+    if (value instanceof RegExp) {
+        return value.toString();
+    }
+    // Handle Arrays
+    if (Array.isArray(value)) {
+        const truncated = value.slice(0, MAX_ARRAY_LENGTH);
+        const serialized = truncated.map((item) => safeSerialize(item, depth + 1));
+        if (value.length > MAX_ARRAY_LENGTH) {
+            serialized.push(`[... ${value.length - MAX_ARRAY_LENGTH} more items]`);
+        }
+        return serialized;
+    }
+    // Handle DOM elements
+    if (typeof Element !== 'undefined' && value instanceof Element) {
+        return describeElement(value);
+    }
+    // Handle other objects
+    if (typeof value === 'object') {
+        const result = {};
+        const keys = Object.keys(value);
+        const truncatedKeys = keys.slice(0, MAX_ARRAY_LENGTH);
+        for (const key of truncatedKeys) {
+            try {
+                result[key] = safeSerialize(value[key], depth + 1);
+            }
+            catch {
+                result[key] = '[Unserializable]';
+            }
+        }
+        if (keys.length > MAX_ARRAY_LENGTH) {
+            result['...'] = `${keys.length - MAX_ARRAY_LENGTH} more keys`;
+        }
+        return result;
+    }
+    return '[Unknown type]';
+}
+/**
+ * Truncate a string to max length
+ */
+function truncateString(str, maxLength) {
+    if (str.length <= maxLength) {
+        return str;
+    }
+    return str.substring(0, maxLength) + '...';
+}
+/**
+ * Describe a DOM element as a string
+ */
+function describeElement(element) {
+    const tag = element.tagName.toLowerCase();
+    const id = element.id ? `#${element.id}` : '';
+    const classes = element.className
+        ? `.${element.className.split(' ').filter(Boolean).join('.')}`
+        : '';
+    let text = '';
+    if (element.textContent) {
+        text = truncateString(element.textContent.trim(), 50);
+        if (text) {
+            text = ` "${text}"`;
+        }
+    }
+    return `<${tag}${id}${classes}${text}>`;
+}
+/**
+ * Get element selector (best effort)
+ */
+function getElementSelector(element) {
+    const parts = [];
+    let current = element;
+    let depth = 0;
+    const maxDepth = 5;
+    while (current && depth < maxDepth) {
+        let selector = current.tagName.toLowerCase();
+        if (current.id) {
+            selector += `#${current.id}`;
+            parts.unshift(selector);
+            break; // ID is unique, no need to go further
+        }
+        if (current.className) {
+            const classes = current.className.split(' ').filter(Boolean).slice(0, 2);
+            if (classes.length > 0) {
+                selector += `.${classes.join('.')}`;
+            }
+        }
+        parts.unshift(selector);
+        current = current.parentElement;
+        depth++;
+    }
+    return parts.join(' > ');
+}
+
+/**
+ * Track click events on the document
+ */
+class ClickTracker {
+    constructor() {
+        this.enabled = false;
+        this.handler = null;
+    }
+    /**
+     * Start tracking clicks
+     */
+    start() {
+        if (this.enabled || typeof document === 'undefined') {
+            return;
+        }
+        this.handler = (event) => {
+            this.handleClick(event);
+        };
+        document.addEventListener('click', this.handler, {
+            capture: true,
+            passive: true,
+        });
+        this.enabled = true;
+    }
+    /**
+     * Stop tracking clicks
+     */
+    stop() {
+        if (!this.enabled || !this.handler) {
+            return;
+        }
+        document.removeEventListener('click', this.handler, { capture: true });
+        this.handler = null;
+        this.enabled = false;
+    }
+    /**
+     * Handle a click event
+     */
+    handleClick(event) {
+        const target = event.target;
+        if (!(target instanceof Element)) {
+            return;
+        }
+        const manager = getBreadcrumbManager();
+        if (!manager) {
+            return;
+        }
+        const breadcrumb = {
+            type: 'click',
+            category: 'ui',
+            level: 'info',
+            data: {
+                element: describeElement(target),
+                selector: getElementSelector(target),
+            },
+        };
+        // Add text content for buttons and links
+        if (target instanceof HTMLButtonElement || target instanceof HTMLAnchorElement) {
+            const text = target.textContent?.trim();
+            if (text) {
+                breadcrumb.message = `Clicked: "${truncateString(text, 50)}"`;
+            }
+        }
+        // Add href for links
+        if (target instanceof HTMLAnchorElement && target.href) {
+            breadcrumb.data = {
+                ...breadcrumb.data,
+                href: target.href,
+            };
+        }
+        manager.add(breadcrumb);
+    }
+}
+// Singleton instance
+let instance$e = null;
+function getClickTracker() {
+    if (!instance$e) {
+        instance$e = new ClickTracker();
+    }
+    return instance$e;
+}
+function resetClickTracker() {
+    if (instance$e) {
+        instance$e.stop();
+        instance$e = null;
+    }
+}
+
+/**
+ * Track navigation events (History API, hash changes)
+ */
+class NavigationTracker {
+    constructor() {
+        this.enabled = false;
+        this.lastUrl = '';
+        this.popstateHandler = null;
+        this.hashchangeHandler = null;
+        this.originalPushState = null;
+        this.originalReplaceState = null;
+    }
+    /**
+     * Start tracking navigation
+     */
+    start() {
+        if (this.enabled || typeof window === 'undefined') {
+            return;
+        }
+        this.lastUrl = window.location.href;
+        // Track popstate (back/forward)
+        this.popstateHandler = () => {
+            this.recordNavigation('popstate');
+        };
+        window.addEventListener('popstate', this.popstateHandler);
+        // Track hash changes
+        this.hashchangeHandler = () => {
+            this.recordNavigation('hashchange');
+        };
+        window.addEventListener('hashchange', this.hashchangeHandler);
+        // Wrap pushState
+        this.originalPushState = history.pushState.bind(history);
+        history.pushState = (...args) => {
+            this.originalPushState(...args);
+            this.recordNavigation('pushState');
+        };
+        // Wrap replaceState
+        this.originalReplaceState = history.replaceState.bind(history);
+        history.replaceState = (...args) => {
+            this.originalReplaceState(...args);
+            this.recordNavigation('replaceState');
+        };
+        this.enabled = true;
+    }
+    /**
+     * Stop tracking navigation
+     */
+    stop() {
+        if (!this.enabled) {
+            return;
+        }
+        if (this.popstateHandler) {
+            window.removeEventListener('popstate', this.popstateHandler);
+            this.popstateHandler = null;
+        }
+        if (this.hashchangeHandler) {
+            window.removeEventListener('hashchange', this.hashchangeHandler);
+            this.hashchangeHandler = null;
+        }
+        // Restore original history methods
+        if (this.originalPushState) {
+            history.pushState = this.originalPushState;
+            this.originalPushState = null;
+        }
+        if (this.originalReplaceState) {
+            history.replaceState = this.originalReplaceState;
+            this.originalReplaceState = null;
+        }
+        this.enabled = false;
+    }
+    /**
+     * Record a navigation event
+     */
+    recordNavigation(navigationType) {
+        const manager = getBreadcrumbManager();
+        if (!manager) {
+            return;
+        }
+        const currentUrl = window.location.href;
+        const from = this.lastUrl;
+        const to = currentUrl;
+        // Don't record if URL hasn't changed
+        if (from === to) {
+            return;
+        }
+        this.lastUrl = currentUrl;
+        const breadcrumb = {
+            type: 'navigation',
+            category: 'navigation',
+            level: 'info',
+            message: `Navigated to ${getPathname(to)}`,
+            data: {
+                from: stripOrigin(from),
+                to: stripOrigin(to),
+                type: navigationType,
+            },
+        };
+        manager.add(breadcrumb);
+    }
+}
+/**
+ * Get pathname from URL
+ */
+function getPathname(url) {
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * Strip origin from URL, keeping path + query + hash
+ */
+function stripOrigin(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.pathname + parsed.search + parsed.hash;
+    }
+    catch {
+        return url;
+    }
+}
+// Singleton instance
+let instance$d = null;
+function getNavigationTracker() {
+    if (!instance$d) {
+        instance$d = new NavigationTracker();
+    }
+    return instance$d;
+}
+function resetNavigationTracker() {
+    if (instance$d) {
+        instance$d.stop();
+        instance$d = null;
+    }
+}
+
+/**
+ * Track fetch() requests
+ */
+class FetchTracker {
+    constructor() {
+        this.enabled = false;
+        this.originalFetch = null;
+    }
+    /**
+     * Start tracking fetch requests
+     */
+    start() {
+        if (this.enabled || typeof window === 'undefined' || typeof fetch === 'undefined') {
+            return;
+        }
+        this.originalFetch = window.fetch.bind(window);
+        window.fetch = async (input, init) => {
+            const startTime = Date.now();
+            const { method, url } = this.extractRequestInfo(input, init);
+            let response;
+            let error = null;
+            try {
+                response = await this.originalFetch(input, init);
+            }
+            catch (e) {
+                error = e instanceof Error ? e : new Error(String(e));
+                this.recordBreadcrumb(method, url, startTime, undefined, error);
+                throw e;
+            }
+            this.recordBreadcrumb(method, url, startTime, response.status);
+            return response;
+        };
+        this.enabled = true;
+    }
+    /**
+     * Stop tracking fetch requests
+     */
+    stop() {
+        if (!this.enabled || !this.originalFetch) {
+            return;
+        }
+        window.fetch = this.originalFetch;
+        this.originalFetch = null;
+        this.enabled = false;
+    }
+    /**
+     * Extract method and URL from fetch arguments
+     */
+    extractRequestInfo(input, init) {
+        let method = 'GET';
+        let url;
+        if (typeof input === 'string') {
+            url = input;
+        }
+        else if (input instanceof URL) {
+            url = input.toString();
+        }
+        else if (input instanceof Request) {
+            url = input.url;
+            method = input.method;
+        }
+        else {
+            url = String(input);
+        }
+        if (init?.method) {
+            method = init.method;
+        }
+        return { method: method.toUpperCase(), url };
+    }
+    /**
+     * Record a fetch breadcrumb
+     */
+    recordBreadcrumb(method, url, startTime, statusCode, error) {
+        const manager = getBreadcrumbManager();
+        if (!manager) {
+            return;
+        }
+        const duration = Date.now() - startTime;
+        const parsedUrl = parseUrl$1(url);
+        const breadcrumb = {
+            type: 'fetch',
+            category: 'http',
+            level: error || (statusCode && statusCode >= 400) ? 'error' : 'info',
+            message: `${method} ${parsedUrl.pathname}`,
+            data: {
+                method,
+                url: parsedUrl.full,
+                status_code: statusCode,
+                duration_ms: duration,
+            },
+        };
+        if (error) {
+            breadcrumb.data = {
+                ...breadcrumb.data,
+                error: error.message,
+            };
+        }
+        manager.add(breadcrumb);
+    }
+}
+/**
+ * Parse URL and extract components
+ */
+function parseUrl$1(url) {
+    try {
+        // Handle relative URLs
+        const parsed = new URL(url, window.location.origin);
+        return {
+            full: parsed.href,
+            pathname: parsed.pathname,
+        };
+    }
+    catch {
+        return { full: url, pathname: url };
+    }
+}
+// Singleton instance
+let instance$c = null;
+function getFetchTracker() {
+    if (!instance$c) {
+        instance$c = new FetchTracker();
+    }
+    return instance$c;
+}
+function resetFetchTracker() {
+    if (instance$c) {
+        instance$c.stop();
+        instance$c = null;
+    }
+}
+
+/**
+ * Track XMLHttpRequest requests
+ */
+class XHRTracker {
+    constructor() {
+        this.enabled = false;
+        this.originalOpen = null;
+        this.originalSend = null;
+        this.xhrInfoMap = new WeakMap();
+    }
+    /**
+     * Start tracking XHR requests
+     */
+    start() {
+        if (this.enabled || typeof XMLHttpRequest === 'undefined') {
+            return;
+        }
+        const self = this;
+        // Wrap open() to capture method and URL
+        this.originalOpen = XMLHttpRequest.prototype.open;
+        XMLHttpRequest.prototype.open = function (method, url, async = true, username, password) {
+            self.xhrInfoMap.set(this, {
+                method: method.toUpperCase(),
+                url: url.toString(),
+                startTime: 0,
+            });
+            return self.originalOpen.call(this, method, url, async, username, password);
+        };
+        // Wrap send() to capture timing and response
+        this.originalSend = XMLHttpRequest.prototype.send;
+        XMLHttpRequest.prototype.send = function (body) {
+            const info = self.xhrInfoMap.get(this);
+            if (info) {
+                info.startTime = Date.now();
+            }
+            // Listen for completion
+            this.addEventListener('loadend', () => {
+                self.recordBreadcrumb(this);
+            });
+            return self.originalSend.call(this, body);
+        };
+        this.enabled = true;
+    }
+    /**
+     * Stop tracking XHR requests
+     */
+    stop() {
+        if (!this.enabled) {
+            return;
+        }
+        if (this.originalOpen) {
+            XMLHttpRequest.prototype.open = this.originalOpen;
+            this.originalOpen = null;
+        }
+        if (this.originalSend) {
+            XMLHttpRequest.prototype.send = this.originalSend;
+            this.originalSend = null;
+        }
+        this.enabled = false;
+    }
+    /**
+     * Record an XHR breadcrumb
+     */
+    recordBreadcrumb(xhr) {
+        const manager = getBreadcrumbManager();
+        if (!manager) {
+            return;
+        }
+        const info = this.xhrInfoMap.get(xhr);
+        if (!info) {
+            return;
+        }
+        const duration = info.startTime > 0 ? Date.now() - info.startTime : 0;
+        const parsedUrl = parseUrl(info.url);
+        const statusCode = xhr.status;
+        const isError = statusCode === 0 || statusCode >= 400;
+        const breadcrumb = {
+            type: 'xhr',
+            category: 'http',
+            level: isError ? 'error' : 'info',
+            message: `${info.method} ${parsedUrl.pathname}`,
+            data: {
+                method: info.method,
+                url: parsedUrl.full,
+                status_code: statusCode || undefined,
+                duration_ms: duration,
+            },
+        };
+        // Add error info if request failed
+        if (statusCode === 0) {
+            breadcrumb.data = {
+                ...breadcrumb.data,
+                error: 'Request failed (network error or CORS)',
+            };
+        }
+        manager.add(breadcrumb);
+    }
+}
+/**
+ * Parse URL and extract components
+ */
+function parseUrl(url) {
+    try {
+        const parsed = new URL(url, window.location.origin);
+        return {
+            full: parsed.href,
+            pathname: parsed.pathname,
+        };
+    }
+    catch {
+        return { full: url, pathname: url };
+    }
+}
+// Singleton instance
+let instance$b = null;
+function getXHRTracker() {
+    if (!instance$b) {
+        instance$b = new XHRTracker();
+    }
+    return instance$b;
+}
+function resetXHRTracker() {
+    if (instance$b) {
+        instance$b.stop();
+        instance$b = null;
+    }
+}
+
+const LEVEL_MAP = {
+    log: 'info',
+    info: 'info',
+    warn: 'warning',
+    error: 'error',
+    debug: 'debug',
+};
+/**
+ * Track console.log/info/warn/error/debug calls
+ */
+class ConsoleTracker {
+    constructor() {
+        this.enabled = false;
+        this.originalMethods = {};
+    }
+    /**
+     * Start tracking console calls
+     */
+    start() {
+        if (this.enabled || typeof console === 'undefined') {
+            return;
+        }
+        const levels = ['log', 'info', 'warn', 'error', 'debug'];
+        for (const level of levels) {
+            this.wrapConsoleMethod(level);
+        }
+        this.enabled = true;
+    }
+    /**
+     * Stop tracking console calls
+     */
+    stop() {
+        if (!this.enabled) {
+            return;
+        }
+        // Restore original methods
+        for (const [level, original] of Object.entries(this.originalMethods)) {
+            if (original) {
+                console[level] = original;
+            }
+        }
+        this.originalMethods = {};
+        this.enabled = false;
+    }
+    /**
+     * Wrap a console method
+     */
+    wrapConsoleMethod(level) {
+        const original = console[level];
+        if (!original) {
+            return;
+        }
+        this.originalMethods[level] = original;
+        console[level] = (...args) => {
+            // Always call original first
+            original.apply(console, args);
+            // Then record breadcrumb
+            this.recordBreadcrumb(level, args);
+        };
+    }
+    /**
+     * Record a console breadcrumb
+     */
+    recordBreadcrumb(level, args) {
+        const manager = getBreadcrumbManager();
+        if (!manager) {
+            return;
+        }
+        // Format message
+        const message = this.formatMessage(args);
+        const breadcrumb = {
+            type: 'console',
+            category: 'console',
+            level: LEVEL_MAP[level],
+            message: truncateString(message, 200),
+            data: {
+                level,
+                arguments: args.length > 1 ? args.map((arg) => safeSerialize(arg)) : undefined,
+            },
+        };
+        manager.add(breadcrumb);
+    }
+    /**
+     * Format console arguments into a message string
+     */
+    formatMessage(args) {
+        if (args.length === 0) {
+            return '';
+        }
+        return args
+            .map((arg) => {
+            if (typeof arg === 'string') {
+                return arg;
+            }
+            if (arg instanceof Error) {
+                return `${arg.name}: ${arg.message}`;
+            }
+            try {
+                return JSON.stringify(arg);
+            }
+            catch {
+                return String(arg);
+            }
+        })
+            .join(' ');
+    }
+}
+// Singleton instance
+let instance$a = null;
+function getConsoleTracker() {
+    if (!instance$a) {
+        instance$a = new ConsoleTracker();
+    }
+    return instance$a;
+}
+function resetConsoleTracker() {
+    if (instance$a) {
+        instance$a.stop();
+        instance$a = null;
+    }
+}
+
+/**
+ * Track input focus events (NOT values - privacy first!)
+ */
+class InputTracker {
+    constructor() {
+        this.enabled = false;
+        this.focusHandler = null;
+        this.blurHandler = null;
+    }
+    /**
+     * Start tracking input events
+     */
+    start() {
+        if (this.enabled || typeof document === 'undefined') {
+            return;
+        }
+        this.focusHandler = (event) => {
+            this.handleFocus(event);
+        };
+        this.blurHandler = (event) => {
+            this.handleBlur(event);
+        };
+        // Use capture phase to catch all focus/blur events
+        document.addEventListener('focus', this.focusHandler, { capture: true, passive: true });
+        document.addEventListener('blur', this.blurHandler, { capture: true, passive: true });
+        this.enabled = true;
+    }
+    /**
+     * Stop tracking input events
+     */
+    stop() {
+        if (!this.enabled) {
+            return;
+        }
+        if (this.focusHandler) {
+            document.removeEventListener('focus', this.focusHandler, { capture: true });
+            this.focusHandler = null;
+        }
+        if (this.blurHandler) {
+            document.removeEventListener('blur', this.blurHandler, { capture: true });
+            this.blurHandler = null;
+        }
+        this.enabled = false;
+    }
+    /**
+     * Handle focus event
+     */
+    handleFocus(event) {
+        const target = event.target;
+        if (!this.isTrackedElement(target)) {
+            return;
+        }
+        this.recordBreadcrumb(target, 'focus');
+    }
+    /**
+     * Handle blur event
+     */
+    handleBlur(event) {
+        const target = event.target;
+        if (!this.isTrackedElement(target)) {
+            return;
+        }
+        this.recordBreadcrumb(target, 'blur');
+    }
+    /**
+     * Check if element should be tracked
+     */
+    isTrackedElement(target) {
+        if (!target) {
+            return false;
+        }
+        return (target instanceof HTMLInputElement ||
+            target instanceof HTMLTextAreaElement ||
+            target instanceof HTMLSelectElement);
+    }
+    /**
+     * Record an input breadcrumb
+     */
+    recordBreadcrumb(element, action) {
+        const manager = getBreadcrumbManager();
+        if (!manager) {
+            return;
+        }
+        const inputType = element instanceof HTMLInputElement ? element.type : element.tagName.toLowerCase();
+        const name = element.name || element.id || undefined;
+        const breadcrumb = {
+            type: 'input',
+            category: 'ui',
+            level: 'info',
+            message: `Input ${action}: ${inputType}${name ? ` (${name})` : ''}`,
+            data: {
+                action,
+                element_type: inputType,
+                name,
+                selector: getElementSelector(element),
+                // NEVER include the actual value for privacy!
+            },
+        };
+        manager.add(breadcrumb);
+    }
+}
+// Singleton instance
+let instance$9 = null;
+function getInputTracker() {
+    if (!instance$9) {
+        instance$9 = new InputTracker();
+    }
+    return instance$9;
+}
+function resetInputTracker() {
+    if (instance$9) {
+        instance$9.stop();
+        instance$9 = null;
+    }
+}
+
+/**
+ * Captures window.onerror errors
+ */
+class ErrorCapture {
+    constructor() {
+        this.enabled = false;
+        this.handler = null;
+        this.originalOnError = null;
+    }
+    /**
+     * Start capturing errors
+     */
+    start(handler) {
+        if (this.enabled || typeof window === 'undefined') {
+            return;
+        }
+        this.handler = handler;
+        this.originalOnError = window.onerror;
+        window.onerror = (message, filename, lineno, colno, error) => {
+            // Call original handler first
+            if (this.originalOnError) {
+                this.originalOnError.call(window, message, filename, lineno, colno, error);
+            }
+            this.handleError(message, filename, lineno, colno, error);
+            // Don't prevent default handling
+            return false;
+        };
+        this.enabled = true;
+    }
+    /**
+     * Stop capturing errors
+     */
+    stop() {
+        if (!this.enabled) {
+            return;
+        }
+        window.onerror = this.originalOnError;
+        this.originalOnError = null;
+        this.handler = null;
+        this.enabled = false;
+    }
+    /**
+     * Handle an error event
+     */
+    handleError(message, filename, lineno, colno, error) {
+        if (!this.handler) {
+            return;
+        }
+        const captured = {
+            message: this.extractMessage(message, error),
+            name: error ? getErrorName(error) : 'Error',
+            stack: error ? getErrorStack(error) : undefined,
+            filename,
+            lineno,
+            colno,
+            severity: 'error',
+            originalError: error,
+        };
+        this.handler(captured);
+    }
+    /**
+     * Extract error message from various sources
+     */
+    extractMessage(message, error) {
+        // If we have an Error object, prefer its message
+        if (error) {
+            return getErrorMessage(error);
+        }
+        // If message is a string, use it
+        if (typeof message === 'string') {
+            return message;
+        }
+        // If message is an Event, try to extract useful info
+        if (message instanceof ErrorEvent) {
+            return message.message || 'Unknown error';
+        }
+        return 'Unknown error';
+    }
+}
+// Singleton instance
+let instance$8 = null;
+function getErrorCapture() {
+    if (!instance$8) {
+        instance$8 = new ErrorCapture();
+    }
+    return instance$8;
+}
+function resetErrorCapture() {
+    if (instance$8) {
+        instance$8.stop();
+        instance$8 = null;
+    }
+}
+
+/**
+ * Captures unhandled promise rejections
+ */
+class PromiseCapture {
+    constructor() {
+        this.enabled = false;
+        this.handler = null;
+        this.rejectionHandler = null;
+    }
+    /**
+     * Start capturing unhandled rejections
+     */
+    start(handler) {
+        if (this.enabled || typeof window === 'undefined') {
+            return;
+        }
+        this.handler = handler;
+        this.rejectionHandler = (event) => {
+            this.handleRejection(event);
+        };
+        window.addEventListener('unhandledrejection', this.rejectionHandler);
+        this.enabled = true;
+    }
+    /**
+     * Stop capturing unhandled rejections
+     */
+    stop() {
+        if (!this.enabled || !this.rejectionHandler) {
+            return;
+        }
+        window.removeEventListener('unhandledrejection', this.rejectionHandler);
+        this.rejectionHandler = null;
+        this.handler = null;
+        this.enabled = false;
+    }
+    /**
+     * Handle an unhandled rejection event
+     */
+    handleRejection(event) {
+        if (!this.handler) {
+            return;
+        }
+        const reason = event.reason;
+        const captured = {
+            message: this.extractMessage(reason),
+            name: this.extractName(reason),
+            stack: this.extractStack(reason),
+            severity: 'error',
+            originalError: reason instanceof Error ? reason : undefined,
+        };
+        this.handler(captured);
+    }
+    /**
+     * Extract error message from rejection reason
+     */
+    extractMessage(reason) {
+        if (reason instanceof Error) {
+            return getErrorMessage(reason);
+        }
+        if (typeof reason === 'string') {
+            return reason;
+        }
+        if (reason === undefined) {
+            return 'Promise rejected with undefined';
+        }
+        if (reason === null) {
+            return 'Promise rejected with null';
+        }
+        // Try to get message property
+        if (typeof reason === 'object' && reason !== null) {
+            const obj = reason;
+            if (typeof obj['message'] === 'string') {
+                return obj['message'];
+            }
+        }
+        try {
+            return `Promise rejected with: ${JSON.stringify(reason)}`;
+        }
+        catch {
+            return 'Promise rejected with non-serializable value';
+        }
+    }
+    /**
+     * Extract error name from rejection reason
+     */
+    extractName(reason) {
+        if (reason instanceof Error) {
+            return getErrorName(reason);
+        }
+        if (typeof reason === 'object' && reason !== null) {
+            const obj = reason;
+            if (typeof obj['name'] === 'string') {
+                return obj['name'];
+            }
+        }
+        return 'UnhandledRejection';
+    }
+    /**
+     * Extract stack trace from rejection reason
+     */
+    extractStack(reason) {
+        if (reason instanceof Error) {
+            return getErrorStack(reason);
+        }
+        if (typeof reason === 'object' && reason !== null) {
+            const obj = reason;
+            if (typeof obj['stack'] === 'string') {
+                return obj['stack'];
+            }
+        }
+        return undefined;
+    }
+}
+// Singleton instance
+let instance$7 = null;
+function getPromiseCapture() {
+    if (!instance$7) {
+        instance$7 = new PromiseCapture();
+    }
+    return instance$7;
+}
+function resetPromiseCapture() {
+    if (instance$7) {
+        instance$7.stop();
+        instance$7 = null;
+    }
+}
+
+/**
+ * Captures console.error calls as errors (not just breadcrumbs)
+ */
+class ConsoleCapture {
+    constructor() {
+        this.enabled = false;
+        this.handler = null;
+        this.originalConsoleError = null;
+    }
+    /**
+     * Start capturing console.error
+     */
+    start(handler) {
+        if (this.enabled || typeof console === 'undefined') {
+            return;
+        }
+        this.handler = handler;
+        this.originalConsoleError = console.error;
+        console.error = (...args) => {
+            // Always call original first
+            this.originalConsoleError.apply(console, args);
+            // Then capture as error
+            this.handleConsoleError(args);
+        };
+        this.enabled = true;
+    }
+    /**
+     * Stop capturing console.error
+     */
+    stop() {
+        if (!this.enabled || !this.originalConsoleError) {
+            return;
+        }
+        console.error = this.originalConsoleError;
+        this.originalConsoleError = null;
+        this.handler = null;
+        this.enabled = false;
+    }
+    /**
+     * Handle a console.error call
+     */
+    handleConsoleError(args) {
+        if (!this.handler || args.length === 0) {
+            return;
+        }
+        // Check if first argument is an Error
+        const firstArg = args[0];
+        let captured;
+        if (firstArg instanceof Error) {
+            captured = {
+                message: getErrorMessage(firstArg),
+                name: getErrorName(firstArg),
+                stack: getErrorStack(firstArg),
+                severity: 'error',
+                originalError: firstArg,
+            };
+        }
+        else {
+            // Treat as a message
+            const message = args
+                .map((arg) => {
+                if (typeof arg === 'string')
+                    return arg;
+                if (arg instanceof Error)
+                    return arg.message;
+                try {
+                    return JSON.stringify(arg);
+                }
+                catch {
+                    return String(arg);
+                }
+            })
+                .join(' ');
+            captured = {
+                message,
+                name: 'ConsoleError',
+                severity: 'error',
+            };
+            // Try to find an Error in the args for stack trace
+            for (const arg of args) {
+                if (arg instanceof Error) {
+                    captured.stack = getErrorStack(arg);
+                    captured.originalError = arg;
+                    break;
+                }
+            }
+        }
+        this.handler(captured);
+    }
+}
+// Singleton instance
+let instance$6 = null;
+function getConsoleCapture() {
+    if (!instance$6) {
+        instance$6 = new ConsoleCapture();
+    }
+    return instance$6;
+}
+function resetConsoleCapture() {
+    if (instance$6) {
+        instance$6.stop();
+        instance$6 = null;
+    }
+}
+
+/**
+ * Collect browser context information
+ */
+function collectBrowserContext() {
+    if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+        return {};
+    }
+    const context = {
+        user_agent: navigator.userAgent,
+        language: navigator.language,
+        online: navigator.onLine,
+    };
+    // Parse user agent for browser name/version
+    const browserInfo = parseBrowserInfo(navigator.userAgent);
+    if (browserInfo) {
+        context.name = browserInfo.name;
+        context.version = browserInfo.version;
+    }
+    // Viewport size
+    context.viewport = {
+        width: window.innerWidth,
+        height: window.innerHeight,
+    };
+    // Memory info (Chrome only)
+    if ('memory' in performance) {
+        const memory = performance.memory;
+        if (memory) {
+            context.memory = {
+                used_js_heap_size: memory.usedJSHeapSize,
+                total_js_heap_size: memory.totalJSHeapSize,
+                js_heap_size_limit: memory.jsHeapSizeLimit,
+            };
+        }
+    }
+    return context;
+}
+/**
+ * Parse browser info from user agent string
+ */
+function parseBrowserInfo(userAgent) {
+    // Order matters - check more specific patterns first
+    const browsers = [
+        { name: 'Edge', pattern: /Edg(?:e|A|iOS)?\/(\d+(?:\.\d+)*)/ },
+        { name: 'Opera', pattern: /(?:OPR|Opera)\/(\d+(?:\.\d+)*)/ },
+        { name: 'Chrome', pattern: /Chrome\/(\d+(?:\.\d+)*)/ },
+        { name: 'Safari', pattern: /Version\/(\d+(?:\.\d+)*).*Safari/ },
+        { name: 'Firefox', pattern: /Firefox\/(\d+(?:\.\d+)*)/ },
+        { name: 'IE', pattern: /(?:MSIE |rv:)(\d+(?:\.\d+)*)/ },
+    ];
+    for (const browser of browsers) {
+        const match = userAgent.match(browser.pattern);
+        if (match?.[1]) {
+            return {
+                name: browser.name,
+                version: match[1],
+            };
+        }
+    }
+    return null;
+}
+
+const SESSION_KEY = 'ee_session';
+const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
+/**
+ * Session manager - tracks user sessions across page views
+ */
+class SessionManager {
+    constructor() {
+        this.session = null;
+        this.loadOrCreateSession();
+    }
+    /**
+     * Get current session context
+     */
+    getContext() {
+        this.ensureActiveSession();
+        return {
+            id: this.session.id,
+            started_at: this.session.started_at,
+            page_views: this.session.page_views,
+        };
+    }
+    /**
+     * Record a page view
+     */
+    recordPageView() {
+        this.ensureActiveSession();
+        this.session.page_views++;
+        this.session.last_activity = Date.now();
+        this.saveSession();
+    }
+    /**
+     * Get session ID
+     */
+    getSessionId() {
+        this.ensureActiveSession();
+        return this.session.id;
+    }
+    /**
+     * Load existing session or create a new one
+     */
+    loadOrCreateSession() {
+        const stored = this.loadSession();
+        if (stored && this.isSessionValid(stored)) {
+            this.session = stored;
+            this.session.last_activity = Date.now();
+            this.session.page_views++;
+            this.saveSession();
+        }
+        else {
+            this.createNewSession();
+        }
+    }
+    /**
+     * Ensure we have an active session
+     */
+    ensureActiveSession() {
+        if (!this.session || !this.isSessionValid(this.session)) {
+            this.createNewSession();
+        }
+    }
+    /**
+     * Create a new session
+     */
+    createNewSession() {
+        this.session = {
+            id: generateShortId(),
+            started_at: new Date().toISOString(),
+            last_activity: Date.now(),
+            page_views: 1,
+        };
+        this.saveSession();
+    }
+    /**
+     * Check if session is still valid (not timed out)
+     */
+    isSessionValid(session) {
+        const elapsed = Date.now() - session.last_activity;
+        return elapsed < SESSION_TIMEOUT_MS;
+    }
+    /**
+     * Load session from storage
+     */
+    loadSession() {
+        try {
+            if (typeof sessionStorage === 'undefined') {
+                return null;
+            }
+            const data = sessionStorage.getItem(SESSION_KEY);
+            if (!data) {
+                return null;
+            }
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Save session to storage
+     */
+    saveSession() {
+        try {
+            if (typeof sessionStorage === 'undefined' || !this.session) {
+                return;
+            }
+            sessionStorage.setItem(SESSION_KEY, JSON.stringify(this.session));
+        }
+        catch {
+            // Storage might be full or disabled
+        }
+    }
+}
+// Singleton instance
+let instance$5 = null;
+function getSessionManager() {
+    if (!instance$5) {
+        instance$5 = new SessionManager();
+    }
+    return instance$5;
+}
+function resetSessionManager() {
+    instance$5 = null;
+}
+
+/**
+ * Manages user context
+ */
+class UserContextManager {
+    constructor() {
+        this.user = null;
+    }
+    /**
+     * Set user context
+     */
+    setUser(user) {
+        this.user = { ...user };
+    }
+    /**
+     * Get current user context
+     */
+    getUser() {
+        return this.user ? { ...this.user } : null;
+    }
+    /**
+     * Clear user context
+     */
+    clearUser() {
+        this.user = null;
+    }
+    /**
+     * Check if user is set
+     */
+    hasUser() {
+        return this.user !== null;
+    }
+}
+// Singleton instance
+let instance$4 = null;
+function getUserContextManager() {
+    if (!instance$4) {
+        instance$4 = new UserContextManager();
+    }
+    return instance$4;
+}
+function resetUserContextManager() {
+    instance$4 = null;
+}
+
+/**
+ * Collect current request/page context
+ */
+function collectRequestContext() {
+    if (typeof window === 'undefined') {
+        return {};
+    }
+    const location = window.location;
+    return {
+        url: location.href,
+        method: 'GET', // Browser is always GET for page loads
+        query_string: location.search ? location.search.substring(1) : undefined,
+    };
+}
+
+/**
+ * HMAC Signer for secure webhook transmission
+ *
+ * Uses timestamp-based signing to prevent replay attacks:
+ * - Signature = HMAC-SHA256(timestamp.payload, secret)
+ * - Headers: X-Webhook-Signature, X-Webhook-Timestamp
+ */
+class HmacSigner {
+    constructor(secret) {
+        this.secret = secret;
+        this.encoder = new TextEncoder();
+    }
+    /**
+     * Sign a payload with timestamp
+     */
+    async sign(payload, timestamp) {
+        const ts = timestamp ?? Math.floor(Date.now() / 1000);
+        const signedPayload = `${ts}.${payload}`;
+        const key = await this.getKey();
+        const signature = await crypto.subtle.sign('HMAC', key, this.encoder.encode(signedPayload));
+        return this.arrayBufferToHex(signature);
+    }
+    /**
+     * Build headers for a signed request
+     */
+    async buildHeaders(payload) {
+        const timestamp = Math.floor(Date.now() / 1000);
+        const signature = await this.sign(payload, timestamp);
+        return {
+            'X-Webhook-Signature': signature,
+            'X-Webhook-Timestamp': String(timestamp),
+        };
+    }
+    /**
+     * Get or create the HMAC key
+     */
+    async getKey() {
+        return crypto.subtle.importKey('raw', this.encoder.encode(this.secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    }
+    /**
+     * Convert ArrayBuffer to hex string
+     */
+    arrayBufferToHex(buffer) {
+        const bytes = new Uint8Array(buffer);
+        return Array.from(bytes)
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('');
+    }
+}
+
+/**
+ * HTTP transport for sending error events to the API
+ */
+class HttpTransport {
+    constructor(options) {
+        this.hmacSigner = null;
+        this.endpoint = options.endpoint;
+        this.token = options.token;
+        this.timeout = options.timeout;
+        if (options.hmacSecret) {
+            this.hmacSigner = new HmacSigner(options.hmacSecret);
+        }
+    }
+    /**
+     * Send an error event to the API
+     */
+    async send(event) {
+        try {
+            const payload = JSON.stringify(event);
+            // Try sendBeacon first (non-blocking, works during page unload)
+            // Note: sendBeacon doesn't support custom headers, so no HMAC for beacon
+            if (!this.hmacSigner && this.trySendBeacon(payload)) {
+                return true;
+            }
+            // Fall back to fetch (supports HMAC headers)
+            return await this.sendFetch(payload);
+        }
+        catch (error) {
+            console.warn('[ErrorExplorer] Failed to send event:', error);
+            return false;
+        }
+    }
+    /**
+     * Try to send using sendBeacon (best for page unload)
+     * Note: sendBeacon doesn't support custom headers, so HMAC is not used
+     */
+    trySendBeacon(payload) {
+        if (typeof navigator === 'undefined' || !navigator.sendBeacon) {
+            return false;
+        }
+        try {
+            const blob = new Blob([payload], { type: 'application/json' });
+            return navigator.sendBeacon(this.endpoint, blob);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Send using fetch with timeout and optional HMAC signing
+     */
+    async sendFetch(payload) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            // Build headers
+            const headers = {
+                'Content-Type': 'application/json',
+                'X-Webhook-Token': this.token,
+            };
+            // Add HMAC signature headers if configured
+            if (this.hmacSigner) {
+                const hmacHeaders = await this.hmacSigner.buildHeaders(payload);
+                Object.assign(headers, hmacHeaders);
+            }
+            const response = await fetch(this.endpoint, {
+                method: 'POST',
+                headers,
+                body: payload,
+                signal: controller.signal,
+                keepalive: true, // Allow request to outlive the page
+            });
+            clearTimeout(timeoutId);
+            return response.ok;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            // Don't log abort errors (expected on timeout)
+            if (error instanceof Error && error.name === 'AbortError') {
+                console.warn('[ErrorExplorer] Request timed out');
+            }
+            return false;
+        }
+    }
+}
+
+/**
+ * Rate limiter to prevent flooding the API
+ */
+class RateLimiter {
+    /**
+     * Create a rate limiter
+     * @param maxRequests Maximum requests allowed in the time window
+     * @param windowMs Time window in milliseconds
+     */
+    constructor(maxRequests = 10, windowMs = 60000) {
+        this.timestamps = [];
+        this.maxRequests = maxRequests;
+        this.windowMs = windowMs;
+    }
+    /**
+     * Check if a request is allowed
+     */
+    isAllowed() {
+        const now = Date.now();
+        // Remove timestamps outside the window
+        this.timestamps = this.timestamps.filter((t) => now - t < this.windowMs);
+        // Check if under limit
+        if (this.timestamps.length >= this.maxRequests) {
+            return false;
+        }
+        // Record this request
+        this.timestamps.push(now);
+        return true;
+    }
+    /**
+     * Get remaining requests in current window
+     */
+    getRemaining() {
+        const now = Date.now();
+        this.timestamps = this.timestamps.filter((t) => now - t < this.windowMs);
+        return Math.max(0, this.maxRequests - this.timestamps.length);
+    }
+    /**
+     * Reset the rate limiter
+     */
+    reset() {
+        this.timestamps = [];
+    }
+}
+// Singleton instance
+let instance$3 = null;
+function getRateLimiter() {
+    if (!instance$3) {
+        instance$3 = new RateLimiter();
+    }
+    return instance$3;
+}
+function resetRateLimiter() {
+    instance$3 = null;
+}
+
+/**
+ * Manages retry logic for failed requests
+ */
+class RetryManager {
+    constructor(maxRetries = 3) {
+        this.queue = [];
+        this.processing = false;
+        this.sendFn = null;
+        this.maxRetries = maxRetries;
+    }
+    /**
+     * Set the send function
+     */
+    setSendFunction(fn) {
+        this.sendFn = fn;
+    }
+    /**
+     * Add an event to the retry queue
+     */
+    enqueue(event) {
+        this.queue.push({
+            event,
+            retries: 0,
+            timestamp: Date.now(),
+        });
+        this.processQueue();
+    }
+    /**
+     * Process the retry queue
+     */
+    async processQueue() {
+        if (this.processing || !this.sendFn || this.queue.length === 0) {
+            return;
+        }
+        this.processing = true;
+        while (this.queue.length > 0) {
+            const item = this.queue[0];
+            if (!item) {
+                break;
+            }
+            // Check if max retries exceeded
+            if (item.retries >= this.maxRetries) {
+                this.queue.shift();
+                continue;
+            }
+            // Exponential backoff
+            const delay = this.calculateDelay(item.retries);
+            await this.sleep(delay);
+            // Try to send
+            const success = await this.sendFn(item.event);
+            if (success) {
+                this.queue.shift();
+            }
+            else {
+                item.retries++;
+                // If max retries reached, remove from queue
+                if (item.retries >= this.maxRetries) {
+                    this.queue.shift();
+                    console.warn('[ErrorExplorer] Max retries reached, dropping event');
+                }
+            }
+        }
+        this.processing = false;
+    }
+    /**
+     * Calculate delay with exponential backoff
+     */
+    calculateDelay(retries) {
+        // 1s, 2s, 4s, 8s, etc. with jitter
+        const baseDelay = 1000 * Math.pow(2, retries);
+        const jitter = Math.random() * 1000;
+        return baseDelay + jitter;
+    }
+    /**
+     * Sleep for a given duration
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Get queue size
+     */
+    getQueueSize() {
+        return this.queue.length;
+    }
+    /**
+     * Clear the queue
+     */
+    clear() {
+        this.queue = [];
+    }
+}
+// Singleton instance
+let instance$2 = null;
+function getRetryManager() {
+    if (!instance$2) {
+        instance$2 = new RetryManager();
+    }
+    return instance$2;
+}
+function resetRetryManager() {
+    if (instance$2) {
+        instance$2.clear();
+    }
+    instance$2 = null;
+}
+
+const STORAGE_KEY = 'ee_offline_queue';
+const MAX_QUEUE_SIZE = 50;
+/**
+ * Offline queue using localStorage
+ * Stores events when offline and sends them when back online
+ */
+class OfflineQueue {
+    constructor(enabled = true) {
+        this.sendFn = null;
+        this.onlineHandler = null;
+        this.enabled = enabled && typeof localStorage !== 'undefined';
+        if (this.enabled) {
+            this.setupOnlineListener();
+        }
+    }
+    /**
+     * Set the send function
+     */
+    setSendFunction(fn) {
+        this.sendFn = fn;
+    }
+    /**
+     * Check if browser is online
+     */
+    isOnline() {
+        if (typeof navigator === 'undefined') {
+            return true;
+        }
+        return navigator.onLine;
+    }
+    /**
+     * Add event to offline queue
+     */
+    enqueue(event) {
+        if (!this.enabled) {
+            return;
+        }
+        try {
+            const queue = this.loadQueue();
+            // Add to queue (FIFO)
+            queue.push(event);
+            // Trim if too large
+            while (queue.length > MAX_QUEUE_SIZE) {
+                queue.shift();
+            }
+            this.saveQueue(queue);
+        }
+        catch (error) {
+            console.warn('[ErrorExplorer] Failed to save to offline queue:', error);
+        }
+    }
+    /**
+     * Process queued events
+     */
+    async flush() {
+        if (!this.enabled || !this.sendFn || !this.isOnline()) {
+            return;
+        }
+        const queue = this.loadQueue();
+        if (queue.length === 0) {
+            return;
+        }
+        // Clear queue first (to avoid duplicates if page closes during flush)
+        this.saveQueue([]);
+        // Try to send each event
+        const failed = [];
+        for (const event of queue) {
+            try {
+                const success = await this.sendFn(event);
+                if (!success) {
+                    failed.push(event);
+                }
+            }
+            catch {
+                failed.push(event);
+            }
+        }
+        // Re-queue failed events
+        if (failed.length > 0) {
+            const currentQueue = this.loadQueue();
+            this.saveQueue([...failed, ...currentQueue].slice(0, MAX_QUEUE_SIZE));
+        }
+    }
+    /**
+     * Get queue size
+     */
+    getQueueSize() {
+        return this.loadQueue().length;
+    }
+    /**
+     * Clear the offline queue
+     */
+    clear() {
+        this.saveQueue([]);
+    }
+    /**
+     * Destroy the offline queue
+     */
+    destroy() {
+        if (this.onlineHandler && typeof window !== 'undefined') {
+            window.removeEventListener('online', this.onlineHandler);
+            this.onlineHandler = null;
+        }
+    }
+    /**
+     * Setup listener for online event
+     */
+    setupOnlineListener() {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        this.onlineHandler = () => {
+            this.flush();
+        };
+        window.addEventListener('online', this.onlineHandler);
+    }
+    /**
+     * Load queue from localStorage
+     */
+    loadQueue() {
+        try {
+            const data = localStorage.getItem(STORAGE_KEY);
+            if (!data) {
+                return [];
+            }
+            return JSON.parse(data);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Save queue to localStorage
+     */
+    saveQueue(queue) {
+        try {
+            if (queue.length === 0) {
+                localStorage.removeItem(STORAGE_KEY);
+            }
+            else {
+                localStorage.setItem(STORAGE_KEY, JSON.stringify(queue));
+            }
+        }
+        catch {
+            // Storage might be full
+        }
+    }
+}
+// Singleton instance
+let instance$1 = null;
+function getOfflineQueue(enabled = true) {
+    if (!instance$1) {
+        instance$1 = new OfflineQueue(enabled);
+    }
+    return instance$1;
+}
+function resetOfflineQueue() {
+    if (instance$1) {
+        instance$1.destroy();
+    }
+    instance$1 = null;
+}
+
+/**
+ * Default fields to scrub (case-insensitive)
+ */
+const DEFAULT_SCRUB_FIELDS = [
+    'password',
+    'passwd',
+    'secret',
+    'token',
+    'api_key',
+    'apikey',
+    'access_token',
+    'accesstoken',
+    'refresh_token',
+    'refreshtoken',
+    'auth',
+    'authorization',
+    'credit_card',
+    'creditcard',
+    'card_number',
+    'cardnumber',
+    'cvv',
+    'cvc',
+    'ssn',
+    'social_security',
+    'private_key',
+    'privatekey',
+];
+/**
+ * Replacement string for scrubbed values
+ */
+const SCRUBBED = '[FILTERED]';
+/**
+ * Data scrubber to remove sensitive information before sending
+ */
+class DataScrubber {
+    constructor(additionalFields = []) {
+        // Combine default and additional fields, all lowercase
+        this.scrubFields = new Set([
+            ...DEFAULT_SCRUB_FIELDS.map((f) => f.toLowerCase()),
+            ...additionalFields.map((f) => f.toLowerCase()),
+        ]);
+    }
+    /**
+     * Scrub sensitive data from an object
+     */
+    scrub(data) {
+        return this.scrubValue(data, 0);
+    }
+    /**
+     * Recursively scrub a value
+     */
+    scrubValue(value, depth) {
+        // Limit recursion depth
+        if (depth > 10) {
+            return value;
+        }
+        // Handle null/undefined
+        if (value === null || value === undefined) {
+            return value;
+        }
+        // Handle primitives
+        if (typeof value !== 'object') {
+            return value;
+        }
+        // Handle arrays
+        if (Array.isArray(value)) {
+            return value.map((item) => this.scrubValue(item, depth + 1));
+        }
+        // Handle objects
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            if (this.shouldScrub(key)) {
+                result[key] = SCRUBBED;
+            }
+            else if (typeof val === 'string') {
+                result[key] = this.scrubString(val);
+            }
+            else {
+                result[key] = this.scrubValue(val, depth + 1);
+            }
+        }
+        return result;
+    }
+    /**
+     * Check if a key should be scrubbed
+     */
+    shouldScrub(key) {
+        const lowerKey = key.toLowerCase();
+        return this.scrubFields.has(lowerKey);
+    }
+    /**
+     * Scrub sensitive patterns from strings
+     */
+    scrubString(value) {
+        let result = value;
+        // Scrub credit card numbers (13-19 digits, possibly with spaces/dashes)
+        result = result.replace(/\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{1,7}\b/g, SCRUBBED);
+        // Scrub email addresses (optional, can be disabled if needed)
+        // result = result.replace(/[\w.+-]+@[\w.-]+\.\w{2,}/g, SCRUBBED);
+        // Scrub potential API keys (long alphanumeric strings)
+        result = result.replace(/\b(sk|pk|api|key|token|secret)_[a-zA-Z0-9]{20,}\b/gi, SCRUBBED);
+        // Scrub Bearer tokens
+        result = result.replace(/Bearer\s+[a-zA-Z0-9._-]+/gi, `Bearer ${SCRUBBED}`);
+        return result;
+    }
+    /**
+     * Add fields to scrub
+     */
+    addFields(fields) {
+        for (const field of fields) {
+            this.scrubFields.add(field.toLowerCase());
+        }
+    }
+}
+// Singleton instance
+let instance = null;
+function initDataScrubber(additionalFields = []) {
+    instance = new DataScrubber(additionalFields);
+    return instance;
+}
+function resetDataScrubber() {
+    instance = null;
+}
+
+const SDK_NAME = '@error-explorer/browser';
+const SDK_VERSION = '1.0.0';
+/**
+ * Main ErrorExplorer class - singleton pattern
+ */
+class ErrorExplorerClient {
+    constructor() {
+        this.config = null;
+        this.transport = null;
+        this.initialized = false;
+        this.tags = {};
+        this.extra = {};
+        this.contexts = {};
+    }
+    /**
+     * Initialize the SDK
+     */
+    init(options) {
+        if (this.initialized) {
+            console.warn('[ErrorExplorer] Already initialized');
+            return;
+        }
+        try {
+            // Resolve configuration
+            this.config = resolveConfig(options);
+            // Initialize transport
+            this.transport = new HttpTransport({
+                endpoint: this.config.endpoint,
+                token: this.config.token,
+                timeout: this.config.timeout,
+                maxRetries: this.config.maxRetries,
+                hmacSecret: this.config.hmacSecret,
+            });
+            // Initialize data scrubber
+            initDataScrubber();
+            // Setup send function for retry/offline managers
+            const sendFn = this.sendEvent.bind(this);
+            getRetryManager().setSendFunction(sendFn);
+            getOfflineQueue(this.config.offline).setSendFunction(sendFn);
+            // Initialize breadcrumbs
+            if (this.config.breadcrumbs.enabled) {
+                initBreadcrumbManager(this.config);
+                this.startBreadcrumbTrackers();
+            }
+            // Setup error captures
+            if (this.config.autoCapture.errors) {
+                getErrorCapture().start(this.handleCapturedError.bind(this));
+            }
+            if (this.config.autoCapture.unhandledRejections) {
+                getPromiseCapture().start(this.handleCapturedError.bind(this));
+            }
+            if (this.config.autoCapture.console) {
+                getConsoleCapture().start(this.handleCapturedError.bind(this));
+            }
+            // Record page view
+            getSessionManager().recordPageView();
+            // Flush offline queue on init
+            getOfflineQueue(this.config.offline).flush();
+            this.initialized = true;
+            if (this.config.debug) {
+                console.log('[ErrorExplorer] Initialized', {
+                    endpoint: this.config.endpoint,
+                    environment: this.config.environment,
+                });
+            }
+        }
+        catch (error) {
+            console.error('[ErrorExplorer] Initialization failed:', error);
+        }
+    }
+    /**
+     * Check if SDK is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Set user context
+     */
+    setUser(user) {
+        getUserContextManager().setUser(user);
+    }
+    /**
+     * Clear user context
+     */
+    clearUser() {
+        getUserContextManager().clearUser();
+    }
+    /**
+     * Set a single tag
+     */
+    setTag(key, value) {
+        this.tags[key] = value;
+    }
+    /**
+     * Set multiple tags
+     */
+    setTags(tags) {
+        this.tags = { ...this.tags, ...tags };
+    }
+    /**
+     * Set extra data
+     */
+    setExtra(extra) {
+        this.extra = { ...this.extra, ...extra };
+    }
+    /**
+     * Set a named context
+     */
+    setContext(name, context) {
+        this.contexts[name] = context;
+    }
+    /**
+     * Add a manual breadcrumb
+     */
+    addBreadcrumb(breadcrumb) {
+        const manager = getBreadcrumbManager();
+        if (manager) {
+            manager.add(breadcrumb);
+        }
+    }
+    /**
+     * Capture an exception manually
+     */
+    captureException(error, context) {
+        if (!this.initialized || !this.config) {
+            console.warn('[ErrorExplorer] Not initialized');
+            return '';
+        }
+        const eventId = generateUuid();
+        const event = this.buildEvent(error, context, 'error');
+        this.processAndSend(event);
+        return eventId;
+    }
+    /**
+     * Capture a message manually
+     */
+    captureMessage(message, level = 'info') {
+        if (!this.initialized || !this.config) {
+            console.warn('[ErrorExplorer] Not initialized');
+            return '';
+        }
+        const eventId = generateUuid();
+        const event = this.buildEvent(new Error(message), undefined, level);
+        event.exception_class = 'Message';
+        this.processAndSend(event);
+        return eventId;
+    }
+    /**
+     * Flush all pending events
+     */
+    async flush(timeout = 5000) {
+        if (!this.initialized) {
+            return false;
+        }
+        return new Promise((resolve) => {
+            const timeoutId = setTimeout(() => resolve(false), timeout);
+            Promise.all([getOfflineQueue().flush()])
+                .then(() => {
+                clearTimeout(timeoutId);
+                resolve(true);
+            })
+                .catch(() => {
+                clearTimeout(timeoutId);
+                resolve(false);
+            });
+        });
+    }
+    /**
+     * Close the SDK and cleanup
+     */
+    async close(timeout = 5000) {
+        if (!this.initialized) {
+            return true;
+        }
+        // Flush pending events
+        await this.flush(timeout);
+        // Stop all trackers and captures
+        this.stopAllTrackers();
+        // Reset all singletons
+        resetBreadcrumbManager();
+        resetErrorCapture();
+        resetPromiseCapture();
+        resetConsoleCapture();
+        resetSessionManager();
+        resetUserContextManager();
+        resetRateLimiter();
+        resetRetryManager();
+        resetOfflineQueue();
+        resetDataScrubber();
+        this.config = null;
+        this.transport = null;
+        this.initialized = false;
+        this.tags = {};
+        this.extra = {};
+        this.contexts = {};
+        return true;
+    }
+    /**
+     * Handle a captured error from auto-capture
+     */
+    handleCapturedError(captured) {
+        if (!this.config) {
+            return;
+        }
+        // Check if error should be ignored
+        if (this.shouldIgnoreError(captured)) {
+            if (this.config.debug) {
+                console.log('[ErrorExplorer] Ignoring error:', captured.message);
+            }
+            return;
+        }
+        const event = this.buildEventFromCapture(captured);
+        this.processAndSend(event);
+    }
+    /**
+     * Check if an error should be ignored
+     */
+    shouldIgnoreError(captured) {
+        if (!this.config) {
+            return true;
+        }
+        // Check ignoreErrors patterns
+        if (matchesPattern(captured.message, this.config.ignoreErrors)) {
+            return true;
+        }
+        // Check denyUrls
+        if (captured.filename && matchesPattern(captured.filename, this.config.denyUrls)) {
+            return true;
+        }
+        // Check allowUrls (if specified, only allow these)
+        if (this.config.allowUrls.length > 0 && captured.filename) {
+            if (!matchesPattern(captured.filename, this.config.allowUrls)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Build event from captured error
+     */
+    buildEventFromCapture(captured) {
+        return this.buildEvent(captured.originalError || new Error(captured.message), undefined, captured.severity);
+    }
+    /**
+     * Build a complete error event
+     */
+    buildEvent(error, context, severity = 'error') {
+        const config = this.config;
+        const message = getErrorMessage(error);
+        const name = getErrorName(error);
+        const stack = getErrorStack(error);
+        // Parse stack trace
+        const frames = parseStackTrace(stack);
+        const topFrame = frames[0];
+        // Get project name from config or derive from token
+        const project = config.project || this.deriveProjectName(config.token);
+        const event = {
+            message,
+            project,
+            exception_class: name,
+            file: topFrame?.filename || 'unknown',
+            line: topFrame?.lineno || 0,
+            column: topFrame?.colno,
+            stack_trace: stack,
+            frames,
+            severity: context?.level ?? severity,
+            environment: config.environment,
+            release: config.release || undefined,
+            timestamp: new Date().toISOString(),
+            // User context
+            user: context?.user ?? getUserContextManager().getUser() ?? undefined,
+            // Request context
+            request: collectRequestContext(),
+            // Browser context
+            browser: collectBrowserContext(),
+            // Session context
+            session: getSessionManager().getContext(),
+            // Breadcrumbs
+            breadcrumbs: getBreadcrumbManager()?.getAll(),
+            // Tags (merge global + context)
+            tags: { ...this.tags, ...context?.tags },
+            // Extra data
+            extra: { ...this.extra, ...context?.extra },
+            // Custom contexts
+            contexts: this.contexts,
+            // SDK info
+            sdk: {
+                name: SDK_NAME,
+                version: SDK_VERSION,
+            },
+            // Fingerprint for grouping
+            fingerprint: context?.fingerprint,
+        };
+        return event;
+    }
+    /**
+     * Process event through beforeSend and send
+     */
+    processAndSend(event) {
+        if (!this.config) {
+            return;
+        }
+        // Apply beforeSend hook
+        let processedEvent = event;
+        if (this.config.beforeSend) {
+            try {
+                processedEvent = this.config.beforeSend(event);
+            }
+            catch (e) {
+                console.error('[ErrorExplorer] beforeSend threw an error:', e);
+                processedEvent = event;
+            }
+        }
+        // If beforeSend returned null, drop the event
+        if (!processedEvent) {
+            if (this.config.debug) {
+                console.log('[ErrorExplorer] Event dropped by beforeSend');
+            }
+            return;
+        }
+        // Check rate limiter
+        if (!getRateLimiter().isAllowed()) {
+            if (this.config.debug) {
+                console.log('[ErrorExplorer] Rate limit exceeded, queuing event');
+            }
+            getRetryManager().enqueue(processedEvent);
+            return;
+        }
+        // Check if offline
+        if (!getOfflineQueue(this.config.offline).isOnline()) {
+            getOfflineQueue(this.config.offline).enqueue(processedEvent);
+            return;
+        }
+        // Send event
+        this.sendEvent(processedEvent);
+    }
+    /**
+     * Send event to the API
+     */
+    async sendEvent(event) {
+        if (!this.transport) {
+            return false;
+        }
+        const success = await this.transport.send(event);
+        if (!success && this.config?.offline) {
+            // Queue for retry
+            getRetryManager().enqueue(event);
+        }
+        return success;
+    }
+    /**
+     * Start all breadcrumb trackers
+     */
+    startBreadcrumbTrackers() {
+        if (!this.config) {
+            return;
+        }
+        const bc = this.config.breadcrumbs;
+        if (bc.clicks) {
+            getClickTracker().start();
+        }
+        if (bc.navigation) {
+            getNavigationTracker().start();
+        }
+        if (bc.fetch) {
+            getFetchTracker().start();
+        }
+        if (bc.xhr) {
+            getXHRTracker().start();
+        }
+        if (bc.console) {
+            getConsoleTracker().start();
+        }
+        if (bc.inputs) {
+            getInputTracker().start();
+        }
+    }
+    /**
+     * Stop all breadcrumb trackers
+     */
+    stopAllTrackers() {
+        resetClickTracker();
+        resetNavigationTracker();
+        resetFetchTracker();
+        resetXHRTracker();
+        resetConsoleTracker();
+        resetInputTracker();
+    }
+    /**
+     * Derive project name from token or use default
+     */
+    deriveProjectName(token) {
+        // If token starts with ee_, use a sanitized version as project name
+        if (token.startsWith('ee_')) {
+            // Take first 16 chars after ee_ for project identifier
+            return `project_${token.slice(3, 19)}`;
+        }
+        // Fallback to generic name
+        return 'browser-app';
+    }
+}
+// Export singleton instance
+const ErrorExplorer = new ErrorExplorerClient();
+
+/**
+ * @error-explorer/browser
+ * Error Explorer SDK for Browser - Automatic error tracking and breadcrumbs
+ */
+// Main export
+
+exports.ErrorExplorer = ErrorExplorer;
+exports.default = ErrorExplorer;
+//# sourceMappingURL=error-explorer.cjs.js.map