@kitbase/analytics 0.1.6

package/dist/index.js

@@ -0,0 +1,2374 @@
+// src/errors.ts
+var KitbaseError = class _KitbaseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "KitbaseError";
+    Object.setPrototypeOf(this, _KitbaseError.prototype);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends KitbaseError {
+  constructor(message = "Invalid API key") {
+    super(message);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var ApiError = class _ApiError extends KitbaseError {
+  statusCode;
+  response;
+  constructor(message, statusCode, response) {
+    super(message);
+    this.name = "ApiError";
+    this.statusCode = statusCode;
+    this.response = response;
+    Object.setPrototypeOf(this, _ApiError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends KitbaseError {
+  field;
+  constructor(message, field) {
+    super(message);
+    this.name = "ValidationError";
+    this.field = field;
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends KitbaseError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+
+// src/botDetection.ts
+var AUTOMATION_GLOBALS = [
+  "__webdriver_evaluate",
+  "__selenium_evaluate",
+  "__webdriver_script_function",
+  "__webdriver_unwrapped",
+  "__fxdriver_evaluate",
+  "__driver_evaluate",
+  "_Selenium_IDE_Recorder",
+  "_selenium",
+  "calledSelenium",
+  "$cdc_asdjflasutopfhvcZLmcfl_",
+  // Chrome DevTools Protocol marker
+  "__nightmare",
+  "domAutomation",
+  "domAutomationController"
+];
+var HEADLESS_PATTERNS = [
+  "headlesschrome",
+  "phantomjs",
+  "selenium",
+  "webdriver",
+  "puppeteer",
+  "playwright"
+];
+var HTTP_CLIENT_PATTERNS = [
+  "python",
+  "curl",
+  "wget",
+  "java/",
+  "go-http",
+  "node-fetch",
+  "axios",
+  "postman",
+  "insomnia",
+  "httpie",
+  "ruby",
+  "perl",
+  "scrapy",
+  "bot",
+  "spider",
+  "crawler",
+  "slurp",
+  "googlebot",
+  "bingbot",
+  "yandexbot",
+  "baiduspider",
+  "duckduckbot",
+  "facebookexternalhit",
+  "twitterbot",
+  "linkedinbot",
+  "whatsapp",
+  "telegram",
+  "discord",
+  "slack"
+];
+var DEFAULT_BOT_DETECTION_CONFIG = {
+  enabled: true,
+  checkWebdriver: true,
+  checkPhantomJS: true,
+  checkNightmare: true,
+  checkAutomationGlobals: true,
+  checkDocumentAttributes: true,
+  checkUserAgentHeadless: true,
+  checkUserAgentHttpClient: true
+};
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function getWindowProperty(key) {
+  try {
+    return window[key];
+  } catch {
+    return void 0;
+  }
+}
+function checkWebdriver() {
+  if (!isBrowser()) return false;
+  try {
+    return window.navigator?.webdriver === true;
+  } catch {
+    return false;
+  }
+}
+function checkPhantomJS() {
+  if (!isBrowser()) return false;
+  try {
+    return !!(getWindowProperty("callPhantom") || getWindowProperty("_phantom") || getWindowProperty("phantom"));
+  } catch {
+    return false;
+  }
+}
+function checkNightmare() {
+  if (!isBrowser()) return false;
+  try {
+    return !!getWindowProperty("__nightmare");
+  } catch {
+    return false;
+  }
+}
+function checkAutomationGlobals() {
+  if (!isBrowser()) return false;
+  try {
+    for (const global of AUTOMATION_GLOBALS) {
+      if (getWindowProperty(global) !== void 0) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function checkDocumentAttributes() {
+  if (!isBrowser()) return false;
+  try {
+    const docEl = document.documentElement;
+    if (!docEl) return false;
+    return !!(docEl.getAttribute("webdriver") || docEl.getAttribute("selenium") || docEl.getAttribute("driver"));
+  } catch {
+    return false;
+  }
+}
+function checkUserAgentHeadless() {
+  if (!isBrowser()) return false;
+  try {
+    const ua = window.navigator?.userAgent?.toLowerCase() || "";
+    if (!ua) return false;
+    for (const pattern of HEADLESS_PATTERNS) {
+      if (ua.includes(pattern)) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function checkUserAgentHttpClient(additionalPatterns) {
+  if (!isBrowser()) return false;
+  try {
+    const ua = window.navigator?.userAgent?.toLowerCase() || "";
+    if (!ua) return false;
+    for (const pattern of HTTP_CLIENT_PATTERNS) {
+      if (ua.includes(pattern)) {
+        return true;
+      }
+    }
+    if (additionalPatterns) {
+      for (const pattern of additionalPatterns) {
+        if (ua.includes(pattern.toLowerCase())) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function checkMissingUserAgent() {
+  if (!isBrowser()) return false;
+  try {
+    const ua = window.navigator?.userAgent;
+    return !ua || ua === "" || ua === "undefined" || ua.length < 10;
+  } catch {
+    return false;
+  }
+}
+function checkInvalidEnvironment() {
+  if (!isBrowser()) return false;
+  try {
+    if (!window.navigator || !window.location || !window.document || typeof window.navigator !== "object" || typeof window.location !== "object" || typeof window.document !== "object") {
+      return true;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+function detectBot(config = {}) {
+  const mergedConfig = { ...DEFAULT_BOT_DETECTION_CONFIG, ...config };
+  const checks = {
+    webdriver: mergedConfig.checkWebdriver ? checkWebdriver() : false,
+    phantomjs: mergedConfig.checkPhantomJS ? checkPhantomJS() : false,
+    nightmare: mergedConfig.checkNightmare ? checkNightmare() : false,
+    automationGlobals: mergedConfig.checkAutomationGlobals ? checkAutomationGlobals() : false,
+    documentAttributes: mergedConfig.checkDocumentAttributes ? checkDocumentAttributes() : false,
+    userAgentHeadless: mergedConfig.checkUserAgentHeadless ? checkUserAgentHeadless() : false,
+    userAgentHttpClient: mergedConfig.checkUserAgentHttpClient ? checkUserAgentHttpClient(config.additionalBotPatterns) : false,
+    missingUserAgent: checkMissingUserAgent(),
+    invalidEnvironment: checkInvalidEnvironment()
+  };
+  let reason;
+  if (checks.webdriver) {
+    reason = "WebDriver detected";
+  } else if (checks.phantomjs) {
+    reason = "PhantomJS detected";
+  } else if (checks.nightmare) {
+    reason = "Nightmare.js detected";
+  } else if (checks.automationGlobals) {
+    reason = "Automation tool globals detected";
+  } else if (checks.documentAttributes) {
+    reason = "Automation attributes on document element";
+  } else if (checks.userAgentHeadless) {
+    reason = "Headless browser user agent detected";
+  } else if (checks.userAgentHttpClient) {
+    reason = "HTTP client/bot user agent detected";
+  } else if (checks.missingUserAgent) {
+    reason = "Missing or invalid user agent";
+  } else if (checks.invalidEnvironment) {
+    reason = "Invalid browser environment";
+  }
+  const isBot2 = Object.values(checks).some(Boolean);
+  const result = {
+    isBot: isBot2,
+    reason,
+    checks
+  };
+  if (isBot2 && config.onBotDetected) {
+    try {
+      config.onBotDetected(result);
+    } catch {
+    }
+  }
+  return result;
+}
+function isBot(config = {}) {
+  return detectBot(config).isBot;
+}
+function isUserAgentBot(userAgent, additionalPatterns) {
+  if (!userAgent || userAgent.length < 10) {
+    return true;
+  }
+  const ua = userAgent.toLowerCase();
+  for (const pattern of HEADLESS_PATTERNS) {
+    if (ua.includes(pattern)) {
+      return true;
+    }
+  }
+  for (const pattern of HTTP_CLIENT_PATTERNS) {
+    if (ua.includes(pattern)) {
+      return true;
+    }
+  }
+  if (additionalPatterns) {
+    for (const pattern of additionalPatterns) {
+      if (ua.includes(pattern.toLowerCase())) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function getUserAgent() {
+  if (!isBrowser()) return null;
+  try {
+    return window.navigator?.userAgent || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/plugins/utils.ts
+var CLICKABLE_SELECTOR = [
+  "a",
+  "button",
+  "input",
+  "select",
+  "textarea",
+  '[role="button"]',
+  '[role="link"]',
+  '[role="menuitem"]',
+  '[role="tab"]'
+].join(", ");
+function findClickableElement(event) {
+  const path = event.composedPath?.();
+  if (path) {
+    for (const node of path) {
+      if (!(node instanceof Element)) continue;
+      if (node === document.documentElement) break;
+      if (node.matches(CLICKABLE_SELECTOR)) {
+        const root = node.getRootNode();
+        if (root instanceof ShadowRoot && root.host instanceof Element) {
+          return root.host;
+        }
+        return node;
+      }
+      if (node.tagName.includes("-")) {
+        return node;
+      }
+    }
+  }
+  const target = event.target;
+  if (!target?.closest) return null;
+  return target.closest(CLICKABLE_SELECTOR);
+}
+function buildCssSelector(el) {
+  if (el.id) return `#${el.id}`;
+  const tag = el.tagName.toLowerCase();
+  const classes = el.className && typeof el.className === "string" ? "." + el.className.trim().split(/\s+/).slice(0, 2).join(".") : "";
+  if (classes) return `${tag}${classes}`;
+  return tag;
+}
+function getRootDomain(hostname) {
+  const parts = hostname.replace(/^www\./, "").split(".");
+  if (parts.length >= 2) {
+    return parts.slice(-2).join(".");
+  }
+  return hostname;
+}
+function isSameRootDomain(host1, host2) {
+  return getRootDomain(host1) === getRootDomain(host2);
+}
+function getUtmParams() {
+  if (typeof window === "undefined") return {};
+  const params = new URLSearchParams(window.location.search);
+  const utmParams = {};
+  const utmKeys = ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"];
+  for (const key of utmKeys) {
+    const value = params.get(key);
+    if (value) {
+      utmParams[`__${key}`] = value;
+    }
+  }
+  return utmParams;
+}
+
+// src/client-base.ts
+var DEFAULT_BASE_URL = "https://api.kitbase.dev";
+var TIMEOUT = 3e4;
+var ANALYTICS_CHANNEL = "__analytics";
+var KitbaseAnalytics = class _KitbaseAnalytics {
+  sdkKey;
+  baseUrl;
+  // Super properties (memory-only, merged into all events)
+  superProperties = {};
+  // Time event tracking
+  timedEvents = /* @__PURE__ */ new Map();
+  // Debug mode
+  debugMode;
+  // Analytics config (stored for PluginContext)
+  analyticsConfig;
+  userId = null;
+  // Bot detection
+  botDetectionConfig;
+  botDetectionResult = null;
+  // Client-side session tracking
+  clientSessionId = null;
+  lastActivityAt = 0;
+  static SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+  // 30 minutes
+  // Plugin system
+  _plugins = /* @__PURE__ */ new Map();
+  _pluginContext = null;
+  constructor(config, defaultPlugins) {
+    if (!config.sdkKey) {
+      throw new ValidationError("SDK key is required", "sdkKey");
+    }
+    this.sdkKey = config.sdkKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.debugMode = config.debug ?? false;
+    this.analyticsConfig = config.analytics;
+    this.botDetectionConfig = {
+      ...DEFAULT_BOT_DETECTION_CONFIG,
+      ...config.botDetection
+    };
+    if (this.botDetectionConfig.enabled) {
+      this.botDetectionResult = detectBot(this.botDetectionConfig);
+      if (this.botDetectionResult.isBot) {
+        this.log("Bot detected", {
+          reason: this.botDetectionResult.reason,
+          checks: this.botDetectionResult.checks
+        });
+      } else {
+        this.log("Bot detection enabled, no bot detected");
+      }
+    }
+    if (defaultPlugins) {
+      for (const plugin of defaultPlugins) {
+        this.use(plugin);
+      }
+    }
+  }
+  // ============================================================
+  // Plugin System
+  // ============================================================
+  /**
+   * Register a plugin
+   *
+   * @param plugin - The plugin instance to register
+   *
+   * @example
+   * ```typescript
+   * kitbase.use(new WebVitalsPlugin());
+   * ```
+   */
+  use(plugin) {
+    if (this._plugins.has(plugin.name)) {
+      this.log(`Plugin "${plugin.name}" already registered`);
+      return;
+    }
+    const ctx = this.getPluginContext();
+    const result = plugin.setup(ctx);
+    if (result === false) {
+      this.log(`Plugin "${plugin.name}" declined to activate`);
+      return;
+    }
+    this._plugins.set(plugin.name, plugin);
+    const methods = plugin.methods;
+    if (methods) {
+      for (const [name, fn] of Object.entries(methods)) {
+        this[name] = fn;
+      }
+    }
+    this.log(`Plugin "${plugin.name}" registered`);
+  }
+  /**
+   * Get the names of all registered plugins
+   */
+  getPlugins() {
+    return Array.from(this._plugins.keys());
+  }
+  getPluginContext() {
+    if (this._pluginContext) return this._pluginContext;
+    this._pluginContext = {
+      track: (options) => this.track(options),
+      config: Object.freeze({
+        autoTrackPageViews: this.analyticsConfig?.autoTrackPageViews,
+        autoTrackOutboundLinks: this.analyticsConfig?.autoTrackOutboundLinks,
+        autoTrackClicks: this.analyticsConfig?.autoTrackClicks,
+        autoTrackScrollDepth: this.analyticsConfig?.autoTrackScrollDepth,
+        autoTrackVisibility: this.analyticsConfig?.autoTrackVisibility,
+        autoTrackWebVitals: this.analyticsConfig?.autoTrackWebVitals,
+        autoDetectFrustration: this.analyticsConfig?.autoDetectFrustration
+      }),
+      debug: this.debugMode,
+      log: (message, data) => this.log(message, data),
+      isBotBlockingActive: () => this.isBotBlockingActive(),
+      findClickableElement,
+      CLICKABLE_SELECTOR,
+      getRootDomain,
+      isSameRootDomain,
+      getUtmParams
+    };
+    return this._pluginContext;
+  }
+  // ============================================================
+  // Debug Mode
+  // ============================================================
+  /**
+   * Enable or disable debug mode
+   * When enabled, all SDK operations are logged to the console
+   *
+   * @param enabled - Whether to enable debug mode
+   *
+   * @example
+   * ```typescript
+   * kitbase.setDebugMode(true);
+   * // All events and operations will now be logged
+   * ```
+   */
+  setDebugMode(enabled) {
+    this.debugMode = enabled;
+    this.log(`Debug mode ${enabled ? "enabled" : "disabled"}`);
+  }
+  /**
+   * Check if debug mode is enabled
+   */
+  isDebugMode() {
+    return this.debugMode;
+  }
+  /**
+   * Internal logging function
+   */
+  log(message, data) {
+    if (!this.debugMode) return;
+    const prefix = "[Kitbase]";
+    if (data !== void 0) {
+      console.log(prefix, message, data);
+    } else {
+      console.log(prefix, message);
+    }
+  }
+  // ============================================================
+  // Super Properties
+  // ============================================================
+  /**
+   * Register super properties that will be included with every event
+   * These properties are stored in memory only and reset on page reload
+   *
+   * @param properties - Properties to register
+   *
+   * @example
+   * ```typescript
+   * kitbase.register({
+   *   app_version: '2.1.0',
+   *   platform: 'web',
+   *   environment: 'production',
+   * });
+   * ```
+   */
+  register(properties) {
+    this.superProperties = { ...this.superProperties, ...properties };
+    this.log("Super properties registered", properties);
+  }
+  /**
+   * Register super properties only if they haven't been set yet
+   * Useful for setting default values that shouldn't override existing ones
+   *
+   * @param properties - Properties to register if not already set
+   *
+   * @example
+   * ```typescript
+   * kitbase.registerOnce({ first_visit: new Date().toISOString() });
+   * ```
+   */
+  registerOnce(properties) {
+    const newProps = {};
+    for (const [key, value] of Object.entries(properties)) {
+      if (!(key in this.superProperties)) {
+        newProps[key] = value;
+      }
+    }
+    if (Object.keys(newProps).length > 0) {
+      this.superProperties = { ...this.superProperties, ...newProps };
+      this.log("Super properties registered (once)", newProps);
+    }
+  }
+  /**
+   * Remove a super property
+   *
+   * @param key - The property key to remove
+   *
+   * @example
+   * ```typescript
+   * kitbase.unregister('platform');
+   * ```
+   */
+  unregister(key) {
+    if (key in this.superProperties) {
+      delete this.superProperties[key];
+      this.log("Super property removed", { key });
+    }
+  }
+  /**
+   * Get all registered super properties
+   *
+   * @returns A copy of the current super properties
+   *
+   * @example
+   * ```typescript
+   * const props = kitbase.getSuperProperties();
+   * console.log(props); // { app_version: '2.1.0', platform: 'web' }
+   * ```
+   */
+  getSuperProperties() {
+    return { ...this.superProperties };
+  }
+  /**
+   * Clear all super properties
+   *
+   * @example
+   * ```typescript
+   * kitbase.clearSuperProperties();
+   * ```
+   */
+  clearSuperProperties() {
+    this.superProperties = {};
+    this.log("Super properties cleared");
+  }
+  // ============================================================
+  // Time Events (Duration Tracking)
+  // ============================================================
+  /**
+   * Start timing an event
+   * When the same event is tracked later, a $duration property (in seconds)
+   * will automatically be included
+   *
+   * @param eventName - The name of the event to time
+   *
+   * @example
+   * ```typescript
+   * kitbase.timeEvent('Video Watched');
+   * // ... user watches video ...
+   * await kitbase.track({
+   *   channel: 'engagement',
+   *   event: 'Video Watched',
+   *   tags: { video_id: '123' }
+   * });
+   * // Event will include $duration: 45.2 (seconds)
+   * ```
+   */
+  timeEvent(eventName) {
+    this.timedEvents.set(eventName, Date.now());
+    this.log("Timer started", { event: eventName });
+  }
+  /**
+   * Cancel a timed event without tracking it
+   *
+   * @param eventName - The name of the event to cancel timing for
+   *
+   * @example
+   * ```typescript
+   * kitbase.timeEvent('Checkout Flow');
+   * // User abandons checkout
+   * kitbase.cancelTimeEvent('Checkout Flow');
+   * ```
+   */
+  cancelTimeEvent(eventName) {
+    if (this.timedEvents.has(eventName)) {
+      this.timedEvents.delete(eventName);
+      this.log("Timer cancelled", { event: eventName });
+    }
+  }
+  /**
+   * Get all currently timed events
+   *
+   * @returns Array of event names that are currently being timed
+   *
+   * @example
+   * ```typescript
+   * const timedEvents = kitbase.getTimedEvents();
+   * console.log(timedEvents); // ['Video Watched', 'Checkout Flow']
+   * ```
+   */
+  getTimedEvents() {
+    return Array.from(this.timedEvents.keys());
+  }
+  /**
+   * Get the duration of a timed event (without stopping it)
+   * @internal
+   *
+   * @param eventName - The name of the event
+   * @returns Duration in seconds, or null if not being timed
+   */
+  getEventDuration(eventName) {
+    const startTime = this.timedEvents.get(eventName);
+    if (startTime === void 0) return null;
+    return (Date.now() - startTime) / 1e3;
+  }
+  // ============================================================
+  // Bot Detection
+  // ============================================================
+  /**
+   * Check if the current visitor is detected as a bot
+   *
+   * @internal This is an internal API and may change without notice.
+   * @returns true if bot detected, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (kitbase.isBot()) {
+   *   console.log('Bot detected, tracking disabled');
+   * }
+   * ```
+   */
+  isBot() {
+    if (!this.botDetectionConfig?.enabled) {
+      return false;
+    }
+    if (!this.botDetectionResult) {
+      this.botDetectionResult = detectBot(this.botDetectionConfig);
+    }
+    return this.botDetectionResult.isBot;
+  }
+  /**
+   * Get detailed bot detection result
+   *
+   * @internal This is an internal API and may change without notice.
+   * @returns Bot detection result with detailed checks, or null if detection not enabled
+   *
+   * @example
+   * ```typescript
+   * const result = kitbase.getBotDetectionResult();
+   * if (result?.isBot) {
+   *   console.log('Bot detected:', result.reason);
+   *   console.log('Checks:', result.checks);
+   * }
+   * ```
+   */
+  getBotDetectionResult() {
+    if (!this.botDetectionConfig.enabled) {
+      return null;
+    }
+    if (!this.botDetectionResult) {
+      this.botDetectionResult = detectBot(this.botDetectionConfig);
+    }
+    return this.botDetectionResult;
+  }
+  /**
+   * Force re-run bot detection
+   * Useful if you want to check again after page state changes
+   *
+   * @internal This is an internal API and may change without notice.
+   * @returns Updated bot detection result
+   *
+   * @example
+   * ```typescript
+   * const result = kitbase.redetectBot();
+   * console.log('Is bot:', result.isBot);
+   * ```
+   */
+  redetectBot() {
+    this.botDetectionResult = detectBot(this.botDetectionConfig);
+    this.log("Bot detection re-run", {
+      isBot: this.botDetectionResult.isBot,
+      reason: this.botDetectionResult.reason
+    });
+    return this.botDetectionResult;
+  }
+  /**
+   * Check if bot blocking is currently active
+   * When bot detection is enabled and a bot is detected, all events are blocked.
+   *
+   * @internal This is an internal API and may change without notice.
+   * @returns true if bots are being blocked from tracking
+   */
+  isBotBlockingActive() {
+    return this.botDetectionConfig?.enabled === true && this.isBot();
+  }
+  // ============================================================
+  // Client Session Tracking
+  // ============================================================
+  /**
+   * Get or create a client-side session ID.
+   * Rotates the session after 30 minutes of inactivity.
+   * @internal
+   */
+  getClientSessionId() {
+    const now = Date.now();
+    if (!this.clientSessionId || this.lastActivityAt > 0 && now - this.lastActivityAt > _KitbaseAnalytics.SESSION_TIMEOUT_MS) {
+      this.clientSessionId = _KitbaseAnalytics.generateUUID();
+      this.log("New client session started", { sessionId: this.clientSessionId });
+    }
+    this.lastActivityAt = now;
+    return this.clientSessionId;
+  }
+  /**
+   * Generate a UUID v4, with fallback for environments where
+   * crypto.randomUUID() is not available (older WebViews, Ionic).
+   */
+  static generateUUID() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      return crypto.randomUUID();
+    }
+    if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+      const bytes = new Uint8Array(16);
+      crypto.getRandomValues(bytes);
+      bytes[6] = bytes[6] & 15 | 64;
+      bytes[8] = bytes[8] & 63 | 128;
+      const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+      return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  // ============================================================
+  // Track Event
+  // ============================================================
+  /**
+   * Track an event
+   *
+   * Events are sent directly to the API. For offline queueing support,
+   * use the full Kitbase client instead.
+   *
+   * @param options - Event tracking options
+   * @returns Promise resolving to the track response, or void if tracking is blocked
+   * @throws {ValidationError} When required fields are missing
+   * @throws {AuthenticationError} When the API key is invalid
+   * @throws {ApiError} When the API returns an error
+   * @throws {TimeoutError} When the request times out
+   */
+  async track(options) {
+    this.validateTrackOptions(options);
+    if (this.isBotBlockingActive()) {
+      this.log("Event skipped - bot detected", { event: options.event });
+      return;
+    }
+    let duration;
+    const startTime = this.timedEvents.get(options.event);
+    if (startTime !== void 0) {
+      duration = (Date.now() - startTime) / 1e3;
+      this.timedEvents.delete(options.event);
+      this.log("Timer stopped", { event: options.event, duration });
+    }
+    const mergedTags = {
+      ...this.superProperties,
+      ...options.tags ?? {},
+      ...duration !== void 0 ? { $duration: duration } : {}
+    };
+    const payload = {
+      channel: options.channel,
+      event: options.event,
+      client_timestamp: Date.now(),
+      client_session_id: this.getClientSessionId(),
+      ...options.user_id && { user_id: options.user_id },
+      ...options.icon && { icon: options.icon },
+      ...options.notify !== void 0 && { notify: options.notify },
+      ...options.description && { description: options.description },
+      ...Object.keys(mergedTags).length > 0 && { tags: mergedTags }
+    };
+    this.log("Track", { event: options.event, payload });
+    const response = await this.sendRequest("/sdk/v1/logs", payload);
+    this.log("Event sent successfully", { id: response.id });
+    return response;
+  }
+  validateTrackOptions(options) {
+    if (!options.event) {
+      throw new ValidationError("Event is required", "event");
+    }
+  }
+  /**
+   * Send a request to the API
+   */
+  async sendRequest(endpoint, body) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), TIMEOUT);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-sdk-key": `${this.sdkKey}`
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorBody = await this.parseResponseBody(response);
+        if (response.status === 401) {
+          throw new AuthenticationError();
+        }
+        throw new ApiError(
+          this.getErrorMessage(errorBody, response.statusText),
+          response.status,
+          errorBody
+        );
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutError();
+      }
+      throw error;
+    }
+  }
+  async parseResponseBody(response) {
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  getErrorMessage(body, fallback) {
+    if (body && typeof body === "object" && "message" in body) {
+      return String(body.message);
+    }
+    if (body && typeof body === "object" && "error" in body) {
+      return String(body.error);
+    }
+    return fallback;
+  }
+  // ============================================================
+  // Analytics — Stub methods (overridden by plugins via methods)
+  // ============================================================
+  /**
+   * Track a page view
+   *
+   * @param options - Page view options
+   * @returns Promise resolving to the track response
+   *
+   * @example
+   * ```typescript
+   * // Track current page
+   * await kitbase.trackPageView();
+   *
+   * // Track with custom path
+   * await kitbase.trackPageView({ path: '/products/123', title: 'Product Details' });
+   * ```
+   */
+  async trackPageView(options) {
+    this.log("trackPageView() called but page-view plugin is not registered");
+  }
+  /**
+   * Track a click on an interactive element
+   */
+  async trackClick(tags) {
+    this.log("trackClick() called but click-tracking plugin is not registered");
+  }
+  /**
+   * Track an outbound link click
+   *
+   * @param options - Outbound link options
+   * @returns Promise resolving to the track response
+   *
+   * @example
+   * ```typescript
+   * await kitbase.trackOutboundLink({
+   *   url: 'https://example.com',
+   *   text: 'Visit Example',
+   * });
+   * ```
+   */
+  async trackOutboundLink(options) {
+    this.log("trackOutboundLink() called but outbound-links plugin is not registered");
+  }
+  // ============================================================
+  // Analytics — Revenue & Identity (non-plugin)
+  // ============================================================
+  /**
+   * Track a revenue event
+   *
+   * @param options - Revenue options
+   * @returns Promise resolving to the track response
+   *
+   * @example
+   * ```typescript
+   * // Track a $19.99 purchase
+   * await kitbase.trackRevenue({
+   *   amount: 1999,
+   *   currency: 'USD',
+   *   tags: { product_id: 'prod_123', plan: 'premium' },
+   * });
+   * ```
+   */
+  async trackRevenue(options) {
+    return this.track({
+      channel: ANALYTICS_CHANNEL,
+      event: "revenue",
+      user_id: options.user_id ?? this.userId ?? void 0,
+      tags: {
+        __revenue: options.amount,
+        __currency: options.currency ?? "USD",
+        ...options.tags ?? {}
+      }
+    });
+  }
+  /**
+   * Identify a user
+   * Sets the user identity on the server.
+   * Call this when a user signs up or logs in.
+   *
+   * @param options - Identify options
+   * @returns Promise that resolves when the identity is set
+   *
+   * @example
+   * ```typescript
+   * await kitbase.identify({
+   *   userId: 'user_123',
+   *   traits: { email: 'user@example.com', plan: 'premium' },
+   * });
+   * ```
+   */
+  async identify(options) {
+    this.userId = options.userId;
+    if (options.traits) {
+      this.register({
+        __user_id: options.userId,
+        ...options.traits
+      });
+    } else {
+      this.register({ __user_id: options.userId });
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}/sdk/v1/identify`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-sdk-key": this.sdkKey
+        },
+        body: JSON.stringify({
+          user_id: options.userId,
+          traits: options.traits
+        })
+      });
+      if (!response.ok) {
+        this.log("Identify API call failed", { status: response.status });
+      } else {
+        this.log("Identity set on server", {
+          userId: options.userId
+        });
+      }
+    } catch (err) {
+      this.log("Failed to call identify endpoint", err);
+    }
+    this.log("User identified", { userId: options.userId });
+  }
+  /**
+   * Get the current user ID (set via identify)
+   */
+  getUserId() {
+    return this.userId;
+  }
+  /**
+   * Reset the user identity
+   * Call this when a user logs out
+   *
+   * @example
+   * ```typescript
+   * kitbase.reset();
+   * ```
+   */
+  reset() {
+    this.userId = null;
+    this.clientSessionId = null;
+    this.lastActivityAt = 0;
+    this.clearSuperProperties();
+    this.log("User reset complete");
+  }
+  // ============================================================
+  // Cleanup
+  // ============================================================
+  /**
+   * Shutdown the client and cleanup resources
+   * Call this when you're done using the client to stop timers and close connections
+   *
+   * @example
+   * ```typescript
+   * kitbase.shutdown();
+   * ```
+   */
+  shutdown() {
+    this.log("Shutting down");
+    this.timedEvents.clear();
+    const pluginNames = Array.from(this._plugins.keys()).reverse();
+    for (const name of pluginNames) {
+      const plugin = this._plugins.get(name);
+      try {
+        plugin.teardown();
+        this.log(`Plugin "${name}" torn down`);
+      } catch (err) {
+        this.log(`Plugin "${name}" teardown failed`, err);
+      }
+    }
+    this._plugins.clear();
+    this._pluginContext = null;
+    this.log("Shutdown complete");
+  }
+};
+
+// src/queue/index.ts
+import Dexie from "dexie";
+var DEFAULT_CONFIG = {
+  enabled: false,
+  maxQueueSize: 1e3,
+  flushInterval: 3e4,
+  flushBatchSize: 50,
+  maxRetries: 3,
+  retryBaseDelay: 1e3
+};
+function isIndexedDBAvailable() {
+  try {
+    return typeof window !== "undefined" && typeof window.indexedDB !== "undefined" && window.indexedDB !== null;
+  } catch {
+    return false;
+  }
+}
+function isBrowser2() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+var KitbaseQueueDB = class extends Dexie {
+  events;
+  constructor(dbName) {
+    super(dbName);
+    this.version(1).stores({
+      events: "++id, timestamp, retries, lastAttempt"
+    });
+  }
+};
+var MemoryQueue = class {
+  queue = [];
+  idCounter = 1;
+  async enqueue(payload) {
+    const event = {
+      id: this.idCounter++,
+      payload,
+      timestamp: Date.now(),
+      retries: 0
+    };
+    this.queue.push(event);
+    return event.id;
+  }
+  async dequeue(count) {
+    this.queue.sort((a, b) => a.timestamp - b.timestamp);
+    return this.queue.slice(0, count);
+  }
+  async delete(ids) {
+    this.queue = this.queue.filter((e) => !ids.includes(e.id));
+  }
+  async updateRetries(ids) {
+    const now = Date.now();
+    for (const event of this.queue) {
+      if (ids.includes(event.id)) {
+        event.retries++;
+        event.lastAttempt = now;
+      }
+    }
+  }
+  async getStats() {
+    const size = this.queue.length;
+    const oldestEvent = size > 0 ? Math.min(...this.queue.map((e) => e.timestamp)) : void 0;
+    return { size, oldestEvent };
+  }
+  async clear() {
+    this.queue = [];
+  }
+  async enforceMaxSize(maxSize) {
+    if (this.queue.length > maxSize) {
+      this.queue.sort((a, b) => a.timestamp - b.timestamp);
+      this.queue = this.queue.slice(-maxSize);
+    }
+  }
+  async getEventsExceedingRetries(maxRetries) {
+    return this.queue.filter((e) => e.retries >= maxRetries).map((e) => e.id);
+  }
+};
+var EventQueue = class {
+  config;
+  dbName;
+  db = null;
+  memoryQueue = null;
+  flushTimer = null;
+  isFlushing = false;
+  sendEvents = null;
+  useIndexedDB;
+  debugMode = false;
+  debugLogger = null;
+  constructor(config = {}, dbName = "_ka_events") {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.dbName = dbName;
+    this.useIndexedDB = isIndexedDBAvailable();
+    if (this.useIndexedDB) {
+      this.db = new KitbaseQueueDB(this.dbName);
+    } else {
+      this.memoryQueue = new MemoryQueue();
+    }
+  }
+  /**
+   * Set debug mode and logger
+   */
+  setDebugMode(enabled, logger) {
+    this.debugMode = enabled;
+    this.debugLogger = logger ?? null;
+  }
+  log(message, data) {
+    if (this.debugMode && this.debugLogger) {
+      this.debugLogger(message, data);
+    }
+  }
+  /**
+   * Set the callback for sending events
+   */
+  setSendCallback(callback) {
+    this.sendEvents = callback;
+  }
+  /**
+   * Check if the queue storage is available
+   */
+  isAvailable() {
+    return this.useIndexedDB || this.memoryQueue !== null;
+  }
+  /**
+   * Get the storage type being used
+   */
+  getStorageType() {
+    return this.useIndexedDB ? "indexeddb" : "memory";
+  }
+  /**
+   * Add an event to the queue
+   */
+  async enqueue(payload) {
+    const event = {
+      payload,
+      timestamp: Date.now(),
+      retries: 0
+    };
+    if (this.useIndexedDB && this.db) {
+      await this.db.events.add(event);
+      this.log("Event queued to IndexedDB", payload);
+    } else if (this.memoryQueue) {
+      await this.memoryQueue.enqueue(payload);
+      this.log("Event queued to memory", payload);
+    }
+    await this.enforceMaxQueueSize();
+  }
+  /**
+   * Get and remove the next batch of events to send
+   */
+  async dequeue(count) {
+    if (this.useIndexedDB && this.db) {
+      return this.db.events.where("retries").below(this.config.maxRetries).sortBy("timestamp").then((events) => events.slice(0, count));
+    } else if (this.memoryQueue) {
+      const events = await this.memoryQueue.dequeue(count);
+      return events.filter((e) => e.retries < this.config.maxRetries);
+    }
+    return [];
+  }
+  /**
+   * Mark events as successfully sent (remove from queue)
+   */
+  async markSent(ids) {
+    if (ids.length === 0) return;
+    if (this.useIndexedDB && this.db) {
+      await this.db.events.bulkDelete(ids);
+      this.log(`Removed ${ids.length} sent events from queue`);
+    } else if (this.memoryQueue) {
+      await this.memoryQueue.delete(ids);
+      this.log(`Removed ${ids.length} sent events from memory queue`);
+    }
+  }
+  /**
+   * Mark events as failed and increment retry count
+   */
+  async markFailed(ids) {
+    if (ids.length === 0) return;
+    const now = Date.now();
+    if (this.useIndexedDB && this.db) {
+      await this.db.transaction("rw", this.db.events, async () => {
+        for (const id of ids) {
+          const event = await this.db.events.get(id);
+          if (event) {
+            await this.db.events.update(id, {
+              retries: event.retries + 1,
+              lastAttempt: now
+            });
+          }
+        }
+      });
+      this.log(`Marked ${ids.length} events as failed`);
+    } else if (this.memoryQueue) {
+      await this.memoryQueue.updateRetries(ids);
+      this.log(`Marked ${ids.length} events as failed in memory queue`);
+    }
+    await this.removeExpiredRetries();
+  }
+  /**
+   * Remove events that have exceeded max retry attempts
+   */
+  async removeExpiredRetries() {
+    if (this.useIndexedDB && this.db) {
+      const expiredIds = await this.db.events.where("retries").aboveOrEqual(this.config.maxRetries).primaryKeys();
+      if (expiredIds.length > 0) {
+        await this.db.events.bulkDelete(expiredIds);
+        this.log(`Removed ${expiredIds.length} events that exceeded max retries`);
+      }
+    } else if (this.memoryQueue) {
+      const expiredIds = await this.memoryQueue.getEventsExceedingRetries(
+        this.config.maxRetries
+      );
+      if (expiredIds.length > 0) {
+        await this.memoryQueue.delete(expiredIds);
+        this.log(`Removed ${expiredIds.length} events that exceeded max retries`);
+      }
+    }
+  }
+  /**
+   * Enforce the maximum queue size by removing oldest events
+   */
+  async enforceMaxQueueSize() {
+    if (this.useIndexedDB && this.db) {
+      const count = await this.db.events.count();
+      if (count > this.config.maxQueueSize) {
+        const excess = count - this.config.maxQueueSize;
+        const oldestEvents = await this.db.events.orderBy("timestamp").limit(excess).primaryKeys();
+        await this.db.events.bulkDelete(oldestEvents);
+        this.log(`Removed ${excess} oldest events to enforce queue size limit`);
+      }
+    } else if (this.memoryQueue) {
+      await this.memoryQueue.enforceMaxSize(this.config.maxQueueSize);
+    }
+  }
+  /**
+   * Get queue statistics
+   */
+  async getStats() {
+    if (this.useIndexedDB && this.db) {
+      const size = await this.db.events.count();
+      const oldestEvent = await this.db.events.orderBy("timestamp").first().then((e) => e?.timestamp);
+      return { size, oldestEvent, isFlushing: this.isFlushing };
+    } else if (this.memoryQueue) {
+      const stats = await this.memoryQueue.getStats();
+      return { ...stats, isFlushing: this.isFlushing };
+    }
+    return { size: 0, isFlushing: this.isFlushing };
+  }
+  /**
+   * Clear all events from the queue
+   */
+  async clear() {
+    if (this.useIndexedDB && this.db) {
+      await this.db.events.clear();
+      this.log("Queue cleared (IndexedDB)");
+    } else if (this.memoryQueue) {
+      await this.memoryQueue.clear();
+      this.log("Queue cleared (memory)");
+    }
+  }
+  /**
+   * Start the automatic flush timer
+   */
+  startFlushTimer() {
+    if (this.flushTimer) return;
+    this.flushTimer = setInterval(() => {
+      this.flush().catch((err) => {
+        this.log("Flush timer error", err);
+      });
+    }, this.config.flushInterval);
+    if (isBrowser2()) {
+      window.addEventListener("online", this.handleOnline);
+    }
+    this.log(`Flush timer started (interval: ${this.config.flushInterval}ms)`);
+  }
+  /**
+   * Stop the automatic flush timer
+   */
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (isBrowser2()) {
+      window.removeEventListener("online", this.handleOnline);
+    }
+    this.log("Flush timer stopped");
+  }
+  /**
+   * Handle coming back online
+   */
+  handleOnline = () => {
+    this.log("Browser came online, triggering flush");
+    this.flush().catch((err) => {
+      this.log("Online flush error", err);
+    });
+  };
+  /**
+   * Check if we're currently online
+   */
+  isOnline() {
+    if (isBrowser2()) {
+      return navigator.onLine;
+    }
+    return true;
+  }
+  /**
+   * Manually trigger a flush of queued events
+   */
+  async flush() {
+    if (this.isFlushing) {
+      this.log("Flush already in progress, skipping");
+      return;
+    }
+    if (!this.isOnline()) {
+      this.log("Offline, skipping flush");
+      return;
+    }
+    if (!this.sendEvents) {
+      this.log("No send callback configured, skipping flush");
+      return;
+    }
+    this.isFlushing = true;
+    try {
+      const stats = await this.getStats();
+      if (stats.size === 0) {
+        this.log("Queue is empty, nothing to flush");
+        return;
+      }
+      this.log(`Flushing queue (${stats.size} events)`);
+      let processed = 0;
+      while (true) {
+        const events = await this.dequeue(this.config.flushBatchSize);
+        if (events.length === 0) break;
+        this.log(`Sending batch of ${events.length} events`);
+        try {
+          const sentIds = await this.sendEvents(events);
+          await this.markSent(sentIds);
+          const failedIds = events.filter((e) => !sentIds.includes(e.id)).map((e) => e.id);
+          if (failedIds.length > 0) {
+            await this.markFailed(failedIds);
+          }
+          processed += sentIds.length;
+        } catch (error) {
+          const allIds = events.map((e) => e.id);
+          await this.markFailed(allIds);
+          this.log("Batch send failed", error);
+          break;
+        }
+      }
+      this.log(`Flush complete, sent ${processed} events`);
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  /**
+   * Close the database connection
+   */
+  async close() {
+    this.stopFlushTimer();
+    if (this.db) {
+      this.db.close();
+      this.log("Database connection closed");
+    }
+  }
+};
+
+// src/plugins/page-view.ts
+var ANALYTICS_CHANNEL2 = "__analytics";
+var PageViewPlugin = class {
+  name = "page-view";
+  ctx;
+  active = false;
+  popstateListener = null;
+  setup(ctx) {
+    if (typeof window === "undefined") return false;
+    this.ctx = ctx;
+    this.active = true;
+    Promise.resolve().then(() => {
+      if (this.active) {
+        this.trackPageView().catch((err) => ctx.log("Failed to track initial page view", err));
+      }
+    });
+    const originalPushState = history.pushState.bind(history);
+    history.pushState = (...args) => {
+      originalPushState(...args);
+      if (this.active) {
+        this.trackPageView().catch((err) => ctx.log("Failed to track page view (pushState)", err));
+      }
+    };
+    const originalReplaceState = history.replaceState.bind(history);
+    history.replaceState = (...args) => {
+      originalReplaceState(...args);
+    };
+    this.popstateListener = () => {
+      if (this.active) {
+        this.trackPageView().catch((err) => ctx.log("Failed to track page view (popstate)", err));
+      }
+    };
+    window.addEventListener("popstate", this.popstateListener);
+    ctx.log("Auto page view tracking enabled");
+  }
+  teardown() {
+    this.active = false;
+    if (this.popstateListener) {
+      window.removeEventListener("popstate", this.popstateListener);
+      this.popstateListener = null;
+    }
+  }
+  get methods() {
+    return {
+      trackPageView: (options) => this.trackPageView(options)
+    };
+  }
+  async trackPageView(options = {}) {
+    const path = options.path ?? (typeof window !== "undefined" ? window.location.pathname : "");
+    const title = options.title ?? (typeof document !== "undefined" ? document.title : "");
+    const referrer = options.referrer ?? (typeof document !== "undefined" ? document.referrer : "");
+    return this.ctx.track({
+      channel: ANALYTICS_CHANNEL2,
+      event: "screen_view",
+      tags: {
+        __path: path,
+        __title: title,
+        __referrer: referrer,
+        ...getUtmParams(),
+        ...options.tags ?? {}
+      }
+    });
+  }
+};
+
+// src/plugins/outbound-links.ts
+var ANALYTICS_CHANNEL3 = "__analytics";
+var OutboundLinksPlugin = class {
+  name = "outbound-links";
+  ctx;
+  clickListener = null;
+  keydownListener = null;
+  setup(ctx) {
+    if (typeof window === "undefined") return false;
+    this.ctx = ctx;
+    this.clickListener = (event) => {
+      const link = event.target?.closest?.("a");
+      if (link) {
+        this.handleLinkClick(link);
+      }
+    };
+    this.keydownListener = (event) => {
+      if (event.key === "Enter" || event.key === " ") {
+        const link = event.target?.closest?.("a");
+        if (link) {
+          this.handleLinkClick(link);
+        }
+      }
+    };
+    document.addEventListener("click", this.clickListener);
+    document.addEventListener("keydown", this.keydownListener);
+    ctx.log("Outbound link tracking enabled");
+  }
+  teardown() {
+    if (this.clickListener) {
+      document.removeEventListener("click", this.clickListener);
+      this.clickListener = null;
+    }
+    if (this.keydownListener) {
+      document.removeEventListener("keydown", this.keydownListener);
+      this.keydownListener = null;
+    }
+  }
+  get methods() {
+    return {
+      trackOutboundLink: (options) => this.trackOutboundLink(options)
+    };
+  }
+  handleLinkClick(link) {
+    if (!link.href) return;
+    try {
+      const linkUrl = new URL(link.href);
+      if (linkUrl.protocol !== "http:" && linkUrl.protocol !== "https:") {
+        return;
+      }
+      const currentHost = window.location.hostname;
+      const linkHost = linkUrl.hostname;
+      if (linkHost === currentHost) return;
+      if (this.ctx.isSameRootDomain(currentHost, linkHost)) return;
+      this.trackOutboundLink({
+        url: link.href,
+        text: link.textContent?.trim() || ""
+      }).catch((err) => this.ctx.log("Failed to track outbound link", err));
+    } catch {
+    }
+  }
+  async trackOutboundLink(options) {
+    return this.ctx.track({
+      channel: ANALYTICS_CHANNEL3,
+      event: "outbound_link",
+      tags: {
+        __url: options.url,
+        __text: options.text || ""
+      }
+    });
+  }
+};
+
+// src/plugins/click-tracking.ts
+var ANALYTICS_CHANNEL4 = "__analytics";
+var ClickTrackingPlugin = class {
+  name = "click-tracking";
+  ctx;
+  clickListener = null;
+  setup(ctx) {
+    if (typeof window === "undefined") return false;
+    this.ctx = ctx;
+    this.clickListener = (event) => {
+      const target = event.target;
+      const annotated = target?.closest?.("[data-kb-track-click]");
+      if (annotated) {
+        const eventName = annotated.getAttribute("data-kb-track-click");
+        if (eventName) {
+          const channel = annotated.getAttribute("data-kb-click-channel") || "engagement";
+          ctx.track({
+            channel,
+            event: eventName,
+            tags: {
+              __path: window.location.pathname
+            }
+          }).catch((err) => ctx.log("Failed to track data-attribute click", err));
+          return;
+        }
+      }
+      const element = ctx.findClickableElement(event);
+      if (!element) return;
+      if (ctx.config.autoTrackOutboundLinks !== false) {
+        const elHref = element.href || element.getAttribute("href") || "";
+        if (elHref) {
+          try {
+            const linkUrl = new URL(elHref, window.location.origin);
+            if ((linkUrl.protocol === "http:" || linkUrl.protocol === "https:") && linkUrl.hostname !== window.location.hostname && !ctx.isSameRootDomain(window.location.hostname, linkUrl.hostname)) {
+              return;
+            }
+          } catch {
+          }
+        }
+      }
+      const tag = element.tagName.toLowerCase();
+      const id = element.id || "";
+      const className = element.className && typeof element.className === "string" ? element.className : "";
+      const text = (element.textContent || "").trim().slice(0, 100);
+      const href = element.href || element.getAttribute("href") || "";
+      const path = window.location.pathname;
+      this.trackClick({ __tag: tag, __id: id, __class: className, __text: text, __href: href, __path: path }).catch(
+        (err) => ctx.log("Failed to track click", err)
+      );
+    };
+    document.addEventListener("click", this.clickListener);
+    ctx.log("Click tracking enabled");
+  }
+  teardown() {
+    if (this.clickListener) {
+      document.removeEventListener("click", this.clickListener);
+      this.clickListener = null;
+    }
+  }
+  get methods() {
+    return {
+      trackClick: (tags) => this.trackClick(tags)
+    };
+  }
+  async trackClick(tags) {
+    return this.ctx.track({
+      channel: ANALYTICS_CHANNEL4,
+      event: "click",
+      tags
+    });
+  }
+};
+
+// src/plugins/scroll-depth.ts
+var ANALYTICS_CHANNEL5 = "__analytics";
+var ScrollDepthPlugin = class {
+  name = "scroll-depth";
+  ctx;
+  active = false;
+  maxScrollDepth = 0;
+  scrollListener = null;
+  beforeUnloadListener = null;
+  popstateListener = null;
+  scrollRafScheduled = false;
+  setup(ctx) {
+    if (typeof window === "undefined") return false;
+    this.ctx = ctx;
+    this.active = true;
+    this.scrollListener = () => {
+      if (this.scrollRafScheduled) return;
+      this.scrollRafScheduled = true;
+      requestAnimationFrame(() => {
+        this.scrollRafScheduled = false;
+        const scrollTop = window.scrollY || document.documentElement.scrollTop;
+        const viewportHeight = window.innerHeight;
+        const documentHeight = Math.max(
+          document.body.scrollHeight,
+          document.documentElement.scrollHeight
+        );
+        if (documentHeight <= 0) return;
+        const depth = Math.min(100, Math.round((scrollTop + viewportHeight) / documentHeight * 100));
+        if (depth > this.maxScrollDepth) {
+          this.maxScrollDepth = depth;
+        }
+      });
+    };
+    this.beforeUnloadListener = () => {
+      this.flushScrollDepth();
+    };
+    window.addEventListener("scroll", this.scrollListener, { passive: true });
+    window.addEventListener("beforeunload", this.beforeUnloadListener);
+    const originalPushState = history.pushState;
+    const self = this;
+    history.pushState = function(...args) {
+      if (self.active) self.flushScrollDepth();
+      return originalPushState.apply(this, args);
+    };
+    this.popstateListener = () => {
+      if (this.active) this.flushScrollDepth();
+    };
+    window.addEventListener("popstate", this.popstateListener);
+    ctx.log("Scroll depth tracking enabled");
+  }
+  teardown() {
+    this.active = false;
+    this.flushScrollDepth();
+    if (this.scrollListener) {
+      window.removeEventListener("scroll", this.scrollListener);
+      this.scrollListener = null;
+    }
+    if (this.beforeUnloadListener) {
+      window.removeEventListener("beforeunload", this.beforeUnloadListener);
+      this.beforeUnloadListener = null;
+    }
+    if (this.popstateListener) {
+      window.removeEventListener("popstate", this.popstateListener);
+      this.popstateListener = null;
+    }
+  }
+  flushScrollDepth() {
+    if (this.maxScrollDepth > 0) {
+      const path = typeof window !== "undefined" ? window.location.pathname : "";
+      this.ctx.track({
+        channel: ANALYTICS_CHANNEL5,
+        event: "scroll_depth",
+        tags: {
+          __depth: this.maxScrollDepth,
+          __path: path
+        }
+      }).catch((err) => this.ctx.log("Failed to track scroll depth", err));
+      this.maxScrollDepth = 0;
+    }
+  }
+};
+
+// src/plugins/visibility.ts
+var VisibilityPlugin = class {
+  name = "visibility";
+  ctx;
+  active = false;
+  visibilityObservers = /* @__PURE__ */ new Map();
+  visibilityMutationObserver = null;
+  visibilityData = /* @__PURE__ */ new Map();
+  beforeUnloadListener = null;
+  popstateListener = null;
+  setup(ctx) {
+    if (typeof window === "undefined") return false;
+    if (typeof IntersectionObserver === "undefined" || typeof MutationObserver === "undefined") return false;
+    this.ctx = ctx;
+    this.active = true;
+    this.scanForVisibilityElements();
+    this.visibilityMutationObserver = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        for (const node of Array.from(mutation.addedNodes)) {
+          if (node instanceof Element) {
+            this.observeVisibilityElement(node);
+            for (const el of Array.from(node.querySelectorAll("[data-kb-track-visibility]"))) {
+              this.observeVisibilityElement(el);
+            }
+          }
+        }
+        for (const node of Array.from(mutation.removedNodes)) {
+          if (node instanceof Element) {
+            this.flushVisibilityForElement(node);
+            for (const el of Array.from(node.querySelectorAll("[data-kb-track-visibility]"))) {
+              this.flushVisibilityForElement(el);
+            }
+          }
+        }
+      }
+    });
+    this.visibilityMutationObserver.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+    this.beforeUnloadListener = () => {
+      this.flushAllVisibilityEvents();
+    };
+    window.addEventListener("beforeunload", this.beforeUnloadListener);
+    const originalPushState = history.pushState;
+    const self = this;
+    history.pushState = function(...args) {
+      if (self.active) self.flushAllVisibilityEvents();
+      return originalPushState.apply(this, args);
+    };
+    this.popstateListener = () => {
+      if (this.active) this.flushAllVisibilityEvents();
+    };
+    window.addEventListener("popstate", this.popstateListener);
+    ctx.log("Visibility tracking enabled");
+  }
+  teardown() {
+    this.active = false;
+    this.flushAllVisibilityEvents();
+    for (const observer of this.visibilityObservers.values()) {
+      observer.disconnect();
+    }
+    this.visibilityObservers.clear();
+    if (this.visibilityMutationObserver) {
+      this.visibilityMutationObserver.disconnect();
+      this.visibilityMutationObserver = null;
+    }
+    if (this.beforeUnloadListener) {
+      window.removeEventListener("beforeunload", this.beforeUnloadListener);
+      this.beforeUnloadListener = null;
+    }
+    if (this.popstateListener) {
+      window.removeEventListener("popstate", this.popstateListener);
+      this.popstateListener = null;
+    }
+    this.visibilityData.clear();
+  }
+  scanForVisibilityElements() {
+    for (const el of Array.from(document.querySelectorAll("[data-kb-track-visibility]"))) {
+      this.observeVisibilityElement(el);
+    }
+  }
+  observeVisibilityElement(el) {
+    const eventName = el.getAttribute("data-kb-track-visibility");
+    if (!eventName || this.visibilityData.has(el)) return;
+    const channel = el.getAttribute("data-kb-visibility-channel") || "engagement";
+    const threshold = parseFloat(el.getAttribute("data-kb-visibility-threshold") || "0.5");
+    const clampedThreshold = Math.max(0, Math.min(1, isNaN(threshold) ? 0.5 : threshold));
+    this.visibilityData.set(el, {
+      visibleSince: null,
+      totalMs: 0,
+      event: eventName,
+      channel
+    });
+    const observer = this.getOrCreateObserver(clampedThreshold);
+    observer.observe(el);
+  }
+  getOrCreateObserver(threshold) {
+    const key = Math.round(threshold * 100);
+    let observer = this.visibilityObservers.get(key);
+    if (observer) return observer;
+    observer = new IntersectionObserver(
+      (entries) => {
+        const now = Date.now();
+        for (const entry of entries) {
+          const data = this.visibilityData.get(entry.target);
+          if (!data) continue;
+          if (entry.isIntersecting) {
+            data.visibleSince = now;
+          } else if (data.visibleSince !== null) {
+            data.totalMs += now - data.visibleSince;
+            data.visibleSince = null;
+          }
+        }
+      },
+      { threshold }
+    );
+    this.visibilityObservers.set(key, observer);
+    return observer;
+  }
+  flushVisibilityForElement(el) {
+    const data = this.visibilityData.get(el);
+    if (!data) return;
+    if (data.visibleSince !== null) {
+      data.totalMs += Date.now() - data.visibleSince;
+      data.visibleSince = null;
+    }
+    if (data.totalMs > 0) {
+      const durationMs = Math.round(data.totalMs);
+      const durationSeconds = Math.round(durationMs / 1e3);
+      this.ctx.track({
+        channel: data.channel,
+        event: "element_visible",
+        tags: {
+          __element_name: data.event,
+          __duration_seconds: durationSeconds,
+          __duration_ms: durationMs
+        }
+      }).catch((err) => this.ctx.log("Failed to track visibility event", err));
+    }
+    for (const observer of this.visibilityObservers.values()) {
+      observer.unobserve(el);
+    }
+    this.visibilityData.delete(el);
+  }
+  flushAllVisibilityEvents() {
+    for (const [, data] of this.visibilityData.entries()) {
+      if (data.visibleSince !== null) {
+        data.totalMs += Date.now() - data.visibleSince;
+        data.visibleSince = null;
+      }
+      if (data.totalMs > 0) {
+        const durationMs = Math.round(data.totalMs);
+        const durationSeconds = Math.round(durationMs / 1e3);
+        this.ctx.track({
+          channel: data.channel,
+          event: "element_visible",
+          tags: {
+            element_name: data.event,
+            duration_seconds: durationSeconds,
+            duration_ms: durationMs
+          }
+        }).catch((err) => this.ctx.log("Failed to track visibility event", err));
+      }
+      data.totalMs = 0;
+      data.visibleSince = null;
+    }
+  }
+};
+
+// src/plugins/web-vitals.ts
+import { onCLS, onFCP, onINP, onLCP, onTTFB } from "web-vitals";
+var ANALYTICS_CHANNEL6 = "__analytics";
+var WebVitalsPlugin = class {
+  name = "web-vitals";
+  ctx;
+  sent = false;
+  timeout = null;
+  beforeUnloadListener = null;
+  data = {
+    lcp: null,
+    cls: null,
+    inp: null,
+    fcp: null,
+    ttfb: null
+  };
+  setup(ctx) {
+    if (typeof window === "undefined") return false;
+    this.ctx = ctx;
+    const checkAndSend = () => {
+      const { lcp, cls, inp, fcp, ttfb } = this.data;
+      if (lcp !== null && cls !== null && inp !== null && fcp !== null && ttfb !== null) {
+        this.sendWebVitals();
+      }
+    };
+    onLCP((metric) => {
+      this.data.lcp = metric.value;
+      ctx.log("Web Vital collected", { name: "LCP", value: metric.value });
+      checkAndSend();
+    });
+    onCLS((metric) => {
+      this.data.cls = metric.value;
+      ctx.log("Web Vital collected", { name: "CLS", value: metric.value });
+      checkAndSend();
+    });
+    onINP((metric) => {
+      this.data.inp = metric.value;
+      ctx.log("Web Vital collected", { name: "INP", value: metric.value });
+      checkAndSend();
+    });
+    onFCP((metric) => {
+      this.data.fcp = metric.value;
+      ctx.log("Web Vital collected", { name: "FCP", value: metric.value });
+      checkAndSend();
+    });
+    onTTFB((metric) => {
+      this.data.ttfb = metric.value;
+      ctx.log("Web Vital collected", { name: "TTFB", value: metric.value });
+      checkAndSend();
+    });
+    this.timeout = setTimeout(() => {
+      this.timeout = null;
+      this.sendWebVitals();
+    }, 3e4);
+    this.beforeUnloadListener = () => {
+      this.sendWebVitals();
+    };
+    window.addEventListener("beforeunload", this.beforeUnloadListener);
+    ctx.log("Web Vitals tracking enabled");
+  }
+  teardown() {
+    if (this.timeout !== null) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    this.sendWebVitals();
+    if (this.beforeUnloadListener) {
+      window.removeEventListener("beforeunload", this.beforeUnloadListener);
+      this.beforeUnloadListener = null;
+    }
+  }
+  sendWebVitals() {
+    if (this.sent) return;
+    const { lcp, cls, inp, fcp, ttfb } = this.data;
+    if (lcp === null && cls === null && inp === null && fcp === null && ttfb === null) return;
+    this.sent = true;
+    if (this.timeout !== null) {
+      clearTimeout(this.timeout);
+      this.timeout = null;
+    }
+    const tags = {};
+    if (lcp !== null) tags.__lcp = lcp;
+    if (cls !== null) tags.__cls = cls;
+    if (inp !== null) tags.__inp = inp;
+    if (fcp !== null) tags.__fcp = fcp;
+    if (ttfb !== null) tags.__ttfb = ttfb;
+    this.ctx.log("Sending Web Vitals", tags);
+    this.ctx.track({
+      channel: ANALYTICS_CHANNEL6,
+      event: "web_vitals",
+      tags
+    }).catch((err) => this.ctx.log("Failed to track web vitals", err));
+  }
+};
+
+// src/plugins/frustration.ts
+var ANALYTICS_CHANNEL7 = "__analytics";
+var RAGE_CLICK_THRESHOLD = 3;
+var RAGE_CLICK_WINDOW_MS = 1e3;
+var RAGE_CLICK_RADIUS_PX = 30;
+var DEAD_CLICK_TIMEOUT_MS = 1e3;
+var FrustrationPlugin = class {
+  name = "frustration";
+  ctx;
+  rageClickBuffer = [];
+  deadClickObserver = null;
+  deadClickTimeout = null;
+  clickListener = null;
+  setup(ctx) {
+    if (typeof window === "undefined") return false;
+    this.ctx = ctx;
+    this.clickListener = (event) => {
+      const target = event.target;
+      if (!target) return;
+      const now = Date.now();
+      this.rageClickBuffer.push({ time: now, x: event.clientX, y: event.clientY, target });
+      this.rageClickBuffer = this.rageClickBuffer.filter(
+        (c) => now - c.time < RAGE_CLICK_WINDOW_MS
+      );
+      if (this.rageClickBuffer.length >= RAGE_CLICK_THRESHOLD) {
+        const first = this.rageClickBuffer[0];
+        const allNearby = this.rageClickBuffer.every(
+          (c) => Math.hypot(c.x - first.x, c.y - first.y) < RAGE_CLICK_RADIUS_PX
+        );
+        if (allNearby) {
+          const element = findClickableElement(event) || target;
+          const clickCount = this.rageClickBuffer.length;
+          this.rageClickBuffer = [];
+          ctx.track({
+            channel: ANALYTICS_CHANNEL7,
+            event: "rage_click",
+            tags: {
+              __path: window.location.pathname,
+              __tag: element.tagName.toLowerCase(),
+              __id: element.id || "",
+              __class: element.className && typeof element.className === "string" ? element.className : "",
+              __text: (element.textContent || "").trim().slice(0, 100),
+              __selector: buildCssSelector(element),
+              __click_count: clickCount
+            }
+          }).catch((err) => ctx.log("Failed to track rage click", err));
+          return;
+        }
+      }
+      const clickedElement = findClickableElement(event);
+      if (!clickedElement) return;
+      if (target.closest?.("a[href]")) return;
+      if (clickedElement.tagName === "SELECT" || target.closest?.("select")) return;
+      if (this.deadClickTimeout !== null) {
+        clearTimeout(this.deadClickTimeout);
+        this.deadClickTimeout = null;
+      }
+      if (this.deadClickObserver) {
+        this.deadClickObserver.disconnect();
+      }
+      let mutationDetected = false;
+      this.deadClickObserver = new MutationObserver(() => {
+        mutationDetected = true;
+      });
+      this.deadClickObserver.observe(document.body, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        characterData: true
+      });
+      this.deadClickTimeout = setTimeout(() => {
+        if (this.deadClickObserver) {
+          this.deadClickObserver.disconnect();
+          this.deadClickObserver = null;
+        }
+        if (!mutationDetected) {
+          ctx.track({
+            channel: ANALYTICS_CHANNEL7,
+            event: "dead_click",
+            tags: {
+              __path: window.location.pathname,
+              __tag: clickedElement.tagName.toLowerCase(),
+              __id: clickedElement.id || "",
+              __class: clickedElement.className && typeof clickedElement.className === "string" ? clickedElement.className : "",
+              __text: (clickedElement.textContent || "").trim().slice(0, 100),
+              __selector: buildCssSelector(clickedElement)
+            }
+          }).catch((err) => ctx.log("Failed to track dead click", err));
+        }
+      }, DEAD_CLICK_TIMEOUT_MS);
+    };
+    document.addEventListener("click", this.clickListener, true);
+    ctx.log("Frustration signal detection enabled");
+  }
+  teardown() {
+    if (this.clickListener) {
+      document.removeEventListener("click", this.clickListener, true);
+      this.clickListener = null;
+    }
+    if (this.deadClickObserver) {
+      this.deadClickObserver.disconnect();
+      this.deadClickObserver = null;
+    }
+    if (this.deadClickTimeout !== null) {
+      clearTimeout(this.deadClickTimeout);
+      this.deadClickTimeout = null;
+    }
+    this.rageClickBuffer = [];
+  }
+};
+
+// src/plugins/defaults.ts
+function createDefaultPlugins(config) {
+  const plugins = [];
+  if (config?.autoTrackPageViews !== false) {
+    plugins.push(new PageViewPlugin());
+  }
+  if (config?.autoTrackOutboundLinks !== false) {
+    plugins.push(new OutboundLinksPlugin());
+  }
+  if (config?.autoTrackClicks !== false) {
+    plugins.push(new ClickTrackingPlugin());
+  }
+  if (config?.autoTrackScrollDepth !== false) {
+    plugins.push(new ScrollDepthPlugin());
+  }
+  if (config?.autoTrackVisibility !== false) {
+    plugins.push(new VisibilityPlugin());
+  }
+  if (config?.autoTrackWebVitals === true) {
+    plugins.push(new WebVitalsPlugin());
+  }
+  if (config?.autoDetectFrustration !== false) {
+    plugins.push(new FrustrationPlugin());
+  }
+  return plugins;
+}
+
+// src/client.ts
+var _instance = null;
+function init(config) {
+  if (_instance) {
+    _instance.shutdown();
+  }
+  _instance = new KitbaseAnalytics2(config);
+  return _instance;
+}
+function getInstance() {
+  return _instance;
+}
+var KitbaseAnalytics2 = class extends KitbaseAnalytics {
+  // Offline queue
+  queue = null;
+  offlineEnabled;
+  constructor(config) {
+    super(config, createDefaultPlugins(config.analytics));
+    this.offlineEnabled = config.offline?.enabled ?? false;
+    if (this.offlineEnabled) {
+      this.queue = new EventQueue(config.offline);
+      this.queue.setDebugMode(this.debugMode, this.log.bind(this));
+      this.queue.setSendCallback(this.sendQueuedEvents.bind(this));
+      this.queue.startFlushTimer();
+      this.log("Offline queueing enabled", {
+        storageType: this.queue.getStorageType()
+      });
+    }
+  }
+  // ============================================================
+  // Debug Mode Override
+  // ============================================================
+  /**
+   * Enable or disable debug mode
+   * When enabled, all SDK operations are logged to the console
+   *
+   * @param enabled - Whether to enable debug mode
+   *
+   * @example
+   * ```typescript
+   * kitbase.setDebugMode(true);
+   * // All events and operations will now be logged
+   * ```
+   */
+  setDebugMode(enabled) {
+    super.setDebugMode(enabled);
+    if (this.queue) {
+      this.queue.setDebugMode(enabled, this.log.bind(this));
+    }
+  }
+  // ============================================================
+  // Offline Queue
+  // ============================================================
+  /**
+   * Get offline queue statistics
+   *
+   * @returns Queue statistics including size and flush status
+   *
+   * @example
+   * ```typescript
+   * const stats = await kitbase.getQueueStats();
+   * console.log(stats); // { size: 5, isFlushing: false }
+   * ```
+   */
+  async getQueueStats() {
+    if (!this.queue) return null;
+    return this.queue.getStats();
+  }
+  /**
+   * Manually flush the offline queue
+   * Events are automatically flushed on interval and when coming back online,
+   * but this method can be used to trigger an immediate flush
+   *
+   * @example
+   * ```typescript
+   * await kitbase.flushQueue();
+   * ```
+   */
+  async flushQueue() {
+    if (!this.queue) return;
+    await this.queue.flush();
+  }
+  /**
+   * Clear all events from the offline queue
+   *
+   * @example
+   * ```typescript
+   * await kitbase.clearQueue();
+   * ```
+   */
+  async clearQueue() {
+    if (!this.queue) return;
+    await this.queue.clear();
+  }
+  /**
+   * Callback for the queue to send batched events via the batch endpoint.
+   * Sends all events in a single HTTP request instead of individual POSTs.
+   */
+  async sendQueuedEvents(events) {
+    try {
+      await this.sendRequest("/sdk/v1/logs/batch", {
+        events: events.map((e) => e.payload)
+      });
+      return events.map((e) => e.id);
+    } catch (error) {
+      this.log("Batch send failed", { count: events.length, error });
+      return [];
+    }
+  }
+  // ============================================================
+  // Track Event Override
+  // ============================================================
+  /**
+   * Track an event
+   *
+   * When offline queueing is enabled, events are always written to the local
+   * database first (write-ahead), then sent to the server. This ensures no
+   * events are lost if the browser crashes or the network fails.
+   *
+   * @param options - Event tracking options
+   * @returns Promise resolving to the track response, or void if tracking is blocked
+   * @throws {ValidationError} When required fields are missing
+   * @throws {AuthenticationError} When the API key is invalid (only when offline disabled)
+   * @throws {ApiError} When the API returns an error (only when offline disabled)
+   * @throws {TimeoutError} When the request times out (only when offline disabled)
+   */
+  async track(options) {
+    this.validateTrackOptions(options);
+    if (this.isBotBlockingActive()) {
+      this.log("Event skipped - bot detected", { event: options.event });
+      return;
+    }
+    let duration;
+    const startTime = this.timedEvents.get(options.event);
+    if (startTime !== void 0) {
+      duration = (Date.now() - startTime) / 1e3;
+      this.timedEvents.delete(options.event);
+      this.log("Timer stopped", { event: options.event, duration });
+    }
+    const mergedTags = {
+      ...this.superProperties,
+      ...options.tags ?? {},
+      ...duration !== void 0 ? { $duration: duration } : {}
+    };
+    const payload = {
+      channel: options.channel,
+      event: options.event,
+      client_timestamp: Date.now(),
+      client_session_id: this.getClientSessionId(),
+      ...options.user_id && { user_id: options.user_id },
+      ...options.icon && { icon: options.icon },
+      ...options.notify !== void 0 && { notify: options.notify },
+      ...options.description && { description: options.description },
+      ...Object.keys(mergedTags).length > 0 && { tags: mergedTags }
+    };
+    this.log("Track", { event: options.event, payload });
+    if (this.queue) {
+      await this.queue.enqueue(payload);
+      this.log("Event persisted to queue");
+      this.queue.flush().catch((err) => {
+        this.log("Background flush failed", err);
+      });
+      return {
+        id: `queued-${Date.now()}`,
+        event: options.event,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    const response = await this.sendRequest("/sdk/v1/logs", payload);
+    this.log("Event sent successfully", { id: response.id });
+    return response;
+  }
+  validateTrackOptions(options) {
+    if (!options.event) {
+      throw new ValidationError("Event is required", "event");
+    }
+  }
+  // ============================================================
+  // Cleanup
+  // ============================================================
+  /**
+   * Shutdown the client and cleanup resources
+   * Call this when you're done using the client to stop timers and close connections
+   *
+   * @example
+   * ```typescript
+   * await kitbase.shutdown();
+   * ```
+   */
+  async shutdown() {
+    if (this.queue) {
+      await this.queue.flush();
+    }
+    super.shutdown();
+    if (this.queue) {
+      await this.queue.flush();
+      await this.queue.close();
+      this.queue = null;
+    }
+  }
+};
+export {
+  ApiError,
+  AuthenticationError,
+  ClickTrackingPlugin,
+  FrustrationPlugin,
+  KitbaseAnalytics2 as KitbaseAnalytics,
+  KitbaseError,
+  OutboundLinksPlugin,
+  PageViewPlugin,
+  ScrollDepthPlugin,
+  TimeoutError,
+  ValidationError,
+  VisibilityPlugin,
+  WebVitalsPlugin,
+  createDefaultPlugins,
+  detectBot,
+  getInstance,
+  getUserAgent,
+  init,
+  isBot,
+  isUserAgentBot
+};
+//# sourceMappingURL=index.js.map