@axeptio/behavior-detection 1.0.0

package/dist/cjs/behavior-detector.js

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BehaviorDetector = void 0;
+/**
+ * Main class for behavior detection
+ * Uses modular strategy pattern for tree-shakeable, autonomous detection modules
+ */
+class BehaviorDetector {
+    constructor(tickOptions) {
+        // Strategy mode
+        this.strategies = new Map();
+        this.isTracking = false;
+        this.isPausedByVisibility = false;
+        this.tickInterval = null;
+        this.tickIntervalMs = 1000; // Default: 1 second
+        this.pauseOnHidden = true;
+        this.visibilityChangeHandler = null;
+        // Confidence tracking
+        this.confidenceScore = 0;
+        this.CONFIDENCE_TARGET = 1.0; // Target confidence for reliable classification
+        this.CONFIDENCE_DECAY = 0.95; // Per event decay to prevent infinite growth
+        if (tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.interval) {
+            this.tickIntervalMs = tickOptions.interval;
+        }
+        if ((tickOptions === null || tickOptions === void 0 ? void 0 : tickOptions.pauseOnHidden) !== undefined) {
+            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);
+        // Set up event callback for confidence tracking
+        if (strategy.setEventCallback) {
+            strategy.setEventCallback((event) => {
+                this.onStrategyEvent(event, config.weight);
+            });
+        }
+        // If already tracking, start this strategy immediately
+        if (this.isTracking) {
+            strategy.start();
+        }
+        return this;
+    }
+    /**
+     * Handle event from strategy - update confidence
+     */
+    onStrategyEvent(event, strategyWeight) {
+        // Apply decay to existing confidence to prevent infinite growth
+        this.confidenceScore *= this.CONFIDENCE_DECAY;
+        // Add weighted contribution from this event
+        // eventWeight (0-1) * strategyWeight (e.g. 0.3 for mouse) = contribution
+        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 tracking and being disabled, stop it
+            if (!enabled && this.isTracking) {
+                config.strategy.stop();
+            }
+            // If tracking and being enabled, start it
+            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;
+        // Set up visibility change listener
+        if (this.pauseOnHidden && typeof document !== 'undefined') {
+            this.visibilityChangeHandler = this.handleVisibilityChange.bind(this);
+            document.addEventListener('visibilitychange', this.visibilityChangeHandler);
+            // Check initial visibility state
+            if (document.hidden) {
+                this.isPausedByVisibility = true;
+                return; // Don't start strategies if already hidden
+            }
+        }
+        // Start all enabled strategies
+        for (const [_, config] of this.strategies) {
+            if (config.enabled) {
+                config.strategy.start();
+            }
+        }
+        // Start tick mechanism
+        this.startTick();
+    }
+    /**
+     * Stop tracking
+     */
+    stop() {
+        if (!this.isTracking)
+            return;
+        this.isTracking = false;
+        this.isPausedByVisibility = false;
+        // Remove visibility change listener
+        if (this.visibilityChangeHandler && typeof document !== 'undefined') {
+            document.removeEventListener('visibilitychange', this.visibilityChangeHandler);
+            this.visibilityChangeHandler = null;
+        }
+        // Stop all strategies
+        for (const [_, config] of this.strategies) {
+            config.strategy.stop();
+        }
+        // Stop tick
+        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;
+        }
+        // Note: auditTrail not available in strategy mode
+        // Each strategy manages its own data independently
+        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) !== undefined) {
+                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) {
+            // Tab became hidden - pause detection
+            if (!this.isPausedByVisibility) {
+                this.isPausedByVisibility = true;
+                // Stop all strategies
+                for (const [_, config] of this.strategies) {
+                    if (config.enabled) {
+                        config.strategy.stop();
+                    }
+                }
+                // Stop tick
+                this.stopTick();
+            }
+        }
+        else {
+            // Tab became visible - resume detection
+            if (this.isPausedByVisibility) {
+                this.isPausedByVisibility = false;
+                // Restart all enabled strategies
+                for (const [_, config] of this.strategies) {
+                    if (config.enabled) {
+                        config.strategy.start();
+                    }
+                }
+                // Restart tick
+                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 !== undefined && 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,
+        };
+    }
+}
+exports.BehaviorDetector = BehaviorDetector;

