@axeptio/behavior-detection 1.0.2 → 1.1.0

package/dist/cjs/index.cjs

@@ -0,0 +1,2320 @@
+"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,
+  Timing: () => TimingStrategy,
+  TimingStrategy: () => TimingStrategy,
+  Visibility: () => VisibilityStrategy,
+  VisibilityStrategy: () => VisibilityStrategy
+});
+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.enterListener = null;
+    this.isActive = false;
+    this.screenDiagonal = 1;
+    this.entryPoints = [];
+    this.microMovements = [];
+    this.STILLNESS_WINDOW = 500;
+    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, timestamp: now };
+      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);
+        if (pixelDistance >= 1 && pixelDistance <= 5) {
+          this.microMovements.push({ dx, dy, timestamp: now });
+          const cutoffMicro = now - this.STILLNESS_WINDOW;
+          while (this.microMovements.length > 0 && this.microMovements[0].timestamp < cutoffMicro) {
+            this.microMovements.shift();
+          }
+        }
+        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.enterListener = (e) => {
+      const mouseEvent = e;
+      const now = Date.now();
+      const x = mouseEvent.clientX;
+      const y = mouseEvent.clientY;
+      const width2 = window.innerWidth;
+      const height2 = window.innerHeight;
+      const distTop = y;
+      const distBottom = height2 - y;
+      const distLeft = x;
+      const distRight = width2 - x;
+      const minEdgeDist = Math.min(distTop, distBottom, distLeft, distRight);
+      let entryEdge;
+      const edgeThreshold = 50;
+      if (minEdgeDist < edgeThreshold) {
+        if (distTop <= minEdgeDist)
+          entryEdge = "top";
+        else if (distBottom <= minEdgeDist)
+          entryEdge = "bottom";
+        else if (distLeft <= minEdgeDist)
+          entryEdge = "left";
+        else
+          entryEdge = "right";
+      } else if (x > width2 * 0.35 && x < width2 * 0.65 && y > height2 * 0.35 && y < height2 * 0.65) {
+        entryEdge = "center";
+      } else if (distTop < edgeThreshold * 2 && distLeft < edgeThreshold * 2 || distTop < edgeThreshold * 2 && distRight < edgeThreshold * 2 || distBottom < edgeThreshold * 2 && distLeft < edgeThreshold * 2 || distBottom < edgeThreshold * 2 && distRight < edgeThreshold * 2) {
+        entryEdge = "corner";
+      } else {
+        if (distTop < distBottom && distTop < distLeft && distTop < distRight)
+          entryEdge = "top";
+        else if (distBottom < distLeft && distBottom < distRight)
+          entryEdge = "bottom";
+        else if (distLeft < distRight)
+          entryEdge = "left";
+        else
+          entryEdge = "right";
+      }
+      this.entryPoints.push({
+        x,
+        y,
+        timestamp: now,
+        edgeDistance: minEdgeDist,
+        entryEdge
+      });
+      if (this.entryPoints.length > 20) {
+        this.entryPoints.shift();
+      }
+    };
+    document.addEventListener("mouseenter", this.enterListener, { passive: true });
+    this.leaveListener = () => {
+      this.distanceSeries = [];
+      this.angleSeries = [];
+      this.lastPosition = null;
+      this.lastAngle = 0;
+      this.cumulativeAngle = 0;
+      this.microMovements = [];
+    };
+    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;
+    }
+    if (this.enterListener) {
+      document.removeEventListener("mouseenter", this.enterListener);
+      this.enterListener = null;
+    }
+  }
+  reset() {
+    this.distanceSeries = [];
+    this.angleSeries = [];
+    this.lastPosition = null;
+    this.lastAngle = 0;
+    this.cumulativeAngle = 0;
+    this.entryPoints = [];
+    this.microMovements = [];
+  }
+  score() {
+    if (this.distanceSeries.length < 10)
+      return void 0;
+    return this.detectMousePatterns();
+  }
+  /**
+   * Mouse-specific pattern detection
+   * Detects bot-like patterns: constant velocity, linear paths, suspicious entry points
+   */
+  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++;
+    }
+    const entryScore = this.scoreEntryPoints();
+    if (entryScore !== void 0) {
+      score += entryScore;
+      factors++;
+    }
+    const microScore = this.scoreMicroMovements();
+    if (microScore !== void 0) {
+      score += microScore;
+      factors++;
+    }
+    return factors > 0 ? score / factors : void 0;
+  }
+  /**
+   * Score based on viewport entry points
+   * Humans enter from edges with momentum; bots often start at (0,0) or center
+   */
+  scoreEntryPoints() {
+    if (this.entryPoints.length < 2)
+      return void 0;
+    let suspiciousCount = 0;
+    let centerCount = 0;
+    let cornerCount = 0;
+    let originCount = 0;
+    for (const entry of this.entryPoints) {
+      if (entry.x < 5 && entry.y < 5) {
+        originCount++;
+        suspiciousCount++;
+      } else if (entry.entryEdge === "center") {
+        centerCount++;
+        suspiciousCount++;
+      } else if (entry.entryEdge === "corner") {
+        cornerCount++;
+        if (entry.edgeDistance < 10)
+          suspiciousCount++;
+      }
+    }
+    const total = this.entryPoints.length;
+    const suspiciousRatio = suspiciousCount / total;
+    if (originCount >= 2 || originCount / total >= 0.5)
+      return 0.1;
+    if (centerCount / total >= 0.5)
+      return 0.2;
+    if (suspiciousRatio >= 0.7)
+      return 0.3;
+    if (suspiciousRatio >= 0.5)
+      return 0.5;
+    if (suspiciousRatio >= 0.3)
+      return 0.7;
+    return 1;
+  }
+  /**
+   * Score based on micro-movements (tremor detection)
+   * Humans have natural hand tremor causing 1-5px jitter
+   * Bots have perfect stillness or no micro-movements
+   */
+  scoreMicroMovements() {
+    if (this.distanceSeries.length < 20)
+      return void 0;
+    const microCount = this.microMovements.length;
+    const oldestEvent = this.distanceSeries[0];
+    const newestEvent = this.distanceSeries[this.distanceSeries.length - 1];
+    const durationMs = newestEvent.timestamp - oldestEvent.timestamp;
+    if (durationMs < 1e3)
+      return void 0;
+    const microPerSecond = microCount / durationMs * 1e3;
+    if (microCount === 0)
+      return 0.3;
+    if (microPerSecond < 1)
+      return 0.5;
+    if (microPerSecond < 5)
+      return 0.7;
+    if (microPerSecond >= 5 && microPerSecond <= 30)
+      return 1;
+    return 0.8;
+  }
+  /**
+   * Get micro-movement count for external use (e.g., by ClickStrategy)
+   */
+  getMicroMovementCount() {
+    return this.microMovements.length;
+  }
+  /**
+   * Get last position for external use
+   */
+  getLastPosition() {
+    return this.lastPosition ? { x: this.lastPosition.x, y: this.lastPosition.y } : null;
+  }
+  getDebugInfo() {
+    return {
+      eventCount: this.distanceSeries.length,
+      rollingWindow: this.rollingWindowMs,
+      isActive: this.isActive,
+      distanceSeries: this.distanceSeries,
+      angleSeries: this.angleSeries,
+      entryPoints: this.entryPoints,
+      microMovementCount: this.microMovements.length,
+      lastPosition: this.lastPosition
+    };
+  }
+};
+
+// 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,
+        timestamp: Date.now()
+      };
+    };
+    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 now = Date.now();
+        const rect = element.getBoundingClientRect();
+        const inViewport = rect.top >= 0 && rect.left >= 0 && rect.bottom <= window.innerHeight && rect.right <= window.innerWidth;
+        let mouseClickDelta = 0;
+        let timeSinceMouseMove = -1;
+        if (this.lastMousePosition) {
+          const dx = clickEvent.clientX - this.lastMousePosition.x;
+          const dy = clickEvent.clientY - this.lastMousePosition.y;
+          mouseClickDelta = Math.sqrt(dx * dx + dy * dy);
+          timeSinceMouseMove = now - this.lastMousePosition.timestamp;
+        }
+        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: now,
+          mouseClickDelta,
+          timeSinceMouseMove,
+          isTrusted: clickEvent.isTrusted
+        });
+        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() {
+    const eventCount = this.events.length;
+    if (eventCount === 0)
+      return void 0;
+    let positionScore = 0;
+    let clicksWithDelta = 0;
+    let mismatchCount = 0;
+    let clicksWithTiming = 0;
+    let suspiciousTimingCount = 0;
+    let untrustedCount = 0;
+    for (const click of this.events) {
+      switch (click.position) {
+        case "no-mouse-data":
+          positionScore += 0;
+          break;
+        case "outside":
+          positionScore += 0;
+          break;
+        case "dead-center":
+          positionScore += 0.5;
+          break;
+        case "over-element":
+          positionScore += 1;
+          break;
+      }
+      if (click.mouseClickDelta >= 0) {
+        clicksWithDelta++;
+        if (click.mouseClickDelta > 5)
+          mismatchCount++;
+      }
+      if (click.timeSinceMouseMove >= 0) {
+        clicksWithTiming++;
+        if (click.timeSinceMouseMove < 10 || click.timeSinceMouseMove > 2e3) {
+          suspiciousTimingCount++;
+        }
+      }
+      if (!click.isTrusted)
+        untrustedCount++;
+    }
+    let score = 0;
+    let factors = 0;
+    score += positionScore / eventCount;
+    factors++;
+    if (clicksWithDelta >= 2) {
+      const mismatchRatio = mismatchCount / clicksWithDelta;
+      let deltaScore;
+      if (mismatchRatio >= 0.8)
+        deltaScore = 0.1;
+      else if (mismatchRatio >= 0.5)
+        deltaScore = 0.3;
+      else if (mismatchRatio >= 0.3)
+        deltaScore = 0.5;
+      else if (mismatchRatio > 0)
+        deltaScore = 0.7;
+      else
+        deltaScore = 1;
+      score += deltaScore;
+      factors++;
+    }
+    if (clicksWithTiming >= 2) {
+      const suspiciousRatio = suspiciousTimingCount / clicksWithTiming;
+      let timingScore;
+      if (suspiciousRatio >= 0.8)
+        timingScore = 0.2;
+      else if (suspiciousRatio >= 0.5)
+        timingScore = 0.4;
+      else if (suspiciousRatio >= 0.3)
+        timingScore = 0.6;
+      else if (suspiciousRatio > 0)
+        timingScore = 0.8;
+      else
+        timingScore = 1;
+      score += timingScore;
+      factors++;
+    }
+    if (eventCount >= 2) {
+      const untrustedRatio = untrustedCount / eventCount;
+      let trustedScore;
+      if (untrustedRatio >= 0.5)
+        trustedScore = 0.1;
+      else if (untrustedRatio > 0)
+        trustedScore = 0.3;
+      else
+        trustedScore = 1;
+      score += trustedScore;
+      factors++;
+    }
+    return factors > 0 ? score / factors : void 0;
+  }
+  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,
+      mouseClickDeltas: this.events.map((e) => e.mouseClickDelta),
+      timeSinceMouseMoves: this.events.map((e) => e.timeSinceMouseMove),
+      untrustedClicks: this.events.filter((e) => !e.isTrusted).length
+    };
+  }
+};
+
+// 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 AUTOMATION_GLOBALS = [
+  "__nightmare",
+  "_phantom",
+  "callPhantom",
+  "__selenium_evaluate",
+  "__webdriver_evaluate",
+  "__driver_evaluate",
+  "__webdriver_script_function",
+  "__lastWatirAlert",
+  "__lastWatirConfirm",
+  "__lastWatirPrompt",
+  "_Selenium_IDE_Recorder",
+  "domAutomation",
+  "domAutomationController",
+  "webdriver",
+  "_webdriver_script_fn",
+  "__webdriver_script_func",
+  "__fxdriver_evaluate",
+  "__fxdriver_unwrapped",
+  "__selenium_unwrapped"
+];
+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;
+    const auto = env.automation;
+    if (auto.isWebdriver) {
+      return 0.05;
+    }
+    if (auto.hasAutomationGlobals) {
+      return 0.1;
+    }
+    if (auto.hasCDPInjection) {
+      return 0.1;
+    }
+    const headlessIndicatorCount = [
+      auto.hasHeadlessUA,
+      auto.hasChromelessRuntime,
+      auto.hasSoftwareRenderer
+    ].filter(Boolean).length;
+    if (headlessIndicatorCount >= 2) {
+      return 0.15;
+    }
+    if (auto.hasHeadlessUA) {
+      return 0.2;
+    }
+    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++;
+    if (!env.isMobile) {
+      score += inverseSigmoid(env.plugins, -2, -0.5);
+      score += env.plugins > 0 ? 1 : 0.1;
+      factors += 2;
+      if (auto.hasNoPlugins && env.vendor.includes("Google")) {
+        score += 0.3;
+        factors++;
+      }
+    }
+    if (auto.hasChromelessRuntime) {
+      score += 0.3;
+      factors++;
+    }
+    if (auto.hasSoftwareRenderer) {
+      score += 0.4;
+      factors++;
+    }
+    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;
+  }
+  /**
+   * Detect automation indicators
+   */
+  detectAutomation() {
+    const isMobile = this.isMobileDevice();
+    const isWebdriver = navigator.webdriver === true;
+    const ua = navigator.userAgent;
+    const hasHeadlessUA = /HeadlessChrome|Headless/i.test(ua);
+    const win = window;
+    const hasChromelessRuntime = !!(win.chrome && typeof win.chrome === "object" && !win.chrome.runtime);
+    const detectedGlobals = [];
+    for (const global of AUTOMATION_GLOBALS) {
+      if (global in win) {
+        detectedGlobals.push(global);
+      }
+    }
+    const hasAutomationGlobals = detectedGlobals.length > 0;
+    const detectedCDPKeys = [];
+    try {
+      for (const key of Object.keys(win)) {
+        if (/^cdc_|^__cdc_/.test(key)) {
+          detectedCDPKeys.push(key);
+        }
+      }
+    } catch (_a) {
+    }
+    const hasCDPInjection = detectedCDPKeys.length > 0;
+    const hasNoPlugins = !isMobile && navigator.plugins.length === 0;
+    let hasSoftwareRenderer = false;
+    try {
+      const canvas = document.createElement("canvas");
+      const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+      if (gl) {
+        const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+        if (debugInfo) {
+          const renderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL);
+          hasSoftwareRenderer = /SwiftShader|Software|LLVMpipe/i.test(renderer);
+          this._webglRenderer = renderer;
+        }
+      }
+    } catch (_b) {
+    }
+    return {
+      isWebdriver,
+      hasHeadlessUA,
+      hasChromelessRuntime,
+      hasSoftwareRenderer,
+      hasNoPlugins,
+      hasAutomationGlobals,
+      detectedGlobals,
+      hasCDPInjection,
+      detectedCDPKeys
+    };
+  }
+  captureEnvironment() {
+    try {
+      let hasWebGL = false;
+      let webglRenderer;
+      try {
+        const canvas = document.createElement("canvas");
+        const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+        hasWebGL = !!gl;
+        if (gl) {
+          const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+          if (debugInfo) {
+            webglRenderer = gl.getParameter(debugInfo.UNMASKED_RENDERER_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;
+      const automation = this.detectAutomation();
+      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(),
+        automation,
+        webglRenderer
+      };
+    } catch (_a) {
+    }
+  }
+  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;
+  }
+  /**
+   * Get automation detection results
+   * Returns null if environment hasn't been captured yet
+   */
+  getAutomationIndicators() {
+    var _a, _b;
+    return (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.automation) !== null && _b !== void 0 ? _b : null;
+  }
+  /**
+   * Quick check if any strong automation indicator is present
+   * Returns true if likely a bot, false if likely human, null if not checked yet
+   */
+  isLikelyBot() {
+    if (!this.data)
+      return null;
+    const auto = this.data.automation;
+    return auto.isWebdriver || auto.hasAutomationGlobals || auto.hasCDPInjection || auto.hasHeadlessUA;
+  }
+};
+
+// 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/strategies/timing.js
+var TimingStrategy = class extends BaseStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "timing";
+    this.defaultWeight = 0.15;
+    this.actions = [];
+    this.mouseStillness = {
+      position: null,
+      lastMoveTime: 0,
+      microMovementCount: 0
+    };
+    this.microMovements = [];
+    this.isActive = false;
+    this.mouseListener = null;
+    this.clickListener = null;
+    this.keydownListener = null;
+    this.scrollListener = null;
+    this.STILLNESS_WINDOW = 500;
+    this.MICRO_MOVEMENT_THRESHOLD = 1;
+    this.MAX_MICRO_MOVEMENT = 5;
+    this.MACHINE_PRECISION_THRESHOLD = 5;
+  }
+  start() {
+    if (this.isActive)
+      return;
+    this.isActive = true;
+    this.mouseListener = (e) => {
+      const mouseEvent = e;
+      const now = Date.now();
+      const currentPos = { x: mouseEvent.clientX, y: mouseEvent.clientY };
+      if (this.mouseStillness.position) {
+        const dx = currentPos.x - this.mouseStillness.position.x;
+        const dy = currentPos.y - this.mouseStillness.position.y;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        if (distance >= this.MICRO_MOVEMENT_THRESHOLD && distance <= this.MAX_MICRO_MOVEMENT) {
+          this.microMovements.push({ timestamp: now, distance });
+        }
+        if (distance >= this.MICRO_MOVEMENT_THRESHOLD) {
+          this.mouseStillness.lastMoveTime = now;
+        }
+      }
+      this.mouseStillness.position = currentPos;
+      const cutoff = now - this.STILLNESS_WINDOW;
+      this.microMovements = this.microMovements.filter((m) => m.timestamp >= cutoff);
+    };
+    this.clickListener = (e) => {
+      this.recordAction("click", e);
+    };
+    this.keydownListener = () => {
+      this.recordAction("keydown");
+    };
+    this.scrollListener = () => {
+      this.recordAction("scroll");
+    };
+    document.addEventListener("mousemove", this.mouseListener, { passive: true });
+    document.addEventListener("click", this.clickListener, { passive: true });
+    document.addEventListener("keydown", this.keydownListener, { passive: true });
+    document.addEventListener("scroll", this.scrollListener, { passive: true });
+  }
+  recordAction(type, _event) {
+    const now = Date.now();
+    const timeSinceMouseMove = this.mouseStillness.lastMoveTime > 0 ? now - this.mouseStillness.lastMoveTime : -1;
+    this.mouseStillness.microMovementCount = this.microMovements.length;
+    this.actions.push({
+      type,
+      timestamp: now,
+      timeSinceMouseMove,
+      wasHidden: document.hidden
+    });
+    this.notifyEvent(0.7);
+    if (this.actions.length > 100) {
+      this.actions.shift();
+    }
+  }
+  stop() {
+    if (!this.isActive)
+      return;
+    this.isActive = false;
+    if (this.mouseListener) {
+      document.removeEventListener("mousemove", this.mouseListener);
+      this.mouseListener = null;
+    }
+    if (this.clickListener) {
+      document.removeEventListener("click", this.clickListener);
+      this.clickListener = null;
+    }
+    if (this.keydownListener) {
+      document.removeEventListener("keydown", this.keydownListener);
+      this.keydownListener = null;
+    }
+    if (this.scrollListener) {
+      document.removeEventListener("scroll", this.scrollListener);
+      this.scrollListener = null;
+    }
+  }
+  reset() {
+    this.actions = [];
+    this.microMovements = [];
+    this.mouseStillness = {
+      position: null,
+      lastMoveTime: 0,
+      microMovementCount: 0
+    };
+  }
+  score() {
+    const actionCount = this.actions.length;
+    if (actionCount < 3)
+      return void 0;
+    let score = 0;
+    let factors = 0;
+    const clicks = [];
+    const clicksWithMouse = [];
+    let hiddenCount = 0;
+    for (const action of this.actions) {
+      if (action.type === "click") {
+        clicks.push(action);
+        if (action.timeSinceMouseMove >= 0) {
+          clicksWithMouse.push(action);
+        }
+      }
+      if (action.wasHidden)
+        hiddenCount++;
+    }
+    if (clicks.length >= 2) {
+      const stillnessScore = this.scorePreActionStillness(clicks);
+      if (stillnessScore !== void 0) {
+        score += stillnessScore;
+        factors++;
+      }
+    }
+    if (clicksWithMouse.length >= 3) {
+      const mouseToClickScore = this.scoreMouseToClickDelayFromCache(clicksWithMouse);
+      if (mouseToClickScore !== void 0) {
+        score += mouseToClickScore;
+        factors++;
+      }
+    }
+    if (actionCount >= 5) {
+      const intervalScore = this.scoreActionIntervals();
+      if (intervalScore !== void 0) {
+        score += intervalScore;
+        factors++;
+      }
+    }
+    const hiddenScore = this.scoreHiddenActionsFromCount(hiddenCount, actionCount);
+    score += hiddenScore;
+    factors++;
+    return factors > 0 ? score / factors : void 0;
+  }
+  /**
+   * Score based on pre-action stillness
+   * Humans have micro-movements before clicking; bots are perfectly still
+   */
+  scorePreActionStillness(clicks) {
+    const clicksWithMouseData = clicks.filter((c) => c.timeSinceMouseMove >= 0);
+    if (clicksWithMouseData.length < 2)
+      return void 0;
+    const perfectlyStillClicks = clicksWithMouseData.filter((c) => {
+      return c.timeSinceMouseMove >= 100 && c.timeSinceMouseMove <= 500 && this.mouseStillness.microMovementCount === 0;
+    }).length;
+    const stillRatio = perfectlyStillClicks / clicksWithMouseData.length;
+    if (stillRatio >= 0.9)
+      return 0.1;
+    if (stillRatio >= 0.7)
+      return 0.3;
+    if (stillRatio >= 0.5)
+      return 0.5;
+    if (stillRatio >= 0.3)
+      return 0.7;
+    return 1;
+  }
+  /**
+   * Score mouse-to-click delay patterns (using pre-filtered cache)
+   */
+  scoreMouseToClickDelayFromCache(clicksWithMouse) {
+    const delays = clicksWithMouse.map((c) => c.timeSinceMouseMove);
+    const stats = calculateStatistics(delays);
+    if (stats.mean < 10)
+      return 0.1;
+    if (stats.cv < 0.2 && clicksWithMouse.length >= 5)
+      return 0.2;
+    if (stats.mean >= 50 && stats.mean <= 300 && stats.cv >= 0.3)
+      return 1;
+    if (stats.cv < 0.4)
+      return 0.6;
+    return 0.8;
+  }
+  /**
+   * Score action intervals for machine-like precision
+   * Detects exact intervals: 100ms, 500ms, 1000ms
+   */
+  scoreActionIntervals() {
+    if (this.actions.length < 5)
+      return void 0;
+    const intervals = [];
+    for (let i = 1; i < this.actions.length; i++) {
+      intervals.push(this.actions[i].timestamp - this.actions[i - 1].timestamp);
+    }
+    const machineIntervals = [100, 200, 250, 500, 1e3];
+    let preciseCount = 0;
+    for (const interval of intervals) {
+      for (const machineInterval of machineIntervals) {
+        const remainder = interval % machineInterval;
+        if (remainder < this.MACHINE_PRECISION_THRESHOLD || machineInterval - remainder < this.MACHINE_PRECISION_THRESHOLD) {
+          preciseCount++;
+          break;
+        }
+      }
+    }
+    const preciseRatio = preciseCount / intervals.length;
+    if (preciseRatio >= 0.8)
+      return 0.1;
+    if (preciseRatio >= 0.6)
+      return 0.3;
+    if (preciseRatio >= 0.4)
+      return 0.5;
+    const stats = calculateStatistics(intervals);
+    if (stats.cv < 0.15)
+      return 0.2;
+    return 1;
+  }
+  /**
+   * Score based on actions while document was hidden (using pre-computed count)
+   */
+  scoreHiddenActionsFromCount(hiddenCount, totalCount) {
+    if (hiddenCount === 0)
+      return 1;
+    const hiddenRatio = hiddenCount / totalCount;
+    if (hiddenRatio > 0.5)
+      return 0.1;
+    if (hiddenRatio > 0.2)
+      return 0.3;
+    if (hiddenRatio > 0)
+      return 0.5;
+    return 1;
+  }
+  getDebugInfo() {
+    const clicks = this.actions.filter((a) => a.type === "click");
+    const intervals = [];
+    for (let i = 1; i < this.actions.length; i++) {
+      intervals.push(this.actions[i].timestamp - this.actions[i - 1].timestamp);
+    }
+    return {
+      actionCount: this.actions.length,
+      clickCount: clicks.length,
+      keydownCount: this.actions.filter((a) => a.type === "keydown").length,
+      scrollCount: this.actions.filter((a) => a.type === "scroll").length,
+      hiddenActionCount: this.actions.filter((a) => a.wasHidden).length,
+      microMovementCount: this.microMovements.length,
+      intervals: intervals.slice(-20),
+      // Last 20 intervals
+      lastStillnessDuration: this.mouseStillness.lastMoveTime > 0 ? Date.now() - this.mouseStillness.lastMoveTime : null
+    };
+  }
+};
+
+// dist/esm/strategies/visibility.js
+var VisibilityStrategy = class extends BaseStrategy {
+  constructor() {
+    super(...arguments);
+    this.name = "visibility";
+    this.defaultWeight = 0.1;
+    this.events = [];
+    this.focusTypingPairs = [];
+    this.actionsWhileHidden = 0;
+    this.lastVisibilityChange = null;
+    this.resumeDelays = [];
+    this.isActive = false;
+    this.visibilityListener = null;
+    this.focusListener = null;
+    this.blurListener = null;
+    this.clickListener = null;
+    this.keydownListener = null;
+    this.inputFocusListener = null;
+    this.lastFocusedInput = null;
+    this.hasTypedInFocusedInput = false;
+    this.lastActionTime = 0;
+    this.preHideActionTime = 0;
+  }
+  start() {
+    if (this.isActive)
+      return;
+    this.isActive = true;
+    this.visibilityListener = () => {
+      const now = Date.now();
+      const wasHidden = document.hidden;
+      if (this.lastVisibilityChange && !wasHidden) {
+        if (this.lastActionTime > 0 && this.preHideActionTime > 0) {
+          const timeSinceLastAction = now - this.lastActionTime;
+          if (timeSinceLastAction < 50) {
+            this.actionsWhileHidden++;
+          }
+        }
+        this.lastVisibilityChange = { hidden: false, timestamp: now };
+      } else if (wasHidden) {
+        this.preHideActionTime = this.lastActionTime;
+        this.lastVisibilityChange = { hidden: true, timestamp: now };
+      }
+      this.events.push({
+        type: "visibility_change",
+        timestamp: now,
+        wasHidden
+      });
+    };
+    this.focusListener = () => {
+      this.events.push({
+        type: "focus_change",
+        timestamp: Date.now(),
+        wasHidden: document.hidden,
+        wasFocused: true
+      });
+    };
+    this.blurListener = () => {
+      this.events.push({
+        type: "focus_change",
+        timestamp: Date.now(),
+        wasHidden: document.hidden,
+        wasFocused: false
+      });
+    };
+    this.clickListener = (e) => {
+      this.recordAction("click", e);
+    };
+    this.keydownListener = (e) => {
+      this.recordAction("keydown", e);
+      if (this.lastFocusedInput && !this.hasTypedInFocusedInput) {
+        const now = Date.now();
+        const delay = now - this.lastFocusedInput.timestamp;
+        this.focusTypingPairs.push({
+          focusTime: this.lastFocusedInput.timestamp,
+          firstKeypressTime: now,
+          delay,
+          element: this.lastFocusedInput.element
+        });
+        this.hasTypedInFocusedInput = true;
+      }
+    };
+    this.inputFocusListener = (e) => {
+      const target = e.target;
+      if (target && (target.tagName === "INPUT" || target.tagName === "TEXTAREA")) {
+        this.lastFocusedInput = {
+          element: target.tagName.toLowerCase(),
+          timestamp: Date.now()
+        };
+        this.hasTypedInFocusedInput = false;
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityListener);
+    window.addEventListener("focus", this.focusListener);
+    window.addEventListener("blur", this.blurListener);
+    document.addEventListener("click", this.clickListener, { passive: true });
+    document.addEventListener("keydown", this.keydownListener, { passive: true });
+    document.addEventListener("focusin", this.inputFocusListener, { passive: true });
+  }
+  recordAction(_type, _event) {
+    const now = Date.now();
+    this.lastActionTime = now;
+    if (document.hidden) {
+      this.actionsWhileHidden++;
+      this.events.push({
+        type: "action_while_hidden",
+        timestamp: now,
+        wasHidden: true
+      });
+      this.notifyEvent(1);
+    }
+    if (this.lastVisibilityChange && !this.lastVisibilityChange.hidden) {
+      const resumeDelay = now - this.lastVisibilityChange.timestamp;
+      if (resumeDelay > 0 && resumeDelay < 1e4 && this.resumeDelays.length < 20) {
+        const lastRecordedDelay = this.resumeDelays[this.resumeDelays.length - 1];
+        if (lastRecordedDelay === void 0 || Math.abs(resumeDelay - lastRecordedDelay) > 100) {
+          this.resumeDelays.push(resumeDelay);
+        }
+      }
+    }
+  }
+  stop() {
+    if (!this.isActive)
+      return;
+    this.isActive = false;
+    if (this.visibilityListener) {
+      document.removeEventListener("visibilitychange", this.visibilityListener);
+      this.visibilityListener = null;
+    }
+    if (this.focusListener) {
+      window.removeEventListener("focus", this.focusListener);
+      this.focusListener = null;
+    }
+    if (this.blurListener) {
+      window.removeEventListener("blur", this.blurListener);
+      this.blurListener = null;
+    }
+    if (this.clickListener) {
+      document.removeEventListener("click", this.clickListener);
+      this.clickListener = null;
+    }
+    if (this.keydownListener) {
+      document.removeEventListener("keydown", this.keydownListener);
+      this.keydownListener = null;
+    }
+    if (this.inputFocusListener) {
+      document.removeEventListener("focusin", this.inputFocusListener);
+      this.inputFocusListener = null;
+    }
+  }
+  reset() {
+    this.events = [];
+    this.focusTypingPairs = [];
+    this.actionsWhileHidden = 0;
+    this.lastVisibilityChange = null;
+    this.resumeDelays = [];
+    this.lastFocusedInput = null;
+    this.hasTypedInFocusedInput = false;
+    this.lastActionTime = 0;
+    this.preHideActionTime = 0;
+  }
+  score() {
+    if (this.events.length < 2)
+      return void 0;
+    let score = 0;
+    let factors = 0;
+    const hiddenActionScore = this.scoreHiddenActions();
+    if (hiddenActionScore !== void 0) {
+      score += hiddenActionScore;
+      factors++;
+    }
+    const resumeScore = this.scoreResumeDelays();
+    if (resumeScore !== void 0) {
+      score += resumeScore;
+      factors++;
+    }
+    const focusTypingScore = this.scoreFocusTyping();
+    if (focusTypingScore !== void 0) {
+      score += focusTypingScore;
+      factors++;
+    }
+    return factors > 0 ? score / factors : void 0;
+  }
+  /**
+   * Score based on actions while document was hidden
+   * Humans can't interact with hidden tabs; bots can
+   */
+  scoreHiddenActions() {
+    if (this.actionsWhileHidden === 0)
+      return 1;
+    if (this.actionsWhileHidden >= 5)
+      return 0.1;
+    if (this.actionsWhileHidden >= 3)
+      return 0.2;
+    if (this.actionsWhileHidden >= 1)
+      return 0.3;
+    return 1;
+  }
+  /**
+   * Score based on how quickly activity resumes after tab becomes visible
+   * Humans need time to refocus (100-500ms minimum)
+   * Bots often resume instantly (< 50ms)
+   */
+  scoreResumeDelays() {
+    if (this.resumeDelays.length < 2)
+      return void 0;
+    const fastResumeCount = this.resumeDelays.filter((d) => d < 50).length;
+    const fastResumeRatio = fastResumeCount / this.resumeDelays.length;
+    if (fastResumeRatio >= 0.8)
+      return 0.1;
+    if (fastResumeRatio >= 0.5)
+      return 0.3;
+    if (fastResumeRatio >= 0.3)
+      return 0.5;
+    if (fastResumeRatio > 0)
+      return 0.7;
+    return 1;
+  }
+  /**
+   * Score based on focus-to-keypress timing
+   * Humans focus inputs before typing (natural delay 100-500ms)
+   * Bots often type without focusing or with instant delay
+   */
+  scoreFocusTyping() {
+    if (this.focusTypingPairs.length < 2)
+      return void 0;
+    let suspiciousCount = 0;
+    for (const pair of this.focusTypingPairs) {
+      if (pair.delay < 20) {
+        suspiciousCount++;
+      }
+    }
+    const suspiciousRatio = suspiciousCount / this.focusTypingPairs.length;
+    if (suspiciousRatio >= 0.8)
+      return 0.2;
+    if (suspiciousRatio >= 0.5)
+      return 0.4;
+    if (suspiciousRatio >= 0.3)
+      return 0.6;
+    if (suspiciousRatio > 0)
+      return 0.8;
+    return 1;
+  }
+  getDebugInfo() {
+    return {
+      eventCount: this.events.length,
+      actionsWhileHidden: this.actionsWhileHidden,
+      visibilityChanges: this.events.filter((e) => e.type === "visibility_change").length,
+      focusChanges: this.events.filter((e) => e.type === "focus_change").length,
+      resumeDelays: this.resumeDelays,
+      focusTypingPairs: this.focusTypingPairs.map((p) => ({
+        delay: p.delay,
+        element: p.element
+      }))
+    };
+  }
+};
+
+// 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,
+  Timing,
+  TimingStrategy,
+  Visibility,
+  VisibilityStrategy
+});