content-security-toolkit 1.0.1 → 1.0.2

package/dist/utils/debuggerDetector/debuggerDetector.js

@@ -0,0 +1,158 @@
+import { FirefoxDevToolsDetector } from "./firefoxDetector";
+export class DebuggerDetector {
+    /**
+     * Create a new DebuggerDetector
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        this.worker = null;
+        this.firefoxDetector = null;
+        this.isChecking = false;
+        this.timeoutId = null;
+        this.isDevToolsOpen = false;
+        this.timeoutDuration = options.timeoutDuration || 500;
+        this.onDevToolsChange = options.onDevToolsChange || (() => { });
+        this.firefoxDetector = new FirefoxDevToolsDetector();
+        this.debugMode = !!options.debugMode;
+        this.initWorker();
+        if (this.debugMode) {
+            console.log("DebuggerDetector: Initialized with timeout:", this.timeoutDuration);
+        }
+    }
+    // Update the worker initialization to handle MIME type issues
+    initWorker() {
+        try {
+            // Create a blob URL for the worker script instead of using a file URL
+            // This avoids MIME type issues with server responses
+            const workerScript = `
+      // Worker script for DevTools detection
+      self.onmessage = function(e) {
+        if (e.data === "checkDevTools") {
+          // Send immediate response (opening heartbeat)
+          console.log("DebuggerDetectionWorker: Received checkDevTools message");
+          self.postMessage("heartbeatStart");
+          
+          // This will pause execution if DevTools is open
+          debugger;
+
+          // If we reach here without significant delay, DevTools is closed
+          self.postMessage("heartbeatEnd");
+        }
+      };
+    `;
+            // Create a blob URL from the script
+            const blob = new Blob([workerScript], { type: "application/javascript" });
+            const workerUrl = URL.createObjectURL(blob);
+            // Create the worker using the blob URL
+            this.worker = new Worker(workerUrl);
+            this.worker.onmessage = (e) => {
+                if (e.data === "heartbeatStart") {
+                    // First heartbeat received, now waiting for second
+                    if (this.debugMode) {
+                        console.log("DebuggerDetector: Received opening heartbeat");
+                    }
+                }
+                else if (e.data === "heartbeatEnd") {
+                    // Second heartbeat received, DevTools is closed
+                    if (this.timeoutId !== null) {
+                        clearTimeout(this.timeoutId);
+                        this.timeoutId = null;
+                    }
+                    this.isChecking = false;
+                    // Only trigger callback if state changed
+                    if (this.isDevToolsOpen) {
+                        this.isDevToolsOpen = false;
+                        this.onDevToolsChange(false);
+                        if (this.debugMode) {
+                            console.log("DebuggerDetector: DevTools closed");
+                        }
+                    }
+                }
+            };
+            this.worker.onerror = (error) => {
+                console.error("DebuggerDetector: Worker error:", error);
+                this.isChecking = false;
+                // Try to recreate the worker
+                this.terminateWorker();
+                this.initWorker();
+            };
+        }
+        catch (error) {
+            console.error("DebuggerDetector: Failed to create worker:", error);
+        }
+    }
+    /**
+     * Check if DevTools is open
+     * @returns Promise that resolves to true if DevTools is open
+     */
+    checkDevTools() {
+        if (this.isChecking || !this.worker)
+            return;
+        this.isChecking = true;
+        try {
+            // Send message to worker
+            this.worker.postMessage("checkDevTools");
+            // Set timeout for missing second heartbeat
+            this.timeoutId = window.setTimeout(() => {
+                // If we reach here, the worker is paused at debugger
+                // which means DevTools is open
+                this.isChecking = false;
+                // Only trigger callback if state changed
+                if (!this.isDevToolsOpen) {
+                    this.isDevToolsOpen = true;
+                    this.onDevToolsChange(true);
+                    if (this.debugMode) {
+                        console.log("DebuggerDetector: DevTools opened");
+                    }
+                }
+            }, this.timeoutDuration);
+            // FIREFOX DETECTION
+            /* if (this.firefoxDetector) {
+              console.log('Running Firefox detection', this.firefoxDetector.detect());
+              const isFirefoxDevToolsOpen = this.firefoxDetector.detect()
+              if (isFirefoxDevToolsOpen) {
+                this.isDevToolsOpen = true
+                this.onDevToolsChange(true)
+              }
+            } */
+        }
+        catch (error) {
+            console.error("DebuggerDetector: Error checking DevTools:", error);
+            this.isChecking = false;
+        }
+    }
+    /**
+     * Get the current DevTools state
+     * @returns True if DevTools is open
+     */
+    isOpen() {
+        return this.isDevToolsOpen;
+    }
+    // Update the terminateWorker method to revoke the blob URL
+    terminateWorker() {
+        if (this.worker) {
+            this.worker.terminate();
+            this.worker = null;
+        }
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        if (this.timeoutId !== null) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+        this.terminateWorker();
+        if (this.debugMode) {
+            console.log("DebuggerDetector: Disposed");
+        }
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+    }
+}

