@axeptio/behavior-detection 1.0.2 → 1.0.3

package/dist/cjs/index.cjs

@@ -0,0 +1,1422 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/esm/index.js
+var index_exports = {};
+__export(index_exports, {
+  BehaviorDetector: () => BehaviorDetector,
+  Click: () => ClickStrategy,
+  ClickStrategy: () => ClickStrategy,
+  DEFAULT_SETTINGS: () => DEFAULT_SETTINGS,
+  Environment: () => EnvironmentStrategy,
+  EnvironmentStrategy: () => EnvironmentStrategy,
+  Keyboard: () => KeyboardStrategy,
+  KeyboardStrategy: () => KeyboardStrategy,
+  Mouse: () => MouseStrategy,
+  MouseStrategy: () => MouseStrategy,
+  Resize: () => ResizeStrategy,
+  ResizeStrategy: () => ResizeStrategy,
+  Scroll: () => ScrollStrategy,
+  ScrollStrategy: () => ScrollStrategy,
+  Tap: () => TapStrategy,
+  TapStrategy: () => TapStrategy
+});
+module.exports = __toCommonJS(index_exports);
+
+// dist/esm/behavior-detector.js
+var BehaviorDetector = class {
+  constructor(tickOptions) {
+    this.strategies = /* @__PURE__ */ new Map();
+    this.isTracking = false;
+    this.isPausedByVisibility = false;
+    this.tickInterval = null;
+    this.tickIntervalMs = 1e3;
+    this.pauseOnHidden = true;
+    this.visibilityChangeHandler = null;
+    this.confidenceScore = 0;
+    this.CONFIDENCE_TARGET = 1;
+    this.CONFIDENCE_DECAY = 0.95;
+    if (tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.interval) {
+      this.tickIntervalMs = tickOptions.interval;
+    }
+    if ((tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.pauseOnHidden) !== void 0) {
+      this.pauseOnHidden = tickOptions.pauseOnHidden;
+    }
+  }
+  /**
+   * Add a detection strategy
+   */
+  addStrategy(strategy, weight) {
+    const config = {
+      strategy,
+      weight: weight !== null && weight !== void 0 ? weight : strategy.defaultWeight,
+      enabled: true
+    };
+    this.strategies.set(strategy.name, config);
+    if (strategy.setEventCallback) {
+      strategy.setEventCallback((event) => {
+        this.onStrategyEvent(event, config.weight);
+      });
+    }
+    if (this.isTracking) {
+      strategy.start();
+    }
+    return this;
+  }
+  /**
+   * Handle event from strategy - update confidence
+   */
+  onStrategyEvent(event, strategyWeight) {
+    this.confidenceScore *= this.CONFIDENCE_DECAY;
+    const contribution = event.weight * strategyWeight;
+    this.confidenceScore = Math.min(this.CONFIDENCE_TARGET, this.confidenceScore + contribution);
+  }
+  /**
+   * Remove a detection strategy
+   */
+  removeStrategy(name) {
+    const config = this.strategies.get(name);
+    if (config) {
+      if (this.isTracking) {
+        config.strategy.stop();
+      }
+      this.strategies.delete(name);
+    }
+    return this;
+  }
+  /**
+   * Enable/disable a strategy
+   */
+  setStrategyEnabled(name, enabled) {
+    const config = this.strategies.get(name);
+    if (config) {
+      config.enabled = enabled;
+      if (!enabled && this.isTracking) {
+        config.strategy.stop();
+      }
+      if (enabled && this.isTracking) {
+        config.strategy.start();
+      }
+    }
+    return this;
+  }
+  /**
+   * Get all registered strategies
+   */
+  getStrategies() {
+    return this.strategies;
+  }
+  /**
+   * Start tracking
+   */
+  start() {
+    if (this.isTracking)
+      return;
+    this.isTracking = true;
+    if (this.pauseOnHidden && typeof document !== "undefined") {
+      this.visibilityChangeHandler = this.handleVisibilityChange.bind(this);
+      document.addEventListener("visibilitychange", this.visibilityChangeHandler);
+      if (document.hidden) {
+        this.isPausedByVisibility = true;
+        return;
+      }
+    }
+    for (const [_, config] of this.strategies) {
+      if (config.enabled) {
+        config.strategy.start();
+      }
+    }
+    this.startTick();
+  }
+  /**
+   * Stop tracking
+   */
+  stop() {
+    if (!this.isTracking)
+      return;
+    this.isTracking = false;
+    this.isPausedByVisibility = false;
+    if (this.visibilityChangeHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.visibilityChangeHandler);
+      this.visibilityChangeHandler = null;
+    }
+    for (const [_, config] of this.strategies) {
+      config.strategy.stop();
+    }
+    this.stopTick();
+  }
+  /**
+   * Reset all data
+   */
+  reset() {
+    this.confidenceScore = 0;
+    for (const [_, config] of this.strategies) {
+      config.strategy.reset();
+    }
+  }
+  /**
+   * Calculate human likelihood score
+   */
+  async score(options = {}) {
+    const breakdown = this.calculateStrategyScore();
+    const result = {
+      score: breakdown.overall
+    };
+    if (options.breakdown) {
+      result.breakdown = breakdown;
+    }
+    return result;
+  }
+  /**
+   * Check if currently tracking
+   */
+  isActive() {
+    return this.isTracking;
+  }
+  /**
+   * Check if currently paused due to tab visibility
+   */
+  isPaused() {
+    return this.isPausedByVisibility;
+  }
+  /**
+   * Get event count from all strategies
+   */
+  getEventCount() {
+    var _a, _b;
+    const counts = {};
+    for (const [name, config] of this.strategies) {
+      const debug = (_b = (_a = config.strategy).getDebugInfo) === null || _b === void 0 ? void 0 : _b.call(_a);
+      if ((debug === null || debug === void 0 ? void 0 : debug.eventCount) !== void 0) {
+        counts[name] = debug.eventCount;
+      }
+    }
+    return counts;
+  }
+  /**
+   * Get debug info from all strategies
+   */
+  getStrategyDebugInfo() {
+    const debug = {};
+    for (const [name, config] of this.strategies) {
+      if (config.strategy.getDebugInfo) {
+        debug[name] = config.strategy.getDebugInfo();
+      }
+    }
+    return debug;
+  }
+  /**
+   * Get current confidence score (0-1)
+   * Represents how much interaction data we've collected
+   * Higher confidence = more reliable classification
+   */
+  getConfidence() {
+    return Math.min(1, this.confidenceScore);
+  }
+  /**
+   * Check if confidence is above threshold for reliable classification
+   * @param threshold - Minimum confidence (0-1), default 0.3
+   */
+  hasConfidentData(threshold = 0.3) {
+    return this.getConfidence() >= threshold;
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.stop();
+    this.strategies.clear();
+  }
+  /**
+   * Handle visibility change events
+   */
+  handleVisibilityChange() {
+    if (!this.isTracking)
+      return;
+    if (document.hidden) {
+      if (!this.isPausedByVisibility) {
+        this.isPausedByVisibility = true;
+        for (const [_, config] of this.strategies) {
+          if (config.enabled) {
+            config.strategy.stop();
+          }
+        }
+        this.stopTick();
+      }
+    } else {
+      if (this.isPausedByVisibility) {
+        this.isPausedByVisibility = false;
+        for (const [_, config] of this.strategies) {
+          if (config.enabled) {
+            config.strategy.start();
+          }
+        }
+        this.startTick();
+      }
+    }
+  }
+  /**
+   * Start tick mechanism for strategies
+   */
+  startTick() {
+    if (this.tickInterval !== null)
+      return;
+    this.tickInterval = window.setInterval(() => {
+      const now = Date.now();
+      for (const [_, config] of this.strategies) {
+        if (config.enabled && config.strategy.onTick) {
+          config.strategy.onTick(now);
+        }
+      }
+    }, this.tickIntervalMs);
+  }
+  /**
+   * Stop tick mechanism
+   */
+  stopTick() {
+    if (this.tickInterval !== null) {
+      clearInterval(this.tickInterval);
+      this.tickInterval = null;
+    }
+  }
+  /**
+   * Calculate score using strategies
+   */
+  calculateStrategyScore() {
+    const factors = {};
+    const weights = {};
+    let totalWeight = 0;
+    let weightedSum = 0;
+    for (const [name, config] of this.strategies) {
+      if (!config.enabled)
+        continue;
+      const score = config.strategy.score();
+      factors[name] = score;
+      weights[name] = config.weight;
+      if (score !== void 0 && score !== null) {
+        totalWeight += config.weight;
+        weightedSum += score * config.weight;
+      }
+    }
+    const overall = totalWeight > 0 ? weightedSum / totalWeight : 0.5;
+    return {
+      overall: Math.max(0, Math.min(1, overall)),
+      factors,
+      weights
+    };
+  }
+};
+
+// dist/esm/strategy.js
+var BaseStrategy = class {
+  constructor() {
+    this.eventCallback = null;
+  }
+  setEventCallback(callback) {
+    this.eventCallback = callback;
+  }
+  notifyEvent(weight) {
+    if (this.eventCallback) {
+      this.eventCallback({
+        strategy: this.name,
+        weight,
+        timestamp: Date.now()
+      });
+    }
+  }
+};
+
+// dist/esm/math-utils.js
+function sigmoid(x, midpoint = 0, steepness = 1) {
+  return 1 / (1 + Math.exp(-steepness * (x - midpoint)));
+}
+function inverseSigmoid(x, midpoint = 0, steepness = 1) {
+  return 1 - sigmoid(x, midpoint, steepness);
+}
+function gaussian(x, ideal = 0, width = 1) {
+  const exponent = -Math.pow(x - ideal, 2) / (2 * width * width);
+  return Math.exp(exponent);
+}
+function calculateStatistics(values) {
+  if (values.length === 0) {
+    return { mean: 0, variance: 0, stdDev: 0, cv: 0 };
+  }
+  const mean = values.reduce((a, b) => a + b, 0) / values.length;
+  const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+  const stdDev = Math.sqrt(variance);
+  const cv = mean > 0 ? stdDev / mean : 0;
+  return { mean, variance, stdDev, cv };
+}
+function analyzeIntervals(intervals) {
+  if (intervals.length < 2)
+    return void 0;
+  const uniqueCount = new Set(intervals.map((i) => Math.round(i / 10))).size;
+  const allIdentical = uniqueCount === 1;
+  const statistics = calculateStatistics(intervals);
+  return {
+    statistics,
+    uniqueCount,
+    allIdentical
+  };
+}
+function scoreCoefficientOfVariation(cv) {
+  if (cv < 0.05)
+    return 0.1;
+  if (cv > 2)
+    return 0.3;
+  return gaussian(cv, 0.45, 0.35);
+}
+
+// dist/esm/strategies/mouse.js
+var MouseStrategy = class extends BaseStrategy {
+  constructor(options) {
+    super();
+    this.name = "mouse";
+    this.defaultWeight = 0.3;
+    this.distanceSeries = [];
+    this.angleSeries = [];
+    this.lastPosition = null;
+    this.lastAngle = 0;
+    this.cumulativeAngle = 0;
+    this.rollingWindowMs = 5e3;
+    this.listener = null;
+    this.leaveListener = null;
+    this.isActive = false;
+    this.screenDiagonal = 1;
+    if ((options === null || options === void 0 ? void 0 : options.rollingWindow) !== void 0)
+      this.rollingWindowMs = options.rollingWindow;
+  }
+  start() {
+    if (this.isActive)
+      return;
+    this.isActive = true;
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+    this.screenDiagonal = Math.sqrt(width * width + height * height);
+    this.listener = (e) => {
+      const mouseEvent = e;
+      const now = Date.now();
+      const currentPos = { x: mouseEvent.clientX, y: mouseEvent.clientY };
+      if (this.lastPosition) {
+        const dx = currentPos.x - this.lastPosition.x;
+        const dy = currentPos.y - this.lastPosition.y;
+        const pixelDistance = Math.sqrt(dx * dx + dy * dy);
+        const normalizedDistance = pixelDistance / this.screenDiagonal;
+        if (normalizedDistance > 1e-3) {
+          const rawAngle = Math.atan2(dy, dx);
+          let angleDiff = rawAngle - this.lastAngle;
+          while (angleDiff > Math.PI)
+            angleDiff -= 2 * Math.PI;
+          while (angleDiff < -Math.PI)
+            angleDiff += 2 * Math.PI;
+          this.cumulativeAngle += angleDiff;
+          this.lastAngle = rawAngle;
+          this.distanceSeries.push({ value: normalizedDistance, timestamp: now });
+          this.angleSeries.push({ value: this.cumulativeAngle, timestamp: now });
+          this.notifyEvent(Math.min(1, normalizedDistance * 100));
+        }
+        const cutoff = now - this.rollingWindowMs;
+        while (this.distanceSeries.length > 0 && this.distanceSeries[0].timestamp < cutoff) {
+          this.distanceSeries.shift();
+          this.angleSeries.shift();
+        }
+      }
+      this.lastPosition = currentPos;
+    };
+    document.addEventListener("mousemove", this.listener, { passive: true });
+    this.leaveListener = () => {
+      this.distanceSeries = [];
+      this.angleSeries = [];
+      this.lastPosition = null;
+      this.lastAngle = 0;
+      this.cumulativeAngle = 0;
+    };
+    document.addEventListener("mouseleave", this.leaveListener, { passive: true });
+  }
+  stop() {
+    if (!this.isActive)
+      return;
+    this.isActive = false;
+    if (this.listener) {
+      document.removeEventListener("mousemove", this.listener);
+      this.listener = null;
+    }
+    if (this.leaveListener) {
+      document.removeEventListener("mouseleave", this.leaveListener);
+      this.leaveListener = null;
+    }
+  }
+  reset() {
+    this.distanceSeries = [];
+    this.angleSeries = [];
+    this.lastPosition = null;
+    this.lastAngle = 0;
+    this.cumulativeAngle = 0;
+  }
+  score() {
+    if (this.distanceSeries.length < 10)
+      return void 0;
+    return this.detectMousePatterns();
+  }
+  /**
+   * Mouse-specific pattern detection
+   * Detects bot-like patterns: constant velocity, linear paths
+   */
+  detectMousePatterns() {
+    if (this.distanceSeries.length < 10)
+      return void 0;
+    let score = 0;
+    let factors = 0;
+    const distances = this.distanceSeries.map((p) => p.value);
+    if (distances.length >= 3) {
+      const stats = calculateStatistics(distances);
+      score += gaussian(stats.cv, 0.9, 0.35);
+      factors++;
+    }
+    const angles = this.angleSeries.map((p) => p.value);
+    if (angles.length >= 3) {
+      const angleChanges = [];
+      for (let i = 1; i < angles.length; i++) {
+        angleChanges.push(Math.abs(angles[i] - angles[i - 1]));
+      }
+      const avgChange = angleChanges.reduce((a, b) => a + b, 0) / angleChanges.length;
+      score += gaussian(avgChange, 0.15, 0.12);
+      factors++;
+    }
+    return factors > 0 ? score / factors : void 0;
+  }
+  getDebugInfo() {
+    return {
+      eventCount: this.distanceSeries.length,
+      rollingWindow: this.rollingWindowMs,
+      isActive: this.isActive,
+      distanceSeries: this.distanceSeries,
+      angleSeries: this.angleSeries
+    };
+  }
+};
+
+// dist/esm/strategies/scroll.js
+var ScrollStrategy = class extends BaseStrategy {
+  constructor(options) {
+    super();
+    this.name = "scroll";
+    this.defaultWeight = 0.15;
+    this.distanceSeries = [];
+    this.velocitySeries = [];
+    this.lastScrollY = null;
+    this.lastTimestamp = 0;
+    this.rollingWindowMs = 5e3;
+    this.documentHeight = 1;
+    this.listener = null;
+    this.isActive = false;
+    if ((options === null || options === void 0 ? void 0 : options.rollingWindow) !== void 0)
+      this.rollingWindowMs = options.rollingWindow;
+  }
+  start() {
+    if (this.isActive)
+      return;
+    this.isActive = true;
+    this.documentHeight = Math.max(document.body.scrollHeight, document.documentElement.scrollHeight, 1);
+    this.listener = (_e) => {
+      const scrollY = window.scrollY;
+      const now = Date.now();
+      if (this.lastScrollY === null) {
+        this.lastScrollY = scrollY;
+        this.lastTimestamp = now;
+        return;
+      }
+      const pixelDelta = scrollY - this.lastScrollY;
+      const deltaTime = now - this.lastTimestamp;
+      if (pixelDelta === 0) {
+        return;
+      }
+      const normalizedDistance = Math.abs(pixelDelta) / this.documentHeight;
+      if (deltaTime > 0) {
+        const velocity = normalizedDistance / deltaTime;
+        this.distanceSeries.push({ value: normalizedDistance, timestamp: now });
+        this.velocitySeries.push({ value: velocity, timestamp: now });
+        this.notifyEvent(Math.min(1, normalizedDistance * 10));
+        const cutoff = now - this.rollingWindowMs;
+        while (this.distanceSeries.length > 0 && this.distanceSeries[0].timestamp < cutoff) {
+          this.distanceSeries.shift();
+          this.velocitySeries.shift();
+        }
+      }
+      this.lastScrollY = scrollY;
+      this.lastTimestamp = now;
+    };
+    window.addEventListener("scroll", this.listener, { passive: true });
+  }
+  stop() {
+    if (!this.isActive)
+      return;
+    this.isActive = false;
+    if (this.listener) {
+      window.removeEventListener("scroll", this.listener);
+      this.listener = null;
+    }
+  }
+  reset() {
+    this.distanceSeries = [];
+    this.velocitySeries = [];
+    this.lastScrollY = null;
+    this.lastTimestamp = 0;
+  }
+  score() {
+    if (this.distanceSeries.length < 2)
+      return void 0;
+    return this.detectScrollPatterns();
+  }
+  /**
+   * Scroll-specific pattern detection
+   * Detects bot-like patterns: constant deltas, instant jumps, too smooth
+   */
+  detectScrollPatterns() {
+    if (this.distanceSeries.length < 2)
+      return void 0;
+    let score = 0;
+    let factors = 0;
+    const distances = this.distanceSeries.map((p) => p.value);
+    if (distances.length >= 2) {
+      const uniqueDistances = new Set(distances.map((d) => Math.round(d * 1e3))).size;
+      if (uniqueDistances === 1) {
+        return 0.05;
+      }
+    }
+    if (distances.length >= 2) {
+      const stats = calculateStatistics(distances);
+      score += gaussian(stats.cv, 1, 0.4);
+      factors++;
+    }
+    const velocities = this.velocitySeries.map((p) => p.value);
+    if (velocities.length >= 2) {
+      const stats = calculateStatistics(velocities);
+      score += gaussian(stats.cv, 1.2, 0.5);
+      factors++;
+    }
+    const instantJumps = distances.filter((d) => d > 0.1).length;
+    if (distances.length > 0) {
+      const jumpRatio = instantJumps / distances.length;
+      score += inverseSigmoid(jumpRatio, 0.3, 15);
+      factors++;
+    }
+    return factors > 0 ? score / factors : void 0;
+  }
+  getDebugInfo() {
+    return {
+      eventCount: this.distanceSeries.length,
+      rollingWindow: this.rollingWindowMs,
+      isActive: this.isActive,
+      distanceSeries: this.distanceSeries,
+      velocitySeries: this.velocitySeries
+    };
+  }
+};
+
+// dist/esm/strategies/click.js
+var ClickStrategy = class extends BaseStrategy {
+  constructor(options) {
+    super();
+    this.name = "click";
+    this.defaultWeight = 0.3;
+    this.events = [];
+    this.targetSelectors = ["button", "a", 'input[type="submit"]', '[role="button"]'];
+    this.lastMousePosition = null;
+    this.mouseListener = null;
+    this.clickListeners = /* @__PURE__ */ new Map();
+    this.isActive = false;
+    if (options === null || options === void 0 ? void 0 : options.targetSelectors) {
+      this.targetSelectors = options.targetSelectors;
+    }
+  }
+  start() {
+    if (this.isActive)
+      return;
+    this.isActive = true;
+    this.mouseListener = (e) => {
+      const mouseEvent = e;
+      this.lastMousePosition = {
+        x: mouseEvent.clientX,
+        y: mouseEvent.clientY
+      };
+    };
+    document.addEventListener("mousemove", this.mouseListener, { passive: true });
+    this.attachClickListeners();
+  }
+  /**
+   * Add a new target selector at runtime
+   */
+  addTarget(selector) {
+    if (!this.targetSelectors.includes(selector)) {
+      this.targetSelectors.push(selector);
+      if (this.isActive) {
+        this.attachClickListenersForSelector(selector);
+      }
+    }
+  }
+  attachClickListeners() {
+    this.targetSelectors.forEach((selector) => {
+      this.attachClickListenersForSelector(selector);
+    });
+  }
+  attachClickListenersForSelector(selector) {
+    const elements = document.querySelectorAll(selector);
+    elements.forEach((element) => {
+      if (this.clickListeners.has(element))
+        return;
+      const listener = (e) => {
+        var _a, _b;
+        const clickEvent = e;
+        const rect = element.getBoundingClientRect();
+        const inViewport = rect.top >= 0 && rect.left >= 0 && rect.bottom <= window.innerHeight && rect.right <= window.innerWidth;
+        let position;
+        if (!this.lastMousePosition) {
+          position = "no-mouse-data";
+        } else {
+          const mx = this.lastMousePosition.x;
+          const my = this.lastMousePosition.y;
+          const overElement = mx >= rect.left && mx <= rect.right && my >= rect.top && my <= rect.bottom;
+          if (!overElement) {
+            position = "outside";
+          } else {
+            const centerX = rect.left + rect.width / 2;
+            const centerY = rect.top + rect.height / 2;
+            const distanceFromCenter = Math.sqrt((mx - centerX) ** 2 + (my - centerY) ** 2);
+            if (distanceFromCenter < 2) {
+              position = "dead-center";
+            } else {
+              position = "over-element";
+            }
+          }
+        }
+        this.events.push({
+          clickX: clickEvent.clientX,
+          clickY: clickEvent.clientY,
+          mouseX: (_a = this.lastMousePosition) === null || _a === void 0 ? void 0 : _a.x,
+          mouseY: (_b = this.lastMousePosition) === null || _b === void 0 ? void 0 : _b.y,
+          rect,
+          inViewport,
+          position,
+          timestamp: Date.now()
+        });
+        this.notifyEvent(1);
+      };
+      element.addEventListener("click", listener);
+      this.clickListeners.set(element, listener);
+    });
+  }
+  stop() {
+    if (!this.isActive)
+      return;
+    this.isActive = false;
+    if (this.mouseListener) {
+      document.removeEventListener("mousemove", this.mouseListener);
+      this.mouseListener = null;
+    }
+    this.clickListeners.forEach((listener, element) => {
+      element.removeEventListener("click", listener);
+    });
+    this.clickListeners.clear();
+  }
+  reset() {
+    this.events = [];
+    this.lastMousePosition = null;
+  }
+  score() {
+    if (this.events.length === 0)
+      return void 0;
+    let totalScore = 0;
+    for (const click of this.events) {
+      switch (click.position) {
+        case "no-mouse-data":
+          totalScore += 0;
+          break;
+        case "outside":
+          totalScore += 0;
+          break;
+        case "dead-center":
+          totalScore += 0.5;
+          break;
+        case "over-element":
+          totalScore += 1;
+          break;
+      }
+    }
+    return totalScore / this.events.length;
+  }
+  getDebugInfo() {
+    return {
+      eventCount: this.events.length,
+      positions: {
+        noMouseData: this.events.filter((e) => e.position === "no-mouse-data").length,
+        outside: this.events.filter((e) => e.position === "outside").length,
+        deadCenter: this.events.filter((e) => e.position === "dead-center").length,
+        overElement: this.events.filter((e) => e.position === "over-element").length
+      },
+      inViewport: this.events.filter((e) => e.inViewport).length,
+      trackedElements: this.clickListeners.size
+    };
+  }
+};
+
+// dist/esm/strategies/tap.js
+var TapStrategy = class extends BaseStrategy {
+  constructor(options) {
+    super();
+    this.name = "tap";
+    this.defaultWeight = 0.35;
+    this.events = [];
+    this.targetSelectors = ["button", "a", 'input[type="submit"]', '[role="button"]'];
+    this.touchStartListeners = /* @__PURE__ */ new Map();
+    this.touchEndListeners = /* @__PURE__ */ new Map();
+    this.activeTouches = /* @__PURE__ */ new Map();
+    this.isActive = false;
+    if (options === null || options === void 0 ? void 0 : options.targetSelectors) {
+      this.targetSelectors = options.targetSelectors;
+    }
+  }
+  start() {
+    if (this.isActive)
+      return;
+    this.isActive = true;
+    this.attachTouchListeners();
+  }
+  addTarget(selector) {
+    if (!this.targetSelectors.includes(selector)) {
+      this.targetSelectors.push(selector);
+      if (this.isActive) {
+        this.attachTouchListenersForSelector(selector);
+      }
+    }
+  }
+  attachTouchListeners() {
+    this.targetSelectors.forEach((selector) => {
+      this.attachTouchListenersForSelector(selector);
+    });
+  }
+  attachTouchListenersForSelector(selector) {
+    const elements = document.querySelectorAll(selector);
+    elements.forEach((element) => {
+      if (this.touchStartListeners.has(element))
+        return;
+      const startListener = (e) => {
+        const touchEvent = e;
+        if (touchEvent.touches.length !== 1)
+          return;
+        const touch = touchEvent.touches[0];
+        this.activeTouches.set(touch.identifier, {
+          x: touch.clientX,
+          y: touch.clientY,
+          timestamp: Date.now(),
+          element
+        });
+      };
+      const endListener = (e) => {
+        const touchEvent = e;
+        if (touchEvent.changedTouches.length !== 1)
+          return;
+        const touch = touchEvent.changedTouches[0];
+        const startData = this.activeTouches.get(touch.identifier);
+        if (!startData || startData.element !== element)
+          return;
+        const now = Date.now();
+        const duration = now - startData.timestamp;
+        const dx = touch.clientX - startData.x;
+        const dy = touch.clientY - startData.y;
+        const movement = Math.sqrt(dx * dx + dy * dy);
+        const rect = element.getBoundingClientRect();
+        const inViewport = rect.top >= 0 && rect.left >= 0 && rect.bottom <= window.innerHeight && rect.right <= window.innerWidth;
+        const tx = touch.clientX;
+        const ty = touch.clientY;
+        const overElement = tx >= rect.left && tx <= rect.right && ty >= rect.top && ty <= rect.bottom;
+        let position;
+        if (!overElement) {
+          position = "outside";
+        } else {
+          const centerX = rect.left + rect.width / 2;
+          const centerY = rect.top + rect.height / 2;
+          const distanceFromCenter = Math.sqrt((tx - centerX) ** 2 + (ty - centerY) ** 2);
+          position = distanceFromCenter < 2 ? "dead-center" : "over-element";
+        }
+        this.events.push({
+          x: tx,
+          y: ty,
+          rect,
+          inViewport,
+          position,
+          duration,
+          movement,
+          timestamp: now
+        });
+        this.notifyEvent(1);
+        this.activeTouches.delete(touch.identifier);
+      };
+      element.addEventListener("touchstart", startListener, { passive: true });
+      element.addEventListener("touchend", endListener, { passive: true });
+      this.touchStartListeners.set(element, startListener);
+      this.touchEndListeners.set(element, endListener);
+    });
+  }
+  stop() {
+    if (!this.isActive)
+      return;
+    this.isActive = false;
+    this.touchStartListeners.forEach((listener, element) => {
+      element.removeEventListener("touchstart", listener);
+    });
+    this.touchStartListeners.clear();
+    this.touchEndListeners.forEach((listener, element) => {
+      element.removeEventListener("touchend", listener);
+    });
+    this.touchEndListeners.clear();
+    this.activeTouches.clear();
+  }
+  reset() {
+    this.events = [];
+    this.activeTouches.clear();
+  }
+  score() {
+    if (this.events.length === 0)
+      return void 0;
+    let score = 0;
+    let factors = 0;
+    let positionScore = 0;
+    for (const tap of this.events) {
+      switch (tap.position) {
+        case "outside":
+          positionScore += 0;
+          break;
+        case "dead-center":
+          positionScore += 0.5;
+          break;
+        case "over-element":
+          positionScore += 1;
+          break;
+      }
+    }
+    score += positionScore / this.events.length;
+    factors++;
+    const durations = this.events.map((e) => e.duration);
+    if (durations.length >= 2) {
+      const durationAnalysis = analyzeIntervals(durations);
+      if (durationAnalysis) {
+        const { statistics, allIdentical } = durationAnalysis;
+        if (allIdentical) {
+          return 0.05;
+        }
+        score += scoreCoefficientOfVariation(statistics.cv);
+        factors++;
+        score += gaussian(statistics.mean, 95, 40);
+        factors++;
+      }
+    }
+    const movements = this.events.map((e) => e.movement);
+    if (movements.length > 0) {
+      const avgMovement = movements.reduce((a, b) => a + b, 0) / movements.length;
+      score += gaussian(avgMovement, 2, 3);
+      factors++;
+    }
+    if (this.events.length >= 3) {
+      const intervals = [];
+      for (let i = 1; i < this.events.length; i++) {
+        intervals.push(this.events[i].timestamp - this.events[i - 1].timestamp);
+      }
+      const intervalAnalysis = analyzeIntervals(intervals);
+      if (intervalAnalysis && !intervalAnalysis.allIdentical) {
+        score += scoreCoefficientOfVariation(intervalAnalysis.statistics.cv);
+        factors++;
+      }
+    }
+    return factors > 0 ? score / factors : void 0;
+  }
+  getDebugInfo() {
+    return {
+      eventCount: this.events.length,
+      positions: {
+        outside: this.events.filter((e) => e.position === "outside").length,
+        deadCenter: this.events.filter((e) => e.position === "dead-center").length,
+        overElement: this.events.filter((e) => e.position === "over-element").length
+      },
+      durations: this.events.map((e) => e.duration),
+      movements: this.events.map((e) => e.movement),
+      inViewport: this.events.filter((e) => e.inViewport).length,
+      trackedElements: this.touchStartListeners.size
+    };
+  }
+};
+
+// dist/esm/strategies/keyboard.js
+var KeyboardStrategy = class extends BaseStrategy {
+  constructor(options) {
+    super();
+    this.name = "keyboard";
+    this.defaultWeight = 0.1;
+    this.events = [];
+    this.targetSelectors = ['input[type="text"]', 'input[type="email"]', "textarea"];
+    this.focusedElement = null;
+    this.focusedElementSelector = "";
+    this.lastEventTimestamp = 0;
+    this.sessionPauseThreshold = 1e3;
+    this.downListener = null;
+    this.upListener = null;
+    this.focusListeners = /* @__PURE__ */ new Map();
+    this.blurListeners = /* @__PURE__ */ new Map();
+    this.isActive = false;
+    if (options === null || options === void 0 ? void 0 : options.targetSelectors) {
+      this.targetSelectors = options.targetSelectors;
+    }
+  }
+  start() {
+    if (this.isActive)
+      return;
+    this.isActive = true;
+    this.attachFocusListeners();
+    this.downListener = (e) => {
+      if (!this.focusedElement)
+        return;
+      const now = Date.now();
+      const keyEvent = e;
+      if (this.lastEventTimestamp > 0 && now - this.lastEventTimestamp > this.sessionPauseThreshold) {
+        this.events = [];
+      }
+      this.events.push({
+        key: keyEvent.key,
+        type: "down",
+        timestamp: now,
+        targetElement: this.focusedElementSelector
+      });
+      this.notifyEvent(0.8);
+      this.lastEventTimestamp = now;
+    };
+    this.upListener = (e) => {
+      if (!this.focusedElement)
+        return;
+      const now = Date.now();
+      const keyEvent = e;
+      if (this.lastEventTimestamp > 0 && now - this.lastEventTimestamp > this.sessionPauseThreshold) {
+        this.events = [];
+      }
+      this.events.push({
+        key: keyEvent.key,
+        type: "up",
+        timestamp: now,
+        targetElement: this.focusedElementSelector
+      });
+      this.lastEventTimestamp = now;
+    };
+    document.addEventListener("keydown", this.downListener);
+    document.addEventListener("keyup", this.upListener);
+  }
+  /**
+   * Add a new target selector at runtime
+   */
+  addTarget(selector) {
+    if (!this.targetSelectors.includes(selector)) {
+      this.targetSelectors.push(selector);
+      if (this.isActive) {
+        this.attachFocusListenersForSelector(selector);
+      }
+    }
+  }
+  attachFocusListeners() {
+    this.targetSelectors.forEach((selector) => {
+      this.attachFocusListenersForSelector(selector);
+    });
+  }
+  attachFocusListenersForSelector(selector) {
+    const elements = document.querySelectorAll(selector);
+    elements.forEach((element) => {
+      if (this.focusListeners.has(element))
+        return;
+      const focusListener = () => {
+        this.focusedElement = element;
+        this.focusedElementSelector = selector;
+      };
+      const blurListener = () => {
+        this.focusedElement = null;
+        this.focusedElementSelector = "";
+      };
+      element.addEventListener("focus", focusListener);
+      element.addEventListener("blur", blurListener);
+      this.focusListeners.set(element, focusListener);
+      this.blurListeners.set(element, blurListener);
+    });
+  }
+  stop() {
+    if (!this.isActive)
+      return;
+    this.isActive = false;
+    if (this.downListener) {
+      document.removeEventListener("keydown", this.downListener);
+      this.downListener = null;
+    }
+    if (this.upListener) {
+      document.removeEventListener("keyup", this.upListener);
+      this.upListener = null;
+    }
+    this.focusListeners.forEach((listener, element) => {
+      element.removeEventListener("focus", listener);
+    });
+    this.focusListeners.clear();
+    this.blurListeners.forEach((listener, element) => {
+      element.removeEventListener("blur", listener);
+    });
+    this.blurListeners.clear();
+    this.focusedElement = null;
+  }
+  reset() {
+    this.events = [];
+    this.focusedElement = null;
+    this.focusedElementSelector = "";
+    this.lastEventTimestamp = 0;
+  }
+  score() {
+    if (this.events.length < 6)
+      return void 0;
+    const downEvents = this.events.filter((e) => e.type === "down");
+    if (downEvents.length < 3)
+      return void 0;
+    let score = 0;
+    let factors = 0;
+    const keystrokeIntervals = [];
+    for (let i = 1; i < downEvents.length; i++) {
+      keystrokeIntervals.push(downEvents[i].timestamp - downEvents[i - 1].timestamp);
+    }
+    const keystrokeAnalysis = analyzeIntervals(keystrokeIntervals);
+    if (keystrokeAnalysis) {
+      const { statistics, allIdentical } = keystrokeAnalysis;
+      if (allIdentical) {
+        return 0.1;
+      }
+      const keystrokeScore = scoreCoefficientOfVariation(statistics.cv);
+      score += keystrokeScore;
+      factors++;
+      if (keystrokeScore <= 0.1)
+        return keystrokeScore;
+    }
+    const pressDurations = [];
+    for (let i = 0; i < this.events.length - 1; i++) {
+      if (this.events[i].type === "down" && this.events[i + 1].type === "up" && this.events[i].key === this.events[i + 1].key) {
+        pressDurations.push(this.events[i + 1].timestamp - this.events[i].timestamp);
+      }
+    }
+    const pressDurationAnalysis = analyzeIntervals(pressDurations);
+    if (pressDurationAnalysis) {
+      const { statistics, allIdentical } = pressDurationAnalysis;
+      if (allIdentical) {
+        return 0.1;
+      }
+      if (statistics.mean < 5) {
+        score += 0.1;
+        factors++;
+      } else {
+        const pressDurationScore = scoreCoefficientOfVariation(statistics.cv);
+        score += pressDurationScore;
+        factors++;
+        if (pressDurationScore <= 0.1)
+          return pressDurationScore;
+      }
+    }
+    const backspaceCount = this.events.filter((e) => e.key === "Backspace").length;
+    if (backspaceCount > 0) {
+      const backspaceRatio = backspaceCount / downEvents.length;
+      if (backspaceRatio > 0.05 && backspaceRatio < 0.3) {
+        score += 1;
+        factors++;
+      } else if (backspaceRatio > 0) {
+        score += 0.8;
+        factors++;
+      }
+    }
+    return factors > 0 ? score / factors : void 0;
+  }
+  getDebugInfo() {
+    const pressDurations = [];
+    for (let i = 0; i < this.events.length - 1; i++) {
+      if (this.events[i].type === "down" && this.events[i + 1].type === "up" && this.events[i].key === this.events[i + 1].key) {
+        pressDurations.push(this.events[i + 1].timestamp - this.events[i].timestamp);
+      }
+    }
+    return {
+      eventCount: this.events.length,
+      downEvents: this.events.filter((e) => e.type === "down").length,
+      upEvents: this.events.filter((e) => e.type === "up").length,
+      backspaceCount: this.events.filter((e) => e.key === "Backspace").length,
+      pressDurations,
+      // For graphing
+      focusedElement: this.focusedElementSelector,
+      trackedElements: this.focusListeners.size
+    };
+  }
+};
+
+// dist/esm/strategies/environment.js
+var EnvironmentStrategy = class extends BaseStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "environment";
+    this.defaultWeight = 0.08;
+    this.data = null;
+  }
+  start() {
+    this.captureEnvironment();
+  }
+  stop() {
+  }
+  reset() {
+    this.data = null;
+  }
+  onTick(_timestamp) {
+    this.captureEnvironment();
+  }
+  score() {
+    if (!this.data)
+      return void 0;
+    const env = this.data;
+    let score = 0;
+    let factors = 0;
+    score += env.suspiciousDimensions ? 0.1 : 1;
+    score += env.suspiciousRatio ? 0.2 : 1;
+    score += env.featureInconsistency ? 0.3 : 1;
+    factors += 3;
+    const featureCount = [
+      env.hasWebGL,
+      env.hasLocalStorage,
+      env.hasSessionStorage,
+      env.hasIndexedDB
+    ].filter(Boolean).length;
+    score += featureCount / 4;
+    factors++;
+    score += inverseSigmoid(env.plugins, -2, -0.5);
+    score += env.plugins > 0 ? 1 : 0.1;
+    factors += 2;
+    score += gaussian(env.devicePixelRatio, 2, 1.5);
+    score += env.colorDepth === 24 || env.colorDepth === 32 ? 1 : 0.4;
+    factors += 2;
+    return factors > 0 ? score / factors : void 0;
+  }
+  isMobileDevice() {
+    const hasTouchScreen = navigator.maxTouchPoints > 0 || "ontouchstart" in window;
+    const mobileUA = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+    const smallScreen = window.innerWidth < 768 && window.innerHeight < 1024;
+    return hasTouchScreen && smallScreen || mobileUA;
+  }
+  captureEnvironment() {
+    try {
+      let hasWebGL = false;
+      try {
+        const canvas = document.createElement("canvas");
+        hasWebGL = !!(canvas.getContext("webgl") || canvas.getContext("experimental-webgl"));
+      } catch (e) {
+        hasWebGL = false;
+      }
+      const hasWebRTC = !!(window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection);
+      const isMobile = this.isMobileDevice();
+      const windowWidth = window.innerWidth;
+      const windowHeight = window.innerHeight;
+      const screenWidth = window.screen.width;
+      const screenHeight = window.screen.height;
+      const suspiciousDimensions = windowWidth === 800 && windowHeight === 600 || windowWidth === 1024 && windowHeight === 768 || windowWidth === 1280 && windowHeight === 720 || screenWidth === 800 && screenHeight === 600;
+      const windowScreenRatio = windowWidth * windowHeight / (screenWidth * screenHeight);
+      const suspiciousRatio = windowScreenRatio === 1 || windowScreenRatio < 0.1 || windowScreenRatio > 1;
+      const hasStorage = typeof localStorage !== "undefined" && typeof sessionStorage !== "undefined";
+      const featureInconsistency = navigator.plugins.length === 0 && navigator.mimeTypes.length === 0 || !hasWebGL || !hasStorage;
+      this.data = {
+        screenWidth,
+        screenHeight,
+        windowWidth,
+        windowHeight,
+        devicePixelRatio: window.devicePixelRatio,
+        colorDepth: window.screen.colorDepth,
+        userAgent: navigator.userAgent,
+        platform: navigator.platform,
+        language: navigator.language,
+        languages: navigator.languages ? Array.from(navigator.languages) : [navigator.language],
+        hardwareConcurrency: navigator.hardwareConcurrency,
+        maxTouchPoints: navigator.maxTouchPoints || 0,
+        vendor: navigator.vendor,
+        hasWebGL,
+        hasWebRTC,
+        hasLocalStorage: typeof localStorage !== "undefined",
+        hasSessionStorage: typeof sessionStorage !== "undefined",
+        hasIndexedDB: "indexedDB" in window,
+        plugins: navigator.plugins.length,
+        mimeTypes: navigator.mimeTypes.length,
+        suspiciousRatio,
+        suspiciousDimensions,
+        featureInconsistency,
+        isMobile,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      console.warn("Failed to capture environment:", error);
+    }
+  }
+  getDebugInfo() {
+    return this.data;
+  }
+  /**
+   * Check if current device is mobile
+   * Returns true if mobile, false otherwise
+   * Returns null if environment hasn't been captured yet
+   */
+  isMobile() {
+    var _a, _b;
+    return (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.isMobile) !== null && _b !== void 0 ? _b : null;
+  }
+};
+
+// dist/esm/strategies/resize.js
+var ResizeStrategy = class extends BaseStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "resize";
+    this.defaultWeight = 0.02;
+    this.events = [];
+    this.listener = null;
+    this.isActive = false;
+    this.lastMousePosition = null;
+    this.mouseListener = null;
+  }
+  start() {
+    if (this.isActive)
+      return;
+    this.isActive = true;
+    this.mouseListener = (e) => {
+      const mouseEvent = e;
+      this.lastMousePosition = {
+        x: mouseEvent.clientX,
+        y: mouseEvent.clientY
+      };
+    };
+    document.addEventListener("mousemove", this.mouseListener, { passive: true });
+    this.listener = () => {
+      var _a, _b;
+      const mouseX = (_a = this.lastMousePosition) === null || _a === void 0 ? void 0 : _a.x;
+      const mouseY = (_b = this.lastMousePosition) === null || _b === void 0 ? void 0 : _b.y;
+      let mouseNearEdge = false;
+      if (mouseX !== void 0 && mouseY !== void 0) {
+        const edgeThreshold = 50;
+        mouseNearEdge = mouseX < edgeThreshold || mouseX > window.innerWidth - edgeThreshold || mouseY < edgeThreshold || mouseY > window.innerHeight - edgeThreshold;
+      }
+      this.events.push({
+        width: window.innerWidth,
+        height: window.innerHeight,
+        mouseX,
+        mouseY,
+        mouseNearEdge,
+        timestamp: Date.now()
+      });
+    };
+    window.addEventListener("resize", this.listener);
+  }
+  stop() {
+    if (!this.isActive)
+      return;
+    this.isActive = false;
+    if (this.listener) {
+      window.removeEventListener("resize", this.listener);
+      this.listener = null;
+    }
+    if (this.mouseListener) {
+      document.removeEventListener("mousemove", this.mouseListener);
+      this.mouseListener = null;
+    }
+  }
+  reset() {
+    this.events = [];
+  }
+  score() {
+    if (this.events.length === 0)
+      return void 0;
+    let score = 0;
+    let factors = 0;
+    score += inverseSigmoid(this.events.length, 5, 0.5);
+    factors++;
+    const withMouse = this.events.filter((e) => e.mouseX !== void 0);
+    if (withMouse.length > 0) {
+      const nearEdge = withMouse.filter((e) => e.mouseNearEdge).length;
+      score += sigmoid(nearEdge / withMouse.length, 0.5, 8);
+      factors++;
+    }
+    return factors > 0 ? score / factors : void 0;
+  }
+  getDebugInfo() {
+    return {
+      eventCount: this.events.length,
+      withMouseData: this.events.filter((e) => e.mouseX !== void 0).length
+    };
+  }
+};
+
+// dist/esm/types.js
+var DEFAULT_SETTINGS = {
+  sampleRates: {
+    mouseMove: 0.1,
+    // Track 10% of mouse moves
+    scroll: 1,
+    // Track ALL scrolls - critical for detection
+    keypress: 1
+    // Track all keypresses
+  },
+  rollingWindows: {
+    mouseMove: 3e4,
+    scroll: 3e4
+  },
+  weights: {
+    mouseMovement: 0.3,
+    // Increased - continuous behavioral signal
+    clickAccuracy: 0.3,
+    // Increased - critical behavioral signal
+    scrollBehavior: 0.15,
+    // Unchanged
+    keyboardTiming: 0.1,
+    // Slightly reduced
+    tabActivity: 0.05,
+    // Unchanged
+    resizeBehavior: 0.02,
+    // Reduced - less reliable
+    environmentFingerprint: 0.08
+    // Reduced - static signal, one-time check
+  },
+  customScorers: {},
+  clickMouseHistoryWindow: 1e3,
+  useWebWorker: false
+  // Will implement Web Worker support in phase 2
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BehaviorDetector,
+  Click,
+  ClickStrategy,
+  DEFAULT_SETTINGS,
+  Environment,
+  EnvironmentStrategy,
+  Keyboard,
+  KeyboardStrategy,
+  Mouse,
+  MouseStrategy,
+  Resize,
+  ResizeStrategy,
+  Scroll,
+  ScrollStrategy,
+  Tap,
+  TapStrategy
+});