@axeptio/behavior-detection 1.0.0

package/dist/esm/strategies/click.js

@@ -0,0 +1,169 @@
+/**
+ * Click Behavior Detection Strategy
+ * Monitors specific elements for click positioning patterns
+ */
+import { BaseStrategy } from '../strategy';
+export class ClickStrategy extends BaseStrategy {
+    constructor(options) {
+        super();
+        this.name = 'click';
+        this.defaultWeight = 0.30;
+        this.events = [];
+        this.targetSelectors = ['button', 'a', 'input[type="submit"]', '[role="button"]'];
+        this.lastMousePosition = null;
+        this.mouseListener = null;
+        this.clickListeners = 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;
+        // Track mouse position globally
+        this.mouseListener = (e) => {
+            const mouseEvent = e;
+            this.lastMousePosition = {
+                x: mouseEvent.clientX,
+                y: mouseEvent.clientY,
+            };
+        };
+        document.addEventListener('mousemove', this.mouseListener, { passive: true });
+        // Find all matching elements and attach listeners
+        this.attachClickListeners();
+    }
+    /**
+     * Add a new target selector at runtime
+     */
+    addTarget(selector) {
+        if (!this.targetSelectors.includes(selector)) {
+            this.targetSelectors.push(selector);
+            // Attach listeners if already active
+            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; // Already attached
+            const listener = (e) => {
+                var _a, _b;
+                const clickEvent = e;
+                const rect = element.getBoundingClientRect();
+                // Check if element is in viewport
+                const inViewport = (rect.top >= 0 &&
+                    rect.left >= 0 &&
+                    rect.bottom <= window.innerHeight &&
+                    rect.right <= window.innerWidth);
+                // Analyze click position
+                let position;
+                if (!this.lastMousePosition) {
+                    position = 'no-mouse-data'; // Bot - no mouse movement
+                }
+                else {
+                    const mx = this.lastMousePosition.x;
+                    const my = this.lastMousePosition.y;
+                    // Check if mouse was over element
+                    const overElement = (mx >= rect.left &&
+                        mx <= rect.right &&
+                        my >= rect.top &&
+                        my <= rect.bottom);
+                    if (!overElement) {
+                        position = 'outside'; // Bot - mouse not over target
+                    }
+                    else {
+                        // Check if dead center (suspicious)
+                        const centerX = rect.left + rect.width / 2;
+                        const centerY = rect.top + rect.height / 2;
+                        const distanceFromCenter = Math.sqrt((mx - centerX) ** 2 + (my - centerY) ** 2);
+                        // Dead center = within 2px of center
+                        if (distanceFromCenter < 2) {
+                            position = 'dead-center'; // Suspicious - too perfect
+                        }
+                        else {
+                            position = 'over-element'; // Human - somewhere on the button
+                        }
+                    }
+                }
+                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(),
+                });
+                // Notify detector - clicks are high-value events
+                this.notifyEvent(1.0);
+            };
+            element.addEventListener('click', listener);
+            this.clickListeners.set(element, listener);
+        });
+    }
+    stop() {
+        if (!this.isActive)
+            return;
+        this.isActive = false;
+        // Remove mouse listener
+        if (this.mouseListener) {
+            document.removeEventListener('mousemove', this.mouseListener);
+            this.mouseListener = null;
+        }
+        // Remove all click listeners
+        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 undefined;
+        let totalScore = 0;
+        for (const click of this.events) {
+            switch (click.position) {
+                case 'no-mouse-data':
+                    totalScore += 0.0; // Bot - no mouse movement
+                    break;
+                case 'outside':
+                    totalScore += 0.0; // Bot - mouse not over target
+                    break;
+                case 'dead-center':
+                    totalScore += 0.5; // Suspicious - too perfect
+                    break;
+                case 'over-element':
+                    totalScore += 1.0; // Human - natural click
+                    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,
+        };
+    }
+}