package/dist/cjs/browser.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Browser Build - Auto-initializing standalone bundle for CDN usage
+ *
+ * Usage:
+ * <script src="https://cdn.../behavior-detector.js"></script>
+ * <script>
+ * window.bdSettings = {
+ *   strategies: {
+ *     mouse: { weight: 0.3 },
+ *     scroll: { weight: 0.15 },
+ *     click: { weight: 0.3 },
+ *     keyboard: { weight: 0.1 },
+ *     environment: { weight: 0.08 },
+ *     resize: { weight: 0.02 }
+ *   },
+ *   autoStart: true,
+ *   checkMs: 2000,
+ *   pauseOnHidden: true,  // Auto-pause when tab hidden (default: true)
+ *   onScore: (result) => {
+ *     console.log('Human likelihood:', result.score);
+ *     if (result.score < 0.3) {
+ *       // Likely bot
+ *     }
+ *   },
+ *   ifBot: (result) => {
+ *     // Called when score < threshold
+ *     console.warn('Bot detected:', result);
+ *   },
+ *   botThreshold: 0.3
+ * }
+ * </script>
+ */
+export {};

package/dist/cjs/browser.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * Browser Build - Auto-initializing standalone bundle for CDN usage
+ *
+ * Usage:
+ * <script src="https://cdn.../behavior-detector.js"></script>
+ * <script>
+ * window.bdSettings = {
+ *   strategies: {
+ *     mouse: { weight: 0.3 },
+ *     scroll: { weight: 0.15 },
+ *     click: { weight: 0.3 },
+ *     keyboard: { weight: 0.1 },
+ *     environment: { weight: 0.08 },
+ *     resize: { weight: 0.02 }
+ *   },
+ *   autoStart: true,
+ *   checkMs: 2000,
+ *   pauseOnHidden: true,  // Auto-pause when tab hidden (default: true)
+ *   onScore: (result) => {
+ *     console.log('Human likelihood:', result.score);
+ *     if (result.score < 0.3) {
+ *       // Likely bot
+ *     }
+ *   },
+ *   ifBot: (result) => {
+ *     // Called when score < threshold
+ *     console.warn('Bot detected:', result);
+ *   },
+ *   botThreshold: 0.3
+ * }
+ * </script>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const behavior_detector_1 = require("./behavior-detector");
+const index_js_1 = require("./strategies/index.js");
+/**
+ * Detect if the current device is mobile
+ */
+function 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;
+}
+class BehaviorDetectionAPI {
+    constructor() {
+        this.detector = null;
+        this.checkInterval = null;
+        this.settings = null;
+    }
+    /**
+     * Initialize the detector with settings
+     */
+    init(settings) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+        if (this.detector) {
+            this.stop();
+        }
+        this.settings = settings;
+        this.detector = new behavior_detector_1.BehaviorDetector({
+            pauseOnHidden: settings.pauseOnHidden !== undefined ? settings.pauseOnHidden : true
+        });
+        // Detect if mobile to adjust strategy selection and weights
+        const isMobile = isMobileDevice();
+        const strategies = settings.strategies || {};
+        // Mobile-adjusted default weights
+        const defaultWeights = isMobile ? {
+            mouse: 0, // Disabled on mobile
+            scroll: 0.35, // Increased (more reliable on mobile)
+            click: 0, // Disabled on mobile (use tap instead)
+            tap: 0.35, // Mobile tap detection
+            keyboard: 0.15,
+            environment: 0.10,
+            resize: 0.05, // Orientation changes
+        } : {
+            mouse: 0.30,
+            scroll: 0.15,
+            click: 0.30,
+            tap: 0, // Disabled on desktop
+            keyboard: 0.10,
+            environment: 0.08,
+            resize: 0.02,
+        };
+        // Mouse - Desktop only
+        if (!isMobile && ((_a = strategies.mouse) === null || _a === void 0 ? void 0 : _a.enabled) !== false) {
+            const strategy = new index_js_1.MouseStrategy();
+            const weight = (_c = (_b = strategies.mouse) === null || _b === void 0 ? void 0 : _b.weight) !== null && _c !== void 0 ? _c : defaultWeights.mouse;
+            this.detector.addStrategy(strategy, weight);
+        }
+        // Scroll - Universal
+        if (((_d = strategies.scroll) === null || _d === void 0 ? void 0 : _d.enabled) !== false) {
+            const strategy = new index_js_1.ScrollStrategy();
+            const weight = (_f = (_e = strategies.scroll) === null || _e === void 0 ? void 0 : _e.weight) !== null && _f !== void 0 ? _f : defaultWeights.scroll;
+            this.detector.addStrategy(strategy, weight);
+        }
+        // Click - Desktop only
+        if (!isMobile && ((_g = strategies.click) === null || _g === void 0 ? void 0 : _g.enabled) !== false) {
+            const strategy = new index_js_1.ClickStrategy();
+            const weight = (_j = (_h = strategies.click) === null || _h === void 0 ? void 0 : _h.weight) !== null && _j !== void 0 ? _j : defaultWeights.click;
+            this.detector.addStrategy(strategy, weight);
+        }
+        // Tap - Mobile only
+        if (isMobile && ((_k = strategies.tap) === null || _k === void 0 ? void 0 : _k.enabled) !== false) {
+            const strategy = new index_js_1.TapStrategy();
+            const weight = (_m = (_l = strategies.tap) === null || _l === void 0 ? void 0 : _l.weight) !== null && _m !== void 0 ? _m : defaultWeights.tap;
+            this.detector.addStrategy(strategy, weight);
+        }
+        // Keyboard - Universal
+        if (((_o = strategies.keyboard) === null || _o === void 0 ? void 0 : _o.enabled) !== false) {
+            const strategy = new index_js_1.KeyboardStrategy();
+            const weight = (_q = (_p = strategies.keyboard) === null || _p === void 0 ? void 0 : _p.weight) !== null && _q !== void 0 ? _q : defaultWeights.keyboard;
+            this.detector.addStrategy(strategy, weight);
+        }
+        // Environment - Universal
+        if (((_r = strategies.environment) === null || _r === void 0 ? void 0 : _r.enabled) !== false) {
+            const strategy = new index_js_1.EnvironmentStrategy();
+            const weight = (_t = (_s = strategies.environment) === null || _s === void 0 ? void 0 : _s.weight) !== null && _t !== void 0 ? _t : defaultWeights.environment;
+            this.detector.addStrategy(strategy, weight);
+        }
+        // Resize - Universal
+        if (((_u = strategies.resize) === null || _u === void 0 ? void 0 : _u.enabled) !== false) {
+            const strategy = new index_js_1.ResizeStrategy();
+            const weight = (_w = (_v = strategies.resize) === null || _v === void 0 ? void 0 : _v.weight) !== null && _w !== void 0 ? _w : defaultWeights.resize;
+            this.detector.addStrategy(strategy, weight);
+        }
+        // Start if autoStart is enabled
+        if (settings.autoStart !== false) {
+            this.start();
+        }
+        // Set up periodic checking if checkMs is specified
+        if (settings.checkMs && settings.checkMs > 0) {
+            this.startPeriodicCheck(settings.checkMs);
+        }
+        // Call onReady callback
+        if (settings.onReady) {
+            settings.onReady(this);
+        }
+    }
+    /**
+     * Start detection
+     */
+    start() {
+        if (!this.detector) {
+            console.warn('BehaviorDetector: Call init() before start()');
+            return;
+        }
+        this.detector.start();
+    }
+    /**
+     * Stop detection
+     */
+    stop() {
+        if (this.detector) {
+            this.detector.stop();
+        }
+        if (this.checkInterval !== null) {
+            clearInterval(this.checkInterval);
+            this.checkInterval = null;
+        }
+    }
+    /**
+     * Get current score
+     */
+    async score() {
+        if (!this.detector) {
+            console.warn('BehaviorDetector: Call init() before score()');
+            return null;
+        }
+        return this.detector.score({ breakdown: true });
+    }
+    /**
+     * Start periodic checking
+     */
+    startPeriodicCheck(intervalMs) {
+        if (this.checkInterval !== null) {
+            clearInterval(this.checkInterval);
+        }
+        this.checkInterval = window.setInterval(async () => {
+            var _a, _b;
+            const result = await this.score();
+            if (!result || !this.settings)
+                return;
+            // Call onScore callback
+            if (this.settings.onScore) {
+                this.settings.onScore(result);
+            }
+            // Check thresholds
+            const botThreshold = (_a = this.settings.botThreshold) !== null && _a !== void 0 ? _a : 0.3;
+            const humanThreshold = (_b = this.settings.humanThreshold) !== null && _b !== void 0 ? _b : 0.7;
+            if (result.score < botThreshold && this.settings.ifBot) {
+                this.settings.ifBot(result);
+            }
+            else if (result.score >= humanThreshold && this.settings.ifHuman) {
+                this.settings.ifHuman(result);
+            }
+        }, intervalMs);
+    }
+    /**
+     * Get the underlying detector instance for advanced usage
+     */
+    getDetector() {
+        return this.detector;
+    }
+}
+// Create global API instance
+const api = new BehaviorDetectionAPI();
+// Auto-initialize if settings are already present
+if (typeof window !== 'undefined') {
+    // Expose API globally
+    window.BehaviorDetector = api;
+    // Check for settings on load
+    const checkAndInit = () => {
+        const settings = window.bdSettings;
+        if (settings) {
+            api.init(settings);
+        }
+    };
+    // Try immediate init
+    checkAndInit();
+    // Also try after DOM ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', checkAndInit);
+    }
+}
+// No exports needed for browser IIFE build - window.BehaviorDetector is sufficient

