@keverdjs/fraud-sdk-angular 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -1,5 +1,6 @@
-import { Injectable, NgModule } from '@angular/core';
-import { from } from 'rxjs';
+import { Injectable, Optional, Inject, NgModule } from '@angular/core';
+import { throwError, from } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
 import { CommonModule } from '@angular/common';
 
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -10,29 +11,3285 @@ var __decorateClass = (decorators, target, key, kind) => {
       result = (decorator(result)) || result;
   return result;
 };
-var KeverdService = class {
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// ../fraud-sdk/src/collectors/device.ts
+var DeviceCollector = class {
+  constructor() {
+    this.cachedDeviceInfo = null;
+  }
+  /**
+   * Collect all device information and generate fingerprint
+   */
+  collect() {
+    if (this.cachedDeviceInfo) {
+      return this.cachedDeviceInfo;
+    }
+    const fingerprint = this.generateDeviceFingerprint();
+    const deviceId = this.generateDeviceId(fingerprint);
+    this.cachedDeviceInfo = {
+      deviceId,
+      fingerprint,
+      manufacturer: this.getManufacturer(),
+      model: this.getModel(),
+      brand: this.getBrand(),
+      device: this.getDevice(),
+      product: this.getProduct(),
+      hardware: this.getHardware(),
+      sdkVersion: "1.0.0",
+      osVersion: this.getOSVersion(),
+      screenWidth: String(screen.width),
+      screenHeight: String(screen.height),
+      screenDensity: this.getScreenDensity(),
+      locale: navigator.language || navigator.languages?.[0] || "en",
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+    };
+    return this.cachedDeviceInfo;
+  }
+  /**
+   * Generate a stable device fingerprint using multiple browser characteristics
+   * Returns SHA-256 hash (64 hex characters) as required by backend
+   */
+  generateDeviceFingerprint() {
+    const components = [];
+    const canvasFingerprint = this.getCanvasFingerprint();
+    if (canvasFingerprint) components.push(canvasFingerprint);
+    const webglFingerprint = this.getWebGLFingerprint();
+    if (webglFingerprint) components.push(webglFingerprint);
+    components.push(navigator.userAgent);
+    components.push(navigator.language || navigator.languages?.[0] || "");
+    components.push(`${screen.width}x${screen.height}x${screen.colorDepth}`);
+    components.push(String((/* @__PURE__ */ new Date()).getTimezoneOffset()));
+    components.push(navigator.platform);
+    components.push(String(navigator.hardwareConcurrency || 0));
+    if ("deviceMemory" in navigator) {
+      components.push(String(navigator.deviceMemory));
+    }
+    if ("maxTouchPoints" in navigator) {
+      components.push(String(navigator.maxTouchPoints));
+    }
+    if (navigator.plugins && navigator.plugins.length > 0) {
+      const pluginNames = Array.from(navigator.plugins).slice(0, 3).map((p) => p.name).join(",");
+      components.push(pluginNames);
+    }
+    const combined = components.join("|");
+    return this.hashString(combined);
+  }
+  /**
+   * Generate canvas fingerprint
+   */
+  getCanvasFingerprint() {
+    try {
+      const canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return "";
+      canvas.width = 200;
+      canvas.height = 50;
+      ctx.textBaseline = "top";
+      ctx.font = "14px Arial";
+      ctx.fillStyle = "#f60";
+      ctx.fillRect(125, 1, 62, 20);
+      ctx.fillStyle = "#069";
+      ctx.fillText("KeverdFingerprint", 2, 15);
+      ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+      ctx.fillText("KeverdFingerprint", 4, 17);
+      return this.hashString(canvas.toDataURL());
+    } catch (error) {
+      return "";
+    }
+  }
+  /**
+   * Generate WebGL fingerprint
+   */
+  getWebGLFingerprint() {
+    try {
+      const canvas = document.createElement("canvas");
+      const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+      if (!gl) return "";
+      const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+      if (debugInfo) {
+        const vendor2 = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL);
+        const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+        return this.hashString(`${vendor2}|${renderer}`);
+      }
+      const version = gl.getParameter(gl.VERSION);
+      const vendor = gl.getParameter(gl.VENDOR);
+      return this.hashString(`${version}|${vendor}`);
+    } catch (error) {
+      return "";
+    }
+  }
+  /**
+   * Generate a stable device ID from fingerprint
+   */
+  generateDeviceId(fingerprint) {
+    return fingerprint.substring(0, 32);
+  }
+  /**
+   * Get manufacturer from user agent
+   */
+  getManufacturer() {
+    const ua = navigator.userAgent.toLowerCase();
+    if (ua.includes("iphone") || ua.includes("ipad")) return "Apple";
+    if (ua.includes("android")) {
+      const match = ua.match(/(?:^|\s)([a-z]+)(?:\s|$)/);
+      return match ? match[1].charAt(0).toUpperCase() + match[1].slice(1) : void 0;
+    }
+    return void 0;
+  }
+  /**
+   * Get model from user agent
+   */
+  getModel() {
+    const ua = navigator.userAgent;
+    const match = ua.match(/(iPhone|iPad|Android)[\s\/]+([\w]+)/i);
+    return match ? match[2] : void 0;
+  }
+  /**
+   * Get brand from user agent
+   */
+  getBrand() {
+    return this.getManufacturer();
+  }
+  /**
+   * Get device type
+   */
+  getDevice() {
+    const ua = navigator.userAgent.toLowerCase();
+    if (ua.includes("mobile")) return "mobile";
+    if (ua.includes("tablet")) return "tablet";
+    return "desktop";
+  }
+  /**
+   * Get product name
+   */
+  getProduct() {
+    const ua = navigator.userAgent;
+    const match = ua.match(/(iPhone|iPad|Android|Windows|Mac|Linux)/i);
+    return match ? match[1] : void 0;
+  }
+  /**
+   * Get hardware info
+   */
+  getHardware() {
+    const ua = navigator.userAgent;
+    const match = ua.match(/\(([^)]+)\)/);
+    return match ? match[1] : void 0;
+  }
+  /**
+   * Get OS version
+   */
+  getOSVersion() {
+    const ua = navigator.userAgent;
+    const patterns = [
+      /OS\s+([\d_]+)/i,
+      // iOS
+      /Android\s+([\d.]+)/i,
+      // Android
+      /Windows\s+([\d.]+)/i,
+      // Windows
+      /Mac\s+OS\s+X\s+([\d_]+)/i,
+      // macOS
+      /Linux/i
+      // Linux
+    ];
+    for (const pattern of patterns) {
+      const match = ua.match(pattern);
+      if (match) {
+        return match[1]?.replace(/_/g, ".") || match[0];
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get screen density
+   */
+  getScreenDensity() {
+    if (window.devicePixelRatio) {
+      return String(window.devicePixelRatio);
+    }
+    return void 0;
+  }
+  /**
+   * Hash a string using SHA-256-like algorithm (64 hex characters)
+   * Backend expects SHA-256 format (64 hex chars)
+   */
+  hashString(str) {
+    return this.sha256LikeHash(str);
+  }
+  /**
+   * SHA-256-like hash function (synchronous, deterministic)
+   * Produces 64-character hex string matching SHA-256 format
+   */
+  sha256LikeHash(str) {
+    const hashes = [];
+    let h1 = 5381;
+    for (let i = 0; i < str.length; i++) {
+      h1 = (h1 << 5) + h1 + str.charCodeAt(i);
+      h1 = h1 & 4294967295;
+    }
+    hashes.push(h1);
+    let h2 = 0;
+    for (let i = str.length - 1; i >= 0; i--) {
+      h2 = (h2 << 7) - h2 + str.charCodeAt(i);
+      h2 = h2 & 4294967295;
+    }
+    hashes.push(h2);
+    let h3 = 0;
+    for (let i = 0; i < str.length; i++) {
+      h3 = h3 ^ str.charCodeAt(i) << i % 4 * 8;
+      h3 = h3 & 4294967295;
+    }
+    hashes.push(h3);
+    let h4 = 0;
+    for (let i = 0; i < str.length; i++) {
+      h4 = h4 * 31 + str.charCodeAt(i) & 4294967295;
+    }
+    hashes.push(h4);
+    let h5 = 0;
+    for (let i = 0; i < str.length; i++) {
+      const rotated = (str.charCodeAt(i) << i % 16 | str.charCodeAt(i) >>> 32 - i % 16) & 4294967295;
+      h5 = h5 + rotated & 4294967295;
+    }
+    hashes.push(h5);
+    let h6 = 2166136261;
+    for (let i = 0; i < str.length; i++) {
+      h6 = (h6 ^ str.charCodeAt(i)) * 16777619;
+      h6 = h6 & 4294967295;
+    }
+    hashes.push(h6);
+    let h7 = 0;
+    for (let i = 0; i < str.length; i++) {
+      h7 = h7 + str.charCodeAt(i) * (i + 1) & 4294967295;
+    }
+    hashes.push(h7);
+    let h8 = 0;
+    for (let i = 0; i < str.length; i += 2) {
+      const combined2 = str.charCodeAt(i) + (str.charCodeAt(i + 1) || 0) * 256;
+      h8 = (h8 << 3) - h8 + combined2;
+      h8 = h8 & 4294967295;
+    }
+    hashes.push(h8);
+    const hexParts = hashes.map((h) => Math.abs(h).toString(16).padStart(8, "0"));
+    const combined = hexParts.join("");
+    return combined.substring(0, 64).padEnd(64, "0");
+  }
+  /**
+   * Clear cached device info (useful for testing)
+   */
+  clearCache() {
+    this.cachedDeviceInfo = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/kinematic-engine.ts
+var VELOCITY_SPIKE_THRESHOLD = 2.5;
+var WINDOW_LIMIT = 200;
+var KinematicEngine = class {
+  constructor(options = {}) {
+    this.featureVectors = [];
+    this.pointerQueue = [];
+    this.lastVelocity = 0;
+    this.lastAcceleration = 0;
+    this.lastAngle = 0;
+    this.lastPoint = null;
+    this.secondLastPoint = null;
+    this.rafId = null;
+    this.maxSwipeVelocity = 0;
+    this.isActive = false;
+    // Enhanced tracking
+    this.clickCount = 0;
+    this.rightClickCount = 0;
+    this.doubleClickCount = 0;
+    this.totalMouseDistance = 0;
+    this.lastClickTime = 0;
+    this.scrollDistance = 0;
+    this.lastScrollTop = 0;
+    this.touchEventCount = 0;
+    this.mouseMoveHandler = (event) => this.enqueuePoint(event, "move");
+    this.mouseDownHandler = (event) => {
+      this.enqueuePoint(event, "down");
+      this.handleClick(event);
+    };
+    this.mouseUpHandler = (event) => this.enqueuePoint(event, "up");
+    this.contextMenuHandler = (event) => this.handleRightClick(event);
+    this.scrollHandler = () => this.handleScroll();
+    this.touchStartHandler = () => this.handleTouch();
+    this.touchMoveHandler = () => this.handleTouch();
+    this.touchEndHandler = () => this.handleTouch();
+    this.onEvent = options.onEvent;
+    this.maskValue = options.maskValue ?? -1;
+  }
+  start() {
+    if (this.isActive || typeof document === "undefined") return;
+    document.addEventListener("mousemove", this.mouseMoveHandler, { passive: true });
+    document.addEventListener("mousedown", this.mouseDownHandler, { passive: true });
+    document.addEventListener("mouseup", this.mouseUpHandler, { passive: true });
+    document.addEventListener("contextmenu", this.contextMenuHandler, { passive: true });
+    window.addEventListener("scroll", this.scrollHandler, { passive: true });
+    document.addEventListener("touchstart", this.touchStartHandler, { passive: true });
+    document.addEventListener("touchmove", this.touchMoveHandler, { passive: true });
+    document.addEventListener("touchend", this.touchEndHandler, { passive: true });
+    this.lastScrollTop = window.pageYOffset || document.documentElement.scrollTop;
+    this.isActive = true;
+  }
+  stop() {
+    if (!this.isActive || typeof document === "undefined") return;
+    document.removeEventListener("mousemove", this.mouseMoveHandler);
+    document.removeEventListener("mousedown", this.mouseDownHandler);
+    document.removeEventListener("mouseup", this.mouseUpHandler);
+    document.removeEventListener("contextmenu", this.contextMenuHandler);
+    window.removeEventListener("scroll", this.scrollHandler);
+    document.removeEventListener("touchstart", this.touchStartHandler);
+    document.removeEventListener("touchmove", this.touchMoveHandler);
+    document.removeEventListener("touchend", this.touchEndHandler);
+    if (this.rafId !== null) {
+      cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+    this.isActive = false;
+  }
+  getVectors() {
+    return this.featureVectors;
+  }
+  getSuspiciousSwipeVelocity() {
+    return this.maxSwipeVelocity;
+  }
+  /**
+   * Get enhanced mouse/touch signals
+   */
+  getMouseSignals() {
+    const averageVelocity = this.featureVectors.length > 0 ? this.featureVectors.reduce((sum, v) => sum + v.velocity, 0) / this.featureVectors.length : 0;
+    const currentScrollTop = window.pageYOffset || document.documentElement.scrollTop;
+    const scrollDiff = Math.abs(currentScrollTop - this.lastScrollTop);
+    const scrollDirection = currentScrollTop > this.lastScrollTop ? "down" : "up";
+    return {
+      totalDistance: this.totalMouseDistance,
+      averageVelocity,
+      clickCount: this.clickCount,
+      rightClickCount: this.rightClickCount,
+      doubleClickCount: this.doubleClickCount,
+      scrollDistance: this.scrollDistance + scrollDiff,
+      scrollDirection,
+      touchEvents: this.touchEventCount
+    };
+  }
+  reset() {
+    this.featureVectors = [];
+    this.pointerQueue = [];
+    this.lastVelocity = 0;
+    this.lastAcceleration = 0;
+    this.lastAngle = 0;
+    this.lastPoint = null;
+    this.secondLastPoint = null;
+    this.maxSwipeVelocity = 0;
+    this.clickCount = 0;
+    this.rightClickCount = 0;
+    this.doubleClickCount = 0;
+    this.totalMouseDistance = 0;
+    this.lastClickTime = 0;
+    this.scrollDistance = 0;
+    this.lastScrollTop = 0;
+    this.touchEventCount = 0;
+  }
+  enqueuePoint(event, type) {
+    const point = {
+      x: event.clientX,
+      y: event.clientY,
+      timestamp: performance.now(),
+      type
+    };
+    this.pointerQueue.push(point);
+    if (this.pointerQueue.length > WINDOW_LIMIT) {
+      this.pointerQueue.shift();
+    }
+    if (this.onEvent) {
+      this.onEvent(type === "move" ? "mousemove" : type === "down" ? "mousedown" : "mouseup");
+    }
+    this.scheduleProcess();
+  }
+  scheduleProcess() {
+    if (this.rafId !== null) return;
+    this.rafId = requestAnimationFrame(() => {
+      this.rafId = null;
+      this.processQueue();
+      if (this.pointerQueue.length > 0) {
+        this.scheduleProcess();
+      }
+    });
+  }
+  processQueue() {
+    while (this.pointerQueue.length > 0) {
+      const point = this.pointerQueue.shift();
+      this.computeFeatures(point);
+      this.secondLastPoint = this.lastPoint;
+      this.lastPoint = point;
+    }
+  }
+  computeFeatures(point) {
+    if (!this.lastPoint) {
+      this.lastPoint = point;
+      this.lastAngle = 0;
+      return;
+    }
+    const dt = point.timestamp - this.lastPoint.timestamp;
+    if (dt <= 0) {
+      return;
+    }
+    const dx = point.x - this.lastPoint.x;
+    const dy = point.y - this.lastPoint.y;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    this.totalMouseDistance += distance;
+    const velocity = distance / dt;
+    const acceleration = (velocity - this.lastVelocity) / dt;
+    const jerk = (acceleration - this.lastAcceleration) / dt;
+    const angle = Math.atan2(dy, dx);
+    const angularVelocity = this.normalizeAngle(angle - this.lastAngle) / dt;
+    const curvature = this.calculateCurvature(point);
+    this.featureVectors.push({
+      timestamp: point.timestamp,
+      velocity,
+      acceleration,
+      jerk,
+      curvature,
+      angularVelocity
+    });
+    this.maxSwipeVelocity = Math.max(this.maxSwipeVelocity, velocity);
+    if (velocity > VELOCITY_SPIKE_THRESHOLD) {
+      this.featureVectors.push({
+        timestamp: point.timestamp,
+        velocity,
+        acceleration,
+        jerk,
+        curvature,
+        angularVelocity: angularVelocity * 1.2
+      });
+    }
+    if (this.featureVectors.length > WINDOW_LIMIT) {
+      this.featureVectors.splice(0, this.featureVectors.length - WINDOW_LIMIT);
+    }
+    this.lastVelocity = velocity;
+    this.lastAcceleration = acceleration;
+    this.lastAngle = angle;
+  }
+  calculateCurvature(point) {
+    if (!this.lastPoint || !this.secondLastPoint) return 0;
+    const p0 = this.secondLastPoint;
+    const p1 = this.lastPoint;
+    const p2 = point;
+    const chordLength = Math.hypot(p2.x - p0.x, p2.y - p0.y);
+    const pathLength = Math.hypot(p1.x - p0.x, p1.y - p0.y) + Math.hypot(p2.x - p1.x, p2.y - p1.y);
+    if (chordLength === 0) return 0;
+    return (pathLength - chordLength) / chordLength;
+  }
+  normalizeAngle(angleDiff) {
+    while (angleDiff > Math.PI) angleDiff -= 2 * Math.PI;
+    while (angleDiff < -Math.PI) angleDiff += 2 * Math.PI;
+    return angleDiff;
+  }
+  handleClick(_event) {
+    const now = performance.now();
+    if (now - this.lastClickTime < 500) {
+      this.doubleClickCount++;
+    } else {
+      this.clickCount++;
+    }
+    this.lastClickTime = now;
+  }
+  handleRightClick(_event) {
+    this.rightClickCount++;
+  }
+  handleScroll() {
+    const currentScrollTop = window.pageYOffset || document.documentElement.scrollTop;
+    const scrollDiff = Math.abs(currentScrollTop - this.lastScrollTop);
+    this.scrollDistance += scrollDiff;
+    this.lastScrollTop = currentScrollTop;
+  }
+  handleTouch() {
+    this.touchEventCount++;
+  }
+};
+
+// ../fraud-sdk/src/collectors/keystroke-monitor.ts
+var MAX_BUFFER = 200;
+var KeystrokeMonitor = class {
+  constructor(options = {}) {
+    this.keyDownTimes = /* @__PURE__ */ new Map();
+    this.lastKeyUpTime = null;
+    this.lastKeyDownTime = null;
+    this.featureVectors = [];
+    this.dwellTimes = [];
+    this.flightTimes = [];
+    this.digraphLatencies = [];
+    this.isActive = false;
+    // Enhanced tracking
+    this.keydownCount = 0;
+    this.keyupCount = 0;
+    this.specialKeyCount = 0;
+    this.lastKeystrokeTime = null;
+    this.pauseCount = 0;
+    this.PAUSE_THRESHOLD = 2e3;
+    // 2 seconds
+    this.keystrokeTimestamps = [];
+    this.keyDownHandler = (event) => this.handleKeyDown(event);
+    this.keyUpHandler = (event) => this.handleKeyUp(event);
+    this.onEvent = options.onEvent;
+  }
+  start() {
+    if (this.isActive || typeof document === "undefined") return;
+    document.addEventListener("keydown", this.keyDownHandler, { passive: true, capture: true });
+    document.addEventListener("keyup", this.keyUpHandler, { passive: true, capture: true });
+    this.isActive = true;
+  }
+  stop() {
+    if (!this.isActive || typeof document === "undefined") return;
+    document.removeEventListener("keydown", this.keyDownHandler, true);
+    document.removeEventListener("keyup", this.keyUpHandler, true);
+    this.isActive = false;
+  }
+  getVectors() {
+    return this.featureVectors;
+  }
+  getDwellTimes(limit = 50) {
+    return this.dwellTimes.slice(-limit);
+  }
+  getFlightTimes(limit = 50) {
+    return this.flightTimes.slice(-limit);
+  }
+  /**
+   * Get enhanced keyboard signals
+   */
+  getKeyboardSignals() {
+    let typingSpeed = 0;
+    if (this.keystrokeTimestamps.length > 1) {
+      const timeSpan = this.keystrokeTimestamps[this.keystrokeTimestamps.length - 1] - this.keystrokeTimestamps[0];
+      const minutes = timeSpan / 6e4;
+      if (minutes > 0) {
+        typingSpeed = this.keystrokeTimestamps.length / minutes;
+      }
+    }
+    const totalKeystrokes = this.keydownCount;
+    const backspaceRatio = totalKeystrokes > 0 ? this.getBackspaceCount() / totalKeystrokes : 0;
+    return {
+      keydownCount: this.keydownCount,
+      keyupCount: this.keyupCount,
+      specialKeyCount: this.specialKeyCount,
+      typingSpeed,
+      pauseCount: this.pauseCount,
+      backspaceRatio
+    };
+  }
+  getBackspaceCount() {
+    return 0;
+  }
+  reset() {
+    this.keyDownTimes.clear();
+    this.lastKeyUpTime = null;
+    this.lastKeyDownTime = null;
+    this.featureVectors = [];
+    this.dwellTimes = [];
+    this.flightTimes = [];
+    this.digraphLatencies = [];
+    this.keydownCount = 0;
+    this.keyupCount = 0;
+    this.specialKeyCount = 0;
+    this.lastKeystrokeTime = null;
+    this.pauseCount = 0;
+    this.keystrokeTimestamps = [];
+  }
+  handleKeyDown(event) {
+    if (!this.isTargetField(event)) return;
+    const now = performance.now();
+    this.keydownCount++;
+    this.keystrokeTimestamps.push(now);
+    if (event.ctrlKey || event.altKey || event.shiftKey || event.metaKey) {
+      this.specialKeyCount++;
+    }
+    if (this.lastKeystrokeTime !== null && now - this.lastKeystrokeTime > this.PAUSE_THRESHOLD) {
+      this.pauseCount++;
+    }
+    this.lastKeystrokeTime = now;
+    if (this.lastKeyUpTime !== null) {
+      const flight = now - this.lastKeyUpTime;
+      this.flightTimes.push(flight);
+      this.appendVector({ dwellTime: -1, flightTime: flight, digraphLatency: -1, timestamp: now });
+    }
+    if (this.lastKeyDownTime !== null) {
+      const digraphLatency = now - this.lastKeyDownTime;
+      this.digraphLatencies.push(digraphLatency);
+      this.appendVector({ dwellTime: -1, flightTime: -1, digraphLatency, timestamp: now });
+    }
+    this.lastKeyDownTime = now;
+    this.keyDownTimes.set(event.code, now);
+    if (this.onEvent) this.onEvent("keydown");
+  }
+  handleKeyUp(event) {
+    if (!this.isTargetField(event)) return;
+    const now = performance.now();
+    this.keyupCount++;
+    const start = this.keyDownTimes.get(event.code);
+    if (start !== void 0) {
+      const dwell = now - start;
+      this.dwellTimes.push(dwell);
+      this.appendVector({ dwellTime: dwell, flightTime: -1, digraphLatency: -1, timestamp: now });
+      this.keyDownTimes.delete(event.code);
+    }
+    this.lastKeyUpTime = now;
+    if (this.onEvent) this.onEvent("keyup");
+  }
+  appendVector(vector) {
+    this.featureVectors.push(vector);
+    if (this.featureVectors.length > MAX_BUFFER) {
+      this.featureVectors.splice(0, this.featureVectors.length - MAX_BUFFER);
+    }
+  }
+  isTargetField(event) {
+    const target = event.target;
+    if (!target) return false;
+    const isEditable = target.isContentEditable || ["INPUT", "TEXTAREA"].includes(target.tagName);
+    return isEditable;
+  }
+};
+
+// ../fraud-sdk/src/collectors/behavioral.ts
+var WINDOW_SIZE = 50;
+var MASK_VALUE = -1;
+var FEATURE_NAMES = [
+  "velocity",
+  "acceleration",
+  "jerk",
+  "curvature",
+  "angularVelocity",
+  "dwell",
+  "flight",
+  "digraphLatency"
+];
+var BehavioralCollector = class {
+  constructor() {
+    this.isActive = false;
+    this.sessionEvents = [];
+    this.trackEvent = (event) => {
+      this.sessionEvents.push({ type: event, timestamp: performance.now() });
+      if (this.sessionEvents.length > 500) {
+        this.sessionEvents.shift();
+      }
+    };
+    this.kinematicEngine = new KinematicEngine({ onEvent: this.trackEvent });
+    this.keystrokeMonitor = new KeystrokeMonitor({ onEvent: this.trackEvent });
+  }
+  start() {
+    if (this.isActive) return;
+    this.kinematicEngine.start();
+    this.keystrokeMonitor.start();
+    this.isActive = true;
+  }
+  stop() {
+    if (!this.isActive) return;
+    this.kinematicEngine.stop();
+    this.keystrokeMonitor.stop();
+    this.isActive = false;
+  }
+  reset() {
+    this.sessionEvents = [];
+    this.kinematicEngine.reset();
+    this.keystrokeMonitor.reset();
+  }
+  getData() {
+    const kinematicVectors = this.kinematicEngine.getVectors();
+    const keystrokeVectors = this.keystrokeMonitor.getVectors();
+    const merged = [
+      ...kinematicVectors.map((v) => ({
+        timestamp: v.timestamp,
+        values: [
+          v.velocity,
+          v.acceleration,
+          v.jerk,
+          v.curvature,
+          v.angularVelocity,
+          MASK_VALUE,
+          MASK_VALUE,
+          MASK_VALUE
+        ]
+      })),
+      ...keystrokeVectors.map((v) => ({
+        timestamp: v.timestamp,
+        values: [
+          MASK_VALUE,
+          MASK_VALUE,
+          MASK_VALUE,
+          MASK_VALUE,
+          MASK_VALUE,
+          v.dwellTime,
+          v.flightTime,
+          v.digraphLatency
+        ]
+      }))
+    ].sort((a, b) => a.timestamp - b.timestamp);
+    const sequence = this.buildSequence(merged);
+    const suspiciousSwipeVelocity = this.kinematicEngine.getSuspiciousSwipeVelocity();
+    const entropy = this.calculateSessionEntropy();
+    const dwellTimes = this.keystrokeMonitor.getDwellTimes();
+    const flightTimes = this.keystrokeMonitor.getFlightTimes();
+    return {
+      typing_dwell_ms: dwellTimes,
+      typing_flight_ms: flightTimes,
+      swipe_velocity: suspiciousSwipeVelocity,
+      suspicious_swipe_velocity: suspiciousSwipeVelocity,
+      session_entropy: entropy,
+      behavioral_vectors: sequence
+    };
+  }
+  buildSequence(vectors) {
+    const padded = [];
+    const startIndex = Math.max(0, vectors.length - WINDOW_SIZE);
+    const window2 = vectors.slice(startIndex);
+    for (const vector of window2) {
+      padded.push(vector.values);
+    }
+    while (padded.length < WINDOW_SIZE) {
+      padded.unshift(new Array(FEATURE_NAMES.length).fill(MASK_VALUE));
+    }
+    return {
+      featureNames: [...FEATURE_NAMES],
+      windowSize: WINDOW_SIZE,
+      maskValue: MASK_VALUE,
+      sequence: padded
+    };
+  }
+  calculateSessionEntropy() {
+    if (this.sessionEvents.length === 0) return 0;
+    const counts = {};
+    this.sessionEvents.forEach((evt) => {
+      counts[evt.type] = (counts[evt.type] || 0) + 1;
+    });
+    const total = this.sessionEvents.length;
+    return Object.values(counts).reduce((entropy, count) => {
+      const probability = count / total;
+      return probability > 0 ? entropy - probability * Math.log2(probability) : entropy;
+    }, 0);
+  }
+  /**
+   * Get mouse signals from kinematic engine
+   */
+  getMouseSignals() {
+    return this.kinematicEngine.getMouseSignals();
+  }
+  /**
+   * Get keyboard signals from keystroke monitor
+   */
+  getKeyboardSignals() {
+    return this.keystrokeMonitor.getKeyboardSignals();
+  }
+};
+
+// ../fraud-sdk/src/collectors/canvas-fingerprint.ts
+var CanvasFingerprintCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Generate canvas fingerprint
+   * Returns null if canvas is not available
+   */
+  collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    try {
+      const canvas = document.createElement("canvas");
+      canvas.width = 200;
+      canvas.height = 50;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        return null;
+      }
+      ctx.textBaseline = "top";
+      ctx.font = "14px Arial";
+      ctx.textBaseline = "alphabetic";
+      ctx.fillStyle = "#f60";
+      ctx.fillRect(125, 1, 62, 20);
+      ctx.fillStyle = "#069";
+      ctx.fillText("KeverdFingerprint", 2, 15);
+      ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+      ctx.fillText("KeverdFingerprint", 4, 17);
+      const gradient = ctx.createLinearGradient(0, 0, 200, 50);
+      gradient.addColorStop(0, "rgba(255, 0, 0, 0.5)");
+      gradient.addColorStop(1, "rgba(0, 0, 255, 0.5)");
+      ctx.fillStyle = gradient;
+      ctx.fillRect(0, 0, 200, 50);
+      ctx.strokeStyle = "#000";
+      ctx.lineWidth = 2;
+      ctx.beginPath();
+      ctx.arc(100, 25, 20, 0, Math.PI * 2);
+      ctx.stroke();
+      ctx.font = "12px Verdana";
+      ctx.fillStyle = "#000";
+      ctx.fillText("CanvasFP", 150, 30);
+      const dataURL = canvas.toDataURL();
+      const hash = this.hashString(dataURL);
+      const duration = performance.now() - startTime;
+      this.cachedFingerprint = {
+        value: hash,
+        duration: Math.round(duration * 100) / 100
+      };
+      return this.cachedFingerprint;
+    } catch (error) {
+      console.warn("[Keverd SDK] Canvas fingerprinting failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Hash a string to create a stable fingerprint
+   */
+  hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16).padStart(8, "0");
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/webgl-fingerprint.ts
+var WebGLFingerprintCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Generate WebGL fingerprint
+   * Returns null if WebGL is not available
+   */
+  collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    try {
+      const canvas = document.createElement("canvas");
+      const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+      if (!gl) {
+        return null;
+      }
+      const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+      let vendor = null;
+      let renderer = null;
+      if (debugInfo) {
+        vendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) || null;
+        renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || null;
+      } else {
+        vendor = gl.getParameter(gl.VENDOR) || null;
+        renderer = gl.getParameter(gl.RENDERER) || null;
+      }
+      const version = gl.getParameter(gl.VERSION) || null;
+      const shadingLanguageVersion = gl.getParameter(gl.SHADING_LANGUAGE_VERSION) || null;
+      const extensions = [];
+      try {
+        const supportedExtensions = gl.getSupportedExtensions();
+        if (supportedExtensions) {
+          extensions.push(...supportedExtensions);
+        }
+      } catch (e) {
+      }
+      const parameters = {
+        maxTextureSize: gl.getParameter(gl.MAX_TEXTURE_SIZE),
+        maxVertexAttribs: gl.getParameter(gl.MAX_VERTEX_ATTRIBS),
+        maxViewportDims: gl.getParameter(gl.MAX_VIEWPORT_DIMS),
+        maxTextureImageUnits: gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS),
+        maxCombinedTextureImageUnits: gl.getParameter(gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
+        maxFragmentUniformVectors: gl.getParameter(gl.MAX_FRAGMENT_UNIFORM_VECTORS),
+        maxVaryingVectors: gl.getParameter(gl.MAX_VARYING_VECTORS),
+        aliasedLineWidthRange: gl.getParameter(gl.ALIASED_LINE_WIDTH_RANGE),
+        aliasedPointSizeRange: gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE)
+      };
+      const precision = {};
+      try {
+        const vertexShader = gl.createShader(gl.VERTEX_SHADER);
+        if (vertexShader) {
+          gl.shaderSource(vertexShader, "precision mediump float;");
+          gl.compileShader(vertexShader);
+          const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+          if (fragmentShader) {
+            gl.shaderSource(fragmentShader, "precision mediump float;");
+            gl.compileShader(fragmentShader);
+            precision.float = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_FLOAT)?.precision?.toString() || "unknown";
+            precision.int = gl.getShaderPrecisionFormat(gl.FRAGMENT_SHADER, gl.HIGH_INT)?.precision?.toString() || "unknown";
+          }
+        }
+      } catch (e) {
+      }
+      const duration = performance.now() - startTime;
+      this.cachedFingerprint = {
+        vendor,
+        renderer,
+        version,
+        shadingLanguageVersion,
+        extensions: extensions.sort(),
+        // Sort for consistency
+        parameters,
+        precision,
+        duration: Math.round(duration * 100) / 100
+      };
+      return this.cachedFingerprint;
+    } catch (error) {
+      console.warn("[Keverd SDK] WebGL fingerprinting failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/audio-fingerprint.ts
+var AudioFingerprintCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Generate audio fingerprint
+   * Returns null if audio context is not available
+   */
+  async collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    try {
+      const AudioContext = window.AudioContext || window.webkitAudioContext || window.mozAudioContext;
+      if (!AudioContext) {
+        return null;
+      }
+      const context = new AudioContext();
+      const oscillator = context.createOscillator();
+      const analyser = context.createAnalyser();
+      const gainNode = context.createGain();
+      const scriptProcessor = context.createScriptProcessor(4096, 1, 1);
+      analyser.fftSize = 2048;
+      analyser.smoothingTimeConstant = 0.8;
+      oscillator.connect(analyser);
+      analyser.connect(scriptProcessor);
+      scriptProcessor.connect(gainNode);
+      gainNode.connect(context.destination);
+      oscillator.type = "triangle";
+      oscillator.frequency.value = 1e4;
+      return new Promise((resolve) => {
+        const audioData = [];
+        let sampleCount = 0;
+        const maxSamples = 5;
+        scriptProcessor.onaudioprocess = (event) => {
+          const inputBuffer = event.inputBuffer;
+          const inputData = inputBuffer.getChannelData(0);
+          let sum = 0;
+          for (let i = 0; i < inputData.length; i++) {
+            sum += inputData[i] * inputData[i];
+          }
+          const rms = Math.sqrt(sum / inputData.length);
+          audioData.push(rms);
+          sampleCount++;
+          if (sampleCount >= maxSamples) {
+            oscillator.stop();
+            context.close();
+            const fingerprint = this.calculateFingerprint(audioData);
+            const duration = performance.now() - startTime;
+            this.cachedFingerprint = {
+              value: fingerprint,
+              duration: Math.round(duration * 100) / 100
+            };
+            resolve(this.cachedFingerprint);
+          }
+        };
+        oscillator.start(0);
+        gainNode.gain.value = 0;
+        setTimeout(() => {
+          if (!this.cachedFingerprint) {
+            oscillator.stop();
+            context.close();
+            const fallbackFingerprint = this.getFallbackFingerprint(context);
+            const duration = performance.now() - startTime;
+            this.cachedFingerprint = {
+              value: fallbackFingerprint,
+              duration: Math.round(duration * 100) / 100
+            };
+            resolve(this.cachedFingerprint);
+          }
+        }, 1e3);
+      });
+    } catch (error) {
+      console.warn("[Keverd SDK] Audio fingerprinting failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Calculate fingerprint from audio data
+   */
+  calculateFingerprint(audioData) {
+    if (audioData.length === 0) {
+      return 0;
+    }
+    const sum = audioData.reduce((a, b) => a + b, 0);
+    const mean = sum / audioData.length;
+    const variance = audioData.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / audioData.length;
+    const stdDev = Math.sqrt(variance);
+    const fingerprint = mean * 1e6 + stdDev * 1e3 + audioData.length;
+    return Math.round(fingerprint * 100) / 100;
+  }
+  /**
+   * Get fallback fingerprint when audio processing fails
+   */
+  getFallbackFingerprint(context) {
+    const sampleRate = context.sampleRate || 44100;
+    const state = context.state || "unknown";
+    const hash = (sampleRate.toString() + state).split("").reduce((acc, char) => {
+      return (acc << 5) - acc + char.charCodeAt(0);
+    }, 0);
+    return Math.abs(hash);
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/font-detection.ts
+var FontDetectionCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+    // Common fonts to test
+    this.testFonts = [
+      "Arial",
+      "Verdana",
+      "Times New Roman",
+      "Courier New",
+      "Georgia",
+      "Palatino",
+      "Garamond",
+      "Bookman",
+      "Comic Sans MS",
+      "Trebuchet MS",
+      "Arial Black",
+      "Impact",
+      "Tahoma",
+      "Lucida Console",
+      "Lucida Sans Unicode",
+      "MS Sans Serif",
+      "MS Serif",
+      "Symbol",
+      "Webdings",
+      "Wingdings",
+      "Monaco",
+      "Menlo",
+      "Consolas",
+      "Courier",
+      "Helvetica",
+      "Helvetica Neue",
+      "Roboto",
+      "Open Sans",
+      "Lato",
+      "Montserrat"
+    ];
+  }
+  /**
+   * Detect available fonts
+   * Returns null if detection fails
+   */
+  collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    try {
+      const canvas = document.createElement("canvas");
+      const ctx = canvas.getContext("2d");
+      if (!ctx) {
+        return null;
+      }
+      const baseFont = "monospace";
+      const testString = "mmmmmmmmmmlli";
+      const testSize = "72px";
+      ctx.font = `${testSize} ${baseFont}`;
+      const baseWidth = ctx.measureText(testString).width;
+      const availableFonts = [];
+      const missingFonts = [];
+      for (const font of this.testFonts) {
+        ctx.font = `${testSize} ${font}, ${baseFont}`;
+        const width = ctx.measureText(testString).width;
+        if (Math.abs(width - baseWidth) > 1) {
+          availableFonts.push(font);
+        } else {
+          missingFonts.push(font);
+        }
+      }
+      const duration = performance.now() - startTime;
+      this.cachedFingerprint = {
+        availableFonts: availableFonts.sort(),
+        missingFonts: missingFonts.sort(),
+        duration: Math.round(duration * 100) / 100
+      };
+      return this.cachedFingerprint;
+    } catch (error) {
+      console.warn("[Keverd SDK] Font detection failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/media-devices.ts
+var MediaDevicesCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Collect media device information
+   * Returns null if MediaDevices API is not available
+   */
+  async collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    try {
+      if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) {
+        return null;
+      }
+      let hasPermission = false;
+      try {
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true, video: false });
+        hasPermission = true;
+        stream.getTracks().forEach((track) => track.stop());
+      } catch (e) {
+        hasPermission = false;
+      }
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      const audioInputs = [];
+      const audioOutputs = [];
+      const videoInputs = [];
+      devices.forEach((device) => {
+        const sanitizedDevice = {
+          deviceId: device.deviceId,
+          kind: device.kind,
+          label: hasPermission ? device.label : "",
+          // Only include label if permission granted
+          groupId: device.groupId,
+          toJSON: () => ({
+            deviceId: device.deviceId,
+            kind: device.kind,
+            label: hasPermission ? device.label : "",
+            groupId: device.groupId
+          })
+        };
+        switch (device.kind) {
+          case "audioinput":
+            audioInputs.push(sanitizedDevice);
+            break;
+          case "audiooutput":
+            audioOutputs.push(sanitizedDevice);
+            break;
+          case "videoinput":
+            videoInputs.push(sanitizedDevice);
+            break;
+        }
+      });
+      const duration = performance.now() - startTime;
+      this.cachedFingerprint = {
+        audioInputs,
+        audioOutputs,
+        videoInputs,
+        hasPermission,
+        duration: Math.round(duration * 100) / 100
+      };
+      return this.cachedFingerprint;
+    } catch (error) {
+      console.warn("[Keverd SDK] Media devices enumeration failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/screen-display.ts
+var ScreenDisplayCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Collect screen and display information
+   */
+  collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    const fingerprint = {
+      width: screen.width,
+      height: screen.height,
+      availWidth: screen.availWidth,
+      availHeight: screen.availHeight,
+      colorDepth: screen.colorDepth,
+      pixelDepth: screen.pixelDepth,
+      pixelRatio: window.devicePixelRatio || 1,
+      orientation: this.getOrientation(),
+      orientationAngle: this.getOrientationAngle(),
+      duration: 0
+    };
+    fingerprint.duration = Math.round((performance.now() - startTime) * 100) / 100;
+    this.cachedFingerprint = fingerprint;
+    return fingerprint;
+  }
+  /**
+   * Get screen orientation
+   */
+  getOrientation() {
+    if ("orientation" in screen) {
+      const orientation = screen.orientation;
+      if (orientation && orientation.type) {
+        return orientation.type;
+      }
+    }
+    if ("orientation" in window) {
+      const angle = window.orientation;
+      if (angle !== void 0) {
+        if (angle === 0 || angle === 180) {
+          return "portrait";
+        } else if (angle === 90 || angle === -90) {
+          return "landscape";
+        }
+      }
+    }
+    if (window.matchMedia) {
+      if (window.matchMedia("(orientation: portrait)").matches) {
+        return "portrait";
+      } else if (window.matchMedia("(orientation: landscape)").matches) {
+        return "landscape";
+      }
+    }
+    return null;
+  }
+  /**
+   * Get screen orientation angle
+   */
+  getOrientationAngle() {
+    if ("orientation" in screen) {
+      const orientation = screen.orientation;
+      if (orientation && typeof orientation.angle === "number") {
+        return orientation.angle;
+      }
+    }
+    if ("orientation" in window) {
+      const angle = window.orientation;
+      if (typeof angle === "number") {
+        return angle;
+      }
+    }
+    return null;
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/timezone-locale.ts
+var TimezoneLocaleCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Collect timezone and locale information
+   */
+  collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+    const resolvedOptions = Intl.DateTimeFormat().resolvedOptions();
+    const locale = resolvedOptions.locale;
+    const locales = navigator.languages || [navigator.language];
+    const dateFormat = this.getDateFormat();
+    const timeFormat = this.getTimeFormat();
+    const numberFormat = this.getNumberFormat();
+    const calendar = resolvedOptions.calendar || null;
+    const fingerprint = {
+      timezone,
+      timezoneOffset,
+      locale,
+      locales: locales.slice(0, 5),
+      // Limit to first 5 locales
+      dateFormat,
+      timeFormat,
+      numberFormat,
+      calendar,
+      duration: 0
+    };
+    fingerprint.duration = Math.round((performance.now() - startTime) * 100) / 100;
+    this.cachedFingerprint = fingerprint;
+    return fingerprint;
+  }
+  /**
+   * Get date format preference
+   */
+  getDateFormat() {
+    try {
+      const formatter = new Intl.DateTimeFormat();
+      const sample = formatter.format(new Date(2023, 0, 15));
+      if (sample.includes("/")) {
+        return "numeric";
+      } else if (sample.includes("-")) {
+        return "iso";
+      } else if (sample.includes(".")) {
+        return "european";
+      }
+      return "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Get time format preference (12h vs 24h)
+   */
+  getTimeFormat() {
+    try {
+      const formatter = new Intl.DateTimeFormat(void 0, {
+        hour: "numeric",
+        minute: "numeric"
+      });
+      const sample = formatter.format(new Date(2023, 0, 15, 13, 30));
+      if (sample.toLowerCase().includes("am") || sample.toLowerCase().includes("pm")) {
+        return "12h";
+      }
+      return "24h";
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Get number format preference
+   */
+  getNumberFormat() {
+    try {
+      const formatter = new Intl.NumberFormat();
+      const sample = formatter.format(1234.56);
+      if (sample.includes(",")) {
+        return "european";
+      } else if (sample.includes(".")) {
+        return "american";
+      }
+      return "unknown";
+    } catch {
+      return "unknown";
+    }
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/plugin-mime.ts
+var PluginMimeCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Collect plugin and MIME type information
+   * Returns null if plugins are not available (modern browsers)
+   */
+  collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    try {
+      if (!navigator.plugins || navigator.plugins.length === 0) {
+        return null;
+      }
+      const plugins = [];
+      const allMimeTypes = /* @__PURE__ */ new Set();
+      for (let i = 0; i < Math.min(navigator.plugins.length, 10); i++) {
+        const plugin = navigator.plugins[i];
+        if (!plugin) continue;
+        const mimeTypes = [];
+        for (let j = 0; j < Math.min(plugin.length, 5); j++) {
+          const mimeType = plugin[j];
+          if (mimeType && mimeType.type) {
+            mimeTypes.push(mimeType.type);
+            allMimeTypes.add(mimeType.type);
+          }
+        }
+        plugins.push({
+          name: plugin.name || "Unknown",
+          description: plugin.description || "",
+          mimeTypes
+        });
+      }
+      const fingerprint = {
+        plugins,
+        mimeTypes: Array.from(allMimeTypes).sort(),
+        duration: 0
+      };
+      fingerprint.duration = Math.round((performance.now() - startTime) * 100) / 100;
+      this.cachedFingerprint = fingerprint;
+      return fingerprint;
+    } catch (error) {
+      console.warn("[Keverd SDK] Plugin/MIME collection failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/battery-api.ts
+var BatteryAPICollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Collect battery information
+   * Returns null if Battery API is not available
+   */
+  async collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    try {
+      const batteryManager = await this.getBatteryManager();
+      if (!batteryManager) {
+        return null;
+      }
+      const fingerprint = {
+        level: batteryManager.level,
+        charging: batteryManager.charging,
+        chargingTime: batteryManager.chargingTime,
+        dischargingTime: batteryManager.dischargingTime,
+        duration: 0
+      };
+      fingerprint.duration = Math.round((performance.now() - startTime) * 100) / 100;
+      this.cachedFingerprint = fingerprint;
+      return fingerprint;
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Get battery manager from various API locations
+   */
+  async getBatteryManager() {
+    if ("getBattery" in navigator) {
+      try {
+        return await navigator.getBattery();
+      } catch (e) {
+      }
+    }
+    if ("webkitGetBattery" in navigator) {
+      try {
+        return await navigator.webkitGetBattery();
+      } catch (e) {
+      }
+    }
+    if ("mozGetBattery" in navigator) {
+      try {
+        return await navigator.mozGetBattery();
+      } catch (e) {
+      }
+    }
+    return null;
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/storage-database.ts
+var StorageDatabaseCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Collect storage and database information
+   */
+  async collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    const fingerprint = {
+      localStorage: await this.checkLocalStorage(),
+      sessionStorage: await this.checkSessionStorage(),
+      indexedDB: this.checkIndexedDB(),
+      webSQL: this.checkWebSQL(),
+      duration: 0
+    };
+    fingerprint.duration = Math.round((performance.now() - startTime) * 100) / 100;
+    this.cachedFingerprint = fingerprint;
+    return fingerprint;
+  }
+  /**
+   * Check localStorage availability and quota
+   */
+  async checkLocalStorage() {
+    let available = false;
+    let quota = null;
+    let usage = null;
+    try {
+      const test = "__localStorage_test__";
+      localStorage.setItem(test, test);
+      localStorage.removeItem(test);
+      available = true;
+      if ("storage" in navigator && "estimate" in navigator.storage) {
+        try {
+          const estimate = await navigator.storage.estimate();
+          if (estimate) {
+            quota = estimate.quota || null;
+            usage = estimate.usage || null;
+          }
+        } catch (e) {
+        }
+      }
+    } catch (e) {
+      available = false;
+    }
+    return { available, quota, usage };
+  }
+  /**
+   * Check sessionStorage availability and quota
+   */
+  async checkSessionStorage() {
+    let available = false;
+    let quota = null;
+    let usage = null;
+    try {
+      const test = "__sessionStorage_test__";
+      sessionStorage.setItem(test, test);
+      sessionStorage.removeItem(test);
+      available = true;
+      if ("storage" in navigator && "estimate" in navigator.storage) {
+        try {
+          const estimate = await navigator.storage.estimate();
+          if (estimate) {
+            quota = estimate.quota || null;
+            usage = estimate.usage || null;
+          }
+        } catch (e) {
+        }
+      }
+    } catch (e) {
+      available = false;
+    }
+    return { available, quota, usage };
+  }
+  /**
+   * Check IndexedDB availability
+   */
+  checkIndexedDB() {
+    return {
+      available: "indexedDB" in window && !!window.indexedDB
+    };
+  }
+  /**
+   * Check WebSQL availability (deprecated but still in some browsers)
+   */
+  checkWebSQL() {
+    return {
+      available: "openDatabase" in window && !!window.openDatabase
+    };
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/cpu-memory.ts
+var CPUMemoryCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Collect CPU and memory information
+   */
+  collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    const fingerprint = {
+      hardwareConcurrency: navigator.hardwareConcurrency || 0,
+      deviceMemory: this.getDeviceMemory(),
+      performanceMemory: this.getPerformanceMemory(),
+      duration: 0
+    };
+    fingerprint.duration = Math.round((performance.now() - startTime) * 100) / 100;
+    this.cachedFingerprint = fingerprint;
+    return fingerprint;
+  }
+  /**
+   * Get device memory (if available)
+   */
+  getDeviceMemory() {
+    if ("deviceMemory" in navigator && navigator.deviceMemory) {
+      return navigator.deviceMemory;
+    }
+    return null;
+  }
+  /**
+   * Get performance memory information (Chrome-specific)
+   */
+  getPerformanceMemory() {
+    if ("memory" in performance) {
+      const memory = performance.memory;
+      return {
+        jsHeapSizeLimit: memory.jsHeapSizeLimit || null,
+        totalJSHeapSize: memory.totalJSHeapSize || null,
+        usedJSHeapSize: memory.usedJSHeapSize || null
+      };
+    }
+    return {
+      jsHeapSizeLimit: null,
+      totalJSHeapSize: null,
+      usedJSHeapSize: null
+    };
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/touch-pointer.ts
+var TouchPointerCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Collect touch and pointer information
+   */
+  collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    const fingerprint = {
+      maxTouchPoints: navigator.maxTouchPoints || 0,
+      touchSupport: this.checkTouchSupport(),
+      pointerSupport: this.checkPointerSupport(),
+      pointerTypes: this.getPointerTypes(),
+      duration: 0
+    };
+    fingerprint.duration = Math.round((performance.now() - startTime) * 100) / 100;
+    this.cachedFingerprint = fingerprint;
+    return fingerprint;
+  }
+  /**
+   * Check if touch events are supported
+   */
+  checkTouchSupport() {
+    return "ontouchstart" in window || navigator.maxTouchPoints > 0 || !!window.DocumentTouch && document instanceof window.DocumentTouch;
+  }
+  /**
+   * Check if Pointer Events are supported
+   */
+  checkPointerSupport() {
+    return "PointerEvent" in window || "MSPointerEvent" in window;
+  }
+  /**
+   * Get available pointer types
+   */
+  getPointerTypes() {
+    const types = [];
+    if ("PointerEvent" in window) {
+      if (navigator.maxTouchPoints > 0) {
+        types.push("touch");
+      }
+      types.push("mouse");
+      if ("pen" in navigator) {
+        types.push("pen");
+      }
+    }
+    return types;
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/permissions-api.ts
+var PermissionsAPICollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Collect permission states
+   * Returns null if Permissions API is not available
+   */
+  async collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    try {
+      if (!("permissions" in navigator)) {
+        return null;
+      }
+      const permissions = navigator.permissions;
+      const fingerprint = {
+        camera: await this.queryPermission(permissions, "camera"),
+        microphone: await this.queryPermission(permissions, "microphone"),
+        notifications: await this.queryPermission(permissions, "notifications"),
+        geolocation: await this.queryPermission(permissions, "geolocation"),
+        persistentStorage: await this.queryPermission(permissions, "persistent-storage"),
+        duration: 0
+      };
+      fingerprint.duration = Math.round((performance.now() - startTime) * 100) / 100;
+      this.cachedFingerprint = fingerprint;
+      return fingerprint;
+    } catch (error) {
+      console.warn("[Keverd SDK] Permissions API collection failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Query a specific permission
+   */
+  async queryPermission(permissions, name) {
+    try {
+      const result = await permissions.query({ name });
+      return result.state || null;
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/webrtc-ip.ts
+var WebRTCIPCollector = class {
+  constructor() {
+    this.cachedFingerprint = null;
+  }
+  /**
+   * Collect WebRTC IP information
+   * Returns null if WebRTC is not available or fails
+   */
+  async collect() {
+    if (this.cachedFingerprint) {
+      return this.cachedFingerprint;
+    }
+    const startTime = performance.now();
+    try {
+      const RTCPeerConnection = window.RTCPeerConnection || window.webkitRTCPeerConnection || window.mozRTCPeerConnection;
+      if (!RTCPeerConnection) {
+        return null;
+      }
+      const localIPs = [];
+      let publicIP = null;
+      const pc = new RTCPeerConnection({
+        iceServers: [{ urls: "stun:stun.l.google.com:19302" }]
+      });
+      pc.onicecandidate = (event) => {
+        if (event.candidate) {
+          const candidate = event.candidate.candidate;
+          const ipMatch = candidate.match(/([0-9]{1,3}\.){3}[0-9]{1,3}/);
+          if (ipMatch) {
+            const ip = ipMatch[0];
+            if (this.isLocalIP(ip)) {
+              if (!localIPs.includes(ip)) {
+                localIPs.push(ip);
+              }
+            } else {
+              publicIP = ip;
+            }
+          }
+        }
+      };
+      pc.createDataChannel("");
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          resolve();
+        }, 2e3);
+        pc.onicegatheringstatechange = () => {
+          if (pc.iceGatheringState === "complete") {
+            clearTimeout(timeout);
+            resolve();
+          }
+        };
+        if (pc.iceGatheringState === "complete") {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+      pc.close();
+      const fingerprint = {
+        localIPs: localIPs.sort(),
+        publicIP,
+        duration: 0
+      };
+      fingerprint.duration = Math.round((performance.now() - startTime) * 100) / 100;
+      this.cachedFingerprint = fingerprint;
+      return fingerprint;
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Check if an IP is a local/private IP
+   */
+  isLocalIP(ip) {
+    if (ip === "127.0.0.1" || ip === "::1") {
+      return true;
+    }
+    const parts = ip.split(".");
+    if (parts.length === 4) {
+      const first = parseInt(parts[0], 10);
+      const second = parseInt(parts[1], 10);
+      if (first === 10) {
+        return true;
+      }
+      if (first === 172 && second >= 16 && second <= 31) {
+        return true;
+      }
+      if (first === 192 && second === 168) {
+        return true;
+      }
+      if (first === 169 && second === 254) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Clear cached fingerprint
+   */
+  clearCache() {
+    this.cachedFingerprint = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/visitor-id-generator.ts
+var VisitorIDGenerator = class {
+  /**
+   * Generate a stable visitor ID from fingerprint components
+   * Uses SHA-256-like hashing for consistency
+   */
+  generate(components) {
+    const identifiers = [];
+    if (components.canvas?.value) {
+      identifiers.push(`canvas:${components.canvas.value}`);
+    }
+    if (components.webgl) {
+      if (components.webgl.vendor) {
+        identifiers.push(`webgl_vendor:${components.webgl.vendor}`);
+      }
+      if (components.webgl.renderer) {
+        identifiers.push(`webgl_renderer:${components.webgl.renderer}`);
+      }
+      if (components.webgl.extensions.length > 0) {
+        identifiers.push(`webgl_ext:${components.webgl.extensions.slice(0, 10).join(",")}`);
+      }
+    }
+    if (components.audio?.value) {
+      identifiers.push(`audio:${components.audio.value}`);
+    }
+    if (components.screen) {
+      identifiers.push(`screen:${components.screen.width}x${components.screen.height}x${components.screen.pixelRatio}`);
+      identifiers.push(`color:${components.screen.colorDepth}`);
+    }
+    if (components.timezone) {
+      identifiers.push(`tz:${components.timezone.timezone}`);
+      identifiers.push(`locale:${components.timezone.locale}`);
+    }
+    if (components.cpu) {
+      identifiers.push(`cpu:${components.cpu.hardwareConcurrency}`);
+      if (components.cpu.deviceMemory) {
+        identifiers.push(`memory:${components.cpu.deviceMemory}`);
+      }
+    }
+    if (components.touch) {
+      identifiers.push(`touch:${components.touch.maxTouchPoints}`);
+    }
+    identifiers.push(`ua:${navigator.userAgent}`);
+    identifiers.push(`lang:${navigator.language}`);
+    identifiers.push(`platform:${navigator.platform}`);
+    if (components.fonts && components.fonts.availableFonts.length > 0) {
+      identifiers.push(`fonts:${components.fonts.availableFonts.slice(0, 20).join(",")}`);
+    }
+    const combined = identifiers.join("|");
+    return this.sha256Hash(combined);
+  }
+  /**
+   * Calculate confidence score based on component availability
+   * More components = higher confidence
+   */
+  calculateConfidence(components) {
+    let score = 0;
+    let maxScore = 0;
+    const weights = {
+      canvas: 20,
+      webgl: 20,
+      audio: 15,
+      screen: 10,
+      timezone: 10,
+      cpu: 10,
+      fonts: 10,
+      touch: 5,
+      storage: 5,
+      permissions: 5,
+      webrtc: 5,
+      mediaDevices: 5,
+      battery: 3,
+      plugins: 3
+    };
+    Object.keys(weights).forEach((key) => {
+      maxScore += weights[key];
+      if (components[key]) {
+        score += weights[key];
+      }
+    });
+    return maxScore > 0 ? Math.min(score / maxScore, 1) : 0;
+  }
+  /**
+   * SHA-256-like hash function
+   * Produces a 64-character hex string (matching SHA-256 format)
+   */
+  sha256Hash(input) {
+    if (typeof crypto !== "undefined" && crypto.subtle) {
+      return this.sha256LikeHash(input);
+    }
+    return this.sha256LikeHash(input);
+  }
+  /**
+   * SHA-256-like hash (synchronous, deterministic)
+   * Produces 64-character hex string
+   */
+  sha256LikeHash(str) {
+    const hashes = [];
+    let h1 = 5381;
+    for (let i = 0; i < str.length; i++) {
+      h1 = (h1 << 5) + h1 + str.charCodeAt(i);
+      h1 = h1 & 4294967295;
+    }
+    hashes.push(h1);
+    let h2 = 0;
+    for (let i = str.length - 1; i >= 0; i--) {
+      h2 = (h2 << 7) - h2 + str.charCodeAt(i);
+      h2 = h2 & 4294967295;
+    }
+    hashes.push(h2);
+    let h3 = 0;
+    for (let i = 0; i < str.length; i++) {
+      h3 = h3 ^ str.charCodeAt(i) << i % 4 * 8;
+      h3 = h3 & 4294967295;
+    }
+    hashes.push(h3);
+    let h4 = 0;
+    for (let i = 0; i < str.length; i++) {
+      h4 = h4 * 31 + str.charCodeAt(i) & 4294967295;
+    }
+    hashes.push(h4);
+    let h5 = 0;
+    for (let i = 0; i < str.length; i++) {
+      const rotated = (str.charCodeAt(i) << i % 16 | str.charCodeAt(i) >>> 32 - i % 16) & 4294967295;
+      h5 = h5 + rotated & 4294967295;
+    }
+    hashes.push(h5);
+    let h6 = 2166136261;
+    for (let i = 0; i < str.length; i++) {
+      h6 = (h6 ^ str.charCodeAt(i)) * 16777619;
+      h6 = h6 & 4294967295;
+    }
+    hashes.push(h6);
+    let h7 = 0;
+    for (let i = 0; i < str.length; i++) {
+      h7 = h7 + str.charCodeAt(i) * (i + 1) & 4294967295;
+    }
+    hashes.push(h7);
+    let h8 = 0;
+    for (let i = 0; i < str.length; i += 2) {
+      const combined2 = str.charCodeAt(i) + (str.charCodeAt(i + 1) || 0) * 256;
+      h8 = (h8 << 3) - h8 + combined2;
+      h8 = h8 & 4294967295;
+    }
+    hashes.push(h8);
+    const hexParts = hashes.map((h) => Math.abs(h).toString(16).padStart(8, "0"));
+    const combined = hexParts.join("");
+    return combined.substring(0, 64).padEnd(64, "0");
+  }
+};
+
+// ../fraud-sdk/src/collectors/fingerprint-manager.ts
+var FingerprintManager = class {
+  constructor() {
+    this.cachedData = null;
+    this.collectionStartTime = 0;
+    this.collectors = {
+      canvas: new CanvasFingerprintCollector(),
+      webgl: new WebGLFingerprintCollector(),
+      audio: new AudioFingerprintCollector(),
+      fonts: new FontDetectionCollector(),
+      mediaDevices: new MediaDevicesCollector(),
+      screen: new ScreenDisplayCollector(),
+      timezone: new TimezoneLocaleCollector(),
+      plugins: new PluginMimeCollector(),
+      battery: new BatteryAPICollector(),
+      storage: new StorageDatabaseCollector(),
+      cpu: new CPUMemoryCollector(),
+      touch: new TouchPointerCollector(),
+      permissions: new PermissionsAPICollector(),
+      webrtc: new WebRTCIPCollector()
+    };
+    this.visitorIDGenerator = new VisitorIDGenerator();
+  }
+  /**
+   * Collect all fingerprint data
+   * This is the main method that replaces FingerprintJS.get()
+   */
+  async collect() {
+    if (this.cachedData) {
+      return this.cachedData;
+    }
+    this.collectionStartTime = performance.now();
+    const components = {};
+    try {
+      components.canvas = this.collectors.canvas.collect() || void 0;
+    } catch (e) {
+      console.warn("[Keverd SDK] Canvas collection failed:", e);
+    }
+    try {
+      components.webgl = this.collectors.webgl.collect() || void 0;
+    } catch (e) {
+      console.warn("[Keverd SDK] WebGL collection failed:", e);
+    }
+    try {
+      components.fonts = this.collectors.fonts.collect() || void 0;
+    } catch (e) {
+      console.warn("[Keverd SDK] Font detection failed:", e);
+    }
+    try {
+      components.screen = this.collectors.screen.collect();
+    } catch (e) {
+      console.warn("[Keverd SDK] Screen collection failed:", e);
+    }
+    try {
+      components.timezone = this.collectors.timezone.collect();
+    } catch (e) {
+      console.warn("[Keverd SDK] Timezone collection failed:", e);
+    }
+    try {
+      components.plugins = this.collectors.plugins.collect() || void 0;
+    } catch (e) {
+      console.warn("[Keverd SDK] Plugin collection failed:", e);
+    }
+    try {
+      components.cpu = this.collectors.cpu.collect();
+    } catch (e) {
+      console.warn("[Keverd SDK] CPU collection failed:", e);
+    }
+    try {
+      components.touch = this.collectors.touch.collect();
+    } catch (e) {
+      console.warn("[Keverd SDK] Touch collection failed:", e);
+    }
+    try {
+      components.audio = await this.collectors.audio.collect() || void 0;
+    } catch (e) {
+      console.warn("[Keverd SDK] Audio collection failed:", e);
+    }
+    try {
+      components.mediaDevices = await this.collectors.mediaDevices.collect() || void 0;
+    } catch (e) {
+      console.warn("[Keverd SDK] Media devices collection failed:", e);
+    }
+    try {
+      components.battery = await this.collectors.battery.collect() || void 0;
+    } catch (e) {
+      console.warn("[Keverd SDK] Battery collection failed:", e);
+    }
+    try {
+      components.storage = await this.collectors.storage.collect();
+    } catch (e) {
+      console.warn("[Keverd SDK] Storage collection failed:", e);
+    }
+    try {
+      components.permissions = await this.collectors.permissions.collect() || void 0;
+    } catch (e) {
+      console.warn("[Keverd SDK] Permissions collection failed:", e);
+    }
+    try {
+      components.webrtc = await this.collectors.webrtc.collect() || void 0;
+    } catch (e) {
+      console.warn("[Keverd SDK] WebRTC collection failed:", e);
+    }
+    const visitorId = this.visitorIDGenerator.generate(components);
+    const confidence = this.visitorIDGenerator.calculateConfidence(components);
+    this.cachedData = {
+      visitorId,
+      confidence: Math.round(confidence * 1e3) / 1e3,
+      // Round to 3 decimal places
+      components,
+      version: "1.0.0",
+      // SDK version
+      timestamp: Date.now()
+    };
+    return this.cachedData;
+  }
+  /**
+   * Get visitor ID only (faster, uses cached data if available)
+   */
+  async getVisitorId() {
+    const data = await this.collect();
+    return data.visitorId;
+  }
+  /**
+   * Clear all cached data
+   */
+  clearCache() {
+    this.cachedData = null;
+    Object.values(this.collectors).forEach((collector) => {
+      if (collector && typeof collector.clearCache === "function") {
+        collector.clearCache();
+      }
+    });
+  }
+  /**
+   * Get collection statistics
+   */
+  getStats() {
+    if (!this.cachedData) {
+      return {
+        componentsCollected: 0,
+        totalComponents: 13,
+        collectionTime: 0
+      };
+    }
+    const componentsCollected = Object.keys(this.cachedData.components).length;
+    const collectionTime = performance.now() - this.collectionStartTime;
+    return {
+      componentsCollected,
+      totalComponents: 13,
+      collectionTime: Math.round(collectionTime * 100) / 100
+    };
+  }
+};
+
+// ../fraud-sdk/src/collectors/privacy-signals.ts
+var PrivacySignalCollector = class {
+  constructor() {
+    this.cachedSignals = null;
+  }
+  /**
+   * Collect all privacy signals
+   */
+  collect() {
+    if (this.cachedSignals) {
+      return this.cachedSignals;
+    }
+    const signals = {
+      isIncognito: this.detectIncognito(),
+      isVPN: false,
+      // VPN detection requires backend IP analysis
+      isAutomated: this.detectAutomation(),
+      hasAdBlocker: this.detectAdBlocker()
+    };
+    this.cachedSignals = signals;
+    return signals;
+  }
+  /**
+   * Detect incognito/private mode
+   * Uses multiple detection methods for accuracy
+   */
+  detectIncognito() {
+    try {
+      if ("storage" in navigator && "estimate" in navigator.storage) {
+        try {
+          navigator.storage.estimate().then(() => {
+          }).catch(() => {
+          });
+        } catch {
+          return true;
+        }
+      }
+      if ("storage" in navigator && "estimate" in navigator.storage) {
+      }
+      if ("getBattery" in navigator) {
+      }
+      if (window.chrome && window.chrome.runtime && !window.chrome.runtime.onConnect) {
+        return true;
+      }
+      try {
+        const testKey = "__incognito_test__";
+        localStorage.setItem(testKey, "test");
+        localStorage.removeItem(testKey);
+      } catch {
+        return true;
+      }
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Detect automation/bot frameworks
+   */
+  detectAutomation() {
+    try {
+      if (navigator.webdriver === true) {
+        return true;
+      }
+      if (window.chrome && window.chrome.runtime && window.chrome.runtime.onConnect) {
+        const hasDevTools = window.chrome.runtime.onConnect.hasListeners();
+        if (hasDevTools) {
+          return true;
+        }
+      }
+      if (!window.chrome && !window.safari) {
+        if (!window.Notification || !window.DeviceMotionEvent) {
+          return true;
+        }
+      }
+      try {
+        const canvas = document.createElement("canvas");
+        const ctx = canvas.getContext("2d");
+        if (ctx) {
+          ctx.textBaseline = "top";
+          ctx.font = "14px Arial";
+          ctx.fillText("Automation test", 2, 2);
+          const fingerprint = canvas.toDataURL();
+          if (fingerprint.length < 100) {
+            return true;
+          }
+        }
+      } catch {
+      }
+      if (window.__nightmare || window.__phantomas || window.Buffer) {
+        return true;
+      }
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Detect ad blocker
+   */
+  detectAdBlocker() {
+    try {
+      const testDiv = document.createElement("div");
+      testDiv.innerHTML = "&nbsp;";
+      testDiv.className = "adsbox";
+      testDiv.style.position = "absolute";
+      testDiv.style.left = "-9999px";
+      document.body.appendChild(testDiv);
+      setTimeout(() => {
+        const isBlocked = testDiv.offsetHeight === 0 || testDiv.offsetWidth === 0;
+        document.body.removeChild(testDiv);
+        return isBlocked;
+      }, 100);
+      const scripts = Array.from(document.getElementsByTagName("script"));
+      const blockedCount = scripts.filter((script) => {
+        return script.src && script.src.includes("ads") && !script.textContent;
+      }).length;
+      if (blockedCount > 0) {
+        return true;
+      }
+      if (window.uBlock || window.adblock || window.BlockAdBlock) {
+        return true;
+      }
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Clear cached signals (useful for testing)
+   */
+  clearCache() {
+    this.cachedSignals = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/browser-capabilities.ts
+var BrowserCapabilityCollector = class {
+  constructor() {
+    this.cachedCapabilities = null;
+  }
+  /**
+   * Collect all browser capabilities
+   */
+  collect() {
+    if (this.cachedCapabilities) {
+      return this.cachedCapabilities;
+    }
+    const capabilities = {
+      hasWebGL: this.checkWebGL(),
+      hasCanvas: this.checkCanvas(),
+      hasWebRTC: this.checkWebRTC(),
+      hasServiceWorker: this.checkServiceWorker(),
+      hasIndexedDB: this.checkIndexedDB(),
+      hasLocalStorage: this.checkLocalStorage(),
+      hasSessionStorage: this.checkSessionStorage(),
+      cookieEnabled: navigator.cookieEnabled,
+      doNotTrack: navigator.doNotTrack === "1" || navigator.doNotTrack === "yes"
+    };
+    this.cachedCapabilities = capabilities;
+    return capabilities;
+  }
+  checkWebGL() {
+    try {
+      const canvas = document.createElement("canvas");
+      return !!(canvas.getContext("webgl") || canvas.getContext("experimental-webgl"));
+    } catch {
+      return false;
+    }
+  }
+  checkCanvas() {
+    try {
+      const canvas = document.createElement("canvas");
+      return !!canvas.getContext("2d");
+    } catch {
+      return false;
+    }
+  }
+  checkWebRTC() {
+    return !!((window.RTCPeerConnection || // @ts-ignore
+    window.webkitRTCPeerConnection || // @ts-ignore
+    window.mozRTCPeerConnection) && navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
+  }
+  checkServiceWorker() {
+    return "serviceWorker" in navigator;
+  }
+  checkIndexedDB() {
+    return "indexedDB" in window;
+  }
+  checkLocalStorage() {
+    try {
+      const test = "__localStorage_test__";
+      localStorage.setItem(test, test);
+      localStorage.removeItem(test);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  checkSessionStorage() {
+    try {
+      const test = "__sessionStorage_test__";
+      sessionStorage.setItem(test, test);
+      sessionStorage.removeItem(test);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Clear cached capabilities (useful for testing)
+   */
+  clearCache() {
+    this.cachedCapabilities = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/hardware-signals.ts
+var HardwareSignalCollector = class {
+  constructor() {
+    this.cachedSignals = null;
+  }
+  /**
+   * Collect all hardware signals
+   */
+  collect() {
+    if (this.cachedSignals) {
+      return this.cachedSignals;
+    }
+    const signals = {
+      hardwareConcurrency: navigator.hardwareConcurrency || 0,
+      deviceMemory: this.getDeviceMemory(),
+      maxTouchPoints: navigator.maxTouchPoints || 0,
+      connectionType: this.getConnectionType(),
+      effectiveType: this.getEffectiveType(),
+      downlink: this.getDownlink(),
+      rtt: this.getRTT(),
+      saveData: this.getSaveData()
+    };
+    this.cachedSignals = signals;
+    return signals;
+  }
+  getDeviceMemory() {
+    if ("deviceMemory" in navigator && navigator.deviceMemory) {
+      return navigator.deviceMemory;
+    }
+    return null;
+  }
+  getConnectionType() {
+    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (connection && connection.type) {
+      return connection.type;
+    }
+    return null;
+  }
+  getEffectiveType() {
+    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (connection && connection.effectiveType) {
+      return connection.effectiveType;
+    }
+    return null;
+  }
+  getDownlink() {
+    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (connection && connection.downlink) {
+      return connection.downlink;
+    }
+    return null;
+  }
+  getRTT() {
+    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (connection && connection.rtt) {
+      return connection.rtt;
+    }
+    return null;
+  }
+  getSaveData() {
+    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (connection && connection.saveData !== void 0) {
+      return connection.saveData;
+    }
+    return null;
+  }
+  /**
+   * Clear cached signals (useful for testing)
+   */
+  clearCache() {
+    this.cachedSignals = null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/form-interactions.ts
+var FormInteractionCollector = class {
   constructor() {
+    this.focusCount = 0;
+    this.blurCount = 0;
+    this.copyCount = 0;
+    this.pasteCount = 0;
+    this.cutCount = 0;
+    this.fieldFocusOrder = [];
+    this.fieldFocusTimes = /* @__PURE__ */ new Map();
+    this.backspaceCount = 0;
+    this.deleteCount = 0;
+    this.autofillDetected = false;
+    this.autocompleteDetected = false;
+    this.isActive = false;
+    this.focusHandler = (event) => this.handleFocus(event);
+    this.blurHandler = (event) => this.handleBlur(event);
+    this.copyHandler = (event) => this.handleCopy(event);
+    this.pasteHandler = (event) => this.handlePaste(event);
+    this.cutHandler = (event) => this.handleCut(event);
+    this.keydownHandler = (event) => this.handleKeyDown(event);
+    this.inputHandler = (event) => this.handleInput(event);
+  }
+  /**
+   * Start collecting form interactions
+   */
+  start() {
+    if (this.isActive || typeof document === "undefined") return;
+    document.addEventListener("focus", this.focusHandler, true);
+    document.addEventListener("blur", this.blurHandler, true);
+    document.addEventListener("copy", this.copyHandler, true);
+    document.addEventListener("paste", this.pasteHandler, true);
+    document.addEventListener("cut", this.cutHandler, true);
+    document.addEventListener("keydown", this.keydownHandler, true);
+    document.addEventListener("input", this.inputHandler, true);
+    this.isActive = true;
+  }
+  /**
+   * Stop collecting form interactions
+   */
+  stop() {
+    if (!this.isActive || typeof document === "undefined") return;
+    document.removeEventListener("focus", this.focusHandler, true);
+    document.removeEventListener("blur", this.blurHandler, true);
+    document.removeEventListener("copy", this.copyHandler, true);
+    document.removeEventListener("paste", this.pasteHandler, true);
+    document.removeEventListener("cut", this.cutHandler, true);
+    document.removeEventListener("keydown", this.keydownHandler, true);
+    document.removeEventListener("input", this.inputHandler, true);
+    this.isActive = false;
+  }
+  /**
+   * Get collected form interaction data
+   */
+  getData() {
+    const timePerField = {};
+    this.fieldFocusTimes.forEach((time, fieldId) => {
+      timePerField[fieldId] = time;
+    });
+    return {
+      focusCount: this.focusCount,
+      blurCount: this.blurCount,
+      copyCount: this.copyCount,
+      pasteCount: this.pasteCount,
+      cutCount: this.cutCount,
+      autofillDetected: this.autofillDetected,
+      autocompleteDetected: this.autocompleteDetected,
+      fieldFocusOrder: [...this.fieldFocusOrder],
+      timePerField,
+      backspaceCount: this.backspaceCount,
+      deleteCount: this.deleteCount
+    };
+  }
+  /**
+   * Reset all collected data
+   */
+  reset() {
+    this.focusCount = 0;
+    this.blurCount = 0;
+    this.copyCount = 0;
+    this.pasteCount = 0;
+    this.cutCount = 0;
+    this.fieldFocusOrder = [];
+    this.fieldFocusTimes.clear();
+    this.backspaceCount = 0;
+    this.deleteCount = 0;
+    this.autofillDetected = false;
+    this.autocompleteDetected = false;
+  }
+  handleFocus(event) {
+    const target = event.target;
+    if (!this.isFormField(target)) return;
+    this.focusCount++;
+    const fieldId = this.getFieldId(target);
+    if (fieldId && !this.fieldFocusOrder.includes(fieldId)) {
+      this.fieldFocusOrder.push(fieldId);
+    }
+    this.fieldFocusTimes.set(fieldId || "unknown", Date.now());
+  }
+  handleBlur(event) {
+    const target = event.target;
+    if (!this.isFormField(target)) return;
+    this.blurCount++;
+    const fieldId = this.getFieldId(target);
+    if (fieldId) {
+      const focusTime = this.fieldFocusTimes.get(fieldId) || Date.now();
+      const timeSpent = Date.now() - focusTime;
+      this.fieldFocusTimes.set(fieldId, timeSpent);
+    }
+  }
+  handleCopy(event) {
+    const target = event.target;
+    if (this.isFormField(target)) {
+      this.copyCount++;
+    }
+  }
+  handlePaste(event) {
+    const target = event.target;
+    if (this.isFormField(target)) {
+      this.pasteCount++;
+    }
+  }
+  handleCut(event) {
+    const target = event.target;
+    if (this.isFormField(target)) {
+      this.cutCount++;
+    }
+  }
+  handleKeyDown(event) {
+    const target = event.target;
+    if (!this.isFormField(target)) return;
+    if (event.key === "Backspace") {
+      this.backspaceCount++;
+    } else if (event.key === "Delete") {
+      this.deleteCount++;
+    }
+  }
+  handleInput(event) {
+    const target = event.target;
+    if (!this.isFormField(target)) return;
+    const value = target.value;
+    if (value && target.type === "password") {
+      this.autofillDetected = true;
+    }
+    if (target.hasAttribute("autocomplete") && target.getAttribute("autocomplete") !== "off") {
+      this.autocompleteDetected = true;
+    }
+  }
+  isFormField(element) {
+    if (!element) return false;
+    const tagName = element.tagName.toLowerCase();
+    return tagName === "input" || tagName === "textarea" || tagName === "select" || element.isContentEditable;
+  }
+  getFieldId(element) {
+    if (element.id) return element.id;
+    if ("name" in element && element.name) {
+      return element.name;
+    }
+    if (element.getAttribute("data-field-id")) {
+      return element.getAttribute("data-field-id");
+    }
+    return null;
+  }
+};
+
+// ../fraud-sdk/src/collectors/page-interactions.ts
+var PageInteractionCollector = class {
+  constructor() {
+    this.pageLoadTime = 0;
+    this.timeToFirstInteraction = 0;
+    this.startTime = Date.now();
+    this.firstInteractionTime = null;
+    this.maxScrollDepth = 0;
+    this.clickCount = 0;
+    this.linkClickCount = 0;
+    this.imageViewCount = 0;
+    this.videoPlayCount = 0;
+    this.isActive = false;
+    this.clickHandler = (event) => this.handleClick(event);
+    this.scrollHandler = () => this.handleScroll();
+    this.loadHandler = () => this.handleLoad();
+    this.imageLoadHandler = () => this.handleImageLoad();
+    this.videoPlayHandler = () => this.handleVideoPlay();
+    this.startTime = performance.now();
+  }
+  /**
+   * Start collecting page interactions
+   */
+  start() {
+    if (this.isActive || typeof document === "undefined") return;
+    if (document.readyState === "complete") {
+      this.pageLoadTime = performance.now() - this.startTime;
+    } else {
+      window.addEventListener("load", this.loadHandler);
+    }
+    document.addEventListener("click", this.clickHandler, true);
+    window.addEventListener("scroll", this.scrollHandler, { passive: true });
+    document.addEventListener("load", this.imageLoadHandler, true);
+    document.addEventListener("play", this.videoPlayHandler, true);
+    this.isActive = true;
+  }
+  /**
+   * Stop collecting page interactions
+   */
+  stop() {
+    if (!this.isActive || typeof document === "undefined") return;
+    window.removeEventListener("load", this.loadHandler);
+    document.removeEventListener("click", this.clickHandler, true);
+    window.removeEventListener("scroll", this.scrollHandler);
+    document.removeEventListener("load", this.imageLoadHandler, true);
+    document.removeEventListener("play", this.videoPlayHandler, true);
+    this.isActive = false;
+  }
+  /**
+   * Get collected page interaction data
+   */
+  getData() {
+    const timeOnPage = Date.now() - this.startTime;
+    const scrollDepth = this.calculateScrollDepth();
+    return {
+      pageLoadTime: this.pageLoadTime,
+      timeToFirstInteraction: this.firstInteractionTime ? this.firstInteractionTime - this.startTime : 0,
+      timeOnPage,
+      scrollDepth,
+      clickCount: this.clickCount,
+      linkClickCount: this.linkClickCount,
+      imageViewCount: this.imageViewCount,
+      videoPlayCount: this.videoPlayCount
+    };
+  }
+  /**
+   * Reset all collected data
+   */
+  reset() {
+    this.pageLoadTime = 0;
+    this.timeToFirstInteraction = 0;
+    this.startTime = Date.now();
+    this.firstInteractionTime = null;
+    this.maxScrollDepth = 0;
+    this.clickCount = 0;
+    this.linkClickCount = 0;
+    this.imageViewCount = 0;
+    this.videoPlayCount = 0;
+  }
+  handleLoad() {
+    this.pageLoadTime = performance.now() - this.startTime;
+  }
+  handleClick(event) {
+    if (!this.firstInteractionTime) {
+      this.firstInteractionTime = performance.now();
+    }
+    this.clickCount++;
+    const target = event.target;
+    if (target.tagName.toLowerCase() === "a" || target.closest("a")) {
+      this.linkClickCount++;
+    }
+  }
+  handleScroll() {
+    const scrollDepth = this.calculateScrollDepth();
+    this.maxScrollDepth = Math.max(this.maxScrollDepth, scrollDepth);
+  }
+  handleImageLoad() {
+    this.imageViewCount++;
+  }
+  handleVideoPlay() {
+    this.videoPlayCount++;
+  }
+  calculateScrollDepth() {
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      return 0;
+    }
+    const windowHeight = window.innerHeight || document.documentElement.clientHeight;
+    const documentHeight = Math.max(
+      document.body.scrollHeight,
+      document.body.offsetHeight,
+      document.documentElement.clientHeight,
+      document.documentElement.scrollHeight,
+      document.documentElement.offsetHeight
+    );
+    const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+    if (documentHeight === 0) return 0;
+    const scrolled = scrollTop + windowHeight;
+    return Math.min(scrolled / documentHeight, 1);
+  }
+};
+
+// ../fraud-sdk/src/core/sdk.ts
+var KeverdSDK = class {
+  constructor() {
+    this.config = null;
+    this.isInitialized = false;
+    this.sessionId = null;
+    this.deviceCollector = new DeviceCollector();
+    this.behavioralCollector = new BehavioralCollector();
+    this.fingerprintManager = new FingerprintManager();
+    this.privacySignalCollector = new PrivacySignalCollector();
+    this.browserCapabilityCollector = new BrowserCapabilityCollector();
+    this.hardwareSignalCollector = new HardwareSignalCollector();
+    this.formInteractionCollector = new FormInteractionCollector();
+    this.pageInteractionCollector = new PageInteractionCollector();
+  }
+  /**
+   * Initialize the SDK with configuration
+   */
+  init(config) {
+    if (this.isInitialized) {
+      if (this.config?.debug) {
+        console.warn("[Keverd SDK] Already initialized");
+      }
+      return;
+    }
+    if (typeof config === "string") {
+      this.config = {
+        apiKey: config,
+        endpoint: "https://api.keverd.com",
+        debug: false
+      };
+    } else {
+      this.config = {
+        endpoint: "https://api.keverd.com",
+        debug: false,
+        ...config
+      };
+    }
+    this.behavioralCollector.start();
+    this.formInteractionCollector.start();
+    this.pageInteractionCollector.start();
+    this.sessionId = this.generateSessionId();
+    this.isInitialized = true;
+    if (this.config.debug) {
+      console.log("[Keverd SDK] Initialized successfully", {
+        endpoint: this.config.endpoint
+      });
+    }
+  }
+  /**
+   * Get visitor data (fingerprint and risk assessment)
+   * This is the main method for getting risk scores
+   */
+  async getVisitorData() {
+    if (!this.isInitialized || !this.config) {
+      throw new Error("Keverd SDK not initialized. Call init() first.");
+    }
+    try {
+      const deviceInfo = this.deviceCollector.collect();
+      const behavioralData = this.behavioralCollector.getData();
+      const fingerprintData = await this.fingerprintManager.collect();
+      const fingerprintjsData = {
+        visitorId: fingerprintData.visitorId,
+        confidence: fingerprintData.confidence,
+        components: fingerprintData.components
+      };
+      const privacySignals = this.privacySignalCollector.collect();
+      const browserCapabilities = this.browserCapabilityCollector.collect();
+      const hardwareSignals = this.hardwareSignalCollector.collect();
+      const formInteractions = this.formInteractionCollector.getData();
+      const mouseSignals = this.behavioralCollector.getMouseSignals();
+      const keyboardSignals = this.behavioralCollector.getKeyboardSignals();
+      const pageInteractions = this.pageInteractionCollector.getData();
+      const networkSignals = {
+        connectionType: hardwareSignals.connectionType || void 0,
+        effectiveType: hardwareSignals.effectiveType || void 0,
+        downlink: hardwareSignals.downlink || void 0,
+        rtt: hardwareSignals.rtt || void 0,
+        saveData: hardwareSignals.saveData || void 0
+      };
+      const sessionInfo = {
+        sessionId: this.sessionId || void 0,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const request = {
+        userId: this.config.userId,
+        device: deviceInfo,
+        session: sessionInfo,
+        behavioral: behavioralData,
+        fingerprintjs: fingerprintjsData || void 0,
+        privacySignals,
+        browserCapabilities,
+        hardwareSignals,
+        formInteractions,
+        mouseSignals,
+        keyboardSignals,
+        pageInteractions,
+        networkSignals,
+        useCase: "general"
+        // Note: sim field is NOT included for web SDKs
+      };
+      const response = await this.sendFingerprintRequest(request);
+      return response;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      if (this.config.debug) {
+        console.error("[Keverd SDK] Error getting visitor data:", error);
+      }
+      throw new Error(`Failed to get visitor data: ${errorMessage}`);
+    }
+  }
+  /**
+   * Create transaction ID with risk assessment (legacy method)
+   * For new implementations, use getVisitorData() instead
+   */
+  async createTransactionID(_metadata) {
+    const response = await this.getVisitorData();
+    return response.session_id;
+  }
+  /**
+   * Verify user identity during login attempts
+   */
+  async verifyLogin(userId, metadata) {
+    if (!this.isInitialized || !this.config) {
+      throw new Error("Keverd SDK not initialized. Call init() first.");
+    }
+    const response = await this.sendVerifyRequest("login", { userId, metadata });
+    return response;
+  }
+  /**
+   * Verify user during checkout/payment
+   */
+  async verifyCheckout(amount, currency, metadata) {
+    if (!this.isInitialized || !this.config) {
+      throw new Error("Keverd SDK not initialized. Call init() first.");
+    }
+    const response = await this.sendVerifyRequest("checkout", { amount, currency, metadata });
+    return response;
+  }
+  /**
+   * Detect fake/bot registrations
+   */
+  async verifyRegistration(metadata) {
+    if (!this.isInitialized || !this.config) {
+      throw new Error("Keverd SDK not initialized. Call init() first.");
+    }
+    const response = await this.sendVerifyRequest("registration", { metadata });
+    return response;
+  }
+  /**
+   * Detect account takeover attempts during password reset
+   */
+  async verifyPasswordReset(email, metadata) {
+    if (!this.isInitialized || !this.config) {
+      throw new Error("Keverd SDK not initialized. Call init() first.");
+    }
+    const response = await this.sendVerifyRequest("password_reset", { email, metadata });
+    return response;
+  }
+  /**
+   * Verify sensitive account changes (email, phone, password)
+   */
+  async verifyAccountChange(changeType, metadata) {
+    if (!this.isInitialized || !this.config) {
+      throw new Error("Keverd SDK not initialized. Call init() first.");
+    }
+    const response = await this.sendVerifyRequest("account_change", { changeType, metadata });
+    return response;
+  }
+  /**
+   * Helper to send verify request to use-case-specific endpoint
+   */
+  async sendVerifyRequest(useCase, options) {
+    if (!this.config) {
+      throw new Error("SDK not initialized");
+    }
+    const deviceInfo = this.deviceCollector.collect();
+    const behavioralData = this.behavioralCollector.getData();
+    const fingerprintData = await this.fingerprintManager.collect();
+    const fingerprintjsData = {
+      visitorId: fingerprintData.visitorId,
+      confidence: fingerprintData.confidence,
+      components: fingerprintData.components
+    };
+    const privacySignals = this.privacySignalCollector.collect();
+    const browserCapabilities = this.browserCapabilityCollector.collect();
+    const hardwareSignals = this.hardwareSignalCollector.collect();
+    const formInteractions = this.formInteractionCollector.getData();
+    const mouseSignals = this.behavioralCollector.getMouseSignals();
+    const keyboardSignals = this.behavioralCollector.getKeyboardSignals();
+    const pageInteractions = this.pageInteractionCollector.getData();
+    const networkSignals = {
+      connectionType: hardwareSignals.connectionType || void 0,
+      effectiveType: hardwareSignals.effectiveType || void 0,
+      downlink: hardwareSignals.downlink || void 0,
+      rtt: hardwareSignals.rtt || void 0,
+      saveData: hardwareSignals.saveData || void 0
+    };
+    const sessionInfo = {
+      sessionId: this.sessionId || void 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const request = {
+      userId: options.userId || this.config.userId,
+      device: deviceInfo,
+      session: sessionInfo,
+      behavioral: behavioralData,
+      fingerprintjs: fingerprintjsData || void 0,
+      privacySignals,
+      browserCapabilities,
+      hardwareSignals,
+      formInteractions,
+      mouseSignals,
+      keyboardSignals,
+      pageInteractions,
+      networkSignals,
+      useCase
+    };
+    if (options.metadata) {
+      Object.assign(request, options.metadata);
+    }
+    if (options.amount !== void 0) {
+      request.amount = options.amount;
+    }
+    if (options.currency) {
+      request.currency = options.currency;
+    }
+    if (options.email) {
+      request.email = options.email;
+    }
+    if (options.changeType) {
+      request.changeType = options.changeType;
+    }
+    const endpoint = this.config.endpoint || "https://api.keverd.com";
+    const url = `${endpoint}/fingerprint/verify/${useCase}`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-SDK-Source": "javascript"
+    };
+    const apiKey = this.config.apiKey;
+    if (apiKey) {
+      headers["x-keverd-key"] = apiKey;
+      headers["X-API-KEY"] = apiKey;
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Send fingerprint request to backend
+   */
+  async sendFingerprintRequest(request) {
+    if (!this.config) {
+      throw new Error("SDK not initialized");
+    }
+    const endpoint = this.config.endpoint || "https://api.keverd.com";
+    const url = `${endpoint}/fingerprint/score`;
+    const headers = {
+      "Content-Type": "application/json",
+      "X-SDK-Source": "javascript"
+      // Identify SDK source for backend analytics
+    };
+    const apiKey = this.config.apiKey;
+    if (apiKey) {
+      headers["x-keverd-key"] = apiKey;
+      headers["X-API-KEY"] = apiKey;
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  /**
+   * Generate a unique session ID
+   */
+  generateSessionId() {
+    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Destroy the SDK instance
+   */
+  destroy() {
+    this.behavioralCollector.stop();
+    this.formInteractionCollector.stop();
+    this.pageInteractionCollector.stop();
+    this.fingerprintManager.clearCache();
+    this.isInitialized = false;
+    if (this.config?.debug) {
+      console.log("[Keverd SDK] Destroyed");
+    }
+    this.config = null;
+    this.sessionId = null;
+  }
+  /**
+   * Check if SDK is initialized and ready to use
+   */
+  isReady() {
+    return this.isInitialized && this.config !== null;
+  }
+};
+var Keverd = new KeverdSDK();
+
+// src/services/keverd.service.ts
+var KeverdService = class {
+  constructor(config) {
     this.config = null;
+    this.isInitialized = false;
+    if (config) {
+      this.init(config);
+    }
   }
+  /**
+   * Initialize the SDK with configuration
+   * Wraps the web SDK initialization
+   */
   init(config) {
-    this.config = config;
+    if (this.isInitialized) {
+      if (this.config?.debug) {
+        console.warn("[Keverd SDK] Already initialized");
+      }
+      return;
+    }
+    if (!config.apiKey) {
+      throw new Error("Keverd SDK: apiKey is required");
+    }
+    this.config = {
+      endpoint: config.endpoint || this.getDefaultEndpoint(),
+      debug: false,
+      ...config
+    };
+    Keverd.init({
+      apiKey: this.config.apiKey,
+      endpoint: this.config.endpoint,
+      userId: this.config.userId,
+      debug: this.config.debug || false
+    });
+    this.isInitialized = true;
+    if (this.config.debug) {
+      console.log("[Keverd SDK] Initialized successfully", {
+        endpoint: this.config.endpoint
+      });
+    }
   }
+  /**
+   * Get visitor data (fingerprint and risk assessment)
+   * Returns an RxJS Observable
+   */
   getVisitorData(options) {
-    return from(Promise.resolve({}));
+    if (!this.isInitialized || !this.config) {
+      const error = {
+        message: "Keverd SDK not initialized. Call init() first.",
+        code: "SDK_NOT_INITIALIZED"
+      };
+      return throwError(() => error);
+    }
+    return from(this.collectAndSendFingerprint(options)).pipe(
+      map((response) => this.transformResponse(response)),
+      catchError((error) => {
+        const keverdError = {
+          message: error instanceof Error ? error.message : "Unknown error",
+          code: "FETCH_ERROR"
+        };
+        if (this.config?.debug) {
+          console.error("[Keverd SDK] Error getting visitor data:", error);
+        }
+        return throwError(() => keverdError);
+      })
+    );
+  }
+  /**
+   * Collect data and send fingerprint request
+   * Uses the web SDK which includes all enhanced signals including FingerprintJS
+   */
+  async collectAndSendFingerprint(_options) {
+    if (!this.config) {
+      throw new Error("SDK not initialized");
+    }
+    return await Keverd.getVisitorData();
+  }
+  /**
+   * Transform API response to visitor data format
+   */
+  transformResponse(response) {
+    return {
+      visitorId: response.requestId,
+      riskScore: response.risk_score,
+      score: response.score,
+      action: response.action,
+      reasons: response.reason || [],
+      sessionId: response.session_id,
+      requestId: response.requestId,
+      simSwapEngine: response.sim_swap_engine,
+      confidence: response.confidence || 1 - response.score,
+      // Enhanced fields
+      fingerprintjsVisitorId: response.fingerprintjs_visitor_id,
+      privacySignals: response.privacy_signals ? {
+        isIncognito: response.privacy_signals.is_incognito,
+        isVPN: response.privacy_signals.is_vpn,
+        isAutomated: response.privacy_signals.is_automated,
+        hasAdBlocker: response.privacy_signals.has_ad_blocker
+      } : void 0,
+      deviceMatch: response.device_match,
+      fraudProbability: response.fraud_probability,
+      recommendedAction: response.recommended_action
+    };
+  }
+  /**
+   * Get default endpoint
+   */
+  getDefaultEndpoint() {
+    return "https://api.keverd.com";
+  }
+  /**
+   * Generate a session ID
+   */
+  generateSessionId() {
+    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Destroy the SDK instance
+   */
+  destroy() {
+    Keverd.destroy();
+    this.isInitialized = false;
+    this.config = null;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Check if SDK is initialized
+   */
+  isReady() {
+    return this.isInitialized;
   }
 };
 KeverdService = __decorateClass([
   Injectable({
     providedIn: "root"
-  })
+  }),
+  __decorateParam(0, Optional()),
+  __decorateParam(0, Inject("KEVERD_CONFIG"))
 ], KeverdService);
 var KeverdModule = class {
+  /**
+   * Configure the module with SDK settings
+   * Call this in your app.module.ts imports array
+   * 
+   * @example
+   * ```typescript
+   * @NgModule({
+   *   imports: [
+   *     KeverdModule.forRoot({
+   *       apiKey: 'your-api-key',
+   *       endpoint: 'https://api.keverd.com'
+   *     })
+   *   ]
+   * })
+   * export class AppModule {}
+   * ```
+   */
   static forRoot(config) {
     return {
       ngModule: KeverdModule,
       providers: [
-        { provide: "KEVERD_CONFIG", useValue: config },
-        KeverdService
+        KeverdService,
+        {
+          provide: "KEVERD_CONFIG",
+          useValue: config
+        }
       ]
     };
   }