content-security-toolkit 1.0.0

package/dist/utils/detectors/devToolsDetectorManager.js

@@ -0,0 +1,246 @@
+import { DebuggerDetector } from "./debuggerDetector";
+import { TimingDetector } from "./timingDetector";
+import { DateToStringDetector } from "./dateToStringDetector";
+import { FuncToStringDetector } from "./funcToStringDetector";
+import { RegToStringDetector } from "./regToStringDetector";
+import { DefineGetterDetector } from "./defineGetterDetector";
+import { DebugLibDetector } from "./debugLibDetector";
+import { SizeDetector } from "./sizeDetector";
+import { getBrowser, isMobile } from "../environment";
+import { SimpleLoggingService } from "../logging/simple/SimpleLoggingService";
+import { AbstractDevToolsDetector } from "./AbstractDevToolsDetector";
+/**
+ * Manager class that coordinates multiple DevTools detection methods
+ * **Chrome, Edge, Opera**: Primarily uses `DebuggerDetector` with `DefineGetterDetector` as backup
+ * **Firefox**: Uses `TimingDetector` and `RegToStringDetector` for reliable detection
+ * **Safari**: Primarily uses `DateToStringDetector` with `DefineGetterDetector` as backup
+ * **QQ Browser**: Uses `RegToStringDetector` which works particularly well for this browser
+ * **Mobile Browsers**: Always includes `DebugLibDetector` to catch third-party debugging tools
+ */
+export class DevToolsDetectorManager extends AbstractDevToolsDetector {
+    /**
+     * Create a new DevToolsDetectorManager
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        super('DevToolsDetectorManager');
+        this.detectors = new Map();
+        this.activeDetectors = [];
+        this.isInitialCheckDone = false;
+        this.initialCheckTimeout = null;
+        const debugMode = !!options.debugMode;
+        this.logger = new SimpleLoggingService("DevToolsDetectorManager", debugMode);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        this.onDevToolsChange = options.onDevToolsChange || ((isOpen) => { });
+        this.browserInfo = getBrowser();
+        this.isMobileDevice = isMobile();
+        this.delayInitialCheck = options.delayInitialCheck !== false; // Default to true
+        this.initialCheckDelay = options.initialCheckDelay || 1000;
+        // Initialize all available detectors
+        this.initializeAllDetectors(options);
+        // Select appropriate detectors based on browser
+        this.selectActiveDetectors(options.enabledDetectors);
+        this.logger.log("Initialized for browser:", this.browserInfo.name);
+        this.logger.log("Mobile device:", this.isMobileDevice);
+        this.logger.log("Active detectors:", Array.from(this.activeDetectors).map((d) => d.constructor.name));
+        // Schedule initial check with delay to avoid false positives during page load
+        if (this.delayInitialCheck) {
+            this.logger.log(`Delaying initial check by ${this.initialCheckDelay}ms`);
+            this.initialCheckTimeout = window.setTimeout(() => {
+                this.isInitialCheckDone = true;
+                this.checkDevTools();
+                this.initialCheckTimeout = null;
+                this.logger.log("Initial check completed");
+            }, this.initialCheckDelay);
+        }
+        else {
+            this.isInitialCheckDone = true;
+        }
+    }
+    /**
+     * Initialize all available detectors
+     */
+    initializeAllDetectors(options) {
+        const commonOptions = {
+            onDevToolsChange: this.handleDetectorChange.bind(this),
+            debugMode: this.logger.isDebugEnabled(),
+        };
+        // Initialize all detectors but don't activate them yet
+        this.detectors.set("debugger", new DebuggerDetector({
+            ...commonOptions,
+            timeoutDuration: options.debuggerTimeoutDuration || 50,
+        }));
+        this.detectors.set("timing", new TimingDetector({
+            ...commonOptions,
+            thresholdMultiplier: 3, // Slightly higher for better reliability
+        }));
+        if (DateToStringDetector.isSupported()) {
+            this.detectors.set("dateToString", new DateToStringDetector({
+                ...commonOptions,
+                threshold: 2,
+            }));
+        }
+        if (FuncToStringDetector.isSupported()) {
+            this.detectors.set("funcToString", new FuncToStringDetector({
+                ...commonOptions,
+                threshold: 2,
+            }));
+        }
+        if (RegToStringDetector.isSupported()) {
+            this.detectors.set("regToString", new RegToStringDetector({
+                ...commonOptions,
+                timeThreshold: 100,
+            }));
+        }
+        this.detectors.set("defineGetter", new DefineGetterDetector({
+            ...commonOptions,
+            checkInterval: options.checkInterval || 1000,
+        }));
+        this.detectors.set("debugLib", new DebugLibDetector({
+            ...commonOptions,
+            checkInterval: options.checkInterval || 1000,
+        }));
+        if (SizeDetector.isSupported()) {
+            this.detectors.set("size", new SizeDetector({
+                ...commonOptions,
+                widthThreshold: 200,
+                heightThreshold: 300,
+            }));
+        }
+    }
+    /**
+     * Select which detectors to activate based on browser
+     */
+    selectActiveDetectors(userEnabledDetectors) {
+        // If user specified detectors, use those
+        if (userEnabledDetectors && userEnabledDetectors.length > 0) {
+            this.activeDetectors = userEnabledDetectors
+                .filter((type) => this.detectors.has(type))
+                .map((type) => this.detectors.get(type))
+                .filter(Boolean);
+            this.logger.log("Using user-specified detectors");
+            return;
+        }
+        // Get browser-specific detectors
+        let detectorTypes = DevToolsDetectorManager.BROWSER_DETECTOR_MAP[this.browserInfo.name] ||
+            DevToolsDetectorManager.BROWSER_DETECTOR_MAP.unknown;
+        // Apply mobile overrides if on mobile
+        if (this.isMobileDevice) {
+            const mobileDetectorTypes = DevToolsDetectorManager.MOBILE_DETECTOR_MAP[this.browserInfo.name] ||
+                DevToolsDetectorManager.MOBILE_DETECTOR_MAP.default;
+            // Combine with browser-specific detectors, prioritizing mobile ones
+            detectorTypes = [...mobileDetectorTypes, ...detectorTypes.filter((type) => !mobileDetectorTypes.includes(type))];
+        }
+        // Activate the selected detectors
+        this.activeDetectors = detectorTypes
+            .filter((type) => this.detectors.has(type))
+            .map((type) => this.detectors.get(type))
+            .filter(Boolean);
+        // Always start the continuous detectors
+        const continuousDetector = this.detectors.get("debugLib");
+        if (continuousDetector) {
+            continuousDetector.startDetection();
+        }
+        this.logger.log("Selected detectors for", this.browserInfo.name, ":", detectorTypes);
+    }
+    /**
+     * Handle state change from any detector
+     */
+    handleDetectorChange(isOpen) {
+        // Skip state changes until initial check is done
+        if (!this.isInitialCheckDone) {
+            this.logger.log("Ignoring state change before initial check");
+            return;
+        }
+        this.updateDevToolsState(isOpen);
+    }
+    /**
+     * Check if DevTools is open using all active detectors
+     */
+    checkDevTools() {
+        // Skip checks until initial check is done
+        if (!this.isInitialCheckDone) {
+            this.logger.log("Skipping check before initial delay");
+            return;
+        }
+        for (const detector of this.activeDetectors) {
+            detector.checkDevTools();
+            // If any detector reports DevTools as open, we can stop checking
+            if (detector.isOpen()) {
+                break;
+            }
+        }
+    }
+    /**
+     * Get the current DevTools state
+     * @returns True if DevTools is open
+     */
+    isOpen() {
+        return this.isDevToolsOpen;
+    }
+    /**
+     * Clean up resources for all detectors
+     */
+    dispose() {
+        // Clear initial check timeout if it exists
+        if (this.initialCheckTimeout !== null) {
+            clearTimeout(this.initialCheckTimeout);
+            this.initialCheckTimeout = null;
+        }
+        for (const detector of this.detectors.values()) {
+            detector.dispose();
+        }
+        this.detectors.clear();
+        this.activeDetectors = [];
+        this.logger.log("Disposed all detectors");
+    }
+    /**
+     * Set debug mode for all detectors
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        this.logger.setDebugMode(enabled);
+        for (const detector of this.detectors.values()) {
+            detector.setDebugMode(enabled);
+        }
+    }
+}
+// Browser-specific detector mapping
+DevToolsDetectorManager.BROWSER_DETECTOR_MAP = {
+    // Chromium-based browsers
+    chrome: ["debugger", "defineGetter"],
+    edge: ["debugger", "defineGetter"],
+    chromium: ["debugger", "defineGetter"],
+    opera: ["debugger", "defineGetter"],
+    vivaldi: ["debugger", "defineGetter"],
+    // Firefox and derivatives
+    firefox: ["timing", "regToString"],
+    // Safari
+    safari: ["dateToString", "defineGetter"],
+    // Chinese browsers
+    qq: ["regToString", "debugger"],
+    uc: ["debugger", "defineGetter"],
+    baidu: ["debugger", "defineGetter"],
+    mi: ["debugger", "defineGetter"],
+    wechat: ["debugger", "defineGetter"],
+    // Korean browsers
+    samsung: ["debugger", "defineGetter"],
+    whale: ["debugger", "defineGetter"],
+    // Russian browsers
+    yandex: ["debugger", "defineGetter"],
+    // Japanese browsers (typically WebKit/Blink based)
+    // Fallback for unknown browsers
+    unknown: ["debugger", "defineGetter", "dateToString"],
+};
+// Mobile-specific overrides
+DevToolsDetectorManager.MOBILE_DETECTOR_MAP = {
+    // iOS Safari needs special handling
+    safari: ["dateToString", "debugLib"],
+    // Android Chrome/WebView
+    chrome: ["debugger", "debugLib"],
+    // UC and QQ browsers on mobile
+    uc: ["debugger", "debugLib"],
+    qq: ["regToString", "debugLib"],
+    // Default for other mobile browsers
+    default: ["debugger", "debugLib"],
+};

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/detectors/funcToStringDetector.d.ts

@@ -0,0 +1,43 @@
+import { AbstractDevToolsDetector } from "./AbstractDevToolsDetector";
+import { DevToolsDetectorOptions } from "./detectorInterface";
+/**
+ * Options for the FuncToStringDetector
+ */
+export interface FuncToStringDetectorOptions extends DevToolsDetectorOptions {
+    /**
+     * Threshold for detection (number of toString calls)
+     */
+    threshold?: number;
+}
+/**
+ * Utility class for detecting DevTools using Function.toString behavior
+ * This approach works by detecting multiple calls to toString when a function is logged
+ * and DevTools is open
+ */
+export declare class FuncToStringDetector extends AbstractDevToolsDetector {
+    private func;
+    private count;
+    private threshold;
+    /**
+     * Create a new FuncToStringDetector
+     * @param options Configuration options
+     */
+    constructor(options?: FuncToStringDetectorOptions);
+    /**
+     * Initialize the function with custom toString method
+     */
+    private initFunction;
+    /**
+     * Check if DevTools is open using Function.toString behavior
+     */
+    checkDevTools(): void;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported(): boolean;
+}

package/dist/utils/detectors/funcToStringDetector.js

@@ -0,0 +1,90 @@
+import { isBrowser, getBrowser, isMobile } from "../environment";
+import { AbstractDevToolsDetector, DetectorErrorType } from "./AbstractDevToolsDetector";
+/**
+ * Utility class for detecting DevTools using Function.toString behavior
+ * This approach works by detecting multiple calls to toString when a function is logged
+ * and DevTools is open
+ */
+export class FuncToStringDetector extends AbstractDevToolsDetector {
+    /**
+     * Create a new FuncToStringDetector
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        super("FuncToStringDetector", options);
+        this.func = null;
+        this.count = 0;
+        this.threshold = options.threshold || 2;
+        // Initialize the function with custom toString
+        this.initFunction();
+        this.logger.log("Initialized with threshold:", this.threshold);
+    }
+    /**
+     * Initialize the function with custom toString method
+     */
+    initFunction() {
+        this.safeExecute("initFunction", DetectorErrorType.INITIALIZATION_ERROR, () => {
+            if (!isBrowser())
+                return;
+            // Create an empty function
+            this.func = () => { };
+            // Override toString to count calls
+            this.func.toString = () => {
+                this.count++;
+                this.logger.log(`toString called (${this.count} times)`);
+                return "";
+            };
+            this.logger.log("Function initialized with custom toString");
+        });
+    }
+    /**
+     * Check if DevTools is open using Function.toString behavior
+     */
+    checkDevTools() {
+        if (this.isChecking || !isBrowser())
+            return;
+        this.isChecking = true;
+        this.safeExecute("checkDevTools", DetectorErrorType.DETECTION_ERROR, () => {
+            // Reset counter
+            this.count = 0;
+            // Log the function - this will trigger toString
+            console.log(this.func);
+            // Clear console to avoid clutter
+            if (!this.debugMode) {
+                console.clear();
+            }
+            // If toString was called multiple times, DevTools is likely open
+            const isOpen = this.count >= this.threshold;
+            // Update state and notify listeners if changed
+            this.updateDevToolsState(isOpen);
+            this.logger.log(`toString called ${this.count} times, threshold: ${this.threshold}`);
+        });
+        // Ensure isChecking is reset even if an error occurs
+        this.isChecking = false;
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        this.safeExecute("dispose", DetectorErrorType.DISPOSAL_ERROR, () => {
+            this.func = null;
+            this.logger.log("Disposed");
+        });
+        super.dispose();
+    }
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported() {
+        if (!isBrowser())
+            return false;
+        const browser = getBrowser();
+        const isMobileDevice = isMobile();
+        // Not supported in iOS Chrome or iOS Edge
+        if (isMobileDevice && (browser.name === "chrome" || browser.name === "edge")) {
+            return false;
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,43 @@
+import { AbstractDevToolsDetector } from "./AbstractDevToolsDetector";
+import { DevToolsDetectorOptions } from "./detectorInterface";
+/**
+ * Options for the RegToStringDetector
+ */
+export interface RegToStringDetectorOptions extends DevToolsDetectorOptions {
+    /**
+     * Time threshold in milliseconds for QQ Browser detection
+     * If two toString calls happen within this time, DevTools is considered open
+     */
+    timeThreshold?: number;
+}
+/**
+ * Utility class for detecting DevTools using RegExp.toString behavior
+ * This approach works especially well in Firefox and QQ Browser
+ */
+export declare class RegToStringDetector extends AbstractDevToolsDetector {
+    private reg;
+    private lastCallTime;
+    private timeThreshold;
+    /**
+     * Create a new RegToStringDetector
+     * @param options Configuration options
+     */
+    constructor(options?: RegToStringDetectorOptions);
+    /**
+     * Initialize the RegExp object with custom toString method
+     */
+    private initRegExpObject;
+    /**
+     * Check if DevTools is open using RegExp.toString behavior
+     */
+    checkDevTools(): void;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported(): boolean;
+}

package/dist/utils/detectors/regToStringDetector.js

@@ -0,0 +1,129 @@
+import { isBrowser, getBrowser } from "../environment";
+import { AbstractDevToolsDetector, DetectorErrorType } from "./AbstractDevToolsDetector";
+/**
+ * Utility class for detecting DevTools using RegExp.toString behavior
+ * This approach works especially well in Firefox and QQ Browser
+ */
+export class RegToStringDetector extends AbstractDevToolsDetector {
+    /**
+     * Create a new RegToStringDetector
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        super("RegToStringDetector", options);
+        this.reg = null;
+        this.lastCallTime = 0;
+        this.timeThreshold = options.timeThreshold || 100;
+        // Initialize the RegExp object with custom toString
+        this.initRegExpObject();
+        this.logger.log("Initialized with time threshold:", this.timeThreshold);
+    }
+    /**
+     * Initialize the RegExp object with custom toString method
+     */
+    initRegExpObject() {
+        this.safeExecute("initRegExpObject", DetectorErrorType.INITIALIZATION_ERROR, () => {
+            if (!isBrowser())
+                return;
+            this.reg = /./;
+            // Override toString to detect DevTools
+            this.reg.toString = () => {
+                const browser = getBrowser();
+                const isQQBrowser = browser.name === "qq" || navigator.userAgent.toLowerCase().includes("qqbrowser");
+                const isFirefox = browser.name === "firefox";
+                if (isQQBrowser) {
+                    // For QQ Browser: When DevTools is closed, toString is called once.
+                    // When DevTools is open, toString is called twice in quick succession.
+                    // We use this timing difference to detect if DevTools is open.
+                    const currentTime = Date.now();
+                    if (this.lastCallTime && currentTime - this.lastCallTime < this.timeThreshold) {
+                        // Two calls in quick succession - DevTools is likely open
+                        this.updateDevToolsState(true);
+                        this.logger.log("DevTools opened (QQ Browser detection)");
+                    }
+                    else {
+                        // First call or calls too far apart
+                        this.lastCallTime = currentTime;
+                    }
+                }
+                else if (isFirefox) {
+                    // For Firefox: toString is only called when DevTools is open
+                    this.updateDevToolsState(true);
+                    this.logger.log("DevTools opened (Firefox detection)");
+                }
+                return "";
+            };
+            this.logger.log("RegExp object initialized");
+        });
+    }
+    /**
+     * Check if DevTools is open using RegExp.toString behavior
+     */
+    checkDevTools() {
+        if (this.isChecking || !isBrowser() || !this.reg)
+            return;
+        this.isChecking = true;
+        this.safeExecute("checkDevTools", DetectorErrorType.DETECTION_ERROR, () => {
+            // Reset detection state for Firefox
+            const browser = getBrowser();
+            if (browser.name === "firefox" && this.isDevToolsOpen) {
+                this.updateDevToolsState(false);
+            }
+            // Log the RegExp object - this will trigger toString
+            console.log(this.reg);
+            // Clear console to avoid clutter
+            if (!this.debugMode) {
+                console.clear();
+            }
+            // For browsers other than Firefox and QQ Browser, we need to check if
+            // DevTools is closed after a short delay
+            setTimeout(() => {
+                this.safeExecute("checkDevToolsTimeout", DetectorErrorType.DETECTION_ERROR, () => {
+                    const browser = getBrowser();
+                    const isQQBrowser = browser.name === "qq" || navigator.userAgent.toLowerCase().includes("qqbrowser");
+                    const isFirefox = browser.name === "firefox";
+                    // If we're not in Firefox or QQ Browser and DevTools is open,
+                    // check if it should be marked as closed
+                    if (!isFirefox && !isQQBrowser && this.isDevToolsOpen) {
+                        const currentTime = Date.now();
+                        // If no recent toString calls, DevTools is likely closed
+                        if (currentTime - this.lastCallTime > this.timeThreshold * 2) {
+                            this.updateDevToolsState(false);
+                            this.logger.log("DevTools closed");
+                        }
+                    }
+                    this.isChecking = false;
+                });
+            }, this.timeThreshold * 2);
+        });
+        // Ensure isChecking is reset if an error occurs
+        if (this.isChecking) {
+            setTimeout(() => {
+                this.isChecking = false;
+            }, this.timeThreshold * 3);
+        }
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        this.safeExecute("dispose", DetectorErrorType.DISPOSAL_ERROR, () => {
+            this.reg = null;
+            this.logger.log("Disposed");
+        });
+        super.dispose();
+    }
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported() {
+        if (!isBrowser())
+            return false;
+        const browser = getBrowser();
+        const isQQBrowser = browser.name === "qq" || navigator.userAgent.toLowerCase().includes("qqbrowser");
+        const isFirefox = browser.name === "firefox";
+        // This detector works best in Firefox and QQ Browser
+        return isFirefox || isQQBrowser;
+    }
+}

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

@@ -0,0 +1,54 @@
+import { AbstractDevToolsDetector } from "./AbstractDevToolsDetector";
+import { DevToolsDetectorOptions } from "./detectorInterface";
+/**
+ * Options for the SizeDetector
+ */
+export interface SizeDetectorOptions extends DevToolsDetectorOptions {
+    /**
+     * Width threshold in pixels
+     * If the difference between outer and inner width exceeds this, DevTools is considered open
+     */
+    widthThreshold?: number;
+    /**
+     * Height threshold in pixels
+     * If the difference between outer and inner height exceeds this, DevTools is considered open
+     */
+    heightThreshold?: number;
+}
+/**
+ * Utility class for detecting DevTools using window size differences
+ * This approach works by detecting unusual differences between outer and inner window dimensions
+ * that typically occur when DevTools are open
+ */
+export declare class SizeDetector extends AbstractDevToolsDetector {
+    private widthThreshold;
+    private heightThreshold;
+    private resizeEventId;
+    /**
+     * Create a new SizeDetector
+     * @param options Configuration options
+     */
+    constructor(options?: SizeDetectorOptions);
+    /**
+     * Initialize resize event listener
+     */
+    private initResizeListener;
+    /**
+     * Calculate screen zoom ratio
+     * @returns The screen zoom ratio or false if it can't be determined
+     */
+    private getScreenZoomRatio;
+    /**
+     * Check if DevTools is open using window size differences
+     */
+    checkDevTools(): void;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    /**
+     * Check if this detector is supported in the current browser
+     * @returns True if supported
+     */
+    static isSupported(): boolean;
+}