analyzer-analytics 0.1.0

package/dist/analytics.js

@@ -0,0 +1,1786 @@
+(() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __moduleCache = /* @__PURE__ */ new WeakMap;
+  var __toCommonJS = (from) => {
+    var entry = __moduleCache.get(from), desc;
+    if (entry)
+      return entry;
+    entry = __defProp({}, "__esModule", { value: true });
+    if (from && typeof from === "object" || typeof from === "function")
+      __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+        get: () => from[key],
+        enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+      }));
+    __moduleCache.set(from, entry);
+    return entry;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, {
+        get: all[name],
+        enumerable: true,
+        configurable: true,
+        set: (newValue) => all[name] = () => newValue
+      });
+  };
+
+  // src/index.ts
+  var exports_src = {};
+  __export(exports_src, {
+    throttle: () => throttle,
+    supportsFetch: () => supportsFetch,
+    supportsCompression: () => supportsCompression,
+    supportsBeacon: () => supportsBeacon,
+    sortByPriority: () => sortByPriority,
+    setSessionItem: () => setSessionItem,
+    setItem: () => setItem,
+    setDebugMode: () => setDebugMode,
+    sendWithRetry: () => sendWithRetry,
+    sendFetch: () => sendFetch,
+    sendBeacon: () => sendBeacon,
+    sendAdaptive: () => sendAdaptive,
+    send: () => send,
+    sanitizeProperties: () => sanitizeProperties,
+    sanitizeEventName: () => sanitizeEventName,
+    resetStorageCache: () => resetStorageCache,
+    resetNetworkAdapter: () => resetNetworkAdapter,
+    resetCapabilityCache: () => resetCapabilityCache,
+    queueOfflineEvents: () => queueOfflineEvents,
+    parseQueryString: () => parseQueryString,
+    onOnline: () => onOnline,
+    isValidUtmParams: () => isValidUtmParams,
+    isValidQueuedEvent: () => isValidQueuedEvent,
+    isValidEvent: () => isValidEvent,
+    isValidConfig: () => isValidConfig,
+    isStorageAvailable: () => isStorageAvailable,
+    isOffline: () => isOffline,
+    isDataSaverEnabled: () => isDataSaverEnabled,
+    isBot: () => isBot,
+    getVisitorId: () => getVisitorId,
+    getUtmParams: () => getUtmParams,
+    getUserAgent: () => getUserAgent,
+    getSessionItem: () => getSessionItem,
+    getSessionId: () => getSessionId,
+    getScreenDimensions: () => getScreenDimensions,
+    getRtt: () => getRtt,
+    getReferrer: () => getReferrer,
+    getPageUrl: () => getPageUrl,
+    getPageTitle: () => getPageTitle,
+    getOfflineEvents: () => getOfflineEvents,
+    getNetworkAdapter: () => getNetworkAdapter,
+    getItem: () => getItem,
+    getDownlink: () => getDownlink,
+    getConnectionType: () => getConnectionType,
+    getConnectionInfo: () => getConnectionInfo,
+    generateId: () => generateId,
+    default: () => src_default,
+    debounce: () => debounce,
+    createVisitorId: () => createVisitorId,
+    createSessionId: () => createSessionId,
+    createAnalytics: () => createAnalytics,
+    clearVisitorId: () => clearVisitorId,
+    clearSessionId: () => clearSessionId,
+    clearOfflineEvents: () => clearOfflineEvents,
+    assignPriority: () => assignPriority,
+    VERSION: () => VERSION,
+    STORAGE_KEYS: () => STORAGE_KEYS,
+    RetryStrategy: () => RetryStrategy,
+    NetworkError: () => NetworkError,
+    NetworkAdapter: () => NetworkAdapter,
+    EventPriority: () => EventPriority,
+    DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+    Analytics: () => Analytics
+  });
+
+  // src/types.ts
+  function isObject(value) {
+    return typeof value === "object" && value !== null;
+  }
+  function isValidUtmParams(value) {
+    if (!isObject(value))
+      return false;
+    const allowedKeys = ["source", "medium", "campaign", "term", "content"];
+    const keys = Object.keys(value);
+    return keys.every((key) => allowedKeys.includes(key) && (value[key] === undefined || typeof value[key] === "string"));
+  }
+  function isValidEvent(value) {
+    if (!isObject(value))
+      return false;
+    const event = value;
+    if (typeof event.event !== "string" || event.event.length === 0)
+      return false;
+    if (typeof event.visitor_id !== "string")
+      return false;
+    if (typeof event.session_id !== "string")
+      return false;
+    if (typeof event.page_url !== "string")
+      return false;
+    if (typeof event.user_agent !== "string")
+      return false;
+    if (typeof event.timestamp !== "number" || !Number.isFinite(event.timestamp))
+      return false;
+    if (typeof event.screen_width !== "number" || !Number.isFinite(event.screen_width))
+      return false;
+    if (typeof event.screen_height !== "number" || !Number.isFinite(event.screen_height))
+      return false;
+    if (!isObject(event.properties))
+      return false;
+    if (event.page_title !== undefined && typeof event.page_title !== "string")
+      return false;
+    if (event.referrer !== undefined && typeof event.referrer !== "string")
+      return false;
+    if (event.utm !== undefined && !isValidUtmParams(event.utm))
+      return false;
+    return true;
+  }
+  function isValidConfig(value) {
+    if (!isObject(value))
+      return false;
+    const config = value;
+    if (typeof config.apiKey !== "string" || config.apiKey.length === 0)
+      return false;
+    if (config.endpoint !== undefined && typeof config.endpoint !== "string")
+      return false;
+    if (config.debug !== undefined && typeof config.debug !== "boolean")
+      return false;
+    if (config.maxQueueSize !== undefined) {
+      if (typeof config.maxQueueSize !== "number" || !Number.isInteger(config.maxQueueSize) || config.maxQueueSize < 1)
+        return false;
+    }
+    if (config.flushInterval !== undefined) {
+      if (typeof config.flushInterval !== "number" || !Number.isInteger(config.flushInterval) || config.flushInterval < 0)
+        return false;
+    }
+    if (config.autoTrack !== undefined && typeof config.autoTrack !== "boolean")
+      return false;
+    return true;
+  }
+  function isValidQueuedEvent(value) {
+    if (!isObject(value))
+      return false;
+    const event = value;
+    if (typeof event.event !== "string" || event.event.length === 0)
+      return false;
+    if (!isObject(event.properties))
+      return false;
+    if (typeof event.timestamp !== "number" || !Number.isFinite(event.timestamp))
+      return false;
+    return true;
+  }
+  function createVisitorId(id) {
+    return id;
+  }
+  function createSessionId(id) {
+    return id;
+  }
+  var DEFAULT_CONFIG = {
+    endpoint: "http://localhost:8080",
+    debug: false,
+    maxQueueSize: 10,
+    flushInterval: 5000,
+    autoTrack: true,
+    adaptiveNetwork: true
+  };
+
+  // src/storage.ts
+  var VISITOR_ID_KEY = "_analytics_vid";
+  var SESSION_ID_KEY = "_analytics_sid";
+  var STORAGE_TEST_KEY = "_analytics_test";
+  function getStorage(type) {
+    try {
+      if (typeof window !== "undefined" && window[type]) {
+        return window[type];
+      }
+      if (typeof globalThis !== "undefined" && globalThis[type]) {
+        return globalThis[type];
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  var memoryStorage = new Map;
+  function getFromMemory(key) {
+    return memoryStorage.get(key) ?? null;
+  }
+  function setInMemory(key, value) {
+    memoryStorage.set(key, value);
+  }
+  var storageAvailabilityCache = {
+    localStorage: null,
+    sessionStorage: null
+  };
+  function isStorageAvailable(type) {
+    if (storageAvailabilityCache[type] !== null) {
+      return storageAvailabilityCache[type];
+    }
+    try {
+      const storage = getStorage(type);
+      if (!storage) {
+        storageAvailabilityCache[type] = false;
+        return false;
+      }
+      storage.setItem(STORAGE_TEST_KEY, "test");
+      storage.removeItem(STORAGE_TEST_KEY);
+      storageAvailabilityCache[type] = true;
+      return true;
+    } catch {
+      storageAvailabilityCache[type] = false;
+      return false;
+    }
+  }
+  function resetStorageCache() {
+    storageAvailabilityCache.localStorage = null;
+    storageAvailabilityCache.sessionStorage = null;
+    memoryStorage.clear();
+  }
+  function getItem(key) {
+    if (isStorageAvailable("localStorage")) {
+      try {
+        const storage = getStorage("localStorage");
+        return storage?.getItem(key) ?? null;
+      } catch {}
+    }
+    return getFromMemory(key);
+  }
+  function setItem(key, value) {
+    if (isStorageAvailable("localStorage")) {
+      try {
+        const storage = getStorage("localStorage");
+        storage?.setItem(key, value);
+        return true;
+      } catch {}
+    }
+    setInMemory(key, value);
+    return false;
+  }
+  function getSessionItem(key) {
+    if (isStorageAvailable("sessionStorage")) {
+      try {
+        const storage = getStorage("sessionStorage");
+        return storage?.getItem(key) ?? null;
+      } catch {}
+    }
+    return getFromMemory(key);
+  }
+  function setSessionItem(key, value) {
+    if (isStorageAvailable("sessionStorage")) {
+      try {
+        const storage = getStorage("sessionStorage");
+        storage?.setItem(key, value);
+        return true;
+      } catch {}
+    }
+    setInMemory(key, value);
+    return false;
+  }
+  function generateId() {
+    const timestamp = Date.now();
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+      try {
+        return `${timestamp}_${crypto.randomUUID()}`;
+      } catch {}
+    }
+    const randomPart = generateRandomString(8);
+    return `${timestamp}_${randomPart}`;
+  }
+  function generateRandomString(length) {
+    const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+      try {
+        const array = new Uint8Array(length);
+        crypto.getRandomValues(array);
+        for (let i = 0;i < length; i++) {
+          result += chars[array[i] % chars.length];
+        }
+        return result;
+      } catch {}
+    }
+    for (let i = 0;i < length; i++) {
+      result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
+  }
+  var cachedVisitorId = null;
+  function getVisitorId() {
+    if (cachedVisitorId !== null) {
+      return cachedVisitorId;
+    }
+    let existingId = getItem(VISITOR_ID_KEY);
+    if (existingId) {
+      cachedVisitorId = createVisitorId(existingId);
+      return cachedVisitorId;
+    }
+    if (isStorageAvailable("sessionStorage")) {
+      try {
+        const storage = getStorage("sessionStorage");
+        existingId = storage?.getItem(VISITOR_ID_KEY) ?? null;
+        if (existingId) {
+          cachedVisitorId = createVisitorId(existingId);
+          return cachedVisitorId;
+        }
+      } catch {}
+    }
+    existingId = getFromMemory(VISITOR_ID_KEY);
+    if (existingId) {
+      cachedVisitorId = createVisitorId(existingId);
+      return cachedVisitorId;
+    }
+    const newId = generateId();
+    cachedVisitorId = createVisitorId(newId);
+    setItem(VISITOR_ID_KEY, newId);
+    if (isStorageAvailable("sessionStorage")) {
+      try {
+        const storage = getStorage("sessionStorage");
+        storage?.setItem(VISITOR_ID_KEY, newId);
+      } catch {}
+    }
+    return cachedVisitorId;
+  }
+  function clearVisitorId() {
+    cachedVisitorId = null;
+    if (isStorageAvailable("localStorage")) {
+      try {
+        const storage = getStorage("localStorage");
+        storage?.removeItem(VISITOR_ID_KEY);
+      } catch {}
+    }
+    if (isStorageAvailable("sessionStorage")) {
+      try {
+        const storage = getStorage("sessionStorage");
+        storage?.removeItem(VISITOR_ID_KEY);
+      } catch {}
+    }
+    memoryStorage.delete(VISITOR_ID_KEY);
+  }
+  var cachedSessionId = null;
+  function getSessionId() {
+    if (cachedSessionId !== null) {
+      return cachedSessionId;
+    }
+    let existingId = getSessionItem(SESSION_ID_KEY);
+    if (existingId) {
+      cachedSessionId = createSessionId(existingId);
+      return cachedSessionId;
+    }
+    existingId = getFromMemory(SESSION_ID_KEY);
+    if (existingId) {
+      cachedSessionId = createSessionId(existingId);
+      return cachedSessionId;
+    }
+    const newId = generateId();
+    cachedSessionId = createSessionId(newId);
+    setSessionItem(SESSION_ID_KEY, newId);
+    return cachedSessionId;
+  }
+  function clearSessionId() {
+    cachedSessionId = null;
+    if (isStorageAvailable("sessionStorage")) {
+      try {
+        const storage = getStorage("sessionStorage");
+        storage?.removeItem(SESSION_ID_KEY);
+      } catch {}
+    }
+    memoryStorage.delete(SESSION_ID_KEY);
+  }
+  var STORAGE_KEYS = {
+    VISITOR_ID: VISITOR_ID_KEY,
+    SESSION_ID: SESSION_ID_KEY
+  };
+
+  // src/utils.ts
+  var capabilityCache = {
+    beacon: null,
+    fetch: null,
+    compression: null
+  };
+  function parseQueryString(search) {
+    if (!search || search === "?") {
+      return {};
+    }
+    const queryString = search.startsWith("?") ? search.slice(1) : search;
+    if (!queryString) {
+      return {};
+    }
+    if (typeof URLSearchParams !== "undefined") {
+      try {
+        const params = new URLSearchParams(queryString);
+        const result2 = {};
+        params.forEach((value, key) => {
+          result2[key] = value;
+        });
+        return result2;
+      } catch {}
+    }
+    const result = {};
+    const pairs = queryString.split("&");
+    for (const pair of pairs) {
+      if (!pair)
+        continue;
+      const [key, ...valueParts] = pair.split("=");
+      if (!key)
+        continue;
+      const value = valueParts.join("=");
+      try {
+        result[decodeURIComponent(key)] = decodeURIComponent(value || "");
+      } catch {
+        result[key] = value || "";
+      }
+    }
+    return result;
+  }
+  function getUtmParams() {
+    if (typeof window === "undefined" && typeof globalThis === "undefined") {
+      return {};
+    }
+    let search = "";
+    try {
+      if (typeof window !== "undefined" && window.location) {
+        search = window.location.search;
+        if (!search && window.location.hash) {
+          const hashQueryIndex = window.location.hash.indexOf("?");
+          if (hashQueryIndex !== -1) {
+            search = window.location.hash.slice(hashQueryIndex);
+          }
+        }
+      }
+    } catch {
+      return {};
+    }
+    const params = parseQueryString(search);
+    return {
+      ...params.utm_source && { source: params.utm_source },
+      ...params.utm_medium && { medium: params.utm_medium },
+      ...params.utm_campaign && { campaign: params.utm_campaign },
+      ...params.utm_term && { term: params.utm_term },
+      ...params.utm_content && { content: params.utm_content }
+    };
+  }
+  function getNavigatorConnection() {
+    if (typeof navigator === "undefined")
+      return null;
+    const nav = navigator;
+    return nav.connection || nav.mozConnection || nav.webkitConnection || null;
+  }
+  function getConnectionInfo() {
+    const connection = getNavigatorConnection();
+    if (!connection) {
+      return null;
+    }
+    const effectiveType = connection.effectiveType;
+    return {
+      effectiveType: effectiveType || "unknown",
+      downlink: connection.downlink,
+      rtt: connection.rtt,
+      saveData: connection.saveData
+    };
+  }
+  function getConnectionType() {
+    const connection = getNavigatorConnection();
+    if (!connection || !connection.effectiveType) {
+      return "unknown";
+    }
+    const type = connection.effectiveType;
+    if (type === "slow-2g" || type === "2g" || type === "3g" || type === "4g") {
+      return type;
+    }
+    return "unknown";
+  }
+  var BOT_PATTERNS = [
+    "googlebot",
+    "bingbot",
+    "slurp",
+    "duckduckbot",
+    "baiduspider",
+    "yandexbot",
+    "sogou",
+    "exabot",
+    "facebot",
+    "ia_archiver",
+    "headless",
+    "phantom",
+    "selenium",
+    "puppeteer",
+    "playwright",
+    "webdriver",
+    "curl",
+    "wget",
+    "python-requests",
+    "python-urllib",
+    "java/",
+    "apache-httpclient",
+    "okhttp",
+    "axios/",
+    "bot",
+    "crawler",
+    "spider",
+    "scraper",
+    "lighthouse",
+    "pagespeed",
+    "gtmetrix"
+  ];
+  function isBot() {
+    if (typeof navigator === "undefined") {
+      return false;
+    }
+    const userAgent = navigator.userAgent?.toLowerCase() || "";
+    if (!userAgent) {
+      return false;
+    }
+    for (const pattern of BOT_PATTERNS) {
+      if (userAgent.includes(pattern)) {
+        return true;
+      }
+    }
+    if (navigator.webdriver === true) {
+      return true;
+    }
+    return false;
+  }
+  function debounce(func, wait) {
+    let timeoutId = null;
+    return function(...args) {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = setTimeout(() => {
+        func.apply(this, args);
+        timeoutId = null;
+      }, wait);
+    };
+  }
+  function throttle(func, limit) {
+    let inThrottle = false;
+    let lastArgs = null;
+    return function(...args) {
+      if (!inThrottle) {
+        func.apply(this, args);
+        inThrottle = true;
+        setTimeout(() => {
+          inThrottle = false;
+          if (lastArgs !== null) {
+            func.apply(this, lastArgs);
+            lastArgs = null;
+          }
+        }, limit);
+      } else {
+        lastArgs = args;
+      }
+    };
+  }
+  function supportsBeacon() {
+    if (capabilityCache.beacon !== null) {
+      return capabilityCache.beacon;
+    }
+    const supported = typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function";
+    capabilityCache.beacon = supported;
+    return supported;
+  }
+  function supportsFetch() {
+    if (capabilityCache.fetch !== null) {
+      return capabilityCache.fetch;
+    }
+    const supported = typeof fetch === "function";
+    capabilityCache.fetch = supported;
+    return supported;
+  }
+  function supportsCompression() {
+    if (capabilityCache.compression !== null) {
+      return capabilityCache.compression;
+    }
+    const supported = typeof CompressionStream !== "undefined";
+    capabilityCache.compression = supported;
+    return supported;
+  }
+  function resetCapabilityCache() {
+    capabilityCache.beacon = null;
+    capabilityCache.fetch = null;
+    capabilityCache.compression = null;
+  }
+  var MAX_EVENT_NAME_LENGTH = 100;
+  var MAX_STRING_LENGTH = 1000;
+  var MAX_OBJECT_DEPTH = 5;
+  function sanitizeEventName(name) {
+    if (typeof name !== "string") {
+      return "unknown_event";
+    }
+    if (!name.trim()) {
+      return "unknown_event";
+    }
+    return name.toLowerCase().trim().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, "").slice(0, MAX_EVENT_NAME_LENGTH);
+  }
+  function sanitizeValue(value, depth) {
+    if (value === null || value === undefined) {
+      return null;
+    }
+    if (typeof value === "string") {
+      return value.slice(0, MAX_STRING_LENGTH);
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value)) {
+        return null;
+      }
+      return value;
+    }
+    if (typeof value === "boolean") {
+      return value;
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (depth >= MAX_OBJECT_DEPTH) {
+      return "[max depth]";
+    }
+    if (Array.isArray(value)) {
+      return value.slice(0, 100).map((item) => sanitizeValue(item, depth + 1));
+    }
+    if (typeof value === "object") {
+      try {
+        const result = {};
+        const keys = Object.keys(value);
+        for (const key of keys.slice(0, 100)) {
+          const propValue = value[key];
+          if (propValue !== undefined) {
+            result[key] = sanitizeValue(propValue, depth + 1);
+          }
+        }
+        return result;
+      } catch {
+        return "[object]";
+      }
+    }
+    return null;
+  }
+  function sanitizeProperties(props) {
+    if (!props || typeof props !== "object" || Array.isArray(props)) {
+      return {};
+    }
+    try {
+      return sanitizeValue(props, 0);
+    } catch {
+      return {};
+    }
+  }
+  function getPageUrl() {
+    try {
+      if (typeof window !== "undefined" && window.location) {
+        return window.location.href;
+      }
+    } catch {}
+    return "";
+  }
+  function getPageTitle() {
+    try {
+      if (typeof document !== "undefined" && document.title) {
+        return document.title;
+      }
+    } catch {}
+    return;
+  }
+  function getReferrer() {
+    try {
+      if (typeof document !== "undefined" && document.referrer) {
+        return document.referrer;
+      }
+    } catch {}
+    return;
+  }
+  function getUserAgent() {
+    try {
+      if (typeof navigator !== "undefined" && navigator.userAgent) {
+        return navigator.userAgent;
+      }
+    } catch {}
+    return "";
+  }
+  function getScreenDimensions() {
+    try {
+      if (typeof window !== "undefined" && window.screen) {
+        return {
+          width: window.screen.width || 0,
+          height: window.screen.height || 0
+        };
+      }
+    } catch {}
+    return { width: 0, height: 0 };
+  }
+
+  // src/network.ts
+  var OFFLINE_QUEUE_KEY = "_analytics_offline_queue";
+  var SENT_REQUESTS_KEY = "_analytics_sent_requests";
+  var MAX_OFFLINE_EVENTS = 100;
+  var MAX_TRACKED_REQUESTS = 100;
+  var MAX_BEACON_PAYLOAD = 64 * 1024;
+  var BASE_RETRY_DELAY = 1000;
+  var debugMode = false;
+  function setDebugMode(enabled) {
+    debugMode = enabled;
+  }
+  function debugLog(message, ...args) {
+    if (debugMode && typeof console !== "undefined") {
+      console.log(`[Analytics Network] ${message}`, ...args);
+    }
+  }
+  function logError(message, error) {
+    if (debugMode && typeof console !== "undefined") {
+      console.error(`[Analytics Network] ${message}`, error);
+    }
+  }
+
+  class NetworkError extends Error {
+    statusCode;
+    retry;
+    constructor(message, statusCode, retry) {
+      super(message);
+      this.statusCode = statusCode;
+      this.retry = retry;
+      this.name = "NetworkError";
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, NetworkError);
+      }
+    }
+  }
+  function sendBeacon(url, data) {
+    try {
+      if (!supportsBeacon()) {
+        debugLog("sendBeacon not available");
+        return false;
+      }
+      const payload = JSON.stringify(data);
+      if (payload.length > MAX_BEACON_PAYLOAD) {
+        debugLog("Payload too large for sendBeacon:", payload.length);
+        return false;
+      }
+      const blob = new Blob([payload], { type: "application/json" });
+      const success = navigator.sendBeacon(url, blob);
+      if (success) {
+        debugLog("Beacon sent successfully");
+      } else {
+        debugLog("Beacon failed to queue");
+      }
+      return success;
+    } catch (error) {
+      logError("sendBeacon error:", error);
+      return false;
+    }
+  }
+  async function sendFetch(url, data, apiKey) {
+    if (!supportsFetch()) {
+      throw new NetworkError("Fetch API not available", undefined, false);
+    }
+    try {
+      const payload = JSON.stringify(data);
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: payload,
+        keepalive: true
+      });
+      if (!response.ok) {
+        const shouldRetry = response.status >= 500 || response.status === 429;
+        throw new NetworkError(`HTTP error: ${response.status} ${response.statusText}`, response.status, shouldRetry);
+      }
+      debugLog("Fetch sent successfully, status:", response.status);
+    } catch (error) {
+      if (error instanceof NetworkError) {
+        throw error;
+      }
+      throw new NetworkError(error instanceof Error ? error.message : "Network request failed", undefined, true);
+    }
+  }
+  function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async function sendWithRetry(url, data, maxRetries = 3, apiKey) {
+    let lastError;
+    for (let attempt = 0;attempt <= maxRetries; attempt++) {
+      try {
+        await sendFetch(url, data, apiKey);
+        debugLog("Request succeeded on attempt:", attempt + 1);
+        return;
+      } catch (error) {
+        lastError = error instanceof NetworkError ? error : new NetworkError("Unknown error", undefined, true);
+        if (!lastError.retry) {
+          debugLog("Not retrying, error is not retryable:", lastError.message);
+          throw lastError;
+        }
+        if (attempt >= maxRetries) {
+          debugLog("Max retries exceeded");
+          break;
+        }
+        const backoffDelay = BASE_RETRY_DELAY * Math.pow(2, attempt);
+        debugLog(`Retry ${attempt + 1}/${maxRetries} after ${backoffDelay}ms`);
+        await delay(backoffDelay);
+      }
+    }
+    throw lastError || new NetworkError("All retries failed", undefined, false);
+  }
+  async function compressData(data) {
+    if (!supportsCompression()) {
+      debugLog("CompressionStream not available, returning uncompressed");
+      return data;
+    }
+    try {
+      const blob = new Blob([data], { type: "application/json" });
+      const compressionStream = new CompressionStream("gzip");
+      const compressedStream = blob.stream().pipeThrough(compressionStream);
+      const compressedBlob = await new Response(compressedStream).blob();
+      debugLog(`Compressed ${data.length} bytes to ${compressedBlob.size} bytes (${Math.round((1 - compressedBlob.size / data.length) * 100)}% reduction)`);
+      return compressedBlob;
+    } catch (error) {
+      logError("Compression failed, returning uncompressed:", error);
+      return data;
+    }
+  }
+  async function sendCompressed(url, data, apiKey) {
+    if (!supportsFetch()) {
+      throw new NetworkError("Fetch API not available", undefined, false);
+    }
+    try {
+      const jsonString = JSON.stringify(data);
+      const compressed = await compressData(jsonString);
+      const isCompressed = compressed instanceof Blob;
+      const headers = {
+        "Content-Type": "application/json",
+        ...isCompressed && { "Content-Encoding": "gzip" }
+      };
+      if (apiKey) {
+        headers["Authorization"] = `Bearer ${apiKey}`;
+      }
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: compressed,
+        keepalive: true
+      });
+      if (!response.ok) {
+        const shouldRetry = response.status >= 500 || response.status === 429;
+        throw new NetworkError(`HTTP error: ${response.status}`, response.status, shouldRetry);
+      }
+      debugLog("Compressed fetch sent successfully");
+    } catch (error) {
+      if (error instanceof NetworkError) {
+        throw error;
+      }
+      throw new NetworkError(error instanceof Error ? error.message : "Compressed send failed", undefined, true);
+    }
+  }
+  function queueOfflineEvents(events) {
+    try {
+      if (typeof localStorage === "undefined") {
+        debugLog("localStorage not available for offline queue");
+        return;
+      }
+      const existingQueue = getOfflineEvents();
+      const combined = [...existingQueue, ...events];
+      const limited = combined.length > MAX_OFFLINE_EVENTS ? combined.slice(-MAX_OFFLINE_EVENTS) : combined;
+      localStorage.setItem(OFFLINE_QUEUE_KEY, JSON.stringify(limited));
+      debugLog(`Queued ${events.length} offline events (total: ${limited.length})`);
+    } catch (error) {
+      logError("Failed to queue offline events:", error);
+    }
+  }
+  function getOfflineEvents() {
+    try {
+      if (typeof localStorage === "undefined") {
+        return [];
+      }
+      const stored = localStorage.getItem(OFFLINE_QUEUE_KEY);
+      if (!stored) {
+        return [];
+      }
+      const parsed = JSON.parse(stored);
+      if (!Array.isArray(parsed)) {
+        debugLog("Invalid offline queue format, clearing");
+        clearOfflineEvents();
+        return [];
+      }
+      return parsed;
+    } catch (error) {
+      logError("Failed to get offline events:", error);
+      return [];
+    }
+  }
+  function clearOfflineEvents() {
+    try {
+      if (typeof localStorage !== "undefined") {
+        localStorage.removeItem(OFFLINE_QUEUE_KEY);
+        debugLog("Cleared offline queue");
+      }
+    } catch (error) {
+      logError("Failed to clear offline events:", error);
+    }
+  }
+  function isOffline() {
+    if (typeof navigator === "undefined") {
+      return false;
+    }
+    return navigator.onLine === false;
+  }
+  function onOnline(callback) {
+    if (typeof window === "undefined") {
+      return () => {};
+    }
+    window.addEventListener("online", callback);
+    return () => {
+      window.removeEventListener("online", callback);
+    };
+  }
+  function getSentRequestIds() {
+    try {
+      if (typeof sessionStorage === "undefined") {
+        return [];
+      }
+      const stored = sessionStorage.getItem(SENT_REQUESTS_KEY);
+      if (!stored) {
+        return [];
+      }
+      const parsed = JSON.parse(stored);
+      if (!Array.isArray(parsed)) {
+        return [];
+      }
+      return parsed;
+    } catch {
+      return [];
+    }
+  }
+  function saveSentRequestIds(ids) {
+    try {
+      if (typeof sessionStorage !== "undefined") {
+        sessionStorage.setItem(SENT_REQUESTS_KEY, JSON.stringify(ids));
+      }
+    } catch {}
+  }
+  function wasRequestSent(requestId) {
+    const sentIds = getSentRequestIds();
+    return sentIds.includes(requestId);
+  }
+  function markRequestSent(requestId) {
+    try {
+      const sentIds = getSentRequestIds();
+      sentIds.push(requestId);
+      const limited = sentIds.length > MAX_TRACKED_REQUESTS ? sentIds.slice(-MAX_TRACKED_REQUESTS) : sentIds;
+      saveSentRequestIds(limited);
+      debugLog("Marked request as sent:", requestId);
+    } catch (error) {
+      logError("Failed to mark request as sent:", error);
+    }
+  }
+  async function send(url, data, options = {}) {
+    const {
+      useBeacon = true,
+      compress = false,
+      retry = true,
+      requestId,
+      apiKey
+    } = options;
+    if (requestId && wasRequestSent(requestId)) {
+      debugLog("Skipping duplicate request:", requestId);
+      return;
+    }
+    if (isOffline()) {
+      debugLog("Offline, queuing events");
+      queueOfflineEvents(data.events);
+      return;
+    }
+    try {
+      if (useBeacon && sendBeacon(url, data)) {
+        if (requestId) {
+          markRequestSent(requestId);
+        }
+        return;
+      }
+      if (compress) {
+        await sendCompressed(url, data, apiKey);
+      } else if (retry) {
+        await sendWithRetry(url, data, 3, apiKey);
+      } else {
+        await sendFetch(url, data, apiKey);
+      }
+      if (requestId) {
+        markRequestSent(requestId);
+      }
+    } catch (error) {
+      logError("Send failed:", error);
+      if (error instanceof NetworkError && error.retry) {
+        queueOfflineEvents(data.events);
+      }
+    }
+  }
+
+  // src/network-adapter.ts
+  var EventPriority;
+  ((EventPriority2) => {
+    EventPriority2[EventPriority2["LOW"] = 0] = "LOW";
+    EventPriority2[EventPriority2["NORMAL"] = 1] = "NORMAL";
+    EventPriority2[EventPriority2["HIGH"] = 2] = "HIGH";
+  })(EventPriority ||= {});
+  var SLOW_2G_SETTINGS = {
+    maxQueueSize: 3,
+    flushInterval: 15000,
+    compressionEnabled: true,
+    batchingStrategy: "aggressive"
+  };
+  var TWO_G_SETTINGS = {
+    maxQueueSize: 5,
+    flushInterval: 1e4,
+    compressionEnabled: true,
+    batchingStrategy: "aggressive"
+  };
+  var THREE_G_SETTINGS = {
+    maxQueueSize: 10,
+    flushInterval: 5000,
+    compressionEnabled: false,
+    batchingStrategy: "balanced"
+  };
+  var FOUR_G_SETTINGS = {
+    maxQueueSize: 20,
+    flushInterval: 3000,
+    compressionEnabled: false,
+    batchingStrategy: "conservative"
+  };
+  var DATA_SAVER_SETTINGS = {
+    maxQueueSize: 10,
+    flushInterval: 20000,
+    compressionEnabled: true,
+    batchingStrategy: "aggressive"
+  };
+  var MAX_BACKOFF_DELAY = 30000;
+  var BASE_BACKOFF_DELAY = 1000;
+  function getNavigatorConnection2() {
+    if (typeof navigator === "undefined") {
+      return null;
+    }
+    const nav = navigator;
+    return nav.connection || nav.mozConnection || nav.webkitConnection || null;
+  }
+  function isDataSaverEnabled() {
+    const connection = getNavigatorConnection2();
+    return connection?.saveData === true;
+  }
+  function getRtt() {
+    const connection = getNavigatorConnection2();
+    return connection?.rtt ?? 100;
+  }
+  function getDownlink() {
+    const connection = getNavigatorConnection2();
+    return connection?.downlink ?? 10;
+  }
+  function sortByPriority(events) {
+    return [...events].sort((a, b) => b.priority - a.priority);
+  }
+  function assignPriority(event) {
+    const eventName = event.event.toLowerCase();
+    if (eventName.includes("purchase") || eventName.includes("conversion") || eventName.includes("signup") || eventName.includes("error") || eventName.includes("checkout") || eventName.includes("subscribe")) {
+      return { ...event, priority: 2 /* HIGH */ };
+    }
+    if (eventName === "pageview" || eventName.includes("impression") || eventName.includes("scroll") || eventName.includes("hover")) {
+      return { ...event, priority: 0 /* LOW */ };
+    }
+    return { ...event, priority: 1 /* NORMAL */ };
+  }
+
+  class RetryStrategy {
+    attempts = 0;
+    maxRetries;
+    constructor(connectionType = "unknown") {
+      switch (connectionType) {
+        case "slow-2g":
+          this.maxRetries = 5;
+          break;
+        case "2g":
+          this.maxRetries = 3;
+          break;
+        case "3g":
+          this.maxRetries = 2;
+          break;
+        default:
+          this.maxRetries = 2;
+      }
+    }
+    getBackoffDelay() {
+      const delay2 = BASE_BACKOFF_DELAY * Math.pow(2, this.attempts);
+      return Math.min(delay2, MAX_BACKOFF_DELAY);
+    }
+    shouldRetry(error) {
+      if (this.attempts >= this.maxRetries) {
+        return false;
+      }
+      if (error instanceof NetworkError) {
+        if (error.retry === false) {
+          return false;
+        }
+        if (error.statusCode !== undefined && error.statusCode >= 400 && error.statusCode < 500 && error.statusCode !== 429) {
+          return false;
+        }
+        return true;
+      }
+      return true;
+    }
+    recordAttempt() {
+      this.attempts++;
+    }
+    reset() {
+      this.attempts = 0;
+    }
+    getAttempts() {
+      return this.attempts;
+    }
+    getMaxRetries() {
+      return this.maxRetries;
+    }
+  }
+
+  class NetworkAdapter {
+    currentSettings;
+    connection = null;
+    changeCallbacks = [];
+    boundHandleChange;
+    cachedConnectionType = "unknown";
+    lastUpdateTime = 0;
+    cacheTimeout = 1000;
+    constructor() {
+      this.connection = getNavigatorConnection2();
+      this.currentSettings = this.computeSettings();
+      this.boundHandleChange = debounce(() => {
+        this.handleConnectionChange();
+      }, 100);
+      if (this.connection?.addEventListener) {
+        this.connection.addEventListener("change", this.boundHandleChange);
+      }
+    }
+    computeSettings() {
+      if (isDataSaverEnabled()) {
+        return { ...DATA_SAVER_SETTINGS };
+      }
+      const connectionType = this.getConnectionType();
+      switch (connectionType) {
+        case "slow-2g":
+          return { ...SLOW_2G_SETTINGS };
+        case "2g":
+          return { ...TWO_G_SETTINGS };
+        case "3g":
+          return { ...THREE_G_SETTINGS };
+        case "4g":
+        case "unknown":
+        default:
+          return { ...FOUR_G_SETTINGS };
+      }
+    }
+    handleConnectionChange() {
+      this.lastUpdateTime = 0;
+      const newSettings = this.computeSettings();
+      if (newSettings.maxQueueSize === this.currentSettings.maxQueueSize && newSettings.flushInterval === this.currentSettings.flushInterval && newSettings.compressionEnabled === this.currentSettings.compressionEnabled) {
+        return;
+      }
+      this.currentSettings = newSettings;
+      for (const callback of this.changeCallbacks) {
+        try {
+          callback(newSettings);
+        } catch {}
+      }
+    }
+    getConnectionType() {
+      const now = Date.now();
+      if (now - this.lastUpdateTime < this.cacheTimeout) {
+        return this.cachedConnectionType;
+      }
+      this.cachedConnectionType = getConnectionType();
+      this.lastUpdateTime = now;
+      return this.cachedConnectionType;
+    }
+    getSettings() {
+      return { ...this.currentSettings };
+    }
+    onConnectionChange(callback) {
+      this.changeCallbacks.push(callback);
+      return () => {
+        const index = this.changeCallbacks.indexOf(callback);
+        if (index > -1) {
+          this.changeCallbacks.splice(index, 1);
+        }
+      };
+    }
+    shouldCompress() {
+      if (!supportsCompression()) {
+        return false;
+      }
+      if (isDataSaverEnabled()) {
+        return true;
+      }
+      return this.currentSettings.compressionEnabled;
+    }
+    getOptimalBatchSize() {
+      const rtt = getRtt();
+      const downlink = getDownlink();
+      if (isDataSaverEnabled()) {
+        return 15;
+      }
+      if (rtt > 500) {
+        return Math.min(this.currentSettings.maxQueueSize + 5, 20);
+      }
+      if (downlink < 1) {
+        return Math.min(this.currentSettings.maxQueueSize + 3, 15);
+      }
+      return this.currentSettings.maxQueueSize;
+    }
+    getRetryStrategy() {
+      return new RetryStrategy(this.getConnectionType());
+    }
+    isSlowConnection() {
+      const type = this.getConnectionType();
+      return type === "slow-2g" || type === "2g";
+    }
+    getRecommendedTimeout() {
+      const rtt = getRtt();
+      const type = this.getConnectionType();
+      let timeout = 1e4;
+      switch (type) {
+        case "slow-2g":
+          timeout = 30000;
+          break;
+        case "2g":
+          timeout = 20000;
+          break;
+        case "3g":
+          timeout = 15000;
+          break;
+      }
+      timeout += rtt * 2;
+      return timeout;
+    }
+    destroy() {
+      if (this.connection?.removeEventListener) {
+        this.connection.removeEventListener("change", this.boundHandleChange);
+      }
+      this.changeCallbacks = [];
+    }
+  }
+  function delay2(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async function sendAdaptive(url, data, adapter) {
+    const retryStrategy = adapter.getRetryStrategy();
+    const shouldCompress = adapter.shouldCompress();
+    if (adapter.isSlowConnection()) {
+      const prioritizedEvents = data.events.map((e) => assignPriority(e));
+      const sortedEvents = sortByPriority(prioritizedEvents);
+      data = {
+        ...data,
+        events: sortedEvents
+      };
+    }
+    const connectionType = getConnectionType();
+    while (true) {
+      try {
+        if (connectionType === "4g" || connectionType === "unknown") {
+          if (sendBeacon(url, data)) {
+            return;
+          }
+        }
+        if (shouldCompress) {
+          await sendCompressed(url, data);
+        } else {
+          await sendFetch(url, data);
+        }
+        return;
+      } catch (error) {
+        retryStrategy.recordAttempt();
+        const err = error instanceof Error ? error : new Error(String(error));
+        if (!retryStrategy.shouldRetry(err)) {
+          throw error;
+        }
+        const backoffDelay = retryStrategy.getBackoffDelay();
+        await delay2(backoffDelay);
+      }
+    }
+  }
+  var globalAdapter = null;
+  function getNetworkAdapter() {
+    if (!globalAdapter) {
+      globalAdapter = new NetworkAdapter;
+    }
+    return globalAdapter;
+  }
+  function resetNetworkAdapter() {
+    if (globalAdapter) {
+      globalAdapter.destroy();
+      globalAdapter = null;
+    }
+  }
+
+  // src/analytics.ts
+  var PAGEVIEW_DEBOUNCE_MS = 100;
+
+  class Analytics {
+    config;
+    queue = [];
+    visitorId;
+    sessionId;
+    flushTimer = null;
+    isInitialized = false;
+    lastPageUrl = "";
+    boundHandlePageUnload;
+    boundHandleOnline;
+    boundHandleOffline;
+    boundHandlePopstate;
+    debouncedTrackPageView;
+    originalPushState = null;
+    originalReplaceState = null;
+    adapter = null;
+    adapterCleanup = null;
+    useAdaptiveNetwork;
+    constructor(config) {
+      if (!config.apiKey || typeof config.apiKey !== "string") {
+        throw new Error("[Analytics] API key is required");
+      }
+      this.config = {
+        apiKey: config.apiKey,
+        endpoint: config.endpoint ?? DEFAULT_CONFIG.endpoint,
+        debug: config.debug ?? DEFAULT_CONFIG.debug,
+        maxQueueSize: config.maxQueueSize ?? DEFAULT_CONFIG.maxQueueSize,
+        flushInterval: config.flushInterval ?? DEFAULT_CONFIG.flushInterval,
+        autoTrack: config.autoTrack ?? DEFAULT_CONFIG.autoTrack,
+        adaptiveNetwork: config.adaptiveNetwork ?? DEFAULT_CONFIG.adaptiveNetwork
+      };
+      setDebugMode(this.config.debug);
+      this.visitorId = getVisitorId();
+      this.sessionId = getSessionId();
+      this.boundHandlePageUnload = this.handlePageUnload.bind(this);
+      this.boundHandleOnline = this.handleOnline.bind(this);
+      this.boundHandleOffline = this.handleOffline.bind(this);
+      this.boundHandlePopstate = this.handlePopstate.bind(this);
+      this.debouncedTrackPageView = debounce(() => {
+        this.trackPageViewInternal();
+      }, PAGEVIEW_DEBOUNCE_MS);
+      this.useAdaptiveNetwork = this.config.adaptiveNetwork;
+      if (this.useAdaptiveNetwork) {
+        this.initNetworkAdapter();
+      }
+      if (isBot()) {
+        this.log("Bot detected, skipping initialization");
+        return;
+      }
+      this.init();
+    }
+    init() {
+      if (this.isInitialized) {
+        return;
+      }
+      this.isInitialized = true;
+      this.lastPageUrl = getPageUrl();
+      if (this.config.autoTrack) {
+        this.trackPageViewInternal();
+      }
+      if (this.config.autoTrack) {
+        this.setupPageViewTracking();
+      }
+      this.startFlushTimer();
+      if (typeof window !== "undefined") {
+        window.addEventListener("beforeunload", this.boundHandlePageUnload);
+        window.addEventListener("online", this.boundHandleOnline);
+        window.addEventListener("offline", this.boundHandleOffline);
+      }
+      this.sendOfflineEvents();
+      this.log("Initialized successfully");
+    }
+    initNetworkAdapter() {
+      if (!this.useAdaptiveNetwork) {
+        return;
+      }
+      try {
+        this.adapter = new NetworkAdapter;
+        this.applyAdaptiveSettings(this.adapter.getSettings());
+        this.adapterCleanup = this.adapter.onConnectionChange((settings) => {
+          this.applyAdaptiveSettings(settings);
+        });
+      } catch (error) {
+        this.warn("Failed to initialize network adapter", error);
+        this.adapter = null;
+      }
+    }
+    applyAdaptiveSettings(settings) {
+      const oldFlushInterval = this.config.flushInterval;
+      this.config = {
+        ...this.config,
+        maxQueueSize: settings.maxQueueSize,
+        flushInterval: settings.flushInterval
+      };
+      if (settings.flushInterval !== oldFlushInterval && this.isInitialized) {
+        this.stopFlushTimer();
+        this.startFlushTimer();
+      }
+      this.log("Adapted to network conditions:", settings);
+    }
+    track(eventName, properties = {}) {
+      if (!this.isInitialized) {
+        this.warn("SDK not initialized, event not tracked");
+        return;
+      }
+      try {
+        const sanitizedName = sanitizeEventName(eventName);
+        const sanitizedProps = sanitizeProperties(properties);
+        const queuedEvent = {
+          event: sanitizedName,
+          properties: sanitizedProps,
+          timestamp: Date.now()
+        };
+        this.queue.push(queuedEvent);
+        this.log(`Tracked event: ${sanitizedName}`, sanitizedProps);
+        if (this.queue.length >= this.config.maxQueueSize) {
+          this.flush();
+        }
+      } catch (error) {
+        this.error("Failed to track event", error);
+      }
+    }
+    trackPageView() {
+      this.debouncedTrackPageView();
+    }
+    trackPageViewInternal() {
+      const currentUrl = getPageUrl();
+      if (currentUrl === this.lastPageUrl && this.queue.length > 0) {
+        const lastEvent = this.queue[this.queue.length - 1];
+        if (lastEvent.event === "pageview") {
+          return;
+        }
+      }
+      this.lastPageUrl = currentUrl;
+      this.track("pageview", {});
+    }
+    async flush() {
+      if (this.queue.length === 0) {
+        return;
+      }
+      const eventsToSend = this.queue;
+      this.queue = [];
+      const rawEvents = this.buildRawEvents(eventsToSend);
+      const batch = {
+        api_key: this.config.apiKey,
+        events: rawEvents
+      };
+      const endpoint = `${this.config.endpoint}/events`;
+      if (isOffline()) {
+        this.log("Offline, queuing events for later");
+        queueOfflineEvents(rawEvents);
+        return;
+      }
+      try {
+        if (this.adapter) {
+          await sendAdaptive(endpoint, batch, this.adapter);
+          this.log(`Flushed ${rawEvents.length} events via adaptive send`);
+          return;
+        }
+        if (sendBeacon(endpoint, batch)) {
+          this.log(`Flushed ${rawEvents.length} events via beacon`);
+          return;
+        }
+        await sendFetch(endpoint, batch);
+        this.log(`Flushed ${rawEvents.length} events via fetch`);
+      } catch (error) {
+        this.error("Failed to send events, queuing for retry", error);
+        queueOfflineEvents(rawEvents);
+      }
+    }
+    buildRawEvents(queuedEvents) {
+      const pageUrl = getPageUrl();
+      const pageTitle = getPageTitle();
+      const referrer = getReferrer();
+      const userAgent = getUserAgent();
+      const screen = getScreenDimensions();
+      const utm = getUtmParams();
+      return queuedEvents.map((queued) => ({
+        event: queued.event,
+        properties: queued.properties,
+        timestamp: queued.timestamp,
+        visitor_id: this.visitorId,
+        session_id: this.sessionId,
+        page_url: pageUrl,
+        page_title: pageTitle,
+        referrer,
+        user_agent: userAgent,
+        screen_width: screen.width,
+        screen_height: screen.height,
+        ...Object.keys(utm).length > 0 && { utm }
+      }));
+    }
+    startFlushTimer() {
+      if (this.flushTimer !== null) {
+        return;
+      }
+      if (this.config.flushInterval <= 0) {
+        return;
+      }
+      this.flushTimer = setInterval(() => {
+        this.flush();
+      }, this.config.flushInterval);
+      this.log(`Started flush timer: ${this.config.flushInterval}ms`);
+    }
+    stopFlushTimer() {
+      if (this.flushTimer !== null) {
+        clearInterval(this.flushTimer);
+        this.flushTimer = null;
+        this.log("Stopped flush timer");
+      }
+    }
+    setupPageViewTracking() {
+      if (typeof window === "undefined" || typeof history === "undefined") {
+        return;
+      }
+      this.wrapHistoryMethod("pushState");
+      this.wrapHistoryMethod("replaceState");
+      window.addEventListener("popstate", this.boundHandlePopstate);
+      this.log("Set up SPA navigation tracking");
+    }
+    wrapHistoryMethod(method) {
+      if (typeof history === "undefined") {
+        return;
+      }
+      const original = history[method];
+      if (!original) {
+        return;
+      }
+      if (method === "pushState") {
+        this.originalPushState = original;
+      } else {
+        this.originalReplaceState = original;
+      }
+      const analytics = this;
+      history[method] = function(data, unused, url) {
+        const result = original.apply(this, [data, unused, url]);
+        analytics.trackPageView();
+        return result;
+      };
+    }
+    handlePopstate = () => {
+      this.trackPageView();
+    };
+    restoreHistoryMethods() {
+      if (typeof history === "undefined") {
+        return;
+      }
+      if (this.originalPushState) {
+        history.pushState = this.originalPushState;
+        this.originalPushState = null;
+      }
+      if (this.originalReplaceState) {
+        history.replaceState = this.originalReplaceState;
+        this.originalReplaceState = null;
+      }
+    }
+    handlePageUnload = () => {
+      if (this.queue.length === 0) {
+        return;
+      }
+      const rawEvents = this.buildRawEvents(this.queue);
+      const batch = {
+        api_key: this.config.apiKey,
+        events: rawEvents
+      };
+      const endpoint = `${this.config.endpoint}/events`;
+      if (!sendBeacon(endpoint, batch)) {
+        queueOfflineEvents(rawEvents);
+      }
+      this.queue = [];
+    };
+    handleOnline = () => {
+      this.log("Back online, sending queued events");
+      this.sendOfflineEvents();
+    };
+    handleOffline = () => {
+      this.log("Gone offline, queuing events");
+      if (this.queue.length > 0) {
+        const rawEvents = this.buildRawEvents(this.queue);
+        queueOfflineEvents(rawEvents);
+        this.queue = [];
+      }
+    };
+    sendOfflineEvents() {
+      const offlineEvents = getOfflineEvents();
+      if (offlineEvents.length === 0) {
+        return;
+      }
+      this.log(`Found ${offlineEvents.length} offline events to send`);
+      clearOfflineEvents();
+      const batch = {
+        api_key: this.config.apiKey,
+        events: offlineEvents
+      };
+      const endpoint = `${this.config.endpoint}/events`;
+      if (!sendBeacon(endpoint, batch)) {
+        sendFetch(endpoint, batch).catch((error) => {
+          this.error("Failed to send offline events", error);
+          queueOfflineEvents(offlineEvents);
+        });
+      }
+    }
+    setConfig(updates) {
+      const oldFlushInterval = this.config.flushInterval;
+      this.config = {
+        ...this.config,
+        ...updates.endpoint !== undefined && { endpoint: updates.endpoint },
+        ...updates.debug !== undefined && { debug: updates.debug },
+        ...updates.maxQueueSize !== undefined && {
+          maxQueueSize: updates.maxQueueSize
+        },
+        ...updates.flushInterval !== undefined && {
+          flushInterval: updates.flushInterval
+        },
+        ...updates.autoTrack !== undefined && { autoTrack: updates.autoTrack }
+      };
+      if (updates.debug !== undefined) {
+        setDebugMode(updates.debug);
+      }
+      if (updates.flushInterval !== undefined && updates.flushInterval !== oldFlushInterval) {
+        this.stopFlushTimer();
+        this.startFlushTimer();
+      }
+      this.log("Config updated", updates);
+    }
+    getVisitorId() {
+      return this.visitorId;
+    }
+    getSessionId() {
+      return this.sessionId;
+    }
+    getConfig() {
+      return { ...this.config };
+    }
+    getQueueLength() {
+      return this.queue.length;
+    }
+    isActive() {
+      return this.isInitialized;
+    }
+    destroy() {
+      this.log("Destroying instance");
+      if (this.queue.length > 0) {
+        this.handlePageUnload();
+      }
+      this.stopFlushTimer();
+      if (typeof window !== "undefined") {
+        window.removeEventListener("beforeunload", this.boundHandlePageUnload);
+        window.removeEventListener("online", this.boundHandleOnline);
+        window.removeEventListener("offline", this.boundHandleOffline);
+        window.removeEventListener("popstate", this.boundHandlePopstate);
+      }
+      this.restoreHistoryMethods();
+      if (this.adapterCleanup) {
+        this.adapterCleanup();
+        this.adapterCleanup = null;
+      }
+      if (this.adapter) {
+        this.adapter.destroy();
+        this.adapter = null;
+      }
+      this.queue = [];
+      this.isInitialized = false;
+      this.log("Destroyed");
+    }
+    log(message, ...args) {
+      if (this.config.debug && typeof console !== "undefined") {
+        console.log(`[Analytics] ${message}`, ...args);
+      }
+    }
+    warn(message, ...args) {
+      if (this.config.debug && typeof console !== "undefined") {
+        console.warn(`[Analytics] ${message}`, ...args);
+      }
+    }
+    error(message, ...args) {
+      if (this.config.debug && typeof console !== "undefined") {
+        console.error(`[Analytics] ${message}`, ...args);
+      }
+    }
+  }
+  function createAnalytics(config) {
+    return new Analytics(config);
+  }
+  // src/index.ts
+  var VERSION = "0.1.0";
+  function createGlobalAnalytics() {
+    return {
+      version: VERSION,
+      instance: null,
+      init(apiKey, config = {}) {
+        if (this.instance) {
+          this.instance.destroy();
+        }
+        this.instance = new Analytics({ apiKey, ...config });
+        return this.instance;
+      },
+      track(event, properties = {}) {
+        if (!this.instance) {
+          if (typeof console !== "undefined") {
+            console.warn("[Analytics] Not initialized. Call analytics.init(apiKey) first.");
+          }
+          return;
+        }
+        this.instance.track(event, properties);
+      },
+      trackPageView() {
+        if (!this.instance) {
+          if (typeof console !== "undefined") {
+            console.warn("[Analytics] Not initialized. Call analytics.init(apiKey) first.");
+          }
+          return;
+        }
+        this.instance.trackPageView();
+      },
+      getVisitorId() {
+        return this.instance?.getVisitorId() ?? null;
+      },
+      getSessionId() {
+        return this.instance?.getSessionId() ?? null;
+      },
+      async flush() {
+        if (this.instance) {
+          await this.instance.flush();
+        }
+      },
+      destroy() {
+        if (this.instance) {
+          this.instance.destroy();
+          this.instance = null;
+        }
+      }
+    };
+  }
+  var globalAnalytics = createGlobalAnalytics();
+  function autoInitFromScriptTag() {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return;
+    }
+    window.analytics = globalAnalytics;
+    const currentScript = document.currentScript;
+    if (!currentScript) {
+      return;
+    }
+    const apiKey = currentScript.getAttribute("data-api-key");
+    if (!apiKey) {
+      return;
+    }
+    const endpoint = currentScript.getAttribute("data-endpoint") || undefined;
+    const debug = currentScript.getAttribute("data-debug") === "true";
+    const autoTrack = currentScript.getAttribute("data-auto-track") !== "false";
+    const adaptiveNetwork = currentScript.getAttribute("data-adaptive") !== "false";
+    globalAnalytics.init(apiKey, {
+      endpoint,
+      debug,
+      autoTrack,
+      adaptiveNetwork
+    });
+  }
+  autoInitFromScriptTag();
+  var src_default = globalAnalytics;
+})();