package/dist/esm/strategies/environment.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Environment Fingerprinting Strategy
+ * Captures browser environment on initialization and tick updates
+ */
+import { BaseStrategy } from '../strategy';
+interface EnvironmentData {
+    screenWidth: number;
+    screenHeight: number;
+    windowWidth: number;
+    windowHeight: number;
+    devicePixelRatio: number;
+    colorDepth: number;
+    userAgent: string;
+    platform: string;
+    language: string;
+    languages: string[];
+    hardwareConcurrency?: number;
+    maxTouchPoints: number;
+    vendor: string;
+    hasWebGL: boolean;
+    hasWebRTC: boolean;
+    hasLocalStorage: boolean;
+    hasSessionStorage: boolean;
+    hasIndexedDB: boolean;
+    plugins: number;
+    mimeTypes: number;
+    suspiciousRatio: boolean;
+    suspiciousDimensions: boolean;
+    featureInconsistency: boolean;
+    isMobile: boolean;
+    timestamp: number;
+}
+export declare class EnvironmentStrategy extends BaseStrategy {
+    readonly name = "environment";
+    readonly defaultWeight = 0.08;
+    private data;
+    start(): void;
+    stop(): void;
+    reset(): void;
+    onTick(_timestamp: number): void;
+    score(): number | undefined;
+    private isMobileDevice;
+    private captureEnvironment;
+    getDebugInfo(): EnvironmentData | null;
+    /**
+     * Check if current device is mobile
+     * Returns true if mobile, false otherwise
+     * Returns null if environment hasn't been captured yet
+     */
+    isMobile(): boolean | null;
+}
+export {};

package/dist/esm/strategies/environment.js

