onerway-analytics 1.0.0

package/dist/bundle/index.js

@@ -0,0 +1,1361 @@
+"use strict";
+var OnrwayAnalytics = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    API_KEY_MAP: () => API_KEY_MAP,
+    Analytics: () => Analytics,
+    DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+    GAManager: () => GAManager,
+    SDK_VERSION: () => SDK_VERSION,
+    STORAGE_KEYS: () => STORAGE_KEYS,
+    Sender: () => Sender,
+    SessionManager: () => SessionManager,
+    StorageQueue: () => StorageQueue,
+    collectContext: () => collectContext,
+    collectMarketing: () => collectMarketing,
+    createAnalytics: () => createAnalytics,
+    detectBrowser: () => detectBrowser,
+    detectOS: () => detectOS,
+    generateId: () => generateId,
+    generateUUID: () => generateUUID,
+    getCountryFromLanguage: () => getCountryFromLanguage,
+    getDeviceType: () => getDeviceType,
+    getHostname: () => getHostname,
+    getLanguage: () => getLanguage,
+    getPageUrl: () => getPageUrl,
+    getReferrer: () => getReferrer,
+    getScreenSize: () => getScreenSize,
+    getTimestamp: () => getTimestamp,
+    getTimezone: () => getTimezone,
+    initAutoTrack: () => initAutoTrack,
+    initErrorMonitor: () => initErrorMonitor,
+    initPerformanceMonitor: () => initPerformanceMonitor,
+    isBrowser: () => isBrowser,
+    isObject: () => isObject,
+    merge: () => merge,
+    parseUTMParams: () => parseUTMParams,
+    truncateText: () => truncateText
+  });
+
+  // src/types/index.ts
+  var API_KEY_MAP = {
+    beta: "5skbadERCne5HKSS9a1EXz5RetUiEfpP",
+    development: "5skbadERCne5HKSS9a1EXz5RetUiEfpP",
+    test: "Dguh5yxNDEwyQlqDmikmd7ImruaOp8c8",
+    testing: "Dguh5yxNDEwyQlqDmikmd7ImruaOp8c8",
+    sit: "Dguh5yxNDEwyQlqDmikmd7ImruaOp8c8",
+    uat: "W565QolX6clTuL1Kqgpp0JmUqBkWKY6i",
+    prod: "HUk5Kogyuv9zH5qDA2qSCjVEnhanSkf8",
+    production: "HUk5Kogyuv9zH5qDA2qSCjVEnhanSkf8"
+  };
+  var SDK_VERSION = "1.0.0";
+  var DEFAULT_CONFIG = {
+    debug: false,
+    autoTrack: true,
+    bufferFlushInterval: 5e3,
+    bufferMaxSize: 25,
+    maxRetryCount: 3,
+    sessionTimeout: 30 * 60 * 1e3,
+    clientType: "WEB",
+    merchantLanguage: "en"
+  };
+  var STORAGE_KEYS = {
+    FAILED_QUEUE: "__analytics_failed_queue__",
+    CLIENT_ID: "__analytics_client_id__",
+    LANDING_PAGE: "__analytics_landing_page__",
+    REFERRER_URL: "__analytics_referrer_url__"
+  };
+  var MAX_STORAGE_ITEMS = 500;
+
+  // src/utils/index.ts
+  function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  }
+  function getTimestamp() {
+    return Date.now();
+  }
+  function isObject(value) {
+    return Object.prototype.toString.call(value) === "[object Object]";
+  }
+  function merge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        result[key] = source[key];
+      }
+    }
+    return result;
+  }
+  function generateUUID() {
+    const hex = "0123456789abcdef";
+    const template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+    return template.replace(/[xy]/g, (c2) => {
+      const r2 = Math.random() * 16 | 0;
+      const v2 = c2 === "x" ? r2 : r2 & 3 | 8;
+      return hex[v2];
+    });
+  }
+  function detectBrowser() {
+    if (typeof navigator === "undefined") return { name: "Unknown", version: "0" };
+    const ua = navigator.userAgent;
+    const edgeMatch = ua.match(/Edg\/(\d+)/);
+    if (edgeMatch) return { name: "Edge", version: edgeMatch[1] };
+    const chromeMatch = ua.match(/Chrome\/(\d+)/);
+    const safariMatch = ua.match(/Safari\/(\d+)/);
+    if (chromeMatch && !ua.includes("Edg") && !ua.includes("OPR")) {
+      return { name: "Chrome", version: chromeMatch[1] };
+    }
+    const firefoxMatch = ua.match(/Firefox\/(\d+)/);
+    if (firefoxMatch) return { name: "Firefox", version: firefoxMatch[1] };
+    const opMatch = ua.match(/OPR\/(\d+)/);
+    if (opMatch) return { name: "Opera", version: opMatch[1] };
+    if (safariMatch && !ua.includes("Chrome")) {
+      const versionMatch = ua.match(/Version\/(\d+)/);
+      return { name: "Safari", version: versionMatch ? versionMatch[1] : safariMatch[1] };
+    }
+    const ieMatch = ua.match(/(?:MSIE |Trident\/.*; rv:)(\d+)/);
+    if (ieMatch) return { name: "IE", version: ieMatch[1] };
+    return { name: "Unknown", version: "0" };
+  }
+  function detectOS() {
+    if (typeof navigator === "undefined") return { name: "Unknown", version: "0" };
+    const ua = navigator.userAgent;
+    const platform = navigator.platform || "";
+    if (ua.includes("Windows NT 10")) return { name: "Windows", version: "10" };
+    if (ua.includes("Windows NT 6.3")) return { name: "Windows", version: "8.1" };
+    if (ua.includes("Windows NT 6.2")) return { name: "Windows", version: "8" };
+    if (ua.includes("Windows NT 6.1")) return { name: "Windows", version: "7" };
+    if (/Windows NT \d/.test(ua)) return { name: "Windows", version: ua.match(/Windows NT (\d+\.?\d*)/)?.[1] || "0" };
+    const macMatch = ua.match(/Mac OS X (\d+[._]\d+)/);
+    if (macMatch) return { name: "macOS", version: macMatch[1].replace("_", ".") };
+    if (platform.startsWith("Mac")) return { name: "macOS", version: "0" };
+    if (/Android (\d+\.?\d*)/.test(ua)) return { name: "Android", version: ua.match(/Android (\d+\.?\d*)/)?.[1] || "0" };
+    if (/iPhone|iPad|iPod/.test(ua)) {
+      const iosMatch = ua.match(/OS (\d+[._]\d+)/);
+      return { name: "iOS", version: iosMatch ? iosMatch[1].replace("_", ".") : "0" };
+    }
+    if (/Linux/.test(ua) || platform.includes("Linux")) return { name: "Linux", version: "0" };
+    return { name: "Unknown", version: "0" };
+  }
+  function getDeviceType() {
+    if (typeof window === "undefined" || typeof navigator === "undefined") return "desktop";
+    const width = window.screen.width;
+    const hasTouch = navigator.maxTouchPoints > 0;
+    if (width < 768 && hasTouch) return "mobile";
+    if (width >= 768 && width <= 1024 && hasTouch) return "tablet";
+    return "desktop";
+  }
+  function getScreenSize() {
+    if (typeof window === "undefined") return { width: 0, height: 0 };
+    return {
+      width: window.screen.width,
+      height: window.screen.height
+    };
+  }
+  function getPageUrl() {
+    if (typeof window === "undefined") return "";
+    return window.location.href;
+  }
+  function getReferrer() {
+    if (typeof document === "undefined") return "";
+    return document.referrer || "";
+  }
+  function getHostname() {
+    if (typeof window === "undefined") return "";
+    return window.location.host.split(":")[0];
+  }
+  function getTimezone() {
+    try {
+      return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch {
+      return "UTC";
+    }
+  }
+  function getLanguage() {
+    if (typeof navigator === "undefined") return "en-US";
+    return navigator.language || "en-US";
+  }
+  function getCountryFromLanguage(language) {
+    const parts = language.split("-");
+    if (parts.length > 1) return parts[1].toUpperCase();
+    const langMap = {
+      zh: "CN",
+      en: "US",
+      ja: "JP",
+      ko: "KR",
+      fr: "FR",
+      de: "DE",
+      es: "ES",
+      pt: "BR",
+      ru: "RU",
+      ar: "SA"
+    };
+    return langMap[parts[0]] || parts[0].toUpperCase();
+  }
+  function parseUTMParams() {
+    if (typeof window === "undefined") return {};
+    const params = {};
+    const searchParams = new URLSearchParams(window.location.search);
+    const utmKeys = ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"];
+    for (const key of utmKeys) {
+      const value = searchParams.get(key);
+      if (value) params[key] = value;
+    }
+    return params;
+  }
+  function isBrowser() {
+    return typeof window !== "undefined" && typeof document !== "undefined";
+  }
+  function safeLocalStorageGet(key) {
+    try {
+      return localStorage.getItem(key);
+    } catch {
+      return null;
+    }
+  }
+  function safeLocalStorageSet(key, value) {
+    try {
+      localStorage.setItem(key, value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function safeLocalStorageRemove(key) {
+    try {
+      localStorage.removeItem(key);
+    } catch {
+    }
+  }
+  function safeSessionStorageGet(key) {
+    try {
+      return sessionStorage.getItem(key);
+    } catch {
+      return null;
+    }
+  }
+  function safeSessionStorageSet(key, value) {
+    try {
+      sessionStorage.setItem(key, value);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  function truncateText(text, maxLength) {
+    if (!text) return "";
+    const trimmed = text.trim().replace(/\s+/g, " ");
+    return trimmed.length > maxLength ? trimmed.substring(0, maxLength) + "..." : trimmed;
+  }
+
+  // src/core/session-manager.ts
+  var SESSION_KEY = "__analytics_session__";
+  var SESSION_DEFAULT_TIMEOUT = 30 * 60 * 1e3;
+  var SessionManager = class {
+    constructor(timeout = SESSION_DEFAULT_TIMEOUT) {
+      this.createdAt = 0;
+      this.timeout = timeout;
+      const existing = this.loadSession();
+      if (existing && !this.isExpired(existing)) {
+        this.sessionId = existing.sessionId;
+        this.createdAt = existing.createdAt;
+      } else {
+        this.sessionId = this.createNewSession();
+        this.createdAt = Date.now();
+      }
+    }
+    getSessionId() {
+      if (this.isExpired({ sessionId: this.sessionId, createdAt: this.createdAt })) {
+        this.sessionId = this.createNewSession();
+      }
+      return this.sessionId;
+    }
+    refresh() {
+      this.sessionId = this.createNewSession();
+    }
+    loadSession() {
+      try {
+        const raw = safeSessionStorageGet(SESSION_KEY);
+        if (!raw) return null;
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    }
+    saveSession() {
+      const data = {
+        sessionId: this.sessionId,
+        createdAt: this.createdAt
+      };
+      safeSessionStorageSet(SESSION_KEY, JSON.stringify(data));
+    }
+    isExpired(data) {
+      return Date.now() - data.createdAt > this.timeout;
+    }
+    createNewSession() {
+      const id = generateUUID();
+      this.createdAt = Date.now();
+      this.saveSession();
+      return id;
+    }
+  };
+
+  // src/core/sender.ts
+  var Sender = class _Sender {
+    static async send(payload, serverUrl, apiKey) {
+      if (_Sender.supportsKeepalive()) {
+        return _Sender.fetchSend(payload, serverUrl, apiKey);
+      }
+      return _Sender.xhrSend(payload, serverUrl, apiKey);
+    }
+    static async sendBeacon(payload, serverUrl, apiKey) {
+      if (typeof navigator === "undefined" || !navigator.sendBeacon) {
+        throw new Error("sendBeacon not available");
+      }
+      const url = _Sender.buildBeaconUrl(serverUrl, apiKey);
+      const blob = new Blob([JSON.stringify(payload)], { type: "application/json" });
+      const success = navigator.sendBeacon(url, blob);
+      if (!success) {
+        throw new Error("sendBeacon rejected payload");
+      }
+    }
+    static async fetchSend(payload, serverUrl, apiKey) {
+      const response = await fetch(serverUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          apiKey
+        },
+        body: JSON.stringify(payload),
+        keepalive: true
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+    }
+    static async xhrSend(payload, serverUrl, apiKey) {
+      return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.open("POST", serverUrl);
+        xhr.setRequestHeader("Content-Type", "application/json");
+        xhr.setRequestHeader("apiKey", apiKey);
+        xhr.timeout = 1e4;
+        xhr.onload = () => {
+          if (xhr.status >= 200 && xhr.status < 300) {
+            resolve();
+          } else {
+            reject(new Error(`HTTP ${xhr.status}: ${xhr.statusText}`));
+          }
+        };
+        xhr.onerror = () => reject(new Error("XHR network error"));
+        xhr.ontimeout = () => reject(new Error("XHR timeout"));
+        xhr.send(JSON.stringify(payload));
+      });
+    }
+    static supportsKeepalive() {
+      try {
+        return typeof Request !== "undefined" && "keepalive" in Request.prototype;
+      } catch {
+        return false;
+      }
+    }
+    static buildBeaconUrl(serverUrl, apiKey) {
+      const separator = serverUrl.includes("?") ? "&" : "?";
+      return `${serverUrl}${separator}apiKey=${encodeURIComponent(apiKey)}`;
+    }
+  };
+
+  // src/core/storage.ts
+  var StorageQueue = class _StorageQueue {
+    static enqueue(event) {
+      try {
+        const queue = _StorageQueue.readQueue();
+        queue.push({ event, storedAt: Date.now() });
+        while (queue.length > MAX_STORAGE_ITEMS) {
+          queue.shift();
+        }
+        safeLocalStorageSet(STORAGE_KEYS.FAILED_QUEUE, JSON.stringify(queue));
+      } catch {
+      }
+    }
+    static recover() {
+      try {
+        const queue = _StorageQueue.readQueue();
+        _StorageQueue.clear();
+        const events = queue.map((item) => item.event);
+        return events;
+      } catch {
+        return [];
+      }
+    }
+    static clear() {
+      safeLocalStorageRemove(STORAGE_KEYS.FAILED_QUEUE);
+    }
+    static getQueueSize() {
+      return _StorageQueue.readQueue().length;
+    }
+    static readQueue() {
+      try {
+        const raw = safeLocalStorageGet(STORAGE_KEYS.FAILED_QUEUE);
+        if (!raw) return [];
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) return [];
+        return parsed;
+      } catch {
+        return [];
+      }
+    }
+  };
+
+  // src/core/context-collector.ts
+  function collectContext(appKey, merchantLanguage, clientType) {
+    const screen = getScreenSize();
+    return {
+      sdk_version: SDK_VERSION,
+      app_key: appKey,
+      screen_width: screen.width,
+      screen_height: screen.height,
+      user_agent: isBrowser() ? navigator.userAgent : "",
+      referrer: getReferrer(),
+      hostname: getHostname(),
+      browser: detectBrowser(),
+      operating_system: detectOS(),
+      device_type: getDeviceType(),
+      country: getCountryFromLanguage(getLanguage()),
+      language: getLanguage(),
+      merchant_language: merchantLanguage,
+      timezone: getTimezone(),
+      client_type: clientType
+    };
+  }
+  function collectMarketing() {
+    if (!isBrowser()) return {};
+    const utm = parseUTMParams();
+    let landingPage = safeLocalStorageGet(STORAGE_KEYS.LANDING_PAGE);
+    if (!landingPage) {
+      landingPage = window.location.href;
+      safeLocalStorageSet(STORAGE_KEYS.LANDING_PAGE, landingPage);
+    }
+    let referrerUrl = safeLocalStorageGet(STORAGE_KEYS.REFERRER_URL);
+    if (referrerUrl === null && document.referrer) {
+      referrerUrl = document.referrer;
+      safeLocalStorageSet(STORAGE_KEYS.REFERRER_URL, referrerUrl);
+    }
+    return {
+      ...utm,
+      landing_page: landingPage || window.location.href,
+      referrer_url: referrerUrl || ""
+    };
+  }
+
+  // src/core/auto-track.ts
+  var TRACK_ATTR_PREFIX = "data-track-";
+  var IGNORE_ATTR = "data-track-ignore";
+  var NAME_ATTR = "data-track-name";
+  var PROPS_ATTR = "data-track-properties";
+  function initAutoTrack(api, selector) {
+    if (typeof document === "undefined") return;
+    const handler = (e2) => {
+      try {
+        const target = e2.target;
+        if (!target) return;
+        if (shouldIgnoreElement(target)) return;
+        if (selector) {
+          const scope = document.querySelector(selector);
+          if (scope && !scope.contains(target)) return;
+        }
+        const eventName = getTrackName(target);
+        const properties = collectElementProperties(target);
+        api.track(eventName, properties);
+      } catch {
+      }
+    };
+    document.addEventListener("click", handler, true);
+  }
+  function shouldIgnoreElement(element) {
+    let current = element;
+    while (current) {
+      if (current.hasAttribute(IGNORE_ATTR)) return true;
+      current = current.parentElement;
+    }
+    return false;
+  }
+  function getTrackName(element) {
+    const name = element.getAttribute(NAME_ATTR);
+    if (name) return name;
+    const id = element.id ? `_${element.id}` : "";
+    const tag = element.tagName.toLowerCase();
+    return `click_${tag}${id}`;
+  }
+  function collectElementProperties(element) {
+    const props = {
+      action: "click",
+      target_type: inferTargetType(element),
+      target_id: getTargetId(element),
+      target_tag: element.tagName.toLowerCase(),
+      target_class: getTruncatedClassName(element),
+      target_text: truncateText(element.innerText || "", 50)
+    };
+    if (element.hasAttribute("href") || element.closest("a")) {
+      const anchor = element.closest("a");
+      if (anchor) {
+        props.target_href = anchor.getAttribute("href") || "";
+      }
+    }
+    const customProps = collectDataTrackProps(element);
+    Object.assign(props, customProps);
+    return props;
+  }
+  function inferTargetType(element) {
+    const tag = element.tagName.toLowerCase();
+    if (tag === "a" || tag === "button") return "button";
+    if (tag === "input") {
+      const type = element.type;
+      if (type === "submit" || type === "button" || type === "reset") return "button";
+      if (type === "checkbox" || type === "radio") return "checkbox";
+      return "input";
+    }
+    if (tag === "select") return "select";
+    if (tag === "img") return "image";
+    if (tag === "form") return "form";
+    if (tag === "textarea") return "input";
+    return "element";
+  }
+  function getTargetId(element) {
+    if (element.id) return element.id;
+    const name = element.getAttribute("name");
+    if (name) return name;
+    const dataTestId = element.getAttribute("data-testid") || element.getAttribute("data-test-id");
+    if (dataTestId) return dataTestId;
+    return "";
+  }
+  function getTruncatedClassName(element) {
+    const cls = typeof element.className === "string" ? element.className : "";
+    return truncateText(cls, 100);
+  }
+  function collectDataTrackProps(element) {
+    const props = {};
+    const trackName = element.getAttribute(NAME_ATTR);
+    if (trackName) props.name = trackName;
+    const rawProps = element.getAttribute(PROPS_ATTR);
+    if (rawProps) {
+      try {
+        const parsed = JSON.parse(rawProps);
+        Object.assign(props, parsed);
+      } catch {
+      }
+    }
+    for (const attr of Array.from(element.attributes)) {
+      if (attr.name.startsWith(TRACK_ATTR_PREFIX) && attr.name !== NAME_ATTR && attr.name !== PROPS_ATTR && attr.name !== IGNORE_ATTR) {
+        const key = attr.name.replace(TRACK_ATTR_PREFIX, "");
+        props[key] = attr.value;
+      }
+    }
+    return props;
+  }
+
+  // src/core/error-monitor.ts
+  function initErrorMonitor(api) {
+    if (typeof window === "undefined") return;
+    window.addEventListener("error", (event) => {
+      try {
+        const { message, filename, lineno, colno, error } = event;
+        const isResourceError = !message && event.target !== window;
+        if (isResourceError) return;
+        api.track("error_event", {
+          action: "error",
+          target_type: "system",
+          error_type: "window_error",
+          error_message: message || "Unknown error",
+          error_filename: filename || "",
+          error_lineno: lineno || 0,
+          error_colno: colno || 0,
+          error_stack: error instanceof Error ? error.stack : "",
+          error_name: error instanceof Error ? error.name : ""
+        });
+      } catch {
+      }
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+      try {
+        const { reason } = event;
+        let errorMessage = "Unhandled Promise Rejection";
+        let errorStack = "";
+        let errorName = "PromiseRejection";
+        if (reason instanceof Error) {
+          errorMessage = reason.message;
+          errorStack = reason.stack || "";
+          errorName = reason.name;
+        } else if (typeof reason === "string") {
+          errorMessage = reason;
+        } else {
+          try {
+            errorMessage = JSON.stringify(reason);
+          } catch {
+            errorMessage = String(reason);
+          }
+        }
+        api.track("error_event", {
+          action: "error",
+          target_type: "system",
+          error_type: "unhandled_rejection",
+          error_message: errorMessage,
+          error_stack: errorStack,
+          error_name: errorName
+        });
+      } catch {
+      }
+    });
+  }
+
+  // src/core/ga-loader.ts
+  function loadGtagScript(measurementId) {
+    return new Promise((resolve, reject) => {
+      if (typeof window !== "undefined" && typeof window.gtag === "function") {
+        resolve();
+        return;
+      }
+      const script = document.createElement("script");
+      script.async = true;
+      script.src = `https://www.googletagmanager.com/gtag/js?id=${measurementId}`;
+      script.onload = () => resolve();
+      script.onerror = () => reject(new Error("Failed to load gtag.js"));
+      document.head.appendChild(script);
+    });
+  }
+  async function initGA(config) {
+    if (!config.enabled || !config.measurementId) return;
+    if (typeof window === "undefined") return;
+    await loadGtagScript(config.measurementId);
+    window.dataLayer = window.dataLayer || [];
+    window.gtag = function gtag(...args) {
+      window.dataLayer.push(args);
+    };
+    window.gtag("js", /* @__PURE__ */ new Date());
+    window.gtag("config", config.measurementId, {
+      send_page_view: config.sendPageView ?? false,
+      debug_mode: config.debugMode ?? false
+    });
+  }
+
+  // node_modules/web-vitals/dist/web-vitals.js
+  var e = -1;
+  var t = (t2) => {
+    addEventListener("pageshow", (n2) => {
+      n2.persisted && (e = n2.timeStamp, t2(n2));
+    }, true);
+  };
+  var n = (e2, t2, n2, i2) => {
+    let s2, o2;
+    return (r2) => {
+      t2.value >= 0 && (r2 || i2) && (o2 = t2.value - (s2 ?? 0), (o2 || void 0 === s2) && (s2 = t2.value, t2.delta = o2, t2.rating = ((e3, t3) => e3 > t3[1] ? "poor" : e3 > t3[0] ? "needs-improvement" : "good")(t2.value, n2), e2(t2)));
+    };
+  };
+  var i = (e2) => {
+    requestAnimationFrame(() => requestAnimationFrame(e2));
+  };
+  var s = () => {
+    const e2 = performance.getEntriesByType("navigation")[0];
+    if (e2 && e2.responseStart > 0 && e2.responseStart < performance.now()) return e2;
+  };
+  var o = () => s()?.activationStart ?? 0;
+  var r = (t2, n2 = -1) => {
+    const i2 = s();
+    let r2 = "navigate";
+    e >= 0 ? r2 = "back-forward-cache" : i2 && (document.prerendering || o() > 0 ? r2 = "prerender" : document.wasDiscarded ? r2 = "restore" : i2.type && (r2 = i2.type.replace(/_/g, "-")));
+    return { name: t2, value: n2, rating: "good", delta: 0, entries: [], id: `v5-${Date.now()}-${Math.floor(8999999999999 * Math.random()) + 1e12}`, navigationType: r2 };
+  };
+  var c = /* @__PURE__ */ new WeakMap();
+  function a(e2, t2) {
+    return c.get(e2) || c.set(e2, new t2()), c.get(e2);
+  }
+  var d = class {
+    t;
+    i = 0;
+    o = [];
+    h(e2) {
+      if (e2.hadRecentInput) return;
+      const t2 = this.o[0], n2 = this.o.at(-1);
+      this.i && t2 && n2 && e2.startTime - n2.startTime < 1e3 && e2.startTime - t2.startTime < 5e3 ? (this.i += e2.value, this.o.push(e2)) : (this.i = e2.value, this.o = [e2]), this.t?.(e2);
+    }
+  };
+  var h = (e2, t2, n2 = {}) => {
+    try {
+      if (PerformanceObserver.supportedEntryTypes.includes(e2)) {
+        const i2 = new PerformanceObserver((e3) => {
+          queueMicrotask(() => {
+            t2(e3.getEntries());
+          });
+        });
+        return i2.observe({ type: e2, buffered: true, ...n2 }), i2;
+      }
+    } catch {
+    }
+  };
+  var f = (e2) => {
+    let t2 = false;
+    return () => {
+      t2 || (e2(), t2 = true);
+    };
+  };
+  var l = -1;
+  var u = /* @__PURE__ */ new Set();
+  var m = () => "hidden" !== document.visibilityState || document.prerendering ? 1 / 0 : 0;
+  var g = (e2) => {
+    if ("hidden" === document.visibilityState) {
+      if ("visibilitychange" === e2.type) for (const e3 of u) e3();
+      isFinite(l) || (l = "visibilitychange" === e2.type ? e2.timeStamp : 0, removeEventListener("prerenderingchange", g, true));
+    }
+  };
+  var p = () => {
+    if (l < 0) {
+      const e2 = o(), n2 = document.prerendering ? void 0 : globalThis.performance.getEntriesByType("visibility-state").find((t2) => "hidden" === t2.name && t2.startTime >= e2)?.startTime;
+      l = n2 ?? m(), addEventListener("visibilitychange", g, true), addEventListener("prerenderingchange", g, true), t(() => {
+        setTimeout(() => {
+          l = m();
+        });
+      });
+    }
+    return { get firstHiddenTime() {
+      return l;
+    }, onHidden(e2) {
+      u.add(e2);
+    } };
+  };
+  var v = (e2) => {
+    document.prerendering ? addEventListener("prerenderingchange", e2, true) : e2();
+  };
+  var y = [1800, 3e3];
+  var T = (e2, s2 = {}) => {
+    v(() => {
+      const c2 = p();
+      let a2, d2 = r("FCP");
+      const f2 = h("paint", (e3) => {
+        for (const t2 of e3) "first-contentful-paint" === t2.name && (f2.disconnect(), t2.startTime < c2.firstHiddenTime && (d2.value = Math.max(t2.startTime - o(), 0), d2.entries.push(t2), a2(true)));
+      });
+      f2 && (a2 = n(e2, d2, y, s2.reportAllChanges), t((t2) => {
+        d2 = r("FCP"), a2 = n(e2, d2, y, s2.reportAllChanges), i(() => {
+          d2.value = performance.now() - t2.timeStamp, a2(true);
+        });
+      }));
+    });
+  };
+  var E = [0.1, 0.25];
+  var b = (e2, s2 = {}) => {
+    const o2 = p();
+    T(f(() => {
+      let c2, f2 = r("CLS", 0);
+      const l2 = a(s2, d), u2 = (e3) => {
+        for (const t2 of e3) l2.h(t2);
+        l2.i > f2.value && (f2.value = l2.i, f2.entries = l2.o, c2());
+      }, m2 = h("layout-shift", u2);
+      m2 && (c2 = n(e2, f2, E, s2.reportAllChanges), o2.onHidden(() => {
+        u2(m2.takeRecords()), c2(true);
+      }), t(() => {
+        l2.i = 0, f2 = r("CLS", 0), c2 = n(e2, f2, E, s2.reportAllChanges), i(c2);
+      }), setTimeout(c2));
+    }));
+  };
+  var L = 0;
+  var P = 1 / 0;
+  var _ = 0;
+  var M = (e2) => {
+    for (const t2 of e2) t2.interactionId && (P = Math.min(P, t2.interactionId), _ = Math.max(_, t2.interactionId), L = _ ? (_ - P) / 7 + 1 : 0);
+  };
+  var w;
+  var C = () => w ? L : performance.interactionCount ?? 0;
+  var I = () => {
+    "interactionCount" in performance || w || (w = h("event", M, { durationThreshold: 0 }));
+  };
+  var F = 0;
+  var k = class {
+    l = [];
+    u = /* @__PURE__ */ new Map();
+    m;
+    p;
+    v() {
+      F = C(), this.l.length = 0, this.u.clear();
+    }
+    T() {
+      const e2 = Math.min(this.l.length - 1, Math.floor((C() - F) / 50));
+      return this.l[e2];
+    }
+    h(e2) {
+      if (this.m?.(e2), !e2.interactionId && "first-input" !== e2.entryType) return;
+      const t2 = this.l.at(-1);
+      let n2 = this.u.get(e2.interactionId);
+      if (n2 || this.l.length < 10 || e2.duration > t2.L) {
+        if (n2 ? e2.duration > n2.L ? (n2.entries = [e2], n2.L = e2.duration) : e2.duration === n2.L && e2.startTime === n2.entries[0].startTime && n2.entries.push(e2) : (n2 = { id: e2.interactionId, entries: [e2], L: e2.duration }, this.u.set(n2.id, n2), this.l.push(n2)), this.l.sort((e3, t3) => t3.L - e3.L), this.l.length > 10) {
+          const e3 = this.l.splice(10);
+          for (const t3 of e3) this.u.delete(t3.id);
+        }
+        this.p?.(n2);
+      }
+    }
+  };
+  var A = (e2) => {
+    const t2 = globalThis.requestIdleCallback || setTimeout, n2 = globalThis.cancelIdleCallback || clearTimeout;
+    if ("hidden" === document.visibilityState) e2();
+    else {
+      const i2 = f(e2);
+      let s2 = -1;
+      const o2 = () => {
+        n2(s2), i2();
+      };
+      addEventListener("visibilitychange", o2, { once: true, capture: true }), s2 = t2(() => {
+        removeEventListener("visibilitychange", o2, { capture: true }), i2();
+      });
+    }
+  };
+  var B = [200, 500];
+  var S = (e2, i2 = {}) => {
+    if (!globalThis.PerformanceEventTiming || !("interactionId" in PerformanceEventTiming.prototype)) return;
+    const s2 = p();
+    v(() => {
+      I();
+      let o2, c2 = r("INP");
+      const d2 = a(i2, k), f2 = (e3) => {
+        A(() => {
+          for (const t3 of e3) d2.h(t3);
+          const t2 = d2.T();
+          t2 && t2.L !== c2.value && (c2.value = t2.L, c2.entries = t2.entries, o2());
+        });
+      }, l2 = h("event", f2, { durationThreshold: i2.durationThreshold ?? 40 });
+      o2 = n(e2, c2, B, i2.reportAllChanges), l2 && (l2.observe({ type: "first-input", buffered: true }), s2.onHidden(() => {
+        f2(l2.takeRecords()), o2(true);
+      }), t(() => {
+        d2.v(), c2 = r("INP"), o2 = n(e2, c2, B, i2.reportAllChanges);
+      }));
+    });
+  };
+  var q = class {
+    m;
+    h(e2) {
+      this.m?.(e2);
+    }
+  };
+  var N = [2500, 4e3];
+  var x = (e2, s2 = {}) => {
+    v(() => {
+      const c2 = p();
+      let d2, l2 = r("LCP");
+      const u2 = a(s2, q), m2 = (e3) => {
+        s2.reportAllChanges || (e3 = e3.slice(-1));
+        for (const t2 of e3) u2.h(t2), t2.startTime < c2.firstHiddenTime && (l2.value = Math.max(t2.startTime - o(), 0), l2.entries = [t2], d2());
+      }, g2 = h("largest-contentful-paint", m2);
+      if (g2) {
+        d2 = n(e2, l2, N, s2.reportAllChanges);
+        const o2 = f(() => {
+          m2(g2.takeRecords()), g2.disconnect(), d2(true);
+        }), c3 = (e3) => {
+          e3.isTrusted && (A(o2), removeEventListener(e3.type, c3, { capture: true }));
+        };
+        for (const e3 of ["keydown", "click", "visibilitychange"]) addEventListener(e3, c3, { capture: true });
+        t((t2) => {
+          l2 = r("LCP"), d2 = n(e2, l2, N, s2.reportAllChanges), i(() => {
+            l2.value = performance.now() - t2.timeStamp, d2(true);
+          });
+        });
+      }
+    });
+  };
+  var H = [800, 1800];
+  var O = (e2) => {
+    document.prerendering ? v(() => O(e2)) : "complete" !== document.readyState ? addEventListener("load", () => O(e2), true) : setTimeout(e2);
+  };
+  var $ = (e2, i2 = {}) => {
+    let c2 = r("TTFB"), a2 = n(e2, c2, H, i2.reportAllChanges);
+    O(() => {
+      const d2 = s();
+      d2 && (c2.value = Math.max(d2.responseStart - o(), 0), c2.entries = [d2], a2(true), t(() => {
+        c2 = r("TTFB", 0), a2 = n(e2, c2, H, i2.reportAllChanges), a2(true);
+      }));
+    });
+  };
+
+  // src/core/performance-monitor.ts
+  function normalize(value, isCLS) {
+    if (isCLS) {
+      return Math.round(value * 1e4) / 1e4;
+    }
+    return Math.round(value);
+  }
+  function reportMetric(api, metric) {
+    const isCLS = metric.name === "CLS";
+    const properties = {
+      action: "metric",
+      target_type: "performance",
+      metric_name: metric.name,
+      metric_value: normalize(metric.value, isCLS),
+      metric_rating: metric.rating,
+      delta: normalize(metric.delta, isCLS),
+      metric_id: metric.id,
+      navigation_type: metric.navigationType
+    };
+    if (metric.name === "LCP") {
+      const entry = metric.entries[metric.entries.length - 1];
+      if (entry) {
+        properties.lcp_element = entry.element?.tagName?.toLowerCase() || "";
+        properties.lcp_url = entry.url || "";
+        properties.lcp_size = entry.size;
+      }
+    }
+    api.track("web_vital", properties);
+  }
+  function initPerformanceMonitor(api, config = {}) {
+    if (config.enabled === false) return;
+    try {
+      x((metric) => reportMetric(api, metric));
+      T((metric) => reportMetric(api, metric));
+      b((metric) => reportMetric(api, metric));
+      S((metric) => reportMetric(api, metric));
+      $((metric) => reportMetric(api, metric));
+    } catch {
+    }
+  }
+
+  // src/core/ga-adapter.ts
+  function trackToGA(eventName, properties, options) {
+    if (typeof window === "undefined" || !window.gtag) return;
+    const params = {
+      session_id: options.sessionId,
+      engagement_time_msec: 100,
+      page_location: options.pageUrl,
+      page_referrer: options.referrer
+    };
+    const { marketing, userId } = options;
+    if (marketing.utm_source) params.utm_source = marketing.utm_source;
+    if (marketing.utm_medium) params.utm_medium = marketing.utm_medium;
+    if (marketing.utm_campaign) params.utm_campaign = marketing.utm_campaign;
+    if (marketing.utm_term) params.utm_term = marketing.utm_term;
+    if (marketing.utm_content) params.utm_content = marketing.utm_content;
+    if (userId) params.user_id = userId;
+    Object.assign(params, properties);
+    window.gtag("event", eventName, params);
+  }
+  function setGAUserId(userId) {
+    if (typeof window === "undefined" || !window.gtag) return;
+    window.gtag("set", { user_id: userId ?? void 0 });
+  }
+  function setGAUserProperties(properties) {
+    if (typeof window === "undefined" || !window.gtag) return;
+    window.gtag("set", "user_properties", properties);
+  }
+
+  // src/core/ga-manager.ts
+  var GAManager = class {
+    constructor() {
+      this._initialized = false;
+    }
+    get ready() {
+      return this._initialized && typeof window !== "undefined" && typeof window.gtag === "function";
+    }
+    get measurementId() {
+      return this._measurementId;
+    }
+    track(eventName, properties) {
+      if (!this.ready) return;
+      window.gtag("event", eventName, properties ?? {});
+    }
+    setUserId(userId) {
+      if (!this.ready) return;
+      window.gtag("set", { user_id: userId ?? void 0 });
+    }
+    setUserProperties(properties) {
+      if (!this.ready) return;
+      window.gtag("set", "user_properties", properties);
+    }
+    set(keyOrParams, value) {
+      if (!this.ready) return;
+      if (typeof keyOrParams === "string") {
+        window.gtag("set", keyOrParams, value);
+      } else {
+        window.gtag("set", keyOrParams);
+      }
+    }
+    config(params) {
+      if (!this.ready || !this._measurementId) return;
+      window.gtag("config", this._measurementId, params ?? {});
+    }
+    consent(mode, params) {
+      if (!this.ready) return;
+      window.gtag("consent", mode, params);
+    }
+    get(key, callback) {
+      if (!this.ready || !this._measurementId) return;
+      window.gtag("get", this._measurementId, key, callback);
+    }
+    gtag(...args) {
+      if (typeof window === "undefined" || !window.gtag) return;
+      window.gtag(...args);
+    }
+    _init(measurementId) {
+      this._measurementId = measurementId;
+      this._initialized = true;
+    }
+    _destroy() {
+      this._initialized = false;
+      this._measurementId = void 0;
+    }
+  };
+
+  // src/core/analytics.ts
+  var globalBatchCounter = 0;
+  var Analytics = class {
+    constructor(config) {
+      this.buffer = [];
+      this.bufferTimer = null;
+      this.userId = null;
+      this.userProps = {};
+      this.initialized = false;
+      this.retrying = 0;
+      this.gaInitialized = false;
+      this.ga = new GAManager();
+      this.config = {
+        debug: false,
+        autoTrack: true,
+        bufferFlushInterval: DEFAULT_CONFIG.bufferFlushInterval,
+        bufferMaxSize: DEFAULT_CONFIG.bufferMaxSize,
+        maxRetryCount: DEFAULT_CONFIG.maxRetryCount,
+        ...config
+      };
+      const appKey = this.config.appKey || this.config.appId || "unknown";
+      if (this.config.appId) this.config.appKey = appKey;
+      this.clientId = this.getOrCreateClientId();
+      this.merchantLang = DEFAULT_CONFIG.merchantLanguage;
+      this.clientType = DEFAULT_CONFIG.clientType;
+      this.batchPageId = this.generateBatchPageId();
+      this.sessionManager = new SessionManager(this.config.sessionTimeout);
+      if (isBrowser()) {
+        this.recoverFailedEvents();
+      }
+      this.registerBeforeUnload();
+      if (this.config.autoTrack && isBrowser()) {
+        initAutoTrack(this, this.config.autoTrackSelector);
+      }
+      if (isBrowser()) {
+        initErrorMonitor(this);
+      }
+      if (isBrowser() && this.config.performance?.enabled !== false) {
+        initPerformanceMonitor(this, this.config.performance);
+      }
+      if (isBrowser() && this.config.ga?.enabled) {
+        this.ga._init(this.config.ga.measurementId);
+        initGA(this.config.ga).then(() => {
+          this.gaInitialized = true;
+          this.log("GA4 initialized with measurementId:", this.config.ga?.measurementId);
+        }).catch((error) => {
+          this.ga._destroy();
+          this.log("Failed to initialize GA4:", error);
+        });
+      }
+      this.initialized = true;
+      this.log("Analytics SDK initialized", {
+        appKey: this.config.appKey,
+        clientId: this.clientId,
+        sessionId: this.sessionManager.getSessionId()
+      });
+      if (isBrowser()) {
+        this.trackPageView();
+      }
+    }
+    track(eventName, properties, options) {
+      if (!eventName || typeof eventName !== "string") {
+        this.log("Invalid event name");
+        return;
+      }
+      const normalizedProps = properties && isObject(properties) ? properties : {};
+      const isKeyEvent = options?.keyEvent === true || this.isKeyEvent(eventName);
+      if (this.gaInitialized) {
+        trackToGA(eventName, normalizedProps, {
+          sessionId: this.sessionManager.getSessionId(),
+          pageUrl: isBrowser() ? getPageUrl() : "",
+          referrer: isBrowser() ? document.referrer : "",
+          marketing: collectMarketing(),
+          userId: this.userId
+        });
+      }
+      const event = {
+        event_id: generateUUID(),
+        event_name: eventName,
+        batch_event_index: 0,
+        batch_ordering_id: this.generateBatchOrderingId(),
+        batch_page_id: this.batchPageId,
+        timestamp: getTimestamp(),
+        key_event: isKeyEvent,
+        event_properties: this.buildEventProperties(normalizedProps)
+      };
+      if (isKeyEvent) {
+        this.flushKeyEvent(event);
+        return;
+      }
+      this.buffer.push(event);
+      this.scheduleBufferFlush();
+      if (this.buffer.length >= this.config.bufferMaxSize) {
+        this.flushBuffer();
+      }
+    }
+    identify(userId, attributes) {
+      const wasAnonymous = !this.userId;
+      this.userId = userId;
+      if (attributes && isObject(attributes)) {
+        this.userProps = attributes;
+      }
+      if (this.gaInitialized) {
+        setGAUserId(userId);
+        if (attributes && isObject(attributes)) {
+          setGAUserProperties(attributes);
+        }
+      }
+      this.log("User identified:", { userId, attributes });
+      if (wasAnonymous && this.buffer.length > 0) {
+        this.flushBuffer();
+      }
+    }
+    setMerchantLanguage(language) {
+      this.merchantLang = language;
+    }
+    setClientType(clientType) {
+      this.clientType = clientType;
+    }
+    reset() {
+      this.userId = null;
+      this.userProps = {};
+      this.buffer = [];
+      if (this.bufferTimer) {
+        clearTimeout(this.bufferTimer);
+        this.bufferTimer = null;
+      }
+      if (this.gaInitialized) {
+        setGAUserId(null);
+      }
+      this.log("Analytics reset");
+    }
+    getUserProfile() {
+      return {
+        userId: this.userId ?? void 0,
+        anonymousId: this.clientId,
+        attributes: this.userProps
+      };
+    }
+    getSessionId() {
+      return this.sessionManager.getSessionId();
+    }
+    getClientId() {
+      return this.clientId;
+    }
+    flush() {
+      this.flushBuffer();
+    }
+    log(...args) {
+      if (this.config.debug) {
+        console.log("[Analytics]", ...args);
+      }
+    }
+    getOrCreateClientId() {
+      if (!isBrowser()) return generateUUID();
+      let clientId = safeLocalStorageGet(STORAGE_KEYS.CLIENT_ID);
+      if (!clientId) {
+        clientId = generateUUID();
+        safeLocalStorageSet(STORAGE_KEYS.CLIENT_ID, clientId);
+      }
+      return clientId;
+    }
+    resolveApiKey() {
+      if (this.config.apiKey) return this.config.apiKey;
+      if (this.config.env) {
+        const key = API_KEY_MAP[this.config.env];
+        if (key) return key;
+      }
+      return "";
+    }
+    isKeyEvent(eventName) {
+      if (!this.config.keyEvents || this.config.keyEvents.length === 0) return false;
+      return this.config.keyEvents.includes(eventName);
+    }
+    generateBatchPageId() {
+      return `${getTimestamp().toString(36)}-${generateId().split("-")[1] || Math.random().toString(36).slice(2, 9)}`;
+    }
+    generateBatchOrderingId() {
+      globalBatchCounter += 1;
+      return `${getTimestamp()}-${globalBatchCounter}`;
+    }
+    buildEventProperties(properties) {
+      const defaults = {
+        system: this.config.system || "",
+        domain: this.config.domain || "",
+        scene: "",
+        action: "",
+        target_type: "",
+        target_id: "",
+        page_url: isBrowser() ? getPageUrl() : ""
+      };
+      const merged = {};
+      for (const key of Object.keys(defaults)) {
+        const k2 = key;
+        if (defaults[k2] !== void 0) {
+          merged[k2] = defaults[k2];
+        }
+      }
+      for (const key of Object.keys(properties)) {
+        merged[key] = properties[key];
+      }
+      return merged;
+    }
+    scheduleBufferFlush() {
+      if (this.bufferTimer) return;
+      this.bufferTimer = setTimeout(() => {
+        this.flushBuffer();
+      }, this.config.bufferFlushInterval);
+    }
+    flushBuffer() {
+      if (this.bufferTimer) {
+        clearTimeout(this.bufferTimer);
+        this.bufferTimer = null;
+      }
+      if (this.buffer.length === 0) return;
+      const events = this.buffer.splice(0, this.buffer.length);
+      events.forEach((e2, i2) => {
+        e2.batch_event_index = i2;
+      });
+      this.log(`Flushing ${events.length} events`);
+      this.sendBatch(events, 0);
+    }
+    flushKeyEvent(event) {
+      this.log("Flushing key event:", event.event_name);
+      this.sendBatch([event], 0);
+    }
+    async sendBatch(events, retryCount) {
+      if (events.length === 0) return;
+      const apiKey = this.resolveApiKey();
+      if (!apiKey) {
+        this.log("No API key configured, dropping events");
+        for (const event of events) {
+          StorageQueue.enqueue(event);
+        }
+        return;
+      }
+      const payload = this.buildPayload(events);
+      try {
+        await Sender.send(payload, this.config.serverUrl, apiKey);
+        this.log(`Batch sent successfully: ${events.length} events`);
+      } catch (error) {
+        this.log(`Batch send failed (attempt ${retryCount + 1}/${this.config.maxRetryCount + 1}):`, error);
+        if (retryCount < this.config.maxRetryCount) {
+          const delay = 1e3 * Math.pow(2, retryCount);
+          this.log(`Retrying in ${delay}ms...`);
+          this.retrying += 1;
+          setTimeout(() => {
+            this.retrying -= 1;
+            this.sendBatch(events, retryCount + 1);
+          }, delay);
+        } else {
+          this.log("Max retries reached, persisting events to localStorage");
+          for (const event of events) {
+            StorageQueue.enqueue(event);
+          }
+        }
+      }
+    }
+    buildPayload(events) {
+      return {
+        client_id: this.clientId,
+        user_id: this.userId || "",
+        session_id: this.sessionManager.getSessionId(),
+        user_properties: Object.keys(this.userProps).length > 0 ? this.userProps : void 0,
+        context: collectContext(this.config.appKey || this.config.appId || "unknown", this.merchantLang, this.clientType),
+        marketing: collectMarketing(),
+        events
+      };
+    }
+    recoverFailedEvents() {
+      const failedEvents = StorageQueue.recover();
+      if (failedEvents.length > 0) {
+        this.log(`Recovered ${failedEvents.length} failed events from storage`);
+        for (const event of failedEvents) {
+          event.batch_ordering_id = this.generateBatchOrderingId();
+          event.batch_page_id = this.batchPageId;
+          event.batch_event_index = 0;
+        }
+        const batchSize = this.config.bufferMaxSize;
+        for (let i2 = 0; i2 < failedEvents.length; i2 += batchSize) {
+          const batch = failedEvents.slice(i2, i2 + batchSize);
+          batch.forEach((e2, idx) => {
+            e2.batch_event_index = idx;
+          });
+          this.sendBatch(batch, 0);
+        }
+      }
+    }
+    registerBeforeUnload() {
+      if (!isBrowser()) return;
+      const handler = () => {
+        if (this.buffer.length === 0) return;
+        const events = this.buffer.splice(0, this.buffer.length);
+        events.forEach((e2, i2) => {
+          e2.batch_event_index = i2;
+        });
+        const apiKey = this.resolveApiKey();
+        if (!apiKey) return;
+        const payload = this.buildPayload(events);
+        try {
+          if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+            const url = `${this.config.serverUrl}${this.config.serverUrl.includes("?") ? "&" : "?"}apiKey=${encodeURIComponent(apiKey)}`;
+            const blob = new Blob([JSON.stringify(payload)], { type: "application/json" });
+            const success = navigator.sendBeacon(url, blob);
+            if (!success) throw new Error("sendBeacon rejected");
+          } else {
+            try {
+              const xhr = new XMLHttpRequest();
+              xhr.open("POST", this.config.serverUrl, false);
+              xhr.setRequestHeader("Content-Type", "application/json");
+              xhr.setRequestHeader("apiKey", apiKey);
+              xhr.timeout = 2e3;
+              xhr.send(JSON.stringify(payload));
+            } catch {
+            }
+          }
+        } catch {
+          for (const event of events) {
+            StorageQueue.enqueue(event);
+          }
+        }
+      };
+      window.addEventListener("beforeunload", handler);
+      window.addEventListener("pagehide", handler);
+    }
+    trackPageView() {
+      if (!isBrowser()) return;
+      this.track("page_view", {
+        action: "view",
+        target_type: "page",
+        page_url: getPageUrl(),
+        referrer: document.referrer || ""
+      });
+    }
+  };
+  function createAnalytics(config) {
+    return new Analytics(config);
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.js.map