package/dist/cjs/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @axeptio/behavior-detection
+ *
+ * Lightweight behavior detection library to assess human likelihood of user sessions
+ *
+ * @example Settings-based (all strategies included)
+ * ```ts
+ * import { BehaviorDetector } from '@axeptio/behavior-detection';
+ *
+ * const detector = new BehaviorDetector({
+ *   weights: {
+ *     mouseMovement: 0.3,
+ *     clickAccuracy: 0.3,
+ *   },
+ * });
+ *
+ * detector.start();
+ * const result = await detector.score({ breakdown: true });
+ * ```
+ *
+ * @example Strategy-based (tree-shakeable, import only what you need)
+ * ```ts
+ * import { BehaviorDetector, Mouse, Click, Keyboard } from '@axeptio/behavior-detection';
+ *
+ * const detector = new BehaviorDetector()
+ *   .addStrategy(new Mouse())
+ *   .addStrategy(new Click())
+ *   .addStrategy(new Keyboard());
+ *
+ * detector.start();
+ * const result = await detector.score();
+ * ```
+ */
+export { BehaviorDetector } from './behavior-detector';
+export type { DetectionStrategy, StrategyConfig } from './strategy';
+export { Mouse, Scroll, Click, Tap, Keyboard, Environment, Resize, MouseStrategy, ScrollStrategy, ClickStrategy, TapStrategy, KeyboardStrategy, EnvironmentStrategy, ResizeStrategy, } from './strategies/index.js';
+export type { BehaviorSettings, ScoreOptions, ScoreResult, ScoreBreakdown, TrackedEvent, EventType, ScoringFunction, } from './types';
+export { DEFAULT_SETTINGS } from './types';