@@ -0,0 +1,144 @@
+/**
+ * Environment Fingerprinting Strategy
+ * Captures browser environment on initialization and tick updates
+ */
+import { BaseStrategy } from '../strategy';
+import { inverseSigmoid, gaussian } from '../math-utils';
+export class EnvironmentStrategy extends BaseStrategy {
+    constructor() {
+        super(...arguments);
+        this.name = 'environment';
+        this.defaultWeight = 0.08;
+        this.data = null;
+    }
+    start() {
+        this.captureEnvironment();
+    }
+    stop() {
+        // Environment data persists
+    }
+    reset() {
+        this.data = null;
+    }
+    onTick(_timestamp) {
+        // Re-capture environment periodically to detect changes
+        this.captureEnvironment();
+    }
+    score() {
+        if (!this.data)
+            return undefined;
+        const env = this.data;
+        let score = 0;
+        let factors = 0;
+        // Suspicious indicators
+        score += env.suspiciousDimensions ? 0.1 : 1.0;
+        score += env.suspiciousRatio ? 0.2 : 1.0;
+        score += env.featureInconsistency ? 0.3 : 1.0;
+        factors += 3;
+        // Browser features
+        const featureCount = [
+            env.hasWebGL,
+            env.hasLocalStorage,
+            env.hasSessionStorage,
+            env.hasIndexedDB,
+        ].filter(Boolean).length;
+        score += featureCount / 4;
+        factors++;
+        // Plugins
+        score += inverseSigmoid(env.plugins, -2, -0.5);
+        score += (env.plugins > 0 ? 1.0 : 0.1);
+        factors += 2;
+        // Device
+        score += gaussian(env.devicePixelRatio, 2, 1.5);
+        score += (env.colorDepth === 24 || env.colorDepth === 32) ? 1.0 : 0.4;
+        factors += 2;
+        return factors > 0 ? score / factors : undefined;
+    }
+    isMobileDevice() {
+        // Multiple checks for mobile detection
+        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 {
+            // WebGL detection
+            let hasWebGL = false;
+            try {
+                const canvas = document.createElement('canvas');
+                hasWebGL = !!(canvas.getContext('webgl') || canvas.getContext('experimental-webgl'));
+            }
+            catch (e) {
+                hasWebGL = false;
+            }
+            // WebRTC detection
+            const hasWebRTC = !!(window.RTCPeerConnection ||
+                window.mozRTCPeerConnection ||
+                window.webkitRTCPeerConnection);
+            // Mobile detection
+            const isMobile = this.isMobileDevice();
+            const windowWidth = window.innerWidth;
+            const windowHeight = window.innerHeight;
+            const screenWidth = window.screen.width;
+            const screenHeight = window.screen.height;
+            // Suspicious dimensions
+            const suspiciousDimensions = (windowWidth === 800 && windowHeight === 600) ||
+                (windowWidth === 1024 && windowHeight === 768) ||
+                (windowWidth === 1280 && windowHeight === 720) ||
+                (screenWidth === 800 && screenHeight === 600);
+            // Suspicious ratio
+            const windowScreenRatio = (windowWidth * windowHeight) / (screenWidth * screenHeight);
+            const suspiciousRatio = windowScreenRatio === 1.0 ||
+                windowScreenRatio < 0.1 ||
+                windowScreenRatio > 1.0;
+            // Feature inconsistency
+            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;
+    }
+}

package/dist/esm/strategies/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Detection Strategies - Modular behavior analysis
+ * Import only what you need for optimal bundle size
+ */
+export { MouseStrategy } from './mouse';
+export { ScrollStrategy } from './scroll';
+export { ClickStrategy } from './click';
+export { TapStrategy } from './tap';
+export { KeyboardStrategy } from './keyboard';
+export { EnvironmentStrategy } from './environment';
+export { ResizeStrategy } from './resize';
+export { MouseStrategy as Mouse } from './mouse';
+export { ScrollStrategy as Scroll } from './scroll';
+export { ClickStrategy as Click } from './click';
+export { TapStrategy as Tap } from './tap';
+export { KeyboardStrategy as Keyboard } from './keyboard';
+export { EnvironmentStrategy as Environment } from './environment';
+export { ResizeStrategy as Resize } from './resize';

package/dist/esm/strategies/index.js

@@ -0,0 +1,19 @@
+/**
+ * Detection Strategies - Modular behavior analysis
+ * Import only what you need for optimal bundle size
+ */
+export { MouseStrategy } from './mouse';
+export { ScrollStrategy } from './scroll';
+export { ClickStrategy } from './click';
+export { TapStrategy } from './tap';
+export { KeyboardStrategy } from './keyboard';
+export { EnvironmentStrategy } from './environment';
+export { ResizeStrategy } from './resize';
+// Convenience: All strategies
+export { MouseStrategy as Mouse } from './mouse';
+export { ScrollStrategy as Scroll } from './scroll';
+export { ClickStrategy as Click } from './click';
+export { TapStrategy as Tap } from './tap';
+export { KeyboardStrategy as Keyboard } from './keyboard';
+export { EnvironmentStrategy as Environment } from './environment';
+export { ResizeStrategy as Resize } from './resize';

package/dist/esm/strategies/keyboard.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Keyboard Timing Detection Strategy
+ * Monitors typing in specific input fields
+ * Analyzes keydown/keyup timing and micro-variations
+ */
+import { BaseStrategy } from '../strategy';
+export declare class KeyboardStrategy extends BaseStrategy {
+    readonly name = "keyboard";
+    readonly defaultWeight = 0.1;
+    private events;
+    private targetSelectors;
+    private focusedElement;
+    private focusedElementSelector;
+    private lastEventTimestamp;
+    private sessionPauseThreshold;
+    private downListener;
+    private upListener;
+    private focusListeners;
+    private blurListeners;
+    private isActive;
+    constructor(options?: {
+        targetSelectors?: string[];
+    });
+    start(): void;
+    /**
+     * Add a new target selector at runtime
+     */
+    addTarget(selector: string): void;
+    private attachFocusListeners;
+    private attachFocusListenersForSelector;
+    stop(): void;
+    reset(): void;
+    score(): number | undefined;
+    getDebugInfo(): {
+        eventCount: number;
+        downEvents: number;
+        upEvents: number;
+        backspaceCount: number;
+        pressDurations: number[];
+        focusedElement: string;
+        trackedElements: number;
+    };
+}

package/dist/esm/strategies/keyboard.js

@@ -0,0 +1,229 @@
+/**
+ * Keyboard Timing Detection Strategy
+ * Monitors typing in specific input fields
+ * Analyzes keydown/keyup timing and micro-variations
+ */
+import { BaseStrategy } from '../strategy';
+import { analyzeIntervals, scoreCoefficientOfVariation } from '../math-utils';
+export class KeyboardStrategy extends BaseStrategy {
+    constructor(options) {
+        super();
+        this.name = 'keyboard';
+        this.defaultWeight = 0.10;
+        this.events = [];
+        this.targetSelectors = ['input[type="text"]', 'input[type="email"]', 'textarea'];
+        this.focusedElement = null;
+        this.focusedElementSelector = '';
+        this.lastEventTimestamp = 0;
+        this.sessionPauseThreshold = 1000;
+        this.downListener = null;
+        this.upListener = null;
+        this.focusListeners = new Map();
+        this.blurListeners = 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;
+        // Attach focus/blur listeners to all matching elements
+        this.attachFocusListeners();
+        // Key event listeners (only track when an input is focused)
+        this.downListener = (e) => {
+            if (!this.focusedElement)
+                return; // No input focused
+            const now = Date.now();
+            const keyEvent = e;
+            // Clear events if pause > 1s (new typing session)
+            if (this.lastEventTimestamp > 0 && now - this.lastEventTimestamp > this.sessionPauseThreshold) {
+                this.events = [];
+            }
+            this.events.push({
+                key: keyEvent.key,
+                type: 'down',
+                timestamp: now,
+                targetElement: this.focusedElementSelector,
+            });
+            // Notify detector - keystrokes are valuable events
+            this.notifyEvent(0.8);
+            this.lastEventTimestamp = now;
+        };
+        this.upListener = (e) => {
+            if (!this.focusedElement)
+                return; // No input focused
+            const now = Date.now();
+            const keyEvent = e;
+            // Clear events if pause > 1s (new typing session)
+            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; // Already attached
+            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;
+        }
+        // Remove focus/blur listeners
+        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 undefined; // Need at least 3 key pairs
+        const downEvents = this.events.filter(e => e.type === 'down');
+        if (downEvents.length < 3)
+            return undefined;
+        let score = 0;
+        let factors = 0;
+        // 1. Analyze keystroke intervals (time between keydown events)
+        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;
+            // Keyboard-specific heuristics for keystroke timing
+            if (allIdentical) {
+                return 0.1; // All identical - bot!
+            }
+            const keystrokeScore = scoreCoefficientOfVariation(statistics.cv);
+            score += keystrokeScore;
+            factors++;
+            // Early return if bot detected
+            if (keystrokeScore <= 0.1)
+                return keystrokeScore;
+        }
+        // 2. Analyze press durations (keydown-to-keyup duration)
+        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;
+            // Keyboard-specific heuristics for press duration
+            if (allIdentical) {
+                return 0.1; // All identical - bot!
+            }
+            // Check for suspiciously fast key releases (bots often have <5ms press duration)
+            if (statistics.mean < 5) {
+                score += 0.1; // Too fast = bot (instant release)
+                factors++;
+            }
+            else {
+                const pressDurationScore = scoreCoefficientOfVariation(statistics.cv);
+                score += pressDurationScore;
+                factors++;
+                // Early return if bot detected
+                if (pressDurationScore <= 0.1)
+                    return pressDurationScore;
+            }
+        }
+        // 3. Bonus for backspace usage (human error correction)
+        const backspaceCount = this.events.filter(e => e.key === 'Backspace').length;
+        if (backspaceCount > 0) {
+            // Natural human behavior - making corrections
+            const backspaceRatio = backspaceCount / downEvents.length;
+            if (backspaceRatio > 0.05 && backspaceRatio < 0.3) {
+                score += 1.0; // Reasonable error correction
+                factors++;
+            }
+            else if (backspaceRatio > 0) {
+                score += 0.8; // Some backspaces
+                factors++;
+            }
+        }
+        return factors > 0 ? score / factors : undefined;
+    }
+    getDebugInfo() {
+        // Calculate press durations for visualization
+        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,
+        };
+    }
+}