@active-reach/web-sdk 1.0.0

package/dist/analytics-B11keZ55.mjs

@@ -0,0 +1,1854 @@
+const DEFAULT_CONFIG = {
+  workspace_id: null,
+  batch_size: 10,
+  batch_interval: 1e3,
+  capture_utm: true,
+  capture_referrer: true,
+  auto_page_view: false,
+  session_timeout: 30,
+  debug: false,
+  respect_dnt: true,
+  cross_domain_tracking: false,
+  secure_cookie: true,
+  enable_offline_mode: true,
+  max_offline_events: 100,
+  retry_failed_requests: true,
+  max_retries: 3,
+  retry_backoff_multiplier: 2,
+  request_timeout: 5e3,
+  auto_region_detection: true,
+  wait_for_consent: false,
+  enable_consent_mode: false,
+  integrate_onetrust: false,
+  integrate_cookiebot: false,
+  integrate_google_consent_mode: false,
+  default_consent: {
+    analytics: false,
+    marketing: false,
+    functional: true
+  },
+  initialized: false,
+  api_host: null,
+  cell_endpoints: [],
+  preferred_region: null,
+  cookie_domain: null,
+  plugins: [],
+  active_cell: null
+};
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  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);
+  });
+}
+function generateSessionId() {
+  return `sess_${Date.now()}_${generateUUID().slice(0, 8)}`;
+}
+function generateMessageId() {
+  return `msg_${Date.now()}_${generateUUID().slice(0, 8)}`;
+}
+class Logger {
+  constructor() {
+    this.enabled = false;
+    this.prefix = "[Aegis SDK]";
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  debug(message, ...args) {
+    if (!this.enabled) return;
+    console.debug(`${this.prefix} ${message}`, ...args);
+  }
+  info(message, ...args) {
+    if (!this.enabled) return;
+    console.info(`${this.prefix} ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    console.warn(`${this.prefix} ${message}`, ...args);
+  }
+  error(message, ...args) {
+    console.error(`${this.prefix} ${message}`, ...args);
+  }
+}
+const logger = new Logger();
+class Identity {
+  constructor(storage) {
+    this.userId = null;
+    this.traits = {};
+    this.storage = storage;
+    this.anonymousId = this.getOrCreateAnonymousId();
+    this.loadUserIdentity();
+  }
+  getOrCreateAnonymousId() {
+    let id = this.storage.get("anon_id");
+    if (!id) {
+      id = generateUUID();
+      this.storage.set("anon_id", id, 365);
+      logger.debug("Created new anonymous ID:", id);
+    } else {
+      logger.debug("Loaded existing anonymous ID:", id);
+    }
+    return id;
+  }
+  loadUserIdentity() {
+    const storedUserId = this.storage.get("user_id");
+    const storedTraits = this.storage.get("user_traits");
+    if (storedUserId) {
+      this.userId = storedUserId;
+      logger.debug("Loaded user ID:", storedUserId);
+    }
+    if (storedTraits) {
+      try {
+        this.traits = JSON.parse(storedTraits);
+        logger.debug("Loaded user traits:", this.traits);
+      } catch (error) {
+        logger.warn("Failed to parse stored traits:", error);
+        this.traits = {};
+      }
+    }
+  }
+  getAnonymousId() {
+    return this.anonymousId;
+  }
+  setUserId(userId, traits) {
+    this.userId = userId;
+    this.storage.set("user_id", userId, 365);
+    logger.info("User identified:", userId);
+    if (traits) {
+      this.setTraits(traits);
+    }
+  }
+  getUserId() {
+    return this.userId;
+  }
+  setTraits(traits) {
+    this.traits = { ...this.traits, ...traits };
+    this.storage.set("user_traits", JSON.stringify(this.traits), 365);
+    logger.debug("User traits updated:", this.traits);
+  }
+  getTraits() {
+    return { ...this.traits };
+  }
+  reset() {
+    this.userId = null;
+    this.traits = {};
+    this.anonymousId = generateUUID();
+    this.storage.remove("user_id");
+    this.storage.remove("user_traits");
+    this.storage.set("anon_id", this.anonymousId, 365);
+    logger.info("Identity reset, new anonymous ID:", this.anonymousId);
+  }
+  alias(newUserId) {
+    const previousId = this.userId || this.anonymousId;
+    this.setUserId(newUserId);
+    logger.info("User aliased:", { previousId, newUserId });
+    return { previousId, newUserId };
+  }
+  getState() {
+    return {
+      anonymousId: this.anonymousId,
+      userId: this.userId,
+      traits: this.getTraits()
+    };
+  }
+}
+class SessionManager {
+  constructor(storage, sessionTimeoutMinutes = 30) {
+    this.eventCount = 0;
+    this.checkInterval = null;
+    this.activityThrottle = 1e3;
+    this.lastActivityUpdate = 0;
+    this.adClickIDs = {};
+    this.storage = storage;
+    this.sessionTimeout = sessionTimeoutMinutes * 60 * 1e3;
+    this.lastActivityTime = Date.now();
+    this.sessionStartTime = Date.now();
+    const session = this.loadSession();
+    if (session) {
+      this.sessionId = session.sessionId;
+      this.sessionStartTime = session.startTime;
+      this.lastActivityTime = session.lastActivityTime;
+      this.eventCount = session.eventCount;
+      this.adClickIDs = session.adClickIDs || {};
+      this.landingPage = session.landingPage;
+      logger.debug("Session loaded:", session);
+    } else {
+      this.sessionId = this.createNewSession();
+    }
+    this.startActivityTracking();
+    this.startExpiryCheck();
+  }
+  loadSession() {
+    const sessionData = this.storage.get("session");
+    if (!sessionData) {
+      return null;
+    }
+    try {
+      const session = JSON.parse(sessionData);
+      const elapsed = Date.now() - session.lastActivityTime;
+      if (elapsed < this.sessionTimeout) {
+        return session;
+      } else {
+        logger.debug("Session expired, creating new session");
+        this.storage.remove("session");
+        return null;
+      }
+    } catch (error) {
+      logger.warn("Failed to parse session data:", error);
+      this.storage.remove("session");
+      return null;
+    }
+  }
+  createNewSession() {
+    const newSessionId = generateSessionId();
+    this.sessionStartTime = Date.now();
+    this.lastActivityTime = Date.now();
+    this.eventCount = 0;
+    this.persistSession();
+    logger.info("New session created:", newSessionId);
+    return newSessionId;
+  }
+  persistSession() {
+    const sessionData = {
+      sessionId: this.sessionId,
+      startTime: this.sessionStartTime,
+      lastActivityTime: this.lastActivityTime,
+      eventCount: this.eventCount,
+      adClickIDs: this.adClickIDs,
+      landingPage: this.landingPage
+    };
+    this.storage.set("session", JSON.stringify(sessionData));
+  }
+  startActivityTracking() {
+    const events = ["click", "scroll", "keypress", "mousemove", "touchstart"];
+    const activityHandler = () => this.onActivity();
+    events.forEach((event) => {
+      window.addEventListener(event, activityHandler, { passive: true });
+    });
+    window.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "visible") {
+        this.onActivity();
+      }
+    });
+  }
+  startExpiryCheck() {
+    this.checkInterval = window.setInterval(() => {
+      this.checkSessionExpiry();
+    }, 6e4);
+  }
+  onActivity() {
+    const now = Date.now();
+    const timeSinceLastUpdate = now - this.lastActivityUpdate;
+    if (timeSinceLastUpdate < this.activityThrottle) {
+      return;
+    }
+    this.lastActivityUpdate = now;
+    const timeSinceLastActivity = now - this.lastActivityTime;
+    if (timeSinceLastActivity > this.sessionTimeout) {
+      logger.info("Session expired due to inactivity, creating new session");
+      this.sessionId = this.createNewSession();
+    } else {
+      this.lastActivityTime = now;
+      this.persistSession();
+    }
+  }
+  checkSessionExpiry() {
+    const elapsed = Date.now() - this.lastActivityTime;
+    if (elapsed > this.sessionTimeout) {
+      logger.info("Session expired during check, creating new session");
+      this.sessionId = this.createNewSession();
+    }
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  incrementEventCount() {
+    this.eventCount++;
+    this.lastActivityTime = Date.now();
+    this.persistSession();
+  }
+  getSessionDuration() {
+    return Date.now() - this.sessionStartTime;
+  }
+  getEventCount() {
+    return this.eventCount;
+  }
+  getState() {
+    return {
+      sessionId: this.sessionId,
+      startTime: this.sessionStartTime,
+      lastActivityTime: this.lastActivityTime,
+      eventCount: this.eventCount,
+      adClickIDs: this.adClickIDs,
+      landingPage: this.landingPage
+    };
+  }
+  setAdClickIDs(adClickIDs, landingPage) {
+    if (Object.keys(adClickIDs).length > 0) {
+      this.adClickIDs = { ...this.adClickIDs, ...adClickIDs };
+      if (landingPage) {
+        this.landingPage = landingPage;
+      }
+      this.persistSession();
+      logger.info("Ad click IDs stored in session:", this.adClickIDs);
+    }
+  }
+  getAdClickIDs() {
+    return this.adClickIDs;
+  }
+  getLandingPage() {
+    return this.landingPage;
+  }
+  destroy() {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+  }
+}
+class EventQueue {
+  constructor(config, transport, storage) {
+    this.buffer = [];
+    this.flushInterval = null;
+    this.isFlushing = false;
+    this.offlineQueue = [];
+    this.isOnline = navigator.onLine;
+    this.config = config;
+    this.transport = transport;
+    this.storage = storage;
+    if (config.enableOfflineMode) {
+      this.loadOfflineQueue();
+      this.setupOnlineListener();
+    }
+    this.startFlushTimer();
+    this.setupUnloadHandlers();
+  }
+  loadOfflineQueue() {
+    const offlineData = this.storage.get("offline_queue");
+    if (!offlineData) {
+      return;
+    }
+    try {
+      const events = JSON.parse(offlineData);
+      if (Array.isArray(events) && events.length > 0) {
+        this.offlineQueue = events.slice(0, this.config.maxOfflineEvents);
+        logger.info(`Loaded ${this.offlineQueue.length} offline events`);
+        if (this.isOnline) {
+          this.flushOfflineQueue();
+        }
+      }
+    } catch (error) {
+      logger.warn("Failed to load offline queue:", error);
+      this.storage.remove("offline_queue");
+    }
+  }
+  saveOfflineQueue() {
+    if (this.offlineQueue.length === 0) {
+      this.storage.remove("offline_queue");
+      return;
+    }
+    try {
+      const data = JSON.stringify(this.offlineQueue);
+      this.storage.set("offline_queue", data);
+      logger.debug(`Saved ${this.offlineQueue.length} events to offline queue`);
+    } catch (error) {
+      logger.warn("Failed to save offline queue:", error);
+    }
+  }
+  setupOnlineListener() {
+    window.addEventListener("online", () => {
+      logger.info("Connection restored");
+      this.isOnline = true;
+      this.flushOfflineQueue();
+      this.flush();
+    });
+    window.addEventListener("offline", () => {
+      logger.warn("Connection lost, entering offline mode");
+      this.isOnline = false;
+    });
+  }
+  async flushOfflineQueue() {
+    if (this.offlineQueue.length === 0) {
+      return;
+    }
+    logger.info(`Flushing ${this.offlineQueue.length} offline events`);
+    const events = [...this.offlineQueue];
+    this.offlineQueue = [];
+    this.storage.remove("offline_queue");
+    const result = await this.transport.send(events);
+    if (!result.success) {
+      logger.warn("Failed to send offline events, re-queueing");
+      this.offlineQueue = [...events, ...this.offlineQueue].slice(
+        0,
+        this.config.maxOfflineEvents
+      );
+      this.saveOfflineQueue();
+    } else {
+      logger.info("Offline events sent successfully");
+    }
+  }
+  push(event) {
+    if (!this.isOnline && this.config.enableOfflineMode) {
+      this.addToOfflineQueue(event);
+      return;
+    }
+    this.buffer.push(event);
+    logger.debug("Event queued:", event.type, event);
+    if (this.buffer.length >= this.config.batchSize) {
+      this.flush();
+    }
+  }
+  addToOfflineQueue(event) {
+    if (this.offlineQueue.length >= this.config.maxOfflineEvents) {
+      logger.warn("Offline queue full, dropping oldest event");
+      this.offlineQueue.shift();
+    }
+    this.offlineQueue.push(event);
+    this.saveOfflineQueue();
+    logger.debug("Event added to offline queue");
+  }
+  async flush() {
+    if (this.isFlushing) {
+      logger.debug("Flush already in progress, skipping");
+      return;
+    }
+    if (this.buffer.length === 0) {
+      return;
+    }
+    this.isFlushing = true;
+    const events = [...this.buffer];
+    this.buffer = [];
+    logger.info(`Flushing ${events.length} events`);
+    try {
+      const result = await this.transport.send(events);
+      if (!result.success) {
+        logger.error("Failed to send events:", result.error);
+        if (this.config.enableOfflineMode) {
+          this.offlineQueue = [...this.offlineQueue, ...events].slice(
+            0,
+            this.config.maxOfflineEvents
+          );
+          this.saveOfflineQueue();
+          logger.info("Events saved to offline queue");
+        } else {
+          this.buffer.unshift(...events);
+          logger.warn("Events re-queued for retry");
+        }
+      } else {
+        logger.info("Events sent successfully");
+      }
+    } catch (error) {
+      logger.error("Flush error:", error);
+      if (this.config.enableOfflineMode) {
+        this.offlineQueue = [...this.offlineQueue, ...events].slice(
+          0,
+          this.config.maxOfflineEvents
+        );
+        this.saveOfflineQueue();
+      }
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  startFlushTimer() {
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+    }
+    this.flushInterval = window.setInterval(() => {
+      this.flush();
+    }, this.config.batchInterval);
+    logger.debug(
+      `Flush timer started with interval: ${this.config.batchInterval}ms`
+    );
+  }
+  setupUnloadHandlers() {
+    const flushBeforeUnload = () => {
+      if (this.buffer.length > 0 || this.offlineQueue.length > 0) {
+        this.persistBufferToOfflineQueue();
+        this.flush();
+      }
+    };
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") {
+        flushBeforeUnload();
+      }
+    });
+    window.addEventListener("beforeunload", flushBeforeUnload);
+    window.addEventListener("pagehide", flushBeforeUnload);
+  }
+  persistBufferToOfflineQueue() {
+    if (this.buffer.length === 0) {
+      return;
+    }
+    if (this.config.enableOfflineMode) {
+      this.offlineQueue = [...this.offlineQueue, ...this.buffer].slice(
+        0,
+        this.config.maxOfflineEvents
+      );
+      this.saveOfflineQueue();
+      logger.debug("Buffer persisted to offline queue before unload");
+    }
+  }
+  getQueueSize() {
+    return this.buffer.length;
+  }
+  getOfflineQueueSize() {
+    return this.offlineQueue.length;
+  }
+  clear() {
+    this.buffer = [];
+    this.offlineQueue = [];
+    this.storage.remove("offline_queue");
+    logger.info("Queue cleared");
+  }
+  destroy() {
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+      this.flushInterval = null;
+    }
+    this.flush();
+  }
+}
+class Transport {
+  constructor(config, storage) {
+    this.activeCell = null;
+    this.healthCheckInterval = null;
+    this.regionLatencyMap = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.storage = storage;
+    if (config.cellEndpoints.length > 0) {
+      this.initializeCellularArchitecture();
+    }
+  }
+  async initializeCellularArchitecture() {
+    const cachedCell = this.loadCachedCell();
+    if (cachedCell && this.isCellHealthy(cachedCell)) {
+      this.activeCell = cachedCell;
+      logger.info("Using cached cell:", cachedCell);
+    } else {
+      await this.selectOptimalCell();
+    }
+    this.startHealthChecks();
+  }
+  loadCachedCell() {
+    const cached = this.storage.get("active_cell");
+    if (!cached) {
+      return null;
+    }
+    try {
+      return JSON.parse(cached);
+    } catch (error) {
+      logger.warn("Failed to parse cached cell:", error);
+      return null;
+    }
+  }
+  saveCachedCell(cell) {
+    this.storage.set("active_cell", JSON.stringify(cell), 7);
+  }
+  isCellHealthy(cell) {
+    return cell.healthy && this.config.cellEndpoints.some(
+      (c) => c.region === cell.region && c.url === cell.url
+    );
+  }
+  async selectOptimalCell() {
+    logger.info("Selecting optimal cell...");
+    if (this.config.preferredRegion) {
+      const preferredCell = this.config.cellEndpoints.find(
+        (cell) => cell.region === this.config.preferredRegion && cell.healthy
+      );
+      if (preferredCell) {
+        this.activeCell = preferredCell;
+        this.saveCachedCell(preferredCell);
+        logger.info("Using preferred region cell:", preferredCell);
+        return;
+      }
+    }
+    if (this.config.autoRegionDetection) {
+      await this.detectOptimalRegion();
+    } else {
+      this.selectCellByPriority();
+    }
+  }
+  async detectOptimalRegion() {
+    const healthyCells = this.config.cellEndpoints.filter((cell) => cell.healthy);
+    if (healthyCells.length === 0) {
+      logger.error("No healthy cells available");
+      return;
+    }
+    const latencyPromises = healthyCells.map(async (cell) => {
+      const latency = await this.measureLatency(cell);
+      this.regionLatencyMap.set(cell.region, latency);
+      return { cell, latency };
+    });
+    const results = await Promise.all(latencyPromises);
+    results.sort((a, b) => a.latency - b.latency);
+    const optimalCell = results[0].cell;
+    this.activeCell = optimalCell;
+    this.saveCachedCell(optimalCell);
+    logger.info("Optimal cell selected:", {
+      region: optimalCell.region,
+      latency: results[0].latency
+    });
+  }
+  async measureLatency(cell) {
+    const startTime = performance.now();
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 2e3);
+      const response = await fetch(`${cell.url}/health`, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        return performance.now() - startTime;
+      } else {
+        return Infinity;
+      }
+    } catch (error) {
+      logger.warn(`Health check failed for ${cell.region}:`, error);
+      return Infinity;
+    }
+  }
+  selectCellByPriority() {
+    const sortedCells = [...this.config.cellEndpoints].filter((cell) => cell.healthy).sort((a, b) => a.priority - b.priority);
+    if (sortedCells.length > 0) {
+      this.activeCell = sortedCells[0];
+      this.saveCachedCell(sortedCells[0]);
+      logger.info("Cell selected by priority:", sortedCells[0]);
+    } else {
+      logger.error("No healthy cells available");
+    }
+  }
+  startHealthChecks() {
+    this.healthCheckInterval = window.setInterval(() => {
+      this.performHealthChecks();
+    }, 6e4);
+  }
+  async performHealthChecks() {
+    const healthPromises = this.config.cellEndpoints.map(async (cell) => {
+      const isHealthy = await this.checkCellHealth(cell);
+      cell.healthy = isHealthy;
+      return { cell, isHealthy };
+    });
+    const results = await Promise.all(healthPromises);
+    if (this.activeCell && !this.activeCell.healthy) {
+      logger.warn("Active cell unhealthy, selecting new cell");
+      await this.selectOptimalCell();
+    }
+    logger.debug("Health check results:", results);
+  }
+  async checkCellHealth(cell) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 3e3);
+      const response = await fetch(`${cell.url}/health`, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch (error) {
+      return false;
+    }
+  }
+  async send(events) {
+    if (events.length === 0) {
+      return { success: true };
+    }
+    const endpoint = this.getActiveEndpoint();
+    const payload = this.buildPayload(events);
+    logger.debug("Sending batch:", { endpoint, eventCount: events.length });
+    if (document.visibilityState === "hidden" && typeof navigator.sendBeacon === "function") {
+      const result = this.sendViaBeacon(endpoint, payload);
+      return Promise.resolve(result);
+    } else {
+      return this.sendViaFetch(endpoint, payload);
+    }
+  }
+  getActiveEndpoint() {
+    if (this.activeCell) {
+      return `${this.activeCell.url}/v1/batch`;
+    }
+    if (this.config.apiHost) {
+      return `${this.config.apiHost}/v1/batch`;
+    }
+    throw new Error("No active endpoint available");
+  }
+  buildPayload(events) {
+    return {
+      batch: events,
+      sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+      writeKey: this.config.writeKey,
+      context: this.activeCell ? {
+        cell: {
+          region: this.activeCell.region,
+          endpoint: this.activeCell.url
+        }
+      } : void 0
+    };
+  }
+  sendViaBeacon(endpoint, payload) {
+    try {
+      const blob = new Blob([JSON.stringify(payload)], {
+        type: "application/json"
+      });
+      const sent = navigator.sendBeacon(endpoint, blob);
+      if (sent) {
+        logger.debug("Batch sent via Beacon");
+        return { success: true, endpoint };
+      } else {
+        logger.warn("Beacon send failed, falling back to fetch");
+        return this.sendViaFetch(endpoint, payload);
+      }
+    } catch (error) {
+      logger.error("Beacon send error:", error);
+      return {
+        success: false,
+        error,
+        endpoint
+      };
+    }
+  }
+  async sendViaFetch(endpoint, payload, attempt = 1) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        this.config.requestTimeout
+      );
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.writeKey}`
+        },
+        body: JSON.stringify(payload),
+        keepalive: true,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        const result = await response.json();
+        logger.debug("Batch sent successfully:", result);
+        return { success: true, response: result, endpoint };
+      } else {
+        const errorText = await response.text();
+        const error = new Error(
+          `HTTP ${response.status}: ${errorText || response.statusText}`
+        );
+        logger.error("Batch send failed:", error);
+        if (this.shouldRetry(response.status, attempt)) {
+          return this.retryRequest(endpoint, payload, attempt);
+        }
+        return { success: false, error, endpoint };
+      }
+    } catch (error) {
+      logger.error("Fetch error:", error);
+      if (this.shouldRetry(0, attempt)) {
+        return this.retryRequest(endpoint, payload, attempt);
+      }
+      return {
+        success: false,
+        error,
+        endpoint
+      };
+    }
+  }
+  shouldRetry(statusCode, attempt) {
+    if (!this.config.retryFailedRequests) {
+      return false;
+    }
+    if (attempt >= this.config.maxRetries) {
+      return false;
+    }
+    if (statusCode === 0) {
+      return true;
+    }
+    return statusCode >= 500 || statusCode === 429;
+  }
+  async retryRequest(endpoint, payload, attempt) {
+    const delay = Math.pow(this.config.retryBackoffMultiplier, attempt) * 1e3;
+    logger.info(`Retrying request in ${delay}ms (attempt ${attempt + 1})`);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return this.sendViaFetch(endpoint, payload, attempt + 1);
+  }
+  getActiveCell() {
+    return this.activeCell;
+  }
+  getRegionLatencies() {
+    return new Map(this.regionLatencyMap);
+  }
+  destroy() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+  }
+}
+const STORAGE_PREFIX = "aegis_";
+class Storage {
+  constructor(options = {}) {
+    this.options = options;
+    this.useLocalStorage = this.isLocalStorageAvailable();
+  }
+  isLocalStorageAvailable() {
+    try {
+      const test = "__aegis_test__";
+      localStorage.setItem(test, test);
+      localStorage.removeItem(test);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  set(key, value, expiryDays = 365) {
+    const fullKey = STORAGE_PREFIX + key;
+    if (this.useLocalStorage) {
+      try {
+        const item = {
+          value,
+          expiry: Date.now() + expiryDays * 24 * 60 * 60 * 1e3
+        };
+        localStorage.setItem(fullKey, JSON.stringify(item));
+      } catch (error) {
+        console.warn("[Aegis Storage] localStorage.setItem failed:", error);
+      }
+    }
+    this.setCookie(fullKey, value, expiryDays);
+  }
+  get(key) {
+    const fullKey = STORAGE_PREFIX + key;
+    if (this.useLocalStorage) {
+      try {
+        const itemStr = localStorage.getItem(fullKey);
+        if (itemStr) {
+          const item = JSON.parse(itemStr);
+          if (Date.now() < item.expiry) {
+            return item.value;
+          } else {
+            localStorage.removeItem(fullKey);
+          }
+        }
+      } catch (error) {
+        console.warn("[Aegis Storage] localStorage.getItem failed:", error);
+      }
+    }
+    return this.getCookie(fullKey);
+  }
+  remove(key) {
+    const fullKey = STORAGE_PREFIX + key;
+    if (this.useLocalStorage) {
+      try {
+        localStorage.removeItem(fullKey);
+      } catch (error) {
+        console.warn("[Aegis Storage] localStorage.removeItem failed:", error);
+      }
+    }
+    this.deleteCookie(fullKey);
+  }
+  clear() {
+    if (this.useLocalStorage) {
+      try {
+        const keys = Object.keys(localStorage);
+        keys.forEach((key) => {
+          if (key.startsWith(STORAGE_PREFIX)) {
+            localStorage.removeItem(key);
+          }
+        });
+      } catch (error) {
+        console.warn("[Aegis Storage] localStorage.clear failed:", error);
+      }
+    }
+    const cookies = document.cookie.split(";");
+    cookies.forEach((cookie) => {
+      const key = cookie.split("=")[0].trim();
+      if (key.startsWith(STORAGE_PREFIX)) {
+        this.deleteCookie(key);
+      }
+    });
+  }
+  setCookie(name, value, days) {
+    try {
+      const date = /* @__PURE__ */ new Date();
+      date.setTime(date.getTime() + days * 24 * 60 * 60 * 1e3);
+      const expires = `expires=${date.toUTCString()}`;
+      let cookieStr = `${name}=${value};${expires};path=/`;
+      if (this.options.secureCookie && window.location.protocol === "https:") {
+        cookieStr += ";Secure";
+      }
+      cookieStr += ";SameSite=Lax";
+      if (this.options.cookieDomain) {
+        cookieStr += `;domain=${this.options.cookieDomain}`;
+      } else if (this.options.crossDomain) {
+        const domain = this.getRootDomain();
+        if (domain) {
+          cookieStr += `;domain=${domain}`;
+        }
+      }
+      document.cookie = cookieStr;
+    } catch (error) {
+      console.warn("[Aegis Storage] setCookie failed:", error);
+    }
+  }
+  getCookie(name) {
+    try {
+      const nameEQ = name + "=";
+      const ca = document.cookie.split(";");
+      for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) === " ") {
+          c = c.substring(1, c.length);
+        }
+        if (c.indexOf(nameEQ) === 0) {
+          return c.substring(nameEQ.length, c.length);
+        }
+      }
+    } catch (error) {
+      console.warn("[Aegis Storage] getCookie failed:", error);
+    }
+    return null;
+  }
+  deleteCookie(name) {
+    try {
+      let cookieStr = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 UTC;path=/`;
+      if (this.options.cookieDomain) {
+        cookieStr += `;domain=${this.options.cookieDomain}`;
+      } else if (this.options.crossDomain) {
+        const domain = this.getRootDomain();
+        if (domain) {
+          cookieStr += `;domain=${domain}`;
+        }
+      }
+      document.cookie = cookieStr;
+    } catch (error) {
+      console.warn("[Aegis Storage] deleteCookie failed:", error);
+    }
+  }
+  getRootDomain() {
+    try {
+      const hostname = window.location.hostname;
+      if (/^(\d{1,3}\.){3}\d{1,3}$/.test(hostname)) {
+        return null;
+      }
+      if (hostname === "localhost") {
+        return null;
+      }
+      const parts = hostname.split(".");
+      if (parts.length <= 2) {
+        return `.${hostname}`;
+      }
+      return `.${parts.slice(-2).join(".")}`;
+    } catch (error) {
+      console.warn("[Aegis Storage] getRootDomain failed:", error);
+      return null;
+    }
+  }
+}
+function parseUTMParameters(url) {
+  try {
+    const searchParams = url ? new URL(url).searchParams : new URLSearchParams(window.location.search);
+    const utm = {};
+    const utmKeys = [
+      "source",
+      "medium",
+      "campaign",
+      "term",
+      "content",
+      "name"
+    ];
+    utmKeys.forEach((key) => {
+      const value = searchParams.get(`utm_${key}`);
+      if (value) {
+        utm[key] = value;
+      }
+    });
+    return utm;
+  } catch (error) {
+    console.warn("[Aegis URL Parser] parseUTMParameters failed:", error);
+    return {};
+  }
+}
+function parseAdClickIDs(url) {
+  try {
+    const searchParams = url ? new URL(url).searchParams : new URLSearchParams(window.location.search);
+    const adClickIDs = {};
+    const clickIDKeys = [
+      "gclid",
+      "fbclid",
+      "msclkid",
+      "ctwa_clid",
+      "ttclid",
+      "li_fat_id"
+    ];
+    clickIDKeys.forEach((key) => {
+      const value = searchParams.get(key);
+      if (value) {
+        adClickIDs[key] = value;
+      }
+    });
+    return adClickIDs;
+  } catch (error) {
+    console.warn("[Aegis URL Parser] parseAdClickIDs failed:", error);
+    return {};
+  }
+}
+function hasAdClickIDs(adClickIDs) {
+  return Object.keys(adClickIDs).length > 0;
+}
+function buildContext(config, session) {
+  const utm = config.capture_utm ? parseUTMParameters() : void 0;
+  const device = detectDevice();
+  const os = detectOS();
+  const browser = detectBrowser();
+  const network = detectNetworkInfo();
+  const adClickIDs = session == null ? void 0 : session.getAdClickIDs();
+  const landingPage = session == null ? void 0 : session.getLandingPage();
+  return {
+    library: {
+      name: "@aegis/web-sdk",
+      version: "1.0.0"
+    },
+    page: {
+      path: window.location.pathname,
+      referrer: config.capture_referrer ? document.referrer : "",
+      search: window.location.search,
+      title: document.title,
+      url: window.location.href,
+      hash: window.location.hash
+    },
+    userAgent: navigator.userAgent,
+    locale: navigator.language,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    screen: {
+      width: window.screen.width,
+      height: window.screen.height,
+      density: window.devicePixelRatio || 1
+    },
+    viewport: {
+      width: window.innerWidth,
+      height: window.innerHeight
+    },
+    ...utm && Object.keys(utm).length > 0 && { campaign: utm },
+    ...adClickIDs && Object.keys(adClickIDs).length > 0 && { adClickIDs },
+    ...landingPage && { landingPage },
+    ...network && { network },
+    ...device && { device },
+    ...os && { os },
+    ...browser && { browser },
+    ...config.active_cell && {
+      cell: {
+        region: config.active_cell.region,
+        endpoint: config.active_cell.url
+      }
+    }
+  };
+}
+function detectDevice() {
+  const ua = navigator.userAgent;
+  if (/(tablet|ipad|playbook|silk)|(android(?!.*mobi))/i.test(ua)) {
+    return { type: "tablet" };
+  }
+  if (/Mobile|Android|iP(hone|od)|IEMobile|BlackBerry|Kindle|Silk-Accelerated|(hpw|web)OS|Opera M(obi|ini)/.test(ua)) {
+    return { type: "mobile" };
+  }
+  return { type: "desktop" };
+}
+function detectOS() {
+  const ua = navigator.userAgent;
+  if (/Windows NT 10/i.test(ua)) return { name: "Windows", version: "10" };
+  if (/Windows NT 6.3/i.test(ua)) return { name: "Windows", version: "8.1" };
+  if (/Windows NT 6.2/i.test(ua)) return { name: "Windows", version: "8" };
+  if (/Windows NT 6.1/i.test(ua)) return { name: "Windows", version: "7" };
+  if (/Windows/i.test(ua)) return { name: "Windows", version: "Unknown" };
+  if (/Mac OS X (\d+)[._](\d+)/.test(ua)) {
+    const match = ua.match(/Mac OS X (\d+)[._](\d+)/);
+    return { name: "macOS", version: `${match[1]}.${match[2]}` };
+  }
+  if (/Mac/i.test(ua)) return { name: "macOS", version: "Unknown" };
+  if (/Android (\d+\.\d+)/.test(ua)) {
+    const match = ua.match(/Android (\d+\.\d+)/);
+    return { name: "Android", version: match[1] };
+  }
+  if (/Android/i.test(ua)) return { name: "Android", version: "Unknown" };
+  if (/iPhone OS (\d+)_(\d+)/.test(ua)) {
+    const match = ua.match(/iPhone OS (\d+)_(\d+)/);
+    return { name: "iOS", version: `${match[1]}.${match[2]}` };
+  }
+  if (/iPad.*OS (\d+)_(\d+)/.test(ua)) {
+    const match = ua.match(/iPad.*OS (\d+)_(\d+)/);
+    return { name: "iOS", version: `${match[1]}.${match[2]}` };
+  }
+  if (/iPhone|iPad/i.test(ua)) return { name: "iOS", version: "Unknown" };
+  if (/Linux/i.test(ua)) return { name: "Linux", version: "Unknown" };
+  return { name: "Unknown", version: "Unknown" };
+}
+function detectBrowser() {
+  const ua = navigator.userAgent;
+  if (/Edg\/(\d+\.\d+)/.test(ua)) {
+    const match = ua.match(/Edg\/(\d+\.\d+)/);
+    return { name: "Edge", version: match[1] };
+  }
+  if (/Chrome\/(\d+\.\d+)/.test(ua) && !/Edg/.test(ua)) {
+    const match = ua.match(/Chrome\/(\d+\.\d+)/);
+    return { name: "Chrome", version: match[1] };
+  }
+  if (/Firefox\/(\d+\.\d+)/.test(ua)) {
+    const match = ua.match(/Firefox\/(\d+\.\d+)/);
+    return { name: "Firefox", version: match[1] };
+  }
+  if (/Safari\/(\d+\.\d+)/.test(ua) && !/Chrome/.test(ua)) {
+    const match = ua.match(/Version\/(\d+\.\d+)/);
+    return { name: "Safari", version: match ? match[1] : "Unknown" };
+  }
+  if (/MSIE (\d+\.\d+)/.test(ua) || /Trident\//.test(ua)) {
+    const match = ua.match(/MSIE (\d+\.\d+)/) || ua.match(/rv:(\d+\.\d+)/);
+    return { name: "Internet Explorer", version: match ? match[1] : "Unknown" };
+  }
+  return { name: "Unknown", version: "Unknown" };
+}
+function detectNetworkInfo() {
+  try {
+    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (connection) {
+      return {
+        effectiveType: connection.effectiveType,
+        downlink: connection.downlink,
+        rtt: connection.rtt
+      };
+    }
+  } catch (error) {
+    console.warn("[Aegis Device] detectNetworkInfo failed:", error);
+  }
+  return void 0;
+}
+function isBot() {
+  const ua = navigator.userAgent.toLowerCase();
+  const botPatterns = [
+    "bot",
+    "crawl",
+    "spider",
+    "slurp",
+    "mediapartners",
+    "googlebot",
+    "bingbot",
+    "yahoo",
+    "duckduckbot",
+    "baiduspider",
+    "yandex",
+    "facebookexternalhit",
+    "linkedinbot",
+    "twitterbot",
+    "slackbot",
+    "telegrambot",
+    "whatsapp",
+    "pingdom",
+    "uptimerobot"
+  ];
+  return botPatterns.some((pattern) => ua.includes(pattern));
+}
+class PluginRegistry {
+  constructor() {
+    this.plugins = /* @__PURE__ */ new Map();
+  }
+  register(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      logger.warn(`Plugin "${plugin.name}" already registered, skipping`);
+      return;
+    }
+    this.plugins.set(plugin.name, plugin);
+    logger.info(`Plugin registered: ${plugin.name} v${plugin.version}`);
+  }
+  unregister(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      logger.warn(`Plugin "${pluginName}" not found`);
+      return;
+    }
+    if (plugin.destroy) {
+      try {
+        plugin.destroy();
+      } catch (error) {
+        logger.error(`Error destroying plugin "${pluginName}":`, error);
+      }
+    }
+    this.plugins.delete(pluginName);
+    logger.info(`Plugin unregistered: ${pluginName}`);
+  }
+  get(pluginName) {
+    return this.plugins.get(pluginName);
+  }
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+  async executeHook(hookName, ...args) {
+    for (const plugin of this.plugins.values()) {
+      const hook = plugin[hookName];
+      if (typeof hook === "function") {
+        try {
+          const result = await hook.apply(plugin, args);
+          if (result !== void 0) {
+            return result;
+          }
+        } catch (error) {
+          logger.error(
+            `Error executing ${String(hookName)} in plugin "${plugin.name}":`,
+            error
+          );
+          if (plugin.onError) {
+            try {
+              plugin.onError(error, { hookName, args });
+            } catch (onErrorError) {
+              logger.error(
+                `Error in onError handler for plugin "${plugin.name}":`,
+                onErrorError
+              );
+            }
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  async executeHookChain(hookName, initialValue, ...additionalArgs) {
+    let value = initialValue;
+    for (const plugin of this.plugins.values()) {
+      const hook = plugin[hookName];
+      if (typeof hook === "function") {
+        try {
+          const result = await hook.apply(plugin, [
+            value,
+            ...additionalArgs
+          ]);
+          if (result !== void 0 && result !== null) {
+            value = result;
+          }
+        } catch (error) {
+          logger.error(
+            `Error executing ${String(hookName)} in plugin "${plugin.name}":`,
+            error
+          );
+          if (plugin.onError) {
+            try {
+              plugin.onError(error, { hookName, value, additionalArgs });
+            } catch (onErrorError) {
+              logger.error(
+                `Error in onError handler for plugin "${plugin.name}":`,
+                onErrorError
+              );
+            }
+          }
+        }
+      }
+    }
+    return value;
+  }
+  async executeHookParallel(hookName, ...args) {
+    const promises = [];
+    for (const plugin of this.plugins.values()) {
+      const hook = plugin[hookName];
+      if (typeof hook === "function") {
+        const promise = (async () => {
+          try {
+            return await hook.apply(plugin, args);
+          } catch (error) {
+            logger.error(
+              `Error executing ${String(hookName)} in plugin "${plugin.name}":`,
+              error
+            );
+            if (plugin.onError) {
+              try {
+                plugin.onError(error, { hookName, args });
+              } catch (onErrorError) {
+                logger.error(
+                  `Error in onError handler for plugin "${plugin.name}":`,
+                  onErrorError
+                );
+              }
+            }
+            return void 0;
+          }
+        })();
+        promises.push(promise);
+      }
+    }
+    const results = await Promise.all(promises);
+    return results.filter((r) => r !== void 0);
+  }
+  clear() {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.destroy) {
+        try {
+          plugin.destroy();
+        } catch (error) {
+          logger.error(`Error destroying plugin "${plugin.name}":`, error);
+        }
+      }
+    }
+    this.plugins.clear();
+    logger.info("All plugins cleared");
+  }
+}
+class ConsentManager {
+  constructor(storage, config = {}) {
+    this.listeners = [];
+    this.storage = storage;
+    this.config = {
+      defaultConsent: config.defaultConsent || {},
+      waitForConsent: config.waitForConsent ?? false,
+      consentStorageKey: config.consentStorageKey || "aegis_consent"
+    };
+    this.preferences = this.loadPreferences();
+  }
+  loadPreferences() {
+    const stored = this.storage.get(this.config.consentStorageKey);
+    if (stored) {
+      try {
+        const parsed = JSON.parse(stored);
+        logger.info("Loaded consent preferences:", parsed);
+        return this.mergeWithDefaults(parsed);
+      } catch (error) {
+        logger.warn("Failed to parse consent preferences:", error);
+      }
+    }
+    return this.getDefaultPreferences();
+  }
+  getDefaultPreferences() {
+    return {
+      analytics: this.config.defaultConsent.analytics ?? false,
+      marketing: this.config.defaultConsent.marketing ?? false,
+      functional: this.config.defaultConsent.functional ?? true,
+      necessary: true
+    };
+  }
+  mergeWithDefaults(preferences) {
+    return {
+      necessary: true,
+      analytics: preferences.analytics ?? this.config.defaultConsent.analytics ?? false,
+      marketing: preferences.marketing ?? this.config.defaultConsent.marketing ?? false,
+      functional: preferences.functional ?? this.config.defaultConsent.functional ?? true
+    };
+  }
+  savePreferences() {
+    try {
+      this.storage.set(
+        this.config.consentStorageKey,
+        JSON.stringify(this.preferences),
+        365
+      );
+      logger.info("Saved consent preferences:", this.preferences);
+    } catch (error) {
+      logger.error("Failed to save consent preferences:", error);
+    }
+  }
+  setConsent(preferences) {
+    const updated = { ...this.preferences, ...preferences };
+    updated.necessary = true;
+    this.preferences = updated;
+    this.savePreferences();
+    this.notifyListeners();
+    logger.info("Consent updated:", this.preferences);
+  }
+  grantAll() {
+    this.setConsent({
+      analytics: true,
+      marketing: true,
+      functional: true,
+      necessary: true
+    });
+  }
+  denyAll() {
+    this.setConsent({
+      analytics: false,
+      marketing: false,
+      functional: false,
+      necessary: true
+    });
+  }
+  hasConsent(category) {
+    return this.preferences[category];
+  }
+  getPreferences() {
+    return { ...this.preferences };
+  }
+  getStatus(category) {
+    if (this.hasConsent(category)) {
+      return "granted";
+    }
+    const stored = this.storage.get(this.config.consentStorageKey);
+    if (!stored && this.config.waitForConsent) {
+      return "pending";
+    }
+    return "denied";
+  }
+  isAnalyticsEnabled() {
+    return this.hasConsent("analytics");
+  }
+  isMarketingEnabled() {
+    return this.hasConsent("marketing");
+  }
+  onChange(callback) {
+    this.listeners.push(callback);
+    return () => {
+      const index = this.listeners.indexOf(callback);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  notifyListeners() {
+    this.listeners.forEach((listener) => {
+      try {
+        listener(this.getPreferences());
+      } catch (error) {
+        logger.error("Consent listener error:", error);
+      }
+    });
+  }
+  reset() {
+    this.storage.remove(this.config.consentStorageKey);
+    this.preferences = this.getDefaultPreferences();
+    this.notifyListeners();
+    logger.info("Consent preferences reset");
+  }
+  integrateOneTrust() {
+    if (typeof window === "undefined") return;
+    const oneTrust = window.OneTrust;
+    if (!oneTrust) {
+      logger.warn("OneTrust not detected");
+      return;
+    }
+    const syncWithOneTrust = () => {
+      const activeGroups = window.OnetrustActiveGroups || "";
+      this.setConsent({
+        necessary: true,
+        functional: activeGroups.includes("C0003"),
+        analytics: activeGroups.includes("C0002"),
+        marketing: activeGroups.includes("C0004")
+      });
+      logger.info("Synced with OneTrust consent");
+    };
+    if (window.OptanonWrapper) {
+      const originalWrapper = window.OptanonWrapper;
+      window.OptanonWrapper = function() {
+        originalWrapper();
+        syncWithOneTrust();
+      };
+    } else {
+      window.OptanonWrapper = syncWithOneTrust;
+    }
+    syncWithOneTrust();
+  }
+  integrateCookiebot() {
+    if (typeof window === "undefined") return;
+    const cookiebot = window.Cookiebot;
+    if (!cookiebot) {
+      logger.warn("Cookiebot not detected");
+      return;
+    }
+    const syncWithCookiebot = () => {
+      const consent = cookiebot.consent || {};
+      this.setConsent({
+        necessary: true,
+        functional: consent.preferences || false,
+        analytics: consent.statistics || false,
+        marketing: consent.marketing || false
+      });
+      logger.info("Synced with Cookiebot consent");
+    };
+    window.addEventListener("CookiebotOnAccept", syncWithCookiebot);
+    window.addEventListener("CookiebotOnDecline", syncWithCookiebot);
+    if (cookiebot.consent) {
+      syncWithCookiebot();
+    }
+  }
+  integrateGoogleConsentMode() {
+    if (typeof window === "undefined") return;
+    const gtag = window.gtag;
+    if (!gtag) {
+      logger.warn("Google Tag Manager not detected");
+      return;
+    }
+    const updateGoogleConsent = () => {
+      gtag("consent", "update", {
+        ad_storage: this.preferences.marketing ? "granted" : "denied",
+        analytics_storage: this.preferences.analytics ? "granted" : "denied",
+        ad_user_data: this.preferences.marketing ? "granted" : "denied",
+        ad_personalization: this.preferences.marketing ? "granted" : "denied",
+        functionality_storage: this.preferences.functional ? "granted" : "denied",
+        personalization_storage: this.preferences.functional ? "granted" : "denied",
+        security_storage: "granted"
+      });
+      logger.info("Updated Google Consent Mode");
+    };
+    this.onChange(updateGoogleConsent);
+    updateGoogleConsent();
+  }
+}
+class Aegis {
+  constructor() {
+    this.config = null;
+    this.session = null;
+    this.queue = null;
+    this.transport = null;
+    this.plugins = new PluginRegistry();
+    this.initPromise = null;
+    this.consent = null;
+  }
+  async init(writeKey, config) {
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this._init(writeKey, config);
+    return this.initPromise;
+  }
+  async _init(writeKey, config) {
+    var _a;
+    if ((_a = this.config) == null ? void 0 : _a.initialized) {
+      logger.warn("SDK already initialized");
+      return;
+    }
+    if (this.shouldRespectDNT(config)) {
+      logger.info("Do Not Track is enabled, SDK disabled");
+      return;
+    }
+    if (isBot()) {
+      logger.info("Bot detected, SDK disabled");
+      return;
+    }
+    this.config = this.buildConfig(writeKey, config);
+    if (this.config.debug) {
+      logger.enable();
+    }
+    logger.info("Initializing Aegis SDK...", this.config);
+    this.storage = new Storage({
+      cookieDomain: this.config.cookie_domain,
+      secureCookie: this.config.secure_cookie,
+      crossDomain: this.config.cross_domain_tracking
+    });
+    this.identity = new Identity(this.storage);
+    this.consent = new ConsentManager(this.storage, {
+      defaultConsent: this.config.default_consent,
+      waitForConsent: this.config.wait_for_consent
+    });
+    if (this.config.integrate_onetrust) {
+      this.consent.integrateOneTrust();
+    }
+    if (this.config.integrate_cookiebot) {
+      this.consent.integrateCookiebot();
+    }
+    if (this.config.integrate_google_consent_mode) {
+      this.consent.integrateGoogleConsentMode();
+    }
+    this.session = new SessionManager(
+      this.storage,
+      this.config.session_timeout
+    );
+    this.captureAdClickIDsOnInit();
+    this.transport = new Transport(
+      {
+        writeKey: this.config.write_key,
+        apiHost: this.config.api_host,
+        cellEndpoints: this.config.cell_endpoints,
+        preferredRegion: this.config.preferred_region,
+        autoRegionDetection: this.config.auto_region_detection,
+        requestTimeout: this.config.request_timeout,
+        retryFailedRequests: this.config.retry_failed_requests,
+        maxRetries: this.config.max_retries,
+        retryBackoffMultiplier: this.config.retry_backoff_multiplier
+      },
+      this.storage
+    );
+    this.config.active_cell = this.transport.getActiveCell();
+    this.queue = new EventQueue(
+      {
+        batchSize: this.config.batch_size,
+        batchInterval: this.config.batch_interval,
+        enableOfflineMode: this.config.enable_offline_mode,
+        maxOfflineEvents: this.config.max_offline_events
+      },
+      this.transport,
+      this.storage
+    );
+    await this.initializePlugins();
+    if (this.config.auto_page_view) {
+      this.page();
+    }
+    logger.info("Aegis SDK initialized successfully");
+  }
+  buildConfig(writeKey, config) {
+    return {
+      ...DEFAULT_CONFIG,
+      ...config,
+      write_key: writeKey,
+      initialized: true
+    };
+  }
+  shouldRespectDNT(config) {
+    const respectDNT = (config == null ? void 0 : config.respect_dnt) !== false;
+    if (!respectDNT) return false;
+    const dnt = navigator.doNotTrack || window.doNotTrack || navigator.msDoNotTrack;
+    return dnt === "1" || dnt === "yes";
+  }
+  captureAdClickIDsOnInit() {
+    if (!this.session) return;
+    const adClickIDs = parseAdClickIDs();
+    if (hasAdClickIDs(adClickIDs)) {
+      this.session.setAdClickIDs(adClickIDs, window.location.href);
+      logger.info("Ad click IDs captured on page load:", adClickIDs);
+    }
+  }
+  async initializePlugins() {
+    if (!this.config) return;
+    for (const pluginName of this.config.plugins) {
+      logger.debug(`Initializing plugin: ${pluginName}`);
+    }
+    await this.plugins.executeHook("init", this.config);
+  }
+  use(plugin) {
+    var _a;
+    this.plugins.register(plugin);
+    if (((_a = this.config) == null ? void 0 : _a.initialized) && plugin.init) {
+      Promise.resolve(plugin.init(this.config)).catch((error) => {
+        logger.error(`Failed to initialize plugin "${plugin.name}":`, error);
+      });
+    }
+  }
+  track(eventName, properties) {
+    if (!this.assertInitialized()) return;
+    const event = {
+      type: "track",
+      event: eventName,
+      properties: properties || {},
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: this.identity.getUserId() || void 0,
+      sessionId: this.session.getSessionId(),
+      context: buildContext(this.config, this.session)
+    };
+    this.captureEvent(event);
+  }
+  identify(userId, traits) {
+    if (!this.assertInitialized()) return;
+    this.identity.setUserId(userId, traits);
+    const event = {
+      type: "identify",
+      traits: traits || {},
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId,
+      sessionId: this.session.getSessionId(),
+      context: buildContext(this.config, this.session)
+    };
+    this.captureEvent(event);
+  }
+  page(name, properties) {
+    if (!this.assertInitialized()) return;
+    const event = {
+      type: "page",
+      name: name || document.title,
+      properties: properties || {},
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: this.identity.getUserId() || void 0,
+      sessionId: this.session.getSessionId(),
+      context: buildContext(this.config, this.session)
+    };
+    this.captureEvent(event);
+  }
+  group(groupId, traits) {
+    if (!this.assertInitialized()) return;
+    const event = {
+      type: "group",
+      groupId,
+      traits: traits || {},
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: this.identity.getUserId() || void 0,
+      sessionId: this.session.getSessionId(),
+      context: buildContext(this.config, this.session)
+    };
+    this.captureEvent(event);
+  }
+  alias(newUserId) {
+    if (!this.assertInitialized()) return;
+    const { previousId } = this.identity.alias(newUserId);
+    const event = {
+      type: "alias",
+      previousId,
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: newUserId,
+      sessionId: this.session.getSessionId(),
+      context: buildContext(this.config, this.session)
+    };
+    this.captureEvent(event);
+  }
+  async captureEvent(event) {
+    var _a;
+    if (((_a = this.config) == null ? void 0 : _a.enable_consent_mode) && this.consent) {
+      if (event.type === "track" || event.type === "page") {
+        if (!this.consent.hasConsent("analytics")) {
+          logger.debug("Event blocked: analytics consent not granted");
+          return;
+        }
+      }
+    }
+    logger.debug("Capturing event:", event);
+    const transformedEvent = await this.plugins.executeHookChain(
+      "beforeEventCapture",
+      event
+    );
+    if (!transformedEvent) {
+      logger.debug("Event cancelled by plugin");
+      return;
+    }
+    this.queue.push(transformedEvent);
+    this.session.incrementEventCount();
+    await this.plugins.executeHook("afterEventCapture", transformedEvent);
+  }
+  reset() {
+    if (!this.assertInitialized()) return;
+    this.identity.reset();
+    logger.info("User identity reset");
+  }
+  async flush() {
+    if (!this.assertInitialized()) return;
+    await this.queue.flush();
+  }
+  getAnonymousId() {
+    if (!this.identity) return null;
+    return this.identity.getAnonymousId();
+  }
+  getUserId() {
+    if (!this.identity) return null;
+    return this.identity.getUserId();
+  }
+  getSessionId() {
+    if (!this.session) return null;
+    return this.session.getSessionId();
+  }
+  debug(enable = true) {
+    if (enable) {
+      logger.enable();
+    } else {
+      logger.disable();
+    }
+    if (this.config) {
+      this.config.debug = enable;
+    }
+  }
+  setCell(cellEndpoint) {
+    if (!this.config) {
+      logger.warn("SDK not initialized");
+      return;
+    }
+    const existingCell = this.config.cell_endpoints.find(
+      (c) => c.region === cellEndpoint.region
+    );
+    if (existingCell) {
+      Object.assign(existingCell, cellEndpoint);
+    } else {
+      this.config.cell_endpoints.push(cellEndpoint);
+    }
+    logger.info("Cell endpoint configured:", cellEndpoint);
+  }
+  getCellInfo() {
+    if (!this.transport) return null;
+    return {
+      activeCell: this.transport.getActiveCell(),
+      latencies: this.transport.getRegionLatencies()
+    };
+  }
+  setConsent(preferences) {
+    if (!this.consent) {
+      logger.warn("Consent manager not initialized");
+      return;
+    }
+    this.consent.setConsent(preferences);
+    logger.info("Consent preferences updated");
+  }
+  grantConsent(category) {
+    if (!this.consent) {
+      logger.warn("Consent manager not initialized");
+      return;
+    }
+    if (category) {
+      this.consent.setConsent({ [category]: true });
+    } else {
+      this.consent.grantAll();
+    }
+  }
+  denyConsent(category) {
+    if (!this.consent) {
+      logger.warn("Consent manager not initialized");
+      return;
+    }
+    if (category) {
+      this.consent.setConsent({ [category]: false });
+    } else {
+      this.consent.denyAll();
+    }
+  }
+  hasConsent(category) {
+    if (!this.consent) {
+      return true;
+    }
+    return this.consent.hasConsent(category);
+  }
+  getConsentPreferences() {
+    if (!this.consent) {
+      return null;
+    }
+    return this.consent.getPreferences();
+  }
+  onConsentChange(callback) {
+    if (!this.consent) {
+      logger.warn("Consent manager not initialized");
+      return () => {
+      };
+    }
+    return this.consent.onChange(callback);
+  }
+  assertInitialized() {
+    var _a;
+    if (!((_a = this.config) == null ? void 0 : _a.initialized)) {
+      logger.warn("SDK not initialized. Call aegis.init() first.");
+      return false;
+    }
+    return true;
+  }
+  destroy() {
+    if (this.queue) {
+      this.queue.destroy();
+    }
+    if (this.session) {
+      this.session.destroy();
+    }
+    if (this.transport) {
+      this.transport.destroy();
+    }
+    this.plugins.clear();
+    logger.info("SDK destroyed");
+  }
+}
+export {
+  Aegis as A,
+  logger as l
+};
+//# sourceMappingURL=analytics-B11keZ55.mjs.map