package/dist/utils/debuggerDetector/firefoxDetector.d.ts

@@ -0,0 +1,8 @@
+export declare class FirefoxDevToolsDetector {
+    private debugMode;
+    constructor(debugMode?: boolean);
+    detect(): boolean;
+    private checkDevToolsElements;
+    private checkDevToolsProperties;
+    private checkTimingAnomaly;
+}

package/dist/utils/debuggerDetector/firefoxDetector.js

@@ -0,0 +1,64 @@
+export class FirefoxDevToolsDetector {
+    constructor(debugMode = false) {
+        this.debugMode = debugMode;
+    }
+    detect() {
+        // Method 1: Check for Firefox-specific DevTools elements
+        const hasDevToolsElements = this.checkDevToolsElements();
+        console.log('devtools elements', hasDevToolsElements);
+        // Method 2: Check for Firefox-specific DevTools properties
+        const hasDevToolsProperties = this.checkDevToolsProperties();
+        console.log('devtools properties', hasDevToolsProperties);
+        // Method 3: Performance timing check
+        const hasTimingAnomaly = this.checkTimingAnomaly();
+        console.log('timing anomaly', hasTimingAnomaly);
+        return hasDevToolsElements || hasDevToolsProperties || hasTimingAnomaly;
+    }
+    checkDevToolsElements() {
+        // Firefox adds specific elements when DevTools is open
+        console.log('checking devtools elements');
+        return !!(document.documentElement.getAttribute('debug') ||
+            document.documentElement.getAttribute('webdriver') ||
+            document.documentElement.getAttribute('firefox-devtools'));
+    }
+    checkDevToolsProperties() {
+        console.log('checking devtools properties');
+        // Firefox exposes specific properties when DevTools is open
+        return !!(window.mozInnerScreenX !== undefined ||
+            // Check for Firefox debugger
+            Object.prototype.hasOwnProperty.call(window, '__firefox__') ||
+            Object.prototype.hasOwnProperty.call(window, 'netscape'));
+    }
+    checkTimingAnomaly() {
+        console.log('Checking timing anomaly');
+        const start = performance.now();
+        // Create and manipulate a large array with operations that are 
+        // significantly affected by Firefox DevTools' debugger
+        const array = new Array(100000);
+        // Fill with incrementing numbers and perform operations
+        // This specific pattern is more reliably affected by Firefox's debugger
+        for (let i = 0; i < array.length; i++) {
+            array[i] = i;
+            // Add some basic operations that debugger will need to track
+            const temp = array[i] * 2;
+            array[i] = temp + 1;
+        }
+        // Add a reduce operation which is particularly sensitive to debugger overhead
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const sum = array.reduce((acc, curr) => acc + curr, 0);
+        const end = performance.now();
+        const timeTaken = end - start;
+        console.log(timeTaken);
+        if (this.debugMode) {
+            console.log('Firefox timing check:', {
+                timeTaken,
+                operationsPerformed: array.length * 3, // 3 operations per item
+                averageTimePerOperation: timeTaken / (array.length * 3)
+            });
+        }
+        // Threshold is based on empirical testing
+        // Normal execution: ~5-20ms
+        // With DevTools open: >100ms
+        return timeTaken > 100;
+    }
+}

package/dist/utils/detection.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Detect browser environment
+ */
+export declare const isBrowser: () => boolean;
+/**
+ * Detect mobile device
+ */
+export declare const isMobile: () => boolean;
+/**
+ * Detect specific browser
+ */
+export declare const getBrowser: () => {
+    name: string;
+    version: string;
+};
+/**
+ * Detect operating system
+ */
+export declare const getOS: () => {
+    name: "mac" | "linux" | "windows" | "unknown";
+};
+/**
+ * Check if print is supported
+ */
+export declare const isPrintSupported: () => boolean;
+/**
+ * Check if beforeprint event is supported
+ */
+export declare const isBeforePrintSupported: () => boolean;

package/dist/utils/detection.js

@@ -0,0 +1,267 @@
+// FEATURE/ENVIRONMENT DETECTION
+/**
+ * Detect browser environment
+ */
+export const isBrowser = () => {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+};
+/**
+ * Detect mobile device
+ */
+export const isMobile = () => {
+    if (!isBrowser())
+        return false;
+    const userAgent = navigator.userAgent;
+    // Standard mobile OS and browser detection
+    if (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(userAgent)) {
+        return true;
+    }
+    // Chinese mobile devices
+    if (/Huawei|HUAWEI|Honor|HONOR|Xiaomi|MI\/|Redmi|POCO|OPPO|vivo|OnePlus|Realme/i.test(userAgent)) {
+        return true;
+    }
+    // Korean mobile devices
+    if (/Samsung|SAMSUNG|LG|Tizen/i.test(userAgent)) {
+        return true;
+    }
+    // Japanese mobile devices
+    if (/Sony|SONY|Xperia|Sharp|SHARP|Fujitsu|FOMA|KDDI/i.test(userAgent)) {
+        return true;
+    }
+    // Russian mobile devices
+    if (/Yandex.Phone|YandexPhone|BQ-|BQru/i.test(userAgent)) {
+        return true;
+    }
+    // Other mobile platforms
+    if (/Windows Phone|WindowsPhone|Lumia|Mobile|Tablet|Phone|WPDesktop|ZuneWP|WP7|wds|Fennec|Firefox OS|KaiOS|KAIOS|Sailfish/i.test(userAgent)) {
+        return true;
+    }
+    // Mobile browser detection
+    if (/Mobile|Tablet|Android|Touch/i.test(userAgent) && !/Windows NT|Mac OS X/i.test(userAgent)) {
+        return true;
+    }
+    // Feature detection for touch devices (most mobile devices have touch capability)
+    if (isBrowser() && ("ontouchstart" in window || navigator.maxTouchPoints > 0)) {
+        // Additional check to avoid false positives on desktops with touch screens
+        if (window.innerWidth <= 1024 || /Mobi|Android/i.test(userAgent)) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * Detect specific browser
+ */
+export const getBrowser = () => {
+    if (!isBrowser())
+        return { name: "unknown", version: "0" };
+    const ua = navigator.userAgent;
+    let browserName = "unknown";
+    let version = "0";
+    // Order matters here - we need to check more specific browsers first
+    // before falling back to more generic ones
+    // --- Chinese Browsers ---
+    if (/MicroMessenger|WeChat/.test(ua)) {
+        browserName = "wechat";
+        const match = ua.match(/MicroMessenger\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // QQ Browser
+    else if (/QQBrowser/.test(ua)) {
+        browserName = "qq";
+        const match = ua.match(/QQBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // UC Browser
+    else if (/UCBrowser/.test(ua)) {
+        browserName = "uc";
+        const match = ua.match(/UCBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Baidu Browser
+    else if (/Baidu|BIDUBrowser|baiduboxapp/.test(ua)) {
+        browserName = "baidu";
+        const match = ua.match(/(?:Baidu|BIDUBOX)(?:Browser)?\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Mi Browser
+    else if (/MiuiBrowser/.test(ua)) {
+        browserName = "mi";
+        const match = ua.match(/MiuiBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Russian Browsers ---
+    // Yandex Browser
+    else if (/YaBrowser/.test(ua)) {
+        browserName = "yandex";
+        const match = ua.match(/YaBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Korean Browsers ---
+    // Naver Whale
+    else if (/Whale/.test(ua)) {
+        browserName = "whale";
+        const match = ua.match(/Whale\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Mobile Browsers ---
+    // Samsung Internet
+    else if (/SamsungBrowser/.test(ua)) {
+        browserName = "samsung";
+        const match = ua.match(/SamsungBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Huawei Browser
+    else if (/HuaweiBrowser/.test(ua)) {
+        browserName = "huawei";
+        const match = ua.match(/HuaweiBrowser\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Alternative Browsers ---
+    // Vivaldi
+    else if (/Vivaldi/.test(ua)) {
+        browserName = "vivaldi";
+        const match = ua.match(/Vivaldi\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Lunascape
+    else if (/Lunascape/.test(ua)) {
+        browserName = "lunascape";
+        const match = ua.match(/Lunascape[/| ](\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Opera
+    else if (/OPR|Opera/.test(ua)) {
+        browserName = "opera";
+        const match = ua.match(/(?:OPR|Opera)[/| ](\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Emulators ---
+    // Nox Browser/Emulator
+    else if (/Nox/.test(ua)) {
+        browserName = "nox";
+        const match = ua.match(/Nox\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // BlueStacks
+    else if (/BlueStacks/.test(ua)) {
+        browserName = "bluestacks";
+        const match = ua.match(/BlueStacks\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // --- Major Browsers (keep these last as fallbacks) ---
+    // Edge
+    else if (/Edg/.test(ua)) {
+        browserName = "edge";
+        const match = ua.match(/Edg\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Chrome
+    else if (/Chrome/.test(ua) && !/Chromium|Edge|Edg|OPR|Opera/.test(ua)) {
+        browserName = "chrome";
+        const match = ua.match(/Chrome\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Firefox
+    else if (/Firefox/.test(ua)) {
+        browserName = "firefox";
+        const match = ua.match(/Firefox\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Safari
+    else if (/Safari/.test(ua) && !/Chrome/.test(ua)) {
+        browserName = "safari";
+        const match = ua.match(/Version\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // IE
+    else if (/Trident|MSIE/.test(ua)) {
+        browserName = "ie";
+        const match = ua.match(/(?:rv:|MSIE )(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    // Chromium-based browsers not caught above
+    else if (/Chromium/.test(ua)) {
+        browserName = "chromium";
+        const match = ua.match(/Chromium\/(\d+\.\d+)/);
+        version = match ? match[1] : "0";
+    }
+    return { name: browserName, version };
+};
+/**
+ * Detect operating system
+ */
+export const getOS = () => {
+    if (!isBrowser())
+        return { name: "unknown" };
+    const platform = navigator.platform.toLowerCase();
+    const userAgent = navigator.userAgent.toLowerCase();
+    // macOS and iOS devices
+    if (platform.includes("mac") ||
+        platform.includes("ipad") ||
+        platform.includes("ipod") ||
+        platform.includes("iphone") ||
+        userAgent.includes("mac") ||
+        userAgent.includes("iphone") ||
+        userAgent.includes("ipad") ||
+        (userAgent.includes("safari") && !userAgent.includes("chrome") && !userAgent.includes("android"))) {
+        return { name: "mac" };
+    }
+    // Windows detection
+    else if (platform.includes("win") || userAgent.includes("win") || userAgent.includes("windows nt")) {
+        return { name: "windows" };
+    }
+    // Linux and Linux-based OS detection
+    else if (
+    // Standard Linux
+    platform.includes("linux") ||
+        userAgent.includes("linux") ||
+        // Android (Linux-based)
+        userAgent.includes("android") ||
+        // Chinese OS (most are Linux-based)
+        userAgent.includes("harmonyos") ||
+        userAgent.includes("deepin") ||
+        userAgent.includes("uos") ||
+        userAgent.includes("cos") ||
+        // Russian Linux distributions
+        userAgent.includes("astra linux") ||
+        userAgent.includes("alt linux") ||
+        userAgent.includes("rosa") ||
+        // Korean OS
+        userAgent.includes("tizen") ||
+        userAgent.includes("gooroom") ||
+        // Other Linux-based OS
+        userAgent.includes("ubuntu") ||
+        userAgent.includes("debian") ||
+        userAgent.includes("fedora") ||
+        userAgent.includes("red hat") ||
+        userAgent.includes("suse") ||
+        userAgent.includes("mint") ||
+        // Chrome OS (Linux-based)
+        userAgent.includes("cros") ||
+        userAgent.includes("chromium os") ||
+        userAgent.includes("chrome os") ||
+        // BSD variants (Unix-like, grouped with Linux for simplicity)
+        userAgent.includes("freebsd") ||
+        userAgent.includes("openbsd") ||
+        userAgent.includes("netbsd")) {
+        return { name: "linux" };
+    }
+    // Fallback for undetected OS
+    return { name: "unknown" };
+};
+/**
+ * Check if print is supported
+ */
+export const isPrintSupported = () => {
+    return isBrowser() && typeof window.print === 'function';
+};
+/**
+ * Check if beforeprint event is supported
+ */
+export const isBeforePrintSupported = () => {
+    if (!isBrowser())
+        return false;
+    const mediaQueryList = window.matchMedia('print');
+    return !!mediaQueryList.addListener || 'onbeforeprint' in window;
+};

package/dist/utils/detectors/debuggerDetectionWorker.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Worker script for DevTools detection
+ * This worker helps detect DevTools by using the debugger statement
+ * in a separate thread, which won't block the main UI thread
+ */
+export type DebuggerDetectionWorker = typeof self;

package/dist/utils/detectors/debuggerDetectionWorker.js

@@ -0,0 +1,24 @@
+/**
+ * Worker script for DevTools detection
+ * This worker helps detect DevTools by using the debugger statement
+ * in a separate thread, which won't block the main UI thread
+ */
+// Set up message handler
+self.onmessage = (e) => {
+    if (e.data === "checkDevTools") {
+        // Send immediate response (opening heartbeat)
+        console.log("DebuggerDetectionWorker: Received checkDevTools message");
+        self.postMessage("heartbeatStart");
+        // This will pause execution if DevTools is open
+        // We use a function to make it harder to bypass
+        function triggerDebugger() {
+            // eslint-disable-next-line no-debugger
+            debugger;
+        }
+        // Call the function to trigger the debugger
+        triggerDebugger();
+        // If we reach here without significant delay, DevTools is closed
+        self.postMessage("heartbeatEnd");
+    }
+};
+export {};

package/dist/utils/detectors/firefoxDetector.d.ts

@@ -0,0 +1,8 @@
+export declare class FirefoxDevToolsDetector {
+    private debugMode;
+    constructor(debugMode?: boolean);
+    detect(): boolean;
+    private checkDevToolsElements;
+    private checkDevToolsProperties;
+    private checkTimingAnomaly;
+}

package/dist/utils/detectors/firefoxDetector.js

@@ -0,0 +1,64 @@
+export class FirefoxDevToolsDetector {
+    constructor(debugMode = false) {
+        this.debugMode = debugMode;
+    }
+    detect() {
+        // Method 1: Check for Firefox-specific DevTools elements
+        const hasDevToolsElements = this.checkDevToolsElements();
+        console.log('devtools elements', hasDevToolsElements);
+        // Method 2: Check for Firefox-specific DevTools properties
+        const hasDevToolsProperties = this.checkDevToolsProperties();
+        console.log('devtools properties', hasDevToolsProperties);
+        // Method 3: Performance timing check
+        const hasTimingAnomaly = this.checkTimingAnomaly();
+        console.log('timing anomaly', hasTimingAnomaly);
+        return hasDevToolsElements || hasDevToolsProperties || hasTimingAnomaly;
+    }
+    checkDevToolsElements() {
+        // Firefox adds specific elements when DevTools is open
+        console.log('checking devtools elements');
+        return !!(document.documentElement.getAttribute('debug') ||
+            document.documentElement.getAttribute('webdriver') ||
+            document.documentElement.getAttribute('firefox-devtools'));
+    }
+    checkDevToolsProperties() {
+        console.log('checking devtools properties');
+        // Firefox exposes specific properties when DevTools is open
+        return !!(window.mozInnerScreenX !== undefined ||
+            // Check for Firefox debugger
+            Object.prototype.hasOwnProperty.call(window, '__firefox__') ||
+            Object.prototype.hasOwnProperty.call(window, 'netscape'));
+    }
+    checkTimingAnomaly() {
+        console.log('Checking timing anomaly');
+        const start = performance.now();
+        // Create and manipulate a large array with operations that are 
+        // significantly affected by Firefox DevTools' debugger
+        const array = new Array(100000);
+        // Fill with incrementing numbers and perform operations
+        // This specific pattern is more reliably affected by Firefox's debugger
+        for (let i = 0; i < array.length; i++) {
+            array[i] = i;
+            // Add some basic operations that debugger will need to track
+            const temp = array[i] * 2;
+            array[i] = temp + 1;
+        }
+        // Add a reduce operation which is particularly sensitive to debugger overhead
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const sum = array.reduce((acc, curr) => acc + curr, 0);
+        const end = performance.now();
+        const timeTaken = end - start;
+        console.log(timeTaken);
+        if (this.debugMode) {
+            console.log('Firefox timing check:', {
+                timeTaken,
+                operationsPerformed: array.length * 3, // 3 operations per item
+                averageTimePerOperation: timeTaken / (array.length * 3)
+            });
+        }
+        // Threshold is based on empirical testing
+        // Normal execution: ~5-20ms
+        // With DevTools open: >100ms
+        return timeTaken > 100;
+    }
+}

package/dist/utils/logging/LogLevel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Enum defining log severity levels
+ */
+export declare enum LogLevel {
+    ERROR = 0,// Always shown, represents errors that need immediate attention
+    WARN = 1,// Important issues that don't break functionality but need attention
+    INFO = 2,// General information about application flow
+    DEBUG = 3,// Detailed information useful for debugging
+    TRACE = 4,// Very detailed information, including loop iterations, function entries/exits
+    VERBOSE = 5
+}
+/**
+ * Map of log level names to their enum values
+ */
+export declare const LOG_LEVEL_MAP: Record<string, LogLevel>;
+/**
+ * Get the name of a log level
+ * @param level The log level
+ * @returns The name of the log level
+ */
+export declare function getLogLevelName(level: LogLevel): string;