@aientrophy/sdk 0.3.1 → 0.3.3

package/dist/npm/index.es.js

@@ -211,7 +211,9 @@ const THREAT_EVENTS = /* @__PURE__ */ new Set([
   "init_signals",
   "automation_detected",
   "cross_context_mismatch",
-  "headless_probe"
+  "headless_probe",
+  "script_injection",
+  "worker_integrity"
 ]);
 class CallbackManager {
   constructor() {
@@ -2360,6 +2362,516 @@ class HeadlessProbeDetector {
     });
   }
 }
+class ScriptInjectionDetector {
+  constructor(transmitter) {
+    __publicField(this, "transmitter");
+    __publicField(this, "hasRun", false);
+    __publicField(this, "injectedScriptCount", 0);
+    __publicField(this, "cspViolations", []);
+    this.transmitter = transmitter;
+  }
+  start() {
+    if (this.hasRun || typeof window === "undefined") return;
+    this.hasRun = true;
+    this.startDOMObserver();
+    this.startCSPMonitor();
+    setTimeout(() => this.detect(), 1500);
+  }
+  detect() {
+    const signals = {};
+    let score = 0;
+    try {
+      const nativeIntegrity = this.checkNativeFunctionIntegrity();
+      if (nativeIntegrity.issues.length > 0) {
+        signals.nativeFunctionIntegrity = nativeIntegrity.issues;
+        score += 25;
+      }
+    } catch (e) {
+    }
+    try {
+      const overrides = this.checkPropertyOverrides();
+      if (overrides.issues.length > 0) {
+        signals.propertyOverrides = overrides.issues;
+        score += 30;
+      }
+    } catch (e) {
+    }
+    if (this.injectedScriptCount > 0) {
+      signals.domScriptInjection = {
+        count: this.injectedScriptCount
+      };
+      score += 20;
+    }
+    if (this.cspViolations.length > 0) {
+      signals.cspViolations = this.cspViolations.slice(0, 10);
+      score += 15;
+    }
+    try {
+      const globals = this.checkGlobalPollution();
+      if (globals.length > 0) {
+        signals.globalPollution = globals;
+        score += 20;
+      }
+    } catch (e) {
+    }
+    try {
+      const protoIssues = this.checkPrototypeIntegrity();
+      if (protoIssues.length > 0) {
+        signals.prototypeIntegrity = protoIssues;
+        score += 20;
+      }
+    } catch (e) {
+    }
+    if (score > 0) {
+      this.transmitter.send("script_injection", {
+        signals,
+        score,
+        timestamp: Date.now()
+      });
+    }
+  }
+  /**
+   * 1. Native Function Integrity
+   * Checks if navigator.webdriver descriptor, navigator getters, and
+   * Function.prototype.toString have been tampered with.
+   */
+  checkNativeFunctionIntegrity() {
+    const issues = [];
+    try {
+      const desc = Object.getOwnPropertyDescriptor(navigator, "webdriver");
+      if (desc) {
+        if (desc.configurable === true) {
+          issues.push("webdriver_descriptor_configurable");
+        }
+        if (desc.get) {
+          const getterStr = Function.prototype.toString.call(desc.get);
+          if (!/\[native code\]/.test(getterStr)) {
+            issues.push("webdriver_non_native_getter");
+          }
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const propsToCheck = ["userAgent", "platform", "languages", "hardwareConcurrency"];
+      for (const prop of propsToCheck) {
+        const protoDesc = Object.getOwnPropertyDescriptor(Navigator.prototype, prop);
+        if (protoDesc && protoDesc.get) {
+          const getterStr = Function.prototype.toString.call(protoDesc.get);
+          if (!/\[native code\]/.test(getterStr)) {
+            issues.push(`navigator_${prop}_non_native`);
+          }
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const toStringStr = Function.prototype.toString.call(Function.prototype.toString);
+      if (!/\[native code\]/.test(toStringStr)) {
+        issues.push("function_tostring_overridden");
+      }
+    } catch (e) {
+    }
+    return { issues };
+  }
+  /**
+   * 2. Property Override Detection
+   * Checks for Object.defineProperty abuse on navigator,
+   * proxy wrappers, and spoofed navigator.plugins.
+   */
+  checkPropertyOverrides() {
+    const issues = [];
+    try {
+      const navigatorStr = Object.prototype.toString.call(navigator);
+      if (navigatorStr !== "[object Navigator]") {
+        issues.push("navigator_proxy_or_spoofed");
+      }
+    } catch (e) {
+    }
+    try {
+      if (navigator.plugins) {
+        const pluginsStr = Object.prototype.toString.call(navigator.plugins);
+        if (pluginsStr !== "[object PluginArray]") {
+          issues.push("plugins_spoofed");
+        }
+        if (Array.isArray(navigator.plugins)) {
+          issues.push("plugins_is_array");
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      if (navigator.mimeTypes) {
+        const mimeStr = Object.prototype.toString.call(navigator.mimeTypes);
+        if (mimeStr !== "[object MimeTypeArray]") {
+          issues.push("mimetypes_spoofed");
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const descStr = Function.prototype.toString.call(Object.getOwnPropertyDescriptor);
+      if (!/\[native code\]/.test(descStr)) {
+        issues.push("getOwnPropertyDescriptor_overridden");
+      }
+    } catch (e) {
+    }
+    return { issues };
+  }
+  /**
+   * 3. DOM Script Injection Monitoring
+   * Sets up MutationObserver to watch for dynamically added <script> tags.
+   */
+  startDOMObserver() {
+    try {
+      if (typeof MutationObserver === "undefined") return;
+      const observer = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+          for (let i = 0; i < mutation.addedNodes.length; i++) {
+            const node = mutation.addedNodes[i];
+            if (node.nodeName === "SCRIPT") {
+              const script = node;
+              if (!script.src) {
+                this.injectedScriptCount++;
+              }
+            }
+          }
+        }
+      });
+      observer.observe(document.documentElement, {
+        childList: true,
+        subtree: true
+      });
+      setTimeout(() => {
+        try {
+          observer.disconnect();
+        } catch (e) {
+        }
+      }, 1e4);
+    } catch (e) {
+    }
+  }
+  /**
+   * 4. CSP Violation Monitoring
+   * Listens for securitypolicyviolation events indicating injection attempts.
+   */
+  startCSPMonitor() {
+    try {
+      const handler = (event) => {
+        try {
+          const entry = `${event.violatedDirective}|${event.blockedURI || "inline"}`;
+          this.cspViolations.push(entry);
+        } catch (e) {
+        }
+      };
+      document.addEventListener("securitypolicyviolation", handler);
+      setTimeout(() => {
+        try {
+          document.removeEventListener("securitypolicyviolation", handler);
+        } catch (e) {
+        }
+      }, 1e4);
+    } catch (e) {
+    }
+  }
+  /**
+   * 5. Global Variable Pollution
+   * Checks for known automation framework globals and CDP-injected patterns.
+   */
+  checkGlobalPollution() {
+    const found = [];
+    const w = window;
+    const d = document;
+    const checks = [
+      ["__webdriver_evaluate", () => !!d.__webdriver_evaluate],
+      ["__selenium_evaluate", () => !!d.__selenium_evaluate],
+      ["__webdriver_script_function", () => !!d.__webdriver_script_function],
+      ["__webdriver_script_func", () => !!d.__webdriver_script_func],
+      ["__webdriver_script_fn", () => !!d.__webdriver_script_fn],
+      ["_Selenium_IDE_Recorder", () => !!w._Selenium_IDE_Recorder],
+      ["__lastWatirAlert", () => !!w.__lastWatirAlert],
+      ["__lastWatirConfirm", () => !!w.__lastWatirConfirm],
+      ["__lastWatirPrompt", () => !!w.__lastWatirPrompt],
+      ["_phantom", () => !!w._phantom],
+      ["callPhantom", () => !!w.callPhantom],
+      ["__nightmare", () => !!w.__nightmare],
+      // Buffer and process should not exist in browser context
+      ["Buffer", () => typeof w.Buffer === "function" && typeof w.Buffer.alloc === "function"],
+      ["process", () => !!w.process && !!w.process.versions],
+      // global redefined (in normal browsers, window.global is undefined)
+      ["global_redefined", () => !!w.global && w.global !== w && typeof w.global === "object"],
+      // emit on window (frameworks sometimes attach this)
+      ["window_emit", () => typeof w.emit === "function"]
+    ];
+    for (const [name, check] of checks) {
+      try {
+        if (check()) found.push(name);
+      } catch (e) {
+      }
+    }
+    try {
+      const keys = Object.keys(document);
+      for (const key of keys) {
+        if (/^cdc_|^__cdc_/.test(key)) {
+          found.push(`cdc:${key}`);
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const wKeys = Object.keys(window);
+      for (const key of wKeys) {
+        if (/^cdc_|^__cdc_/.test(key)) {
+          found.push(`cdc_window:${key}`);
+        }
+      }
+    } catch (e) {
+    }
+    return found;
+  }
+  /**
+   * 6. Prototype Chain Integrity
+   * Verifies HTMLElement.prototype, document.createElement, and Event constructor.
+   */
+  checkPrototypeIntegrity() {
+    const issues = [];
+    try {
+      const htmlProto = HTMLElement.prototype;
+      const htmlProtoKeys = Object.getOwnPropertyNames(htmlProto);
+      for (const key of htmlProtoKeys) {
+        if (/^__selenium|^__webdriver|^__playwright|^__puppeteer/.test(key)) {
+          issues.push(`htmlelement_proto_${key}`);
+        }
+      }
+    } catch (e) {
+    }
+    try {
+      const div = document.createElement("div");
+      if (!(div instanceof HTMLDivElement)) {
+        issues.push("createElement_not_genuine");
+      }
+      const divStr = Object.prototype.toString.call(div);
+      if (divStr !== "[object HTMLDivElement]") {
+        issues.push("createElement_wrong_tostring");
+      }
+    } catch (e) {
+    }
+    try {
+      const evt = new Event("test");
+      if (!(evt instanceof Event)) {
+        issues.push("event_not_instance");
+      }
+      const evtStr = Object.prototype.toString.call(evt);
+      if (evtStr !== "[object Event]") {
+        issues.push("event_wrong_prototype");
+      }
+    } catch (e) {
+    }
+    try {
+      const createStr = Function.prototype.toString.call(document.createElement);
+      if (!/\[native code\]/.test(createStr)) {
+        issues.push("createElement_overridden");
+      }
+    } catch (e) {
+    }
+    return issues;
+  }
+}
+class WorkerIntegrityDetector {
+  constructor(transmitter) {
+    __publicField(this, "transmitter");
+    __publicField(this, "hasRun", false);
+    this.transmitter = transmitter;
+  }
+  start() {
+    if (this.hasRun || typeof window === "undefined") return;
+    this.hasRun = true;
+    setTimeout(() => this.detect(), 2e3);
+  }
+  async detect() {
+    try {
+      if (typeof Worker === "undefined" || typeof Blob === "undefined") return;
+      const mainValues = {
+        webdriver: !!navigator.webdriver,
+        userAgent: navigator.userAgent || "",
+        platform: navigator.platform || "",
+        languages: JSON.stringify(navigator.languages || []),
+        hardwareConcurrency: navigator.hardwareConcurrency || 0,
+        dateNow: Date.now(),
+        perfNow: performance.now(),
+        toStringNative: false
+      };
+      try {
+        mainValues.toStringNative = /\[native code\]/.test(
+          Function.prototype.toString.call(Array.prototype.push)
+        );
+      } catch (_e) {
+        mainValues.toStringNative = false;
+      }
+      const workerResult = await this.runWorker(mainValues);
+      if (!workerResult) return;
+      const signals = {};
+      let score = 0;
+      const navMismatches = [];
+      if (!mainValues.webdriver && workerResult.webdriver === true) {
+        navMismatches.push("webdriver_spoofed");
+        score += 40;
+      } else if (workerResult.webdriver !== mainValues.webdriver) {
+        navMismatches.push("webdriver_mismatch");
+        score += 30;
+      }
+      if (workerResult.userAgent !== mainValues.userAgent) {
+        navMismatches.push("userAgent_mismatch");
+        score += 30;
+      }
+      if (workerResult.platform !== mainValues.platform) {
+        navMismatches.push("platform_mismatch");
+        score += 30;
+      }
+      if (workerResult.languages !== mainValues.languages) {
+        navMismatches.push("languages_mismatch");
+        score += 30;
+      }
+      if (workerResult.hardwareConcurrency !== mainValues.hardwareConcurrency) {
+        navMismatches.push("hardwareConcurrency_mismatch");
+        score += 30;
+      }
+      if (navMismatches.length > 0) {
+        signals.navigatorMismatch = navMismatches;
+      }
+      const benchmarkMs = workerResult.benchmarkMs;
+      if (typeof benchmarkMs === "number") {
+        if (benchmarkMs < 1 || benchmarkMs > 500) {
+          signals.benchmarkAnomaly = {
+            benchmarkMs,
+            reason: benchmarkMs < 1 ? "abnormally_fast" : "abnormally_slow"
+          };
+          score += 20;
+        }
+      }
+      if (workerResult.cryptoEntropy === false) {
+        signals.cryptoMock = {
+          entropy: false,
+          values: workerResult.cryptoValues
+        };
+        score += 15;
+      }
+      const timeDelta = Math.abs(workerResult.dateNow - mainValues.dateNow);
+      if (timeDelta > 1e3) {
+        signals.timeManipulation = {
+          mainDateNow: mainValues.dateNow,
+          workerDateNow: workerResult.dateNow,
+          deltaMs: timeDelta
+        };
+        score += 15;
+      }
+      if (!workerResult.toStringNative || !mainValues.toStringNative) {
+        const toStringSignals = [];
+        if (!workerResult.toStringNative) toStringSignals.push("worker_tampered");
+        if (!mainValues.toStringNative) toStringSignals.push("main_tampered");
+        signals.toStringTampering = toStringSignals;
+        score += 20;
+      }
+      if (score > 0) {
+        this.transmitter.send("worker_integrity", {
+          signals,
+          score,
+          timestamp: Date.now()
+        });
+      }
+    } catch (_e) {
+    }
+  }
+  /**
+   * Spawn an inline Web Worker via Blob URL and collect integrity signals.
+   * Returns null if Worker is not supported or times out.
+   */
+  runWorker(mainValues) {
+    return new Promise((resolve) => {
+      try {
+        const workerCode = `
+                    self.onmessage = function(e) {
+                        var results = {};
+
+                        // 1. Navigator check
+                        try {
+                            results.webdriver = !!navigator.webdriver;
+                            results.userAgent = navigator.userAgent || '';
+                            results.platform = navigator.platform || '';
+                            results.languages = JSON.stringify(navigator.languages || []);
+                            results.hardwareConcurrency = navigator.hardwareConcurrency || 0;
+                        } catch(ex) {
+                            results.webdriver = false;
+                            results.userAgent = '';
+                            results.platform = '';
+                            results.languages = '[]';
+                            results.hardwareConcurrency = 0;
+                        }
+
+                        // 2. Performance benchmark
+                        try {
+                            var start = performance.now();
+                            var sum = 0;
+                            for (var i = 0; i < 1000000; i++) sum += i;
+                            results.benchmarkMs = performance.now() - start;
+                        } catch(ex) {
+                            results.benchmarkMs = -1;
+                        }
+
+                        // 3. Crypto check
+                        try {
+                            var arr = new Uint32Array(4);
+                            crypto.getRandomValues(arr);
+                            results.cryptoEntropy = arr[0] !== arr[1] && arr[1] !== arr[2] && arr[0] !== 0;
+                            results.cryptoValues = Array.from(arr);
+                        } catch(ex) {
+                            results.cryptoEntropy = false;
+                            results.cryptoValues = [];
+                        }
+
+                        // 4. Time check
+                        results.dateNow = Date.now();
+                        results.perfNow = performance.now();
+
+                        // 5. toString integrity
+                        try {
+                            results.toStringNative = /\\[native code\\]/.test(
+                                Function.prototype.toString.call(Array.prototype.push)
+                            );
+                        } catch(ex) {
+                            results.toStringNative = false;
+                        }
+
+                        self.postMessage(results);
+                    };
+                `;
+        const blob = new Blob([workerCode], { type: "application/javascript" });
+        const url = URL.createObjectURL(blob);
+        const worker = new Worker(url);
+        const timeout = setTimeout(() => {
+          worker.terminate();
+          URL.revokeObjectURL(url);
+          resolve(null);
+        }, 5e3);
+        worker.onmessage = (e) => {
+          clearTimeout(timeout);
+          worker.terminate();
+          URL.revokeObjectURL(url);
+          resolve(e.data);
+        };
+        worker.onerror = () => {
+          clearTimeout(timeout);
+          worker.terminate();
+          URL.revokeObjectURL(url);
+          resolve(null);
+        };
+        worker.postMessage({ mainValues });
+      } catch (_e) {
+        resolve(null);
+      }
+    });
+  }
+}
 const COOKIE_NAME = "__aie_token";
 const RENEWAL_MARGIN_MS = 5 * 60 * 1e3;
 class CrawlProtect {
@@ -2541,6 +3053,8 @@ class SecuritySDK {
     __publicField(this, "cloudEnvironmentDetector");
     __publicField(this, "crossContextDetector");
     __publicField(this, "headlessProbeDetector");
+    __publicField(this, "scriptInjectionDetector");
+    __publicField(this, "workerIntegrityDetector");
     __publicField(this, "crawlProtect", null);
     __publicField(this, "initialized", false);
     __publicField(this, "wasmService");
@@ -2562,6 +3076,8 @@ class SecuritySDK {
     this.cloudEnvironmentDetector = new CloudEnvironmentDetector(this.transmitter);
     this.crossContextDetector = new CrossContextDetector(this.transmitter);
     this.headlessProbeDetector = new HeadlessProbeDetector(this.transmitter);
+    this.scriptInjectionDetector = new ScriptInjectionDetector(this.transmitter);
+    this.workerIntegrityDetector = new WorkerIntegrityDetector(this.transmitter);
   }
   async init(config) {
     var _a, _b;
@@ -2583,9 +3099,16 @@ class SecuritySDK {
       }
       const devtoolsEnabled = ((_b = config.serverConfig) == null ? void 0 : _b.devtoolsDetection) ?? !config.debug;
       if (devtoolsEnabled) {
-        import("../anti-debug-CRuvY4WC.js").then(({ AntiDebug }) => {
+        import("../anti-debug-Cf0ePnTv.js").then(({ AntiDebug }) => {
           AntiDebug.start();
-          import("../console-DbZZ4Ctg.js").then(({ ConsoleDetector }) => {
+          AntiDebug.setOnDevtoolsMaxed(() => {
+            this.transmitter.send("devtools_force_close", {
+              reason: "devtools_threshold_exceeded",
+              detectionCount: 3,
+              maxThreat: true
+            });
+          });
+          import("../console-n38-3CrG.js").then(({ ConsoleDetector }) => {
             new ConsoleDetector(() => {
               this.transmitter.send("devtools_open", { detected: true });
             }).start();
@@ -2639,6 +3162,8 @@ class SecuritySDK {
     this.cloudEnvironmentDetector.start();
     this.crossContextDetector.start();
     this.headlessProbeDetector.start();
+    this.scriptInjectionDetector.start();
+    this.workerIntegrityDetector.start();
   }
 }
 const securitySDK = new SecuritySDK();

package/dist/sri-hashes.json

@@ -1,8 +1,8 @@
 {
-  "generated": "2026-03-20T02:39:39.149Z",
+  "generated": "2026-03-20T07:11:02.283Z",
   "algorithm": "sha384",
   "hashes": {
-    "core.js": "sha384-a9oAPKIopFcC2T2/9FpPpgShfpq4tmSJuIAjkcTXEh2IdydxjJ5V642FuwONhhNv",
+    "core.js": "sha384-6X6rQ1r2g8Xe7Ip9yTnbfB4yCg1NJ4eQBROEDFGAHLDngu98b3ed7XTzR5zTVWx4",
     "core.wasm": "sha384-fPJjZg5frGy3uptl1c6t4ekPOoQRQPquQVQEbrMf09T7mCur5iJVX4gGqkRfu93q",
     "loader.js": "sha384-0v1eaWmQUDG7Xzh8ujnAFroO2azUb0n547CCqAL1opB0WUltJC8WMyV8e1XoKf2R"
   }

package/dist/types/core/index.d.ts

@@ -33,6 +33,8 @@ declare class SecuritySDK {
     private cloudEnvironmentDetector;
     private crossContextDetector;
     private headlessProbeDetector;
+    private scriptInjectionDetector;
+    private workerIntegrityDetector;
     private crawlProtect;
     private initialized;
     private wasmService;

package/dist/types/detectors/ScriptInjectionDetector.d.ts

@@ -0,0 +1,56 @@
+import { Transmitter } from '../transport';
+/**
+ * ScriptInjectionDetector — Detects script injection attacks.
+ *
+ * Defends against SeleniumBase's insertScript, Puppeteer's evaluateOnNewDocument,
+ * and similar techniques that inject JavaScript before or after page load.
+ *
+ * Detection layers:
+ * 1. Native function integrity (navigator property tampering)
+ * 2. Property override detection (defineProperty / Proxy on navigator)
+ * 3. DOM script injection monitoring (MutationObserver)
+ * 4. CSP violation monitoring (securitypolicyviolation events)
+ * 5. Global variable pollution (automation framework globals)
+ * 6. Prototype chain integrity (HTMLElement, Event, createElement)
+ */
+export declare class ScriptInjectionDetector {
+    private transmitter;
+    private hasRun;
+    private injectedScriptCount;
+    private cspViolations;
+    constructor(transmitter: Transmitter);
+    start(): void;
+    private detect;
+    /**
+     * 1. Native Function Integrity
+     * Checks if navigator.webdriver descriptor, navigator getters, and
+     * Function.prototype.toString have been tampered with.
+     */
+    private checkNativeFunctionIntegrity;
+    /**
+     * 2. Property Override Detection
+     * Checks for Object.defineProperty abuse on navigator,
+     * proxy wrappers, and spoofed navigator.plugins.
+     */
+    private checkPropertyOverrides;
+    /**
+     * 3. DOM Script Injection Monitoring
+     * Sets up MutationObserver to watch for dynamically added <script> tags.
+     */
+    private startDOMObserver;
+    /**
+     * 4. CSP Violation Monitoring
+     * Listens for securitypolicyviolation events indicating injection attempts.
+     */
+    private startCSPMonitor;
+    /**
+     * 5. Global Variable Pollution
+     * Checks for known automation framework globals and CDP-injected patterns.
+     */
+    private checkGlobalPollution;
+    /**
+     * 6. Prototype Chain Integrity
+     * Verifies HTMLElement.prototype, document.createElement, and Event constructor.
+     */
+    private checkPrototypeIntegrity;
+}

package/dist/types/detectors/WorkerIntegrityDetector.d.ts

@@ -0,0 +1,26 @@
+import { Transmitter } from '../transport';
+/**
+ * WorkerIntegrityDetector — Web Worker 격리 환경을 이용한 브라우저 무결성 검증.
+ *
+ * SeleniumBase/Puppeteer의 insertScript는 메인 스레드에만 영향을 주므로,
+ * Worker 내부에서 독립적으로 브라우저 상태를 검증하면 스푸핑을 탐지할 수 있음.
+ *
+ * Detection:
+ *   1. Navigator 일관성 — Worker vs 메인 스레드 navigator 속성 비교
+ *   2. Performance 벤치마크 — 마이크로 벤치마크로 비정상 실행 속도 탐지
+ *   3. Crypto API 검증 — crypto.getRandomValues 엔트로피 확인
+ *   4. Date/Time 일관성 — Worker vs 메인 스레드 시간 불일치 탐지
+ *   5. Function.prototype.toString 무결성 — 네이티브 함수 변조 탐지
+ */
+export declare class WorkerIntegrityDetector {
+    private transmitter;
+    private hasRun;
+    constructor(transmitter: Transmitter);
+    start(): void;
+    private detect;
+    /**
+     * Spawn an inline Web Worker via Blob URL and collect integrity signals.
+     * Returns null if Worker is not supported or times out.
+     */
+    private runWorker;
+}

package/dist/types/protection/anti-debug.d.ts

@@ -3,10 +3,17 @@ export declare class AntiDebug {
     private static intervalId;
     static start(): void;
     static stop(): void;
+    /** Set callback for when DevTools detection exceeds threshold (called by SDK core). */
+    static setOnDevtoolsMaxed(callback: () => void): void;
+    /** Called by ConsoleDetector or size detection when DevTools is detected. */
+    static reportDevtoolsDetection(): void;
     /** Returns saved original console methods (bound to console). */
     static getOriginalConsole(): Record<string, Function>;
+    private static handleDevtoolsMaxed;
     private static saveConsole;
     private static preventDevTools;
     private static debuggerCheck;
+    /** Block F12, Ctrl+Shift+I/J/C, Ctrl+U and right-click */
+    private static blockDevToolsKeys;
     private static disableConsole;
 }