package/dist/cjs/index.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * @axeptio/behavior-detection
+ *
+ * Lightweight behavior detection library to assess human likelihood of user sessions
+ *
+ * @example Settings-based (all strategies included)
+ * ```ts
+ * import { BehaviorDetector } from '@axeptio/behavior-detection';
+ *
+ * const detector = new BehaviorDetector({
+ *   weights: {
+ *     mouseMovement: 0.3,
+ *     clickAccuracy: 0.3,
+ *   },
+ * });
+ *
+ * detector.start();
+ * const result = await detector.score({ breakdown: true });
+ * ```
+ *
+ * @example Strategy-based (tree-shakeable, import only what you need)
+ * ```ts
+ * import { BehaviorDetector, Mouse, Click, Keyboard } from '@axeptio/behavior-detection';
+ *
+ * const detector = new BehaviorDetector()
+ *   .addStrategy(new Mouse())
+ *   .addStrategy(new Click())
+ *   .addStrategy(new Keyboard());
+ *
+ * detector.start();
+ * const result = await detector.score();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SETTINGS = exports.ResizeStrategy = exports.EnvironmentStrategy = exports.KeyboardStrategy = exports.TapStrategy = exports.ClickStrategy = exports.ScrollStrategy = exports.MouseStrategy = exports.Resize = exports.Environment = exports.Keyboard = exports.Tap = exports.Click = exports.Scroll = exports.Mouse = exports.BehaviorDetector = void 0;
+var behavior_detector_1 = require("./behavior-detector");
+Object.defineProperty(exports, "BehaviorDetector", { enumerable: true, get: function () { return behavior_detector_1.BehaviorDetector; } });
+var index_js_1 = require("./strategies/index.js");
+Object.defineProperty(exports, "Mouse", { enumerable: true, get: function () { return index_js_1.Mouse; } });
+Object.defineProperty(exports, "Scroll", { enumerable: true, get: function () { return index_js_1.Scroll; } });
+Object.defineProperty(exports, "Click", { enumerable: true, get: function () { return index_js_1.Click; } });
+Object.defineProperty(exports, "Tap", { enumerable: true, get: function () { return index_js_1.Tap; } });
+Object.defineProperty(exports, "Keyboard", { enumerable: true, get: function () { return index_js_1.Keyboard; } });
+Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return index_js_1.Environment; } });
+Object.defineProperty(exports, "Resize", { enumerable: true, get: function () { return index_js_1.Resize; } });
+Object.defineProperty(exports, "MouseStrategy", { enumerable: true, get: function () { return index_js_1.MouseStrategy; } });
+Object.defineProperty(exports, "ScrollStrategy", { enumerable: true, get: function () { return index_js_1.ScrollStrategy; } });
+Object.defineProperty(exports, "ClickStrategy", { enumerable: true, get: function () { return index_js_1.ClickStrategy; } });
+Object.defineProperty(exports, "TapStrategy", { enumerable: true, get: function () { return index_js_1.TapStrategy; } });
+Object.defineProperty(exports, "KeyboardStrategy", { enumerable: true, get: function () { return index_js_1.KeyboardStrategy; } });
+Object.defineProperty(exports, "EnvironmentStrategy", { enumerable: true, get: function () { return index_js_1.EnvironmentStrategy; } });
+Object.defineProperty(exports, "ResizeStrategy", { enumerable: true, get: function () { return index_js_1.ResizeStrategy; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "DEFAULT_SETTINGS", { enumerable: true, get: function () { return types_1.DEFAULT_SETTINGS; } });