@visitor-analytics-sdk/core 1.0.0

package/dist/index.js

@@ -0,0 +1,1682 @@
+// src/event-bus.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const handler of set) {
+      try {
+        handler(...args);
+      } catch (_err) {
+      }
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  listenerCount(event) {
+    return this.listeners.get(event)?.size ?? 0;
+  }
+};
+
+// ../plugins/src/plugin-manager.ts
+var PluginManager = class {
+  installedPlugins = /* @__PURE__ */ new Map();
+  collectors = /* @__PURE__ */ new Map();
+  eventBus;
+  constructor(eventBus) {
+    this.eventBus = eventBus;
+  }
+  install(plugin, context) {
+    if (this.installedPlugins.has(plugin.name)) {
+      return;
+    }
+    plugin.install(context);
+    this.installedPlugins.set(plugin.name, plugin);
+    this.eventBus.emit("plugin-installed", plugin.name);
+  }
+  uninstall(pluginName, context) {
+    const plugin = this.installedPlugins.get(pluginName);
+    if (!plugin) return;
+    plugin.uninstall?.(context);
+    this.installedPlugins.delete(pluginName);
+    this.eventBus.emit("plugin-uninstalled", pluginName);
+  }
+  has(pluginName) {
+    return this.installedPlugins.has(pluginName);
+  }
+  get(pluginName) {
+    return this.installedPlugins.get(pluginName);
+  }
+  getAll() {
+    return [...this.installedPlugins.values()];
+  }
+  addCollector(collector) {
+    if (this.collectors.has(collector.name)) {
+      return;
+    }
+    this.collectors.set(collector.name, collector);
+    this.eventBus.emit("collector-registered", collector.name);
+  }
+  removeCollector(name) {
+    if (!this.collectors.has(name)) return;
+    this.collectors.delete(name);
+    this.eventBus.emit("collector-removed", name);
+  }
+  getCollectors() {
+    return [...this.collectors.values()];
+  }
+  getCollector(name) {
+    return this.collectors.get(name);
+  }
+};
+function createPluginContext(addCollector, removeCollector, eventBus, getConfig) {
+  return {
+    addCollector,
+    removeCollector,
+    on: (event, handler) => {
+      eventBus.on(event, handler);
+    },
+    off: (event, handler) => {
+      eventBus.off(event, handler);
+    },
+    getConfig
+  };
+}
+
+// ../utils/src/index.ts
+var SDK_VERSION = "1.0.0";
+function generateId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generateShortId() {
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const bytes = new Uint8Array(8);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  return generateId().replace(/-/g, "").slice(0, 16);
+}
+function safeCall(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+function requestIdle(callback, timeout = 5e3) {
+  if (typeof window !== "undefined" && "requestIdleCallback" in window) {
+    window.requestIdleCallback(callback, { timeout });
+  } else {
+    setTimeout(callback, 0);
+  }
+}
+function deepFreeze(obj) {
+  Object.freeze(obj);
+  for (const key of Object.keys(obj)) {
+    const val = obj[key];
+    if (val !== null && typeof val === "object" && !Object.isFrozen(val)) {
+      deepFreeze(val);
+    }
+  }
+  return obj;
+}
+function cloneRecord(record) {
+  return JSON.parse(JSON.stringify(record));
+}
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined" && typeof navigator !== "undefined";
+}
+
+// ../uploader/src/uploader.ts
+var DEFAULT_CONFIG = {
+  endpoint: "",
+  batchSize: 50,
+  flushInterval: 3e4,
+  maxRetries: 5,
+  retryBaseDelay: 1e3,
+  retryMaxDelay: 3e4,
+  compressionEnabled: false,
+  deduplicationEnabled: true,
+  headers: {},
+  timeout: 1e4
+};
+var Uploader = class {
+  config;
+  storage;
+  flushTimer = null;
+  retryQueue = /* @__PURE__ */ new Map();
+  retryTimer = null;
+  eventHandlers = [];
+  seenBatchIds = /* @__PURE__ */ new Set();
+  isUploading = false;
+  isStopped = false;
+  constructor(storage, config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.storage = storage;
+  }
+  start() {
+    this.isStopped = false;
+    if (this.config.flushInterval > 0) {
+      this.flushTimer = setInterval(() => {
+        requestIdle(() => this.flush());
+      }, this.config.flushInterval);
+    }
+  }
+  stop() {
+    this.isStopped = true;
+    if (this.flushTimer !== null) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.retryTimer !== null) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+    this.retryQueue.clear();
+  }
+  onEvent(handler) {
+    this.eventHandlers.push(handler);
+    return () => {
+      const idx = this.eventHandlers.indexOf(handler);
+      if (idx !== -1) this.eventHandlers.splice(idx, 1);
+    };
+  }
+  emitEvent(event) {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+  async flush() {
+    if (this.isUploading || this.isStopped) return;
+    const count = await this.storage.count();
+    if (count === 0) return;
+    this.isUploading = true;
+    try {
+      const records = await this.storage.loadBatch(this.config.batchSize);
+      if (records.length === 0) return;
+      const batchId = generateShortId();
+      const payload = {
+        records,
+        batchId,
+        timestamp: Date.now(),
+        sdkVersion: SDK_VERSION
+      };
+      if (this.config.deduplicationEnabled && this.seenBatchIds.has(batchId)) {
+        return;
+      }
+      this.seenBatchIds.add(batchId);
+      if (this.seenBatchIds.size > 1e3) {
+        const ids = [...this.seenBatchIds];
+        const toRemove = ids.slice(0, ids.length - 1e3);
+        for (const id of toRemove) {
+          this.seenBatchIds.delete(id);
+        }
+      }
+      this.emitEvent({
+        type: "batch-sent",
+        batchId,
+        recordCount: records.length,
+        timestamp: Date.now()
+      });
+      const result = await this.sendBatch(payload);
+      if (result.success) {
+        this.emitEvent({
+          type: "batch-success",
+          batchId,
+          recordCount: records.length,
+          timestamp: Date.now()
+        });
+      } else if (result.retryable) {
+        this.scheduleRetry(payload);
+      } else {
+        this.emitEvent({
+          type: "batch-failed",
+          batchId,
+          recordCount: records.length,
+          timestamp: Date.now(),
+          error: result.error
+        });
+      }
+    } finally {
+      this.isUploading = false;
+    }
+  }
+  async sendBatch(payload) {
+    if (!this.config.endpoint) {
+      return { success: false, batchId: payload.batchId, error: "No endpoint configured", retryable: false };
+    }
+    const body = this.config.compressionEnabled ? await this.compress(JSON.stringify(payload)) : JSON.stringify(payload);
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Batch-Id": payload.batchId,
+      "X-Record-Count": String(payload.records.length),
+      ...this.config.headers
+    };
+    if (this.config.compressionEnabled) {
+      headers["Content-Encoding"] = "gzip";
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(this.config.endpoint, {
+        method: "POST",
+        headers,
+        body,
+        signal: controller.signal,
+        keepalive: true
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        return { success: true, batchId: payload.batchId, statusCode: response.status, retryable: false };
+      }
+      const retryable = response.status >= 500 || response.status === 429;
+      return {
+        success: false,
+        batchId: payload.batchId,
+        statusCode: response.status,
+        error: `HTTP ${response.status}: ${response.statusText}`,
+        retryable
+      };
+    } catch (err) {
+      clearTimeout(timeoutId);
+      const error = err instanceof Error ? err.message : "Unknown error";
+      return { success: false, batchId: payload.batchId, error, retryable: true };
+    }
+  }
+  scheduleRetry(payload) {
+    const existing = this.retryQueue.get(payload.batchId);
+    const retryCount = (existing?.retryCount ?? 0) + 1;
+    if (retryCount > this.config.maxRetries) {
+      this.retryQueue.delete(payload.batchId);
+      this.emitEvent({
+        type: "batch-failed",
+        batchId: payload.batchId,
+        recordCount: payload.records.length,
+        timestamp: Date.now(),
+        error: "Max retries exceeded",
+        retryCount
+      });
+      return;
+    }
+    const delay = Math.min(
+      this.config.retryBaseDelay * Math.pow(2, retryCount - 1),
+      this.config.retryMaxDelay
+    );
+    const jitter = delay * (0.5 + Math.random() * 0.5);
+    const nextRetryAt = Date.now() + jitter;
+    this.retryQueue.set(payload.batchId, { payload, retryCount, nextRetryAt });
+    this.emitEvent({
+      type: "retry-scheduled",
+      batchId: payload.batchId,
+      recordCount: payload.records.length,
+      timestamp: Date.now(),
+      retryCount,
+      nextRetryAt
+    });
+    this.processRetryQueue();
+  }
+  processRetryQueue() {
+    if (this.retryTimer !== null) return;
+    const now = Date.now();
+    let earliest = Infinity;
+    for (const [batchId, entry] of this.retryQueue) {
+      if (entry.nextRetryAt <= now) {
+        this.retryQueue.delete(batchId);
+        this.sendBatch(entry.payload).then((result) => {
+          if (!result.success && result.retryable) {
+            this.scheduleRetry(entry.payload);
+          } else if (result.success) {
+            this.emitEvent({
+              type: "batch-success",
+              batchId: entry.payload.batchId,
+              recordCount: entry.payload.records.length,
+              timestamp: Date.now()
+            });
+          }
+        });
+      } else if (entry.nextRetryAt < earliest) {
+        earliest = entry.nextRetryAt;
+      }
+    }
+    if (earliest < Infinity) {
+      this.retryTimer = setTimeout(() => {
+        this.retryTimer = null;
+        this.processRetryQueue();
+      }, earliest - Date.now());
+    }
+  }
+  async retryFailed() {
+    const entries = [...this.retryQueue.values()];
+    this.retryQueue.clear();
+    for (const entry of entries) {
+      this.scheduleRetry(entry.payload);
+    }
+  }
+  async sync() {
+    await this.flush();
+  }
+  async compress(data) {
+    if (typeof CompressionStream === "undefined") {
+      return data;
+    }
+    try {
+      const stream = new Blob([data]).stream().pipeThrough(new CompressionStream("gzip"));
+      return new Response(stream).blob();
+    } catch {
+      return data;
+    }
+  }
+  destroy() {
+    this.stop();
+    this.retryQueue.clear();
+    this.eventHandlers = [];
+    this.seenBatchIds.clear();
+  }
+};
+
+// ../storage/src/memory-storage.ts
+var MemoryStorage = class {
+  records = [];
+  async save(record) {
+    this.records.push(cloneRecord(record));
+  }
+  async saveBatch(records) {
+    for (const record of records) {
+      this.records.push(cloneRecord(record));
+    }
+  }
+  async load() {
+    return this.records.map((r) => cloneRecord(r));
+  }
+  async loadBatch(limit) {
+    return this.records.splice(0, limit);
+  }
+  async remove(ids) {
+    const idSet = new Set(ids);
+    this.records = this.records.filter((r) => !idSet.has(r.id));
+  }
+  async count() {
+    return this.records.length;
+  }
+  async clear() {
+    this.records = [];
+  }
+  async export() {
+    return JSON.stringify(this.records);
+  }
+};
+
+// ../storage/src/localstorage-adapter.ts
+var STORAGE_KEY = "va_records";
+var LocalStorageAdapter = class {
+  key;
+  constructor(key = STORAGE_KEY) {
+    this.key = key;
+  }
+  async save(record) {
+    const records = this.readAll();
+    records.push(cloneRecord(record));
+    this.writeAll(records);
+  }
+  async saveBatch(records) {
+    const existing = this.readAll();
+    for (const record of records) {
+      existing.push(cloneRecord(record));
+    }
+    this.writeAll(existing);
+  }
+  async load() {
+    return this.readAll();
+  }
+  async loadBatch(limit) {
+    const records = this.readAll();
+    const batch = records.slice(0, limit);
+    this.writeAll(records.slice(limit));
+    return batch;
+  }
+  async remove(ids) {
+    const idSet = new Set(ids);
+    const records = this.readAll().filter((r) => !idSet.has(r.id));
+    this.writeAll(records);
+  }
+  async count() {
+    return this.readAll().length;
+  }
+  async clear() {
+    try {
+      localStorage.removeItem(this.key);
+    } catch {
+    }
+  }
+  async export() {
+    return JSON.stringify(this.readAll());
+  }
+  readAll() {
+    try {
+      const raw = localStorage.getItem(this.key);
+      if (!raw) return [];
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) return [];
+      return parsed;
+    } catch {
+      return [];
+    }
+  }
+  writeAll(records) {
+    try {
+      localStorage.setItem(this.key, JSON.stringify(records));
+    } catch {
+    }
+  }
+};
+
+// ../storage/src/indexeddb-adapter.ts
+var DB_NAME = "visitor-analytics";
+var DB_VERSION = 1;
+var STORE_NAME = "records";
+var IndexedDBAdapter = class {
+  db = null;
+  dbName;
+  storeName;
+  initPromise = null;
+  constructor(dbName = DB_NAME, storeName = STORE_NAME) {
+    this.dbName = dbName;
+    this.storeName = storeName;
+  }
+  async getDB() {
+    if (this.db) return this.db;
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = new Promise((resolve, reject) => {
+      if (typeof indexedDB === "undefined") {
+        reject(new Error("IndexedDB is not available"));
+        return;
+      }
+      const request = indexedDB.open(this.dbName, DB_VERSION);
+      request.onerror = () => {
+        this.initPromise = null;
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        this.db = request.result;
+        resolve(request.result);
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName, { keyPath: "id" });
+        }
+      };
+    }).catch((err) => {
+      this.initPromise = null;
+      throw err;
+    });
+    return this.initPromise;
+  }
+  async save(record) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      const store = tx.objectStore(this.storeName);
+      const request = store.put(cloneRecord(record));
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async saveBatch(records) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      const store = tx.objectStore(this.storeName);
+      for (const record of records) {
+        store.put(cloneRecord(record));
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async load() {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readonly");
+      const store = tx.objectStore(this.storeName);
+      const request = store.getAll();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async loadBatch(limit) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      const store = tx.objectStore(this.storeName);
+      const results = [];
+      let count = 0;
+      const cursorRequest = store.openCursor();
+      cursorRequest.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor && count < limit) {
+          results.push(cursor.value);
+          count++;
+          cursor.delete();
+          cursor.continue();
+        } else {
+          resolve(results);
+        }
+      };
+      cursorRequest.onerror = () => reject(cursorRequest.error);
+    });
+  }
+  async remove(ids) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      const store = tx.objectStore(this.storeName);
+      for (const id of ids) {
+        store.delete(id);
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async count() {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readonly");
+      const store = tx.objectStore(this.storeName);
+      const request = store.count();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async clear() {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      const store = tx.objectStore(this.storeName);
+      const request = store.clear();
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async export() {
+    const records = await this.load();
+    return JSON.stringify(records);
+  }
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      this.initPromise = null;
+    }
+  }
+};
+
+// ../storage/src/factory.ts
+var StorageAdapterFactory = class {
+  static create(type) {
+    if (typeof type === "object" && typeof type.save === "function") {
+      return type;
+    }
+    switch (type) {
+      case "memory":
+        return new MemoryStorage();
+      case "localstorage":
+        return new LocalStorageAdapter();
+      case "indexeddb":
+        return new IndexedDBAdapter();
+      default:
+        throw new Error(`Unknown storage type: ${String(type)}`);
+    }
+  }
+};
+
+// ../collectors/src/browser/browser-collector.ts
+var BrowserCollector = class {
+  name = "browser";
+  category = "browser";
+  version = SDK_VERSION;
+  enabled = true;
+  includeUserAgent;
+  constructor(options) {
+    this.includeUserAgent = options?.includeUserAgent ?? false;
+  }
+  async collect(context) {
+    const nav = context.navigator;
+    const ua = nav.userAgent;
+    const parsed = this.parseUA(ua);
+    return {
+      browser: {
+        name: parsed.name,
+        version: parsed.version,
+        engine: parsed.engine,
+        engineVersion: parsed.engineVersion,
+        userAgent: this.includeUserAgent ? ua : "",
+        language: nav.language,
+        cookiesEnabled: nav.cookieEnabled,
+        javaScriptEnabled: true,
+        doNotTrack: nav.doNotTrack
+      }
+    };
+  }
+  parseUA(ua) {
+    let name = "unknown";
+    let version = "0";
+    let engine = "unknown";
+    let engineVersion = "0";
+    if (ua.includes("Firefox/") && !ua.includes("Seamonkey")) {
+      name = "Firefox";
+      const match = ua.match(/Firefox\/([\d.]+)/);
+      version = match?.[1] ?? "0";
+      engine = "Gecko";
+    } else if (ua.includes("Edg/")) {
+      name = "Edge";
+      const match = ua.match(/Edg\/([\d.]+)/);
+      version = match?.[1] ?? "0";
+      engine = "Blink";
+    } else if (ua.includes("OPR/") || ua.includes("Opera")) {
+      name = "Opera";
+      const match = ua.match(/(?:OPR|Opera)\/([\d.]+)/);
+      version = match?.[1] ?? "0";
+      engine = "Blink";
+    } else if (ua.includes("Chrome/") && !ua.includes("Edg/")) {
+      name = "Chrome";
+      const match = ua.match(/Chrome\/([\d.]+)/);
+      version = match?.[1] ?? "0";
+      engine = "Blink";
+    } else if (ua.includes("Safari/") && !ua.includes("Chrome/") && !ua.includes("Chromium")) {
+      name = "Safari";
+      const match = ua.match(/Version\/([\d.]+)/);
+      version = match?.[1] ?? "0";
+      engine = "WebKit";
+    } else if (ua.includes("MSIE") || ua.includes("Trident/")) {
+      name = "Internet Explorer";
+      const match = ua.match(/(?:MSIE |Trident\/.*rv:)([\d.]+)/);
+      version = match?.[1] ?? "0";
+      engine = "Trident";
+    }
+    if (engine === "Blink") {
+      const match = ua.match(/AppleWebKit\/([\d.]+)/);
+      engineVersion = match?.[1] ?? "0";
+    } else if (engine === "Gecko") {
+      const match = ua.match(/Gecko\/([\d.]+)/);
+      engineVersion = match?.[1] ?? "20100101";
+    } else if (engine === "WebKit") {
+      const match = ua.match(/AppleWebKit\/([\d.]+)/);
+      engineVersion = match?.[1] ?? "0";
+    } else if (engine === "Trident") {
+      const match = ua.match(/Trident\/([\d.]+)/);
+      engineVersion = match?.[1] ?? "0";
+    }
+    return { name, version, engine, engineVersion };
+  }
+  async destroy() {
+  }
+};
+
+// ../collectors/src/device/device-collector.ts
+var DeviceCollector = class {
+  name = "device";
+  category = "device";
+  version = SDK_VERSION;
+  enabled = true;
+  async collect(context) {
+    const nav = context.navigator;
+    const win = context.window;
+    const scr = context.screen;
+    return {
+      device: {
+        os: this.detectOS(nav.platform, nav.userAgent),
+        osVersion: this.detectOSVersion(nav.userAgent),
+        platform: nav.platform,
+        architecture: this.detectArch(nav.userAgent),
+        formFactor: this.detectFormFactor(nav.userAgent, scr),
+        screenWidth: scr.width,
+        screenHeight: scr.height,
+        viewportWidth: win.innerWidth,
+        viewportHeight: win.innerHeight,
+        devicePixelRatio: win.devicePixelRatio,
+        colorDepth: scr.colorDepth,
+        orientation: scr.orientation?.type ?? "portrait-primary",
+        touchSupport: this.detectTouch(nav.maxTouchPoints),
+        hardwareConcurrency: nav.hardwareConcurrency,
+        maxTouchPoints: nav.maxTouchPoints
+      }
+    };
+  }
+  detectOS(platform, ua) {
+    if (platform.includes("Win")) return "Windows";
+    if (platform.includes("Mac")) return "macOS";
+    if (platform.includes("Linux")) return "Linux";
+    if (platform.includes("Android")) return "Android";
+    if (/iPhone|iPad|iPod/.test(ua)) return "iOS";
+    if (ua.includes("Chrome OS")) return "Chrome OS";
+    if (ua.includes("X11") || ua.includes("Linux")) return "Linux";
+    return "Unknown";
+  }
+  detectOSVersion(ua) {
+    const windowsMatch = ua.match(/Windows NT ([\d.]+)/);
+    if (windowsMatch) {
+      const versions = {
+        "10.0": "10/11",
+        "6.3": "8.1",
+        "6.2": "8",
+        "6.1": "7",
+        "6.0": "Vista"
+      };
+      const ver = windowsMatch[1] ?? "";
+      return versions[ver] ?? ver;
+    }
+    const macMatch = ua.match(/Mac OS X ([\d_]+)/);
+    if (macMatch) return (macMatch[1] ?? "").replace(/_/g, ".");
+    const androidMatch = ua.match(/Android ([\d.]+)/);
+    if (androidMatch) return androidMatch[1] ?? "";
+    const iosMatch = ua.match(/OS ([\d_]+)/);
+    if (iosMatch) return (iosMatch[1] ?? "").replace(/_/g, ".");
+    return "unknown";
+  }
+  detectArch(ua) {
+    if (ua.includes("x86_64") || ua.includes("x64") || ua.includes("Win64") || ua.includes("x86-64")) {
+      return "x86_64";
+    }
+    if (ua.includes("arm64") || ua.includes("aarch64")) return "arm64";
+    if (ua.includes("arm")) return "arm";
+    if (ua.includes("x86")) return "x86";
+    if (ua.includes("WOW64")) return "x86_64";
+    return "unknown";
+  }
+  detectFormFactor(ua, scr) {
+    if (/iPhone|iPod/.test(ua)) return "mobile";
+    if (/iPad/.test(ua)) return "tablet";
+    if (/Android/.test(ua)) {
+      if (scr.width < 768) return "mobile";
+      if (scr.width < 1024) return "tablet";
+      return "mobile";
+    }
+    if (/SmartTV|AppleTV|Chromecast|FireTV|Roku/.test(ua)) return "smarttv";
+    if (/Watch|Wearable|Fitbit/.test(ua)) return "wearable";
+    if (/PlayStation|Xbox|Nintendo/.test(ua)) return "console";
+    if (scr.width >= 1024 && !("ontouchstart" in globalThis)) return "desktop";
+    return "unknown";
+  }
+  detectTouch(maxTouchPoints) {
+    if (maxTouchPoints === 0) return "none";
+    if (maxTouchPoints <= 5) return "coarse";
+    return "fine";
+  }
+  async destroy() {
+  }
+};
+
+// ../collectors/src/performance/performance-collector.ts
+var PerformanceCollector = class {
+  name = "performance";
+  category = "performance";
+  version = SDK_VERSION;
+  enabled = true;
+  async collect(context) {
+    const perf = context.performance;
+    const nav = context.navigator;
+    const connection = nav.connection;
+    return {
+      performance: {
+        navigationTiming: this.collectNavigationTiming(perf),
+        paintTiming: this.collectPaintTiming(perf),
+        largestContentfulPaint: this.collectLCP(perf),
+        firstContentfulPaint: this.collectFCP(perf),
+        cumulativeLayoutShift: this.collectCLS(perf),
+        interactionToNextPaint: this.collectINP(perf),
+        deviceMemory: nav.deviceMemory ?? null,
+        networkType: connection?.type ?? "unknown",
+        effectiveType: connection?.effectiveType ?? "unknown",
+        downlink: connection?.downlink ?? null,
+        rtt: connection?.rtt ?? null,
+        saveData: connection?.saveData ?? false
+      }
+    };
+  }
+  collectNavigationTiming(perf) {
+    const timing = perf.timing;
+    if (!timing) return null;
+    return safeCall(() => ({
+      redirectTime: timing.redirectEnd - timing.redirectStart,
+      dnsLookupTime: timing.domainLookupEnd - timing.domainLookupStart,
+      tcpConnectTime: timing.connectEnd - timing.connectStart,
+      requestTime: timing.responseStart - timing.requestStart,
+      responseTime: timing.responseEnd - timing.responseStart,
+      domInteractiveTime: timing.domInteractive - timing.navigationStart,
+      domContentLoadedTime: timing.domContentLoadedEventEnd - timing.navigationStart,
+      domCompleteTime: timing.domComplete - timing.navigationStart,
+      loadTime: timing.loadEventEnd - timing.navigationStart,
+      duration: timing.loadEventEnd - timing.navigationStart
+    }), null);
+  }
+  collectPaintTiming(perf) {
+    const entries = perf.getEntriesByType("paint");
+    if (!entries.length) return null;
+    const fp = entries.find((e) => e.name === "first-paint");
+    const fcp = entries.find((e) => e.name === "first-contentful-paint");
+    if (!fp && !fcp) return null;
+    return {
+      firstPaint: fp?.startTime ?? 0,
+      firstContentfulPaint: fcp?.startTime ?? 0
+    };
+  }
+  collectLCP(perf) {
+    const entries = perf.getEntriesByType("largest-contentful-paint");
+    if (!entries.length) return null;
+    const last = entries[entries.length - 1];
+    return last ? last.startTime : null;
+  }
+  collectFCP(perf) {
+    const entries = perf.getEntriesByType("paint");
+    const fcp = entries.find((e) => e.name === "first-contentful-paint");
+    return fcp?.startTime ?? null;
+  }
+  collectCLS(perf) {
+    const entries = perf.getEntriesByType("layout-shift");
+    if (!entries.length) return null;
+    let cls = 0;
+    for (const entry of entries) {
+      if (!entry.hadRecentInput && entry.value !== void 0) {
+        cls += entry.value;
+      }
+    }
+    return cls;
+  }
+  collectINP(perf) {
+    const entries = perf.getEntriesByType("event");
+    if (!entries.length) return null;
+    const durations = entries.map((e) => e.duration).sort((a, b) => b - a);
+    return durations[0] ?? null;
+  }
+  async destroy() {
+  }
+};
+
+// ../collectors/src/environment/environment-collector.ts
+var EnvironmentCollector = class {
+  name = "environment";
+  category = "environment";
+  version = SDK_VERSION;
+  enabled = true;
+  async collect(context) {
+    const win = context.window;
+    const nav = context.navigator;
+    const doc = context.document;
+    return {
+      environment: {
+        timezone: this.getTimezone(),
+        timezoneOffset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+        languages: [...nav.languages],
+        language: nav.language,
+        locale: this.getLocale(),
+        prefersColorScheme: this.getColorScheme(win),
+        prefersReducedMotion: this.getReducedMotion(win),
+        prefersContrast: this.getContrast(win),
+        colorGamut: this.getColorGamut(win),
+        hdr: this.getHDR(win),
+        localStorageSupport: this.checkStorage(win.localStorage),
+        sessionStorageSupport: this.checkStorage(win.sessionStorage),
+        indexedDBSupport: this.checkIndexedDB(win.indexedDB),
+        cookieSupport: doc.cookie !== void 0,
+        cacheAPISupport: this.checkCacheAPI(win)
+      }
+    };
+  }
+  getTimezone() {
+    try {
+      return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch {
+      return "UTC";
+    }
+  }
+  getLocale() {
+    try {
+      return Intl.DateTimeFormat().resolvedOptions().locale;
+    } catch {
+      return "en-US";
+    }
+  }
+  getColorScheme(win) {
+    if (typeof win.matchMedia !== "function") return "no-preference";
+    const mql = win.matchMedia("(prefers-color-scheme: light)");
+    if (mql?.matches) return "light";
+    const mqlDark = win.matchMedia("(prefers-color-scheme: dark)");
+    if (mqlDark?.matches) return "dark";
+    return "no-preference";
+  }
+  getReducedMotion(win) {
+    if (typeof win.matchMedia !== "function") return false;
+    return win.matchMedia("(prefers-reduced-motion: reduce)")?.matches ?? false;
+  }
+  getContrast(win) {
+    if (typeof win.matchMedia !== "function") return "no-preference";
+    const mql = win.matchMedia("(prefers-contrast: more)");
+    if (mql?.matches) return "more";
+    const mqlLess = win.matchMedia("(prefers-contrast: less)");
+    if (mqlLess?.matches) return "less";
+    const mqlCustom = win.matchMedia("(prefers-contrast: custom)");
+    if (mqlCustom?.matches) return "custom";
+    return "no-preference";
+  }
+  getColorGamut(win) {
+    if (typeof win.matchMedia !== "function") return "unknown";
+    const mqlRec2020 = win.matchMedia("(color-gamut: rec2020)");
+    if (mqlRec2020?.matches) return "rec2020";
+    const mqlP3 = win.matchMedia("(color-gamut: p3)");
+    if (mqlP3?.matches) return "p3";
+    const mqlSrgb = win.matchMedia("(color-gamut: srgb)");
+    if (mqlSrgb?.matches) return "srgb";
+    return "unknown";
+  }
+  getHDR(win) {
+    if (typeof win.matchMedia !== "function") return false;
+    return win.matchMedia("(dynamic-range: high)")?.matches ?? false;
+  }
+  checkStorage(storage) {
+    if (!storage) return false;
+    return safeCall(() => typeof storage.length === "number", false);
+  }
+  checkIndexedDB(idb) {
+    if (!idb) return false;
+    return typeof idb.open === "function";
+  }
+  checkCacheAPI(win) {
+    return safeCall(() => {
+      const w = win;
+      return typeof w.Cache !== "undefined" && typeof w.caches !== "undefined";
+    }, false);
+  }
+  async destroy() {
+  }
+};
+
+// ../collectors/src/features/feature-collector.ts
+var FeatureCollector = class {
+  name = "features";
+  category = "features";
+  version = SDK_VERSION;
+  enabled = true;
+  async collect(context) {
+    const win = context.window;
+    const nav = context.navigator;
+    const doc = context.document;
+    return {
+      features: {
+        webgl: this.checkWebGL(doc),
+        webgl2: this.checkWebGL2(doc),
+        webgpu: this.checkWebGPU(nav),
+        wasm: this.checkWASM(),
+        webrtc: this.checkWebRTC(win),
+        websockets: this.checkWebSockets(win),
+        broadcastChannel: this.checkBroadcastChannel(win),
+        sharedWorker: this.checkSharedWorker(win),
+        serviceWorker: this.checkServiceWorker(nav),
+        notifications: this.checkNotifications(win),
+        clipboard: this.checkClipboard(nav),
+        fileSystemAccess: this.checkFileSystemAccess(win),
+        webShare: this.checkWebShare(nav),
+        webAuthn: this.checkWebAuthn(win),
+        pushManager: this.checkPushManager(win),
+        geolocation: this.checkGeolocation(nav),
+        bluetooth: this.checkBluetooth(nav),
+        usb: this.checkUSB(nav),
+        serial: this.checkSerial(nav),
+        gamepad: this.checkGamepad(win),
+        pictureInPicture: this.checkPictureInPicture(win),
+        fullscreen: this.checkFullscreen(doc)
+      }
+    };
+  }
+  checkWebGL(doc) {
+    return safeCall(() => {
+      const canvas = doc.createElement("canvas");
+      const gl = canvas.getContext("webgl") ?? canvas.getContext("experimental-webgl");
+      return gl !== null;
+    }, false);
+  }
+  checkWebGL2(doc) {
+    return safeCall(() => {
+      const canvas = doc.createElement("canvas");
+      const gl = canvas.getContext("webgl2");
+      return gl !== null;
+    }, false);
+  }
+  checkWebGPU(nav) {
+    return safeCall(() => {
+      const gpu = nav.gpu;
+      return typeof gpu === "object" && typeof gpu?.requestAdapter === "function";
+    }, false);
+  }
+  checkWASM() {
+    return safeCall(() => {
+      return typeof WebAssembly === "object" && typeof WebAssembly.instantiate === "function";
+    }, false);
+  }
+  checkWebRTC(win) {
+    return safeCall(() => {
+      return typeof win.RTCPeerConnection !== "undefined";
+    }, false);
+  }
+  checkWebSockets(win) {
+    return typeof win.WebSocket !== "undefined";
+  }
+  checkBroadcastChannel(win) {
+    return typeof win.BroadcastChannel !== "undefined";
+  }
+  checkSharedWorker(win) {
+    return typeof win.SharedWorker !== "undefined";
+  }
+  checkServiceWorker(nav) {
+    return typeof nav !== "undefined" && "serviceWorker" in nav;
+  }
+  checkNotifications(win) {
+    return safeCall(() => {
+      const w = win;
+      return typeof w.Notification === "object" && typeof w.Notification.permission === "string";
+    }, false);
+  }
+  checkClipboard(nav) {
+    return safeCall(() => {
+      const clipboard = nav.clipboard;
+      return typeof clipboard?.readText === "function";
+    }, false);
+  }
+  checkFileSystemAccess(win) {
+    return typeof win.showOpenFilePicker === "function";
+  }
+  checkWebShare(nav) {
+    return safeCall(() => {
+      return typeof nav.share === "function";
+    }, false);
+  }
+  checkWebAuthn(win) {
+    return safeCall(() => {
+      return typeof win.PublicKeyCredential !== "undefined";
+    }, false);
+  }
+  checkPushManager(win) {
+    return safeCall(() => {
+      return typeof win.PushManager !== "undefined";
+    }, false);
+  }
+  checkGeolocation(nav) {
+    return safeCall(() => {
+      return "geolocation" in nav;
+    }, false);
+  }
+  checkBluetooth(nav) {
+    return safeCall(() => {
+      return "bluetooth" in nav;
+    }, false);
+  }
+  checkUSB(nav) {
+    return safeCall(() => {
+      return "usb" in nav;
+    }, false);
+  }
+  checkSerial(nav) {
+    return safeCall(() => {
+      return "serial" in nav;
+    }, false);
+  }
+  checkGamepad(win) {
+    return safeCall(() => {
+      return typeof win.navigator?.getGamepads === "function";
+    }, false);
+  }
+  checkPictureInPicture(win) {
+    return safeCall(() => {
+      const Video = win.HTMLVideoElement;
+      return typeof Video?.prototype?.requestPictureInPicture === "function";
+    }, false);
+  }
+  checkFullscreen(doc) {
+    return safeCall(() => {
+      const el = doc;
+      return typeof el.documentElement?.requestFullscreen === "function";
+    }, false);
+  }
+  async destroy() {
+  }
+};
+
+// ../collectors/src/interaction/interaction-collector.ts
+var InteractionCollector = class {
+  name = "interaction";
+  category = "interaction";
+  version = SDK_VERSION;
+  enabled = true;
+  state;
+  cleanupFns = [];
+  sessionTimeout = null;
+  sessionTimeoutMs;
+  constructor(options) {
+    this.sessionTimeoutMs = options?.sessionTimeout ?? 30 * 60 * 1e3;
+    this.state = this.createInitialState();
+  }
+  createInitialState() {
+    return {
+      sessionStart: Date.now(),
+      pageStart: Date.now(),
+      routeChanges: 0,
+      scrollDepth: 0,
+      clickCount: 0,
+      resizeCount: 0,
+      visibilityChanges: 0,
+      focusChanges: 0,
+      landingPage: typeof location !== "undefined" ? location.href : "",
+      lastPage: typeof location !== "undefined" ? location.href : "",
+      utmParams: this.parseUTMParams()
+    };
+  }
+  parseUTMParams() {
+    if (typeof location === "undefined") {
+      return { source: null, medium: null, campaign: null, term: null, content: null };
+    }
+    const params = new URLSearchParams(location.search);
+    return {
+      source: params.get("utm_source"),
+      medium: params.get("utm_medium"),
+      campaign: params.get("utm_campaign"),
+      term: params.get("utm_term"),
+      content: params.get("utm_content")
+    };
+  }
+  async init(context) {
+    const win = context.window;
+    const doc = context.document;
+    const clickHandler = () => {
+      this.state.clickCount++;
+      this.resetSessionTimeout();
+    };
+    doc.addEventListener("click", clickHandler, { passive: true });
+    this.cleanupFns.push(() => doc.removeEventListener("click", clickHandler));
+    let scrollRaf = null;
+    const scrollHandler = () => {
+      if (scrollRaf !== null) return;
+      scrollRaf = requestAnimationFrame(() => {
+        const maxScroll = Math.max(
+          doc.documentElement.scrollHeight - win.innerHeight,
+          1
+        );
+        const currentScroll = win.scrollY ?? 0;
+        const depth = Math.min(Math.round(currentScroll / maxScroll * 100), 100);
+        if (depth > this.state.scrollDepth) {
+          this.state.scrollDepth = depth;
+        }
+        scrollRaf = null;
+      });
+    };
+    win.addEventListener("scroll", scrollHandler, { passive: true });
+    this.cleanupFns.push(() => win.removeEventListener("scroll", scrollHandler));
+    let resizeTimer = null;
+    const resizeHandler = () => {
+      if (resizeTimer !== null) return;
+      resizeTimer = setTimeout(() => {
+        this.state.resizeCount++;
+        resizeTimer = null;
+      }, 200);
+    };
+    win.addEventListener("resize", resizeHandler, { passive: true });
+    this.cleanupFns.push(() => {
+      win.removeEventListener("resize", resizeHandler);
+      if (resizeTimer !== null) clearTimeout(resizeTimer);
+    });
+    const visHandler = () => {
+      this.state.visibilityChanges++;
+    };
+    doc.addEventListener("visibilitychange", visHandler, { passive: true });
+    this.cleanupFns.push(() => doc.removeEventListener("visibilitychange", visHandler));
+    const focusHandler = () => {
+      this.state.focusChanges++;
+    };
+    win.addEventListener("focus", focusHandler, { passive: true });
+    win.addEventListener("blur", focusHandler, { passive: true });
+    this.cleanupFns.push(() => {
+      win.removeEventListener("focus", focusHandler);
+      win.removeEventListener("blur", focusHandler);
+    });
+    const onPopState = () => {
+      this.state.routeChanges++;
+      this.state.lastPage = location.href;
+    };
+    win.addEventListener("popstate", onPopState, { passive: true });
+    this.cleanupFns.push(() => {
+      win.removeEventListener("popstate", onPopState);
+    });
+    this.startSessionTimeout();
+  }
+  startSessionTimeout() {
+    this.sessionTimeout = setTimeout(() => {
+      this.state.sessionStart = Date.now();
+      this.state.routeChanges = 0;
+      this.state.clickCount = 0;
+      this.state.resizeCount = 0;
+      this.state.visibilityChanges = 0;
+      this.state.focusChanges = 0;
+      this.state.scrollDepth = 0;
+    }, this.sessionTimeoutMs);
+  }
+  resetSessionTimeout() {
+    if (this.sessionTimeout !== null) {
+      clearTimeout(this.sessionTimeout);
+    }
+    this.startSessionTimeout();
+  }
+  async collect(_context) {
+    const now = Date.now();
+    return {
+      interaction: {
+        sessionDuration: now - this.state.sessionStart,
+        timeOnPage: now - this.state.pageStart,
+        routeChanges: this.state.routeChanges,
+        scrollDepth: this.state.scrollDepth,
+        clickCount: this.state.clickCount,
+        resizeCount: this.state.resizeCount,
+        visibilityChanges: this.state.visibilityChanges,
+        focusChanges: this.state.focusChanges,
+        landingPage: this.state.landingPage,
+        exitPage: this.state.lastPage,
+        utmSource: this.state.utmParams.source,
+        utmMedium: this.state.utmParams.medium,
+        utmCampaign: this.state.utmParams.campaign,
+        utmTerm: this.state.utmParams.term,
+        utmContent: this.state.utmParams.content
+      }
+    };
+  }
+  async destroy() {
+    if (this.sessionTimeout !== null) {
+      clearTimeout(this.sessionTimeout);
+    }
+    for (const fn of this.cleanupFns) {
+      fn();
+    }
+    this.cleanupFns = [];
+  }
+};
+
+// src/visitor-analytics.ts
+var DEFAULT_CONFIG2 = {
+  endpoint: "",
+  storage: "memory",
+  autoStart: true,
+  batchSize: 50,
+  flushInterval: 3e4,
+  maxRetries: 5,
+  retryBaseDelay: 1e3,
+  retryMaxDelay: 3e4,
+  compressionEnabled: false,
+  deduplicationEnabled: true,
+  headers: {},
+  timeout: 1e4,
+  collectBrowser: true,
+  collectDevice: true,
+  collectPerformance: true,
+  collectEnvironment: true,
+  collectFeatures: true,
+  collectInteraction: true,
+  includeUserAgent: false,
+  includeReferrer: true,
+  sessionTimeout: 30 * 60 * 1e3,
+  customData: {}
+};
+var VisitorAnalytics = class {
+  config;
+  eventBus;
+  pluginManager;
+  storage;
+  uploader;
+  collectors = [];
+  collectorContext = null;
+  isRunning = false;
+  sessionId;
+  collectTimer = null;
+  constructor(config = {}) {
+    const merged = { ...DEFAULT_CONFIG2, ...config };
+    if (config.customData) {
+      merged.customData = { ...DEFAULT_CONFIG2.customData, ...config.customData };
+    }
+    if (config.headers) {
+      merged.headers = { ...DEFAULT_CONFIG2.headers, ...config.headers };
+    }
+    this.config = merged;
+    this.eventBus = new EventBus();
+    this.sessionId = generateId();
+    if (typeof this.config.storage === "object" && typeof this.config.storage.save === "function") {
+      this.storage = this.config.storage;
+    } else {
+      this.storage = StorageAdapterFactory.create(this.config.storage);
+    }
+    this.uploader = new Uploader(this.storage, {
+      endpoint: this.config.endpoint,
+      batchSize: this.config.batchSize,
+      flushInterval: this.config.flushInterval,
+      maxRetries: this.config.maxRetries,
+      retryBaseDelay: this.config.retryBaseDelay,
+      retryMaxDelay: this.config.retryMaxDelay,
+      compressionEnabled: this.config.compressionEnabled,
+      deduplicationEnabled: this.config.deduplicationEnabled,
+      headers: this.config.headers,
+      timeout: this.config.timeout
+    });
+    this.pluginManager = new PluginManager(this.eventBus);
+    this.registerBuiltInCollectors();
+    if (this.config.autoStart && isBrowser()) {
+      requestIdle(() => this.start());
+    }
+  }
+  registerBuiltInCollectors() {
+    if (this.config.collectBrowser) {
+      this.addCollector(new BrowserCollector({ includeUserAgent: this.config.includeUserAgent }));
+    }
+    if (this.config.collectDevice) {
+      this.addCollector(new DeviceCollector());
+    }
+    if (this.config.collectPerformance) {
+      this.addCollector(new PerformanceCollector());
+    }
+    if (this.config.collectEnvironment) {
+      this.addCollector(new EnvironmentCollector());
+    }
+    if (this.config.collectFeatures) {
+      this.addCollector(new FeatureCollector());
+    }
+    if (this.config.collectInteraction) {
+      this.addCollector(
+        new InteractionCollector({ sessionTimeout: this.config.sessionTimeout })
+      );
+    }
+  }
+  buildCollectorContext() {
+    if (this.collectorContext) return this.collectorContext;
+    const ctx = {
+      document,
+      navigator,
+      window,
+      performance,
+      location,
+      history,
+      screen
+    };
+    this.collectorContext = ctx;
+    return ctx;
+  }
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.uploader.start();
+    this.eventBus.emit("start");
+    for (const collector of this.collectors) {
+      if (collector.init && isBrowser()) {
+        requestIdle(() => {
+          collector.init(this.buildCollectorContext()).catch((err) => {
+            console.debug("[VisitorAnalytics] Collector init failed:", collector.name, err);
+          });
+        });
+      }
+    }
+    this.collectTimer = setInterval(() => {
+      requestIdle(() => this.collectAndStore());
+    }, this.config.flushInterval);
+  }
+  stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    this.uploader.stop();
+    if (this.collectTimer !== null) {
+      clearInterval(this.collectTimer);
+      this.collectTimer = null;
+    }
+    this.eventBus.emit("stop");
+  }
+  async flush() {
+    await this.collectAndStore();
+    await this.uploader.flush();
+    this.eventBus.emit("flush");
+  }
+  async sync() {
+    await this.collectAndStore();
+    await this.uploader.sync();
+    this.eventBus.emit("sync");
+  }
+  async retryFailed() {
+    await this.uploader.retryFailed();
+  }
+  use(plugin) {
+    const pluginContext = this.createPluginContext();
+    this.pluginManager.install(plugin, pluginContext);
+  }
+  addCollector(collector) {
+    if (this.collectors.some((c) => c.name === collector.name)) {
+      return;
+    }
+    this.collectors.push(collector);
+    this.pluginManager.addCollector(collector);
+    this.eventBus.emit("collector-registered", collector.name);
+  }
+  removeCollector(name) {
+    const idx = this.collectors.findIndex((c) => c.name === name);
+    if (idx === -1) return;
+    const collector = this.collectors[idx];
+    if (collector?.destroy) {
+      collector.destroy().catch(() => {
+      });
+    }
+    this.collectors.splice(idx, 1);
+    this.pluginManager.removeCollector(name);
+    this.eventBus.emit("collector-removed", name);
+  }
+  async getCollectedData() {
+    return this.storage.load();
+  }
+  async export() {
+    return this.storage.export();
+  }
+  on(event, handler) {
+    this.eventBus.on(event, handler);
+  }
+  off(event, handler) {
+    this.eventBus.off(event, handler);
+  }
+  async destroy() {
+    this.stop();
+    for (const collector of this.collectors) {
+      if (collector.destroy) {
+        await collector.destroy();
+      }
+    }
+    this.uploader.destroy();
+    this.eventBus.removeAllListeners();
+    this.collectors = [];
+    this.collectorContext = null;
+  }
+  async collectAndStore() {
+    if (!isBrowser()) return;
+    const context = this.buildCollectorContext();
+    const record = await this.collectRecord(context);
+    if (record) {
+      await this.storage.save(record);
+      this.eventBus.emit("record-collected", record);
+    }
+  }
+  async collectRecord(context) {
+    const now = Date.now();
+    const partials = [];
+    for (const collector of this.collectors) {
+      if (!collector.enabled) continue;
+      try {
+        const data = await collector.collect(context);
+        partials.push(data);
+      } catch (err) {
+        console.debug("[VisitorAnalytics] Collector collect failed:", collector.name, err);
+      }
+    }
+    if (partials.length === 0) return null;
+    const merged = structuredClone(Object.assign({}, ...partials));
+    const record = {
+      id: generateId(),
+      timestamp: now,
+      sessionId: this.sessionId,
+      pageUrl: location.href,
+      pagePath: location.pathname,
+      referrer: this.config.includeReferrer ? document.referrer : "",
+      screenWidth: screen.width,
+      screenHeight: screen.height,
+      viewportWidth: window.innerWidth,
+      viewportHeight: window.innerHeight,
+      devicePixelRatio: window.devicePixelRatio,
+      browser: merged.browser ?? {
+        name: "unknown",
+        version: "0",
+        engine: "unknown",
+        engineVersion: "0",
+        userAgent: "",
+        language: "",
+        cookiesEnabled: false,
+        javaScriptEnabled: true,
+        doNotTrack: null
+      },
+      device: merged.device ?? {
+        os: "unknown",
+        osVersion: "unknown",
+        platform: "",
+        architecture: "unknown",
+        formFactor: "unknown",
+        screenWidth: 0,
+        screenHeight: 0,
+        viewportWidth: 0,
+        viewportHeight: 0,
+        devicePixelRatio: 1,
+        colorDepth: 24,
+        orientation: "portrait-primary",
+        touchSupport: "none",
+        hardwareConcurrency: 0,
+        maxTouchPoints: 0
+      },
+      performance: merged.performance ?? {
+        navigationTiming: null,
+        paintTiming: null,
+        largestContentfulPaint: null,
+        firstContentfulPaint: null,
+        cumulativeLayoutShift: null,
+        interactionToNextPaint: null,
+        deviceMemory: null,
+        networkType: "unknown",
+        effectiveType: "unknown",
+        downlink: null,
+        rtt: null,
+        saveData: false
+      },
+      environment: merged.environment ?? {
+        timezone: "UTC",
+        timezoneOffset: 0,
+        languages: [],
+        language: "",
+        locale: "",
+        prefersColorScheme: "no-preference",
+        prefersReducedMotion: false,
+        prefersContrast: "no-preference",
+        colorGamut: "unknown",
+        hdr: false,
+        localStorageSupport: false,
+        sessionStorageSupport: false,
+        indexedDBSupport: false,
+        cookieSupport: false,
+        cacheAPISupport: false
+      },
+      features: merged.features ?? {
+        webgl: false,
+        webgl2: false,
+        webgpu: false,
+        wasm: false,
+        webrtc: false,
+        websockets: false,
+        broadcastChannel: false,
+        sharedWorker: false,
+        serviceWorker: false,
+        notifications: false,
+        clipboard: false,
+        fileSystemAccess: false,
+        webShare: false,
+        webAuthn: false,
+        pushManager: false,
+        geolocation: false,
+        bluetooth: false,
+        usb: false,
+        serial: false,
+        gamepad: false,
+        pictureInPicture: false,
+        fullscreen: false
+      },
+      interaction: merged.interaction ?? {
+        sessionDuration: 0,
+        timeOnPage: 0,
+        routeChanges: 0,
+        scrollDepth: 0,
+        clickCount: 0,
+        resizeCount: 0,
+        visibilityChanges: 0,
+        focusChanges: 0,
+        landingPage: "",
+        exitPage: null,
+        utmSource: null,
+        utmMedium: null,
+        utmCampaign: null,
+        utmTerm: null,
+        utmContent: null
+      },
+      metadata: {
+        sdkVersion: SDK_VERSION,
+        buildTarget: "browser",
+        collectorVersion: SDK_VERSION,
+        customData: this.config.customData
+      }
+    };
+    deepFreeze(record);
+    return record;
+  }
+  createPluginContext() {
+    return createPluginContext(
+      (c) => this.addCollector(c),
+      (name) => this.removeCollector(name),
+      this.eventBus,
+      () => this.config
+    );
+  }
+};
+function createAnalytics(config) {
+  return new VisitorAnalytics(config);
+}
+export {
+  EventBus,
+  VisitorAnalytics,
+  createAnalytics
+};