@jshookmcp/jshook 0.2.3 → 0.2.6

package/dist/src/modules/collector/DOMInspector.js

@@ -67,28 +67,24 @@ export class DOMInspector {
             const page = await this.collector.getActivePage();
             const readyStateStatus = await this.waitForReadyState(page);
             const runQuery = async () => page.evaluate((sel, maxLimit) => {
-                const collectRoots = () => {
-                    const roots = [document];
-                    const queue = [document];
-                    let shadowRootCount = 0;
-                    while (queue.length > 0) {
-                        const root = queue.shift();
-                        if (!root)
-                            continue;
-                        const elements = Array.from(root.querySelectorAll('*'));
-                        for (const element of elements) {
-                            const shadowRoot = element
-                                .shadowRoot;
-                            if (shadowRoot) {
-                                roots.push(shadowRoot);
-                                queue.push(shadowRoot);
-                                shadowRootCount += 1;
-                            }
+                const roots = [document];
+                const queue = [document];
+                let shadowRootCount = 0;
+                while (queue.length > 0) {
+                    const root = queue.shift();
+                    if (!root)
+                        continue;
+                    const elements = Array.from(root.querySelectorAll('*'));
+                    for (const element of elements) {
+                        const shadowRoot = element
+                            .shadowRoot;
+                        if (shadowRoot) {
+                            roots.push(shadowRoot);
+                            queue.push(shadowRoot);
+                            shadowRootCount += 1;
                         }
                     }
-                    return { roots, shadowRootCount };
-                };
-                const { roots, shadowRootCount } = collectRoots();
+                }
                 const seen = new Set();
                 const results = [];
                 let totalMatches = 0;
@@ -232,28 +228,24 @@ export class DOMInspector {
             const page = await this.collector.getActivePage();
             const readyStateStatus = await this.waitForReadyState(page);
             const runQuery = async () => page.evaluate((filter) => {
-                const collectRoots = () => {
-                    const roots = [document];
-                    const queue = [document];
-                    let shadowRootCount = 0;
-                    while (queue.length > 0) {
-                        const root = queue.shift();
-                        if (!root)
-                            continue;
-                        const elements = Array.from(root.querySelectorAll('*'));
-                        for (const element of elements) {
-                            const shadowRoot = element
-                                .shadowRoot;
-                            if (shadowRoot) {
-                                roots.push(shadowRoot);
-                                queue.push(shadowRoot);
-                                shadowRootCount += 1;
-                            }
+                const roots = [document];
+                const queue = [document];
+                let shadowRootCount = 0;
+                while (queue.length > 0) {
+                    const root = queue.shift();
+                    if (!root)
+                        continue;
+                    const elements = Array.from(root.querySelectorAll('*'));
+                    for (const element of elements) {
+                        const shadowRoot = element
+                            .shadowRoot;
+                        if (shadowRoot) {
+                            roots.push(shadowRoot);
+                            queue.push(shadowRoot);
+                            shadowRootCount += 1;
                         }
                     }
-                    return { roots, shadowRootCount };
-                };
-                const { roots, shadowRootCount } = collectRoots();
+                }
                 const results = [];
                 const seen = new Set();
                 const normalizedFilter = filter?.toLowerCase();
@@ -448,7 +440,7 @@ export class DOMInspector {
                     ? `//${tagName}[contains(text(), "${searchText}")]`
                     : `//*[contains(text(), "${searchText}")]`;
                 const result = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-                const elements = [];
+                const matchedElements = [];
                 for (let i = 0; i < Math.min(result.snapshotLength, 100); i++) {
                     const element = result.snapshotItem(i);
                     if (!element)
@@ -465,7 +457,7 @@ export class DOMInspector {
                             selector = `${element.tagName.toLowerCase()}.${classes[0]}`;
                         }
                     }
-                    elements.push({
+                    matchedElements.push({
                         found: true,
                         nodeName: element.tagName,
                         textContent: element.textContent?.trim(),
@@ -479,7 +471,7 @@ export class DOMInspector {
                         visible: style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0',
                     });
                 }
-                return elements;
+                return matchedElements;
             }, text, tag);
             logger.info(`findByText: "${text}" - found ${elements.length} elements`);
             return elements;
@@ -497,32 +489,30 @@ export class DOMInspector {
                 if (!element) {
                     return null;
                 }
-                function getElementXPath(el) {
-                    if (el.id) {
-                        return `//*[@id="${el.id}"]`;
-                    }
-                    if (el === document.body) {
-                        return '/html/body';
+                const parts = [];
+                let current = element;
+                while (current && current !== document.body && current !== document.documentElement) {
+                    if (current.id) {
+                        parts.unshift(`//*[@id="${current.id}"]`);
+                        return parts.join('');
                     }
                     let ix = 0;
-                    const siblings = el.parentNode?.children;
+                    const siblings = current.parentElement?.children;
                     if (siblings) {
                         for (let i = 0; i < siblings.length; i++) {
                             const sibling = siblings[i];
                             if (!sibling)
                                 continue;
-                            if (sibling === el) {
-                                const parentPath = el.parentElement ? getElementXPath(el.parentElement) : '';
-                                return `${parentPath}/${el.tagName.toLowerCase()}[${ix + 1}]`;
-                            }
-                            if (sibling.tagName === el.tagName) {
+                            if (sibling === current)
+                                break;
+                            if (sibling.tagName === current.tagName)
                                 ix++;
-                            }
                         }
                     }
-                    return '';
+                    parts.unshift(`/${current.tagName.toLowerCase()}[${ix + 1}]`);
+                    current = current.parentElement;
                 }
-                return getElementXPath(element);
+                return '/html/body' + parts.join('');
             }, selector);
             logger.info(`getXPath: ${selector} -> ${xpath}`);
             return xpath;

package/dist/src/modules/collector/PageController.d.ts

@@ -103,13 +103,26 @@ export declare class PageController {
 export declare function evaluateWithTimeout<Args extends readonly unknown[], Result>(page: Page, pageFunction: (...args: Args) => Result, ...args: Args): Promise<Awaited<Result>>;
 export declare function evaluateWithTimeout(page: Page, pageFunction: string, ...args: readonly unknown[]): Promise<unknown>;
 export declare function evaluateOnNewDocumentWithTimeout<Args extends readonly unknown[], Result>(page: Page, pageFunction: string | ((...args: never[]) => Result), ...args: Args): Promise<unknown>;
-export declare function coverageStartJSWithTimeout(page: any, options?: {
+interface CoveragePage {
+    coverage: {
+        startJSCoverage(options?: {
+            resetOnNavigation?: boolean;
+            reportAnonymousScripts?: boolean;
+        }): Promise<void>;
+        stopJSCoverage(): Promise<unknown>;
+        startCSSCoverage(options?: {
+            resetOnNavigation?: boolean;
+        }): Promise<void>;
+        stopCSSCoverage(): Promise<unknown>;
+    };
+}
+export declare function coverageStartJSWithTimeout(page: CoveragePage, options?: {
     resetOnNavigation?: boolean;
     reportAnonymousScripts?: boolean;
 }): Promise<void>;
-export declare function coverageStartCSSWithTimeout(page: any, options?: {
+export declare function coverageStartCSSWithTimeout(page: CoveragePage, options?: {
     resetOnNavigation?: boolean;
 }): Promise<void>;
-export declare function coverageStopJSWithTimeout(page: any): Promise<unknown>;
-export declare function coverageStopCSSWithTimeout(page: any): Promise<unknown>;
+export declare function coverageStopJSWithTimeout(page: CoveragePage): Promise<unknown>;
+export declare function coverageStopCSSWithTimeout(page: CoveragePage): Promise<unknown>;
 export {};

package/dist/src/modules/collector/PageController.js

@@ -313,10 +313,7 @@ async function checkPageCDPHealth(page, timeoutMs = 500) {
         throw new Error('cdp_unreachable');
     });
     try {
-        const cdp = await Promise.race([
-            page.createCDPSession(),
-            timer,
-        ]);
+        const cdp = await Promise.race([page.createCDPSession(), timer]);
         await Promise.race([
             cdp.send('Runtime.evaluate', { expression: '1', returnByValue: true }),
             timer,
@@ -326,7 +323,7 @@ async function checkPageCDPHealth(page, timeoutMs = 500) {
         const msg = err instanceof Error ? err.message : String(err);
         if (msg === 'cdp_unreachable') {
             throw new Error('CDP session unresponsive — the debugger may be blocking page evaluation. ' +
-                'Call debugger_disable() before this tool, or run it before debugger_enable().');
+                'Call debugger_disable() before this tool, or run it before debugger_enable().', { cause: err });
         }
         throw err;
     }

package/dist/src/modules/collector/PageScriptCollectors.js

@@ -28,7 +28,7 @@ export async function setupWebWorkerTracking(page) {
     });
 }
 export async function collectInlineScripts(page, maxSingleSize, maxFilesPerCollect) {
-    const scripts = await page.evaluate((maxSingleSize) => {
+    const scripts = await page.evaluate((limit) => {
         const scriptElements = Array.from(document.querySelectorAll('script'));
         return scriptElements
             .filter((script) => !script.src && script.textContent)
@@ -36,8 +36,8 @@ export async function collectInlineScripts(page, maxSingleSize, maxFilesPerColle
             let content = script.textContent || '';
             const originalSize = content.length;
             let truncated = false;
-            if (content.length > maxSingleSize) {
-                content = content.substring(0, maxSingleSize);
+            if (content.length > limit) {
+                content = content.substring(0, limit);
                 truncated = true;
             }
             return {

package/dist/src/modules/crypto/CryptoDetector.d.ts

@@ -1,5 +1,4 @@
 import type { DetectCryptoOptions, DetectCryptoResult } from '../../types/index.js';
-import { type LLMService } from '../../services/LLMService.js';
 import { CryptoRulesManager } from '../crypto/CryptoRules.js';
 export interface SecurityIssue {
     severity: 'critical' | 'high' | 'medium' | 'low';
@@ -22,9 +21,8 @@ export interface CryptoStrength {
     };
 }
 export declare class CryptoDetector {
-    private llm;
     private rulesManager;
-    constructor(llm: LLMService, customRules?: CryptoRulesManager);
+    constructor(_llm?: any, customRules?: CryptoRulesManager);
     loadCustomRules(json: string): void;
     exportRules(): string;
     detect(options: DetectCryptoOptions): Promise<DetectCryptoResult & {
@@ -33,7 +31,6 @@ export declare class CryptoDetector {
     }>;
     private detectByKeywords;
     private escapeRegex;
-    private detectByAI;
     private detectLibraries;
     private detectByAST;
     private mergeParameters;

package/dist/src/modules/crypto/CryptoDetector.js

@@ -1,16 +1,11 @@
 import * as parser from '@babel/parser';
 import traverse from '@babel/traverse';
 import * as t from '@babel/types';
-import {} from '../../services/LLMService.js';
-import { generateCryptoDetectionPrompt } from '../../services/prompts/crypto.js';
 import { logger } from '../../utils/logger.js';
-import { CRYPTO_DETECT_LLM_MAX_TOKENS } from '../../constants.js';
 import { CryptoRulesManager } from '../crypto/CryptoRules.js';
 export class CryptoDetector {
-    llm;
     rulesManager;
-    constructor(llm, customRules) {
-        this.llm = llm;
+    constructor(_llm, customRules) {
         this.rulesManager = customRules || new CryptoRulesManager();
     }
     loadCustomRules(json) {
@@ -36,11 +31,6 @@ export class CryptoDetector {
             if (astResults.parameters) {
                 this.mergeParameters(algorithms, astResults.parameters);
             }
-            const useAI = options.useAI !== false;
-            if (useAI) {
-                const aiResults = await this.detectByAI(code);
-                algorithms.push(...aiResults);
-            }
             const mergedAlgorithms = this.mergeResults(algorithms);
             const securityResults = this.evaluateSecurity(mergedAlgorithms, code);
             securityIssues.push(...securityResults);
@@ -82,36 +72,6 @@ export class CryptoDetector {
     escapeRegex(str) {
         return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }
-    async detectByAI(code) {
-        try {
-            const messages = generateCryptoDetectionPrompt(code);
-            const response = await this.llm.chat(messages, {
-                temperature: 0.2,
-                maxTokens: CRYPTO_DETECT_LLM_MAX_TOKENS,
-            });
-            const jsonMatch = response.content.match(/\{[\s\S]*\}/);
-            if (!jsonMatch)
-                return [];
-            const result = JSON.parse(jsonMatch[0]);
-            if (!Array.isArray(result.algorithms))
-                return [];
-            return result.algorithms.map((algo) => {
-                const a = algo;
-                return {
-                    name: a.name || 'Unknown',
-                    type: a.type || 'other',
-                    confidence: a.confidence || 0.5,
-                    location: { file: 'current', line: 0 },
-                    parameters: a.parameters,
-                    usage: a.usage || '',
-                };
-            });
-        }
-        catch (error) {
-            logger.warn('AI crypto detection failed', error);
-            return [];
-        }
-    }
     detectLibraries(code) {
         const libraries = [];
         const libraryRules = this.rulesManager.getLibraryRules();
@@ -308,7 +268,7 @@ export class CryptoDetector {
                 merged.set(key, algo);
             }
         });
-        return Array.from(merged.values()).sort((a, b) => b.confidence - a.confidence);
+        return Array.from(merged.values()).toSorted((a, b) => b.confidence - a.confidence);
     }
     findLineNumber(code, keyword) {
         const lines = code.split('\n');

package/dist/src/modules/crypto/CryptoRules.js

@@ -288,7 +288,7 @@ export class CryptoRulesManager {
             }
         }
         catch (error) {
-            throw new Error(`Failed to load rules from JSON: ${error}`);
+            throw new Error(`Failed to load rules from JSON: ${error}`, { cause: error });
         }
     }
     exportToJSON() {

package/dist/src/modules/debugger/BlackboxManager.js

@@ -31,7 +31,7 @@ export class BlackboxManager {
             return escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
         }
         try {
-            new RegExp(input);
+            void new RegExp(input);
             return input;
         }
         catch {

package/dist/src/modules/debugger/DebuggerManager.impl.core.scope.js

@@ -138,7 +138,7 @@ export async function getObjectPropertiesByIdCore(ctx, objectId) {
         const message = toErrorMessage(error);
         if (message.includes('Could not find object with given id') ||
             message.includes('Invalid remote object id')) {
-            throw new Error('Object handle is expired or invalid. Pause execution again and reacquire objectId from get_scope_variables_enhanced.');
+            throw new Error('Object handle is expired or invalid. Pause execution again and reacquire objectId from get_scope_variables_enhanced.', { cause: error });
         }
         throw error;
     }

package/dist/src/modules/debugger/ScriptManager.impl.extract-function-tree.js

@@ -38,7 +38,7 @@ export async function extractFunctionTreeCore(ctx, scriptId, functionName, optio
         t = await import('@babel/types');
     }
     catch (error) {
-        throw new Error(`Failed to load Babel dependencies. Please install: npm install @babel/parser @babel/traverse @babel/generator @babel/types\nError: ${getErrorMessage(error)}`);
+        throw new Error(`Failed to load Babel dependencies. Please install: npm install @babel/parser @babel/traverse @babel/generator @babel/types\nError: ${getErrorMessage(error)}`, { cause: error });
     }
     let ast;
     try {
@@ -48,7 +48,9 @@ export async function extractFunctionTreeCore(ctx, scriptId, functionName, optio
         });
     }
     catch (error) {
-        throw new Error(`Failed to parse script ${scriptId}: ${getErrorMessage(error)}`);
+        throw new Error(`Failed to parse script ${scriptId}: ${getErrorMessage(error)}`, {
+            cause: error,
+        });
     }
     const allFunctions = new Map();
     const callGraph = {};

package/dist/src/modules/debugger/WatchExpressionManager.js

@@ -101,7 +101,7 @@ export class WatchExpressionManager {
     deepEqual(a, b) {
         if (a === b)
             return true;
-        if (a == null || b == null)
+        if (a === null || a === undefined || b === null || b === undefined)
             return false;
         if (!this.isRecord(a) || !this.isRecord(b))
             return false;

package/dist/src/modules/deobfuscator/AdvancedDeobfuscator.d.ts

@@ -20,6 +20,7 @@ export interface AdvancedDeobfuscateResult {
     detectedTechniques: string[];
     confidence: number;
     warnings: string[];
+    cached?: boolean;
     astOptimized?: boolean;
     bundle?: DeobfuscateBundleSummary;
     savedTo?: string;
@@ -33,6 +34,10 @@ export interface AdvancedDeobfuscateResult {
     };
 }
 export declare class AdvancedDeobfuscator {
+    private resultCache;
+    private maxCacheSize;
+    private generateCacheKey;
     deobfuscate(options: AdvancedDeobfuscateOptions): Promise<AdvancedDeobfuscateResult>;
+    private storeCacheEntry;
     private calculateConfidence;
 }

package/dist/src/modules/deobfuscator/AdvancedDeobfuscator.js

@@ -1,8 +1,36 @@
 import { logger } from '../../utils/logger.js';
 import { runWebcrack } from '../deobfuscator/webcrack.js';
 import { detectObfuscationType as detectObfuscationTypeUtil } from '../deobfuscator/Deobfuscator.utils.js';
+import crypto from 'crypto';
 export class AdvancedDeobfuscator {
+    resultCache = new Map();
+    maxCacheSize = 100;
+    generateCacheKey(options) {
+        const key = JSON.stringify({
+            aggressiveVM: options.aggressiveVM,
+            code: options.code.substring(0, 2000),
+            detectOnly: options.detectOnly,
+            forceOutput: options.forceOutput,
+            includeModuleCode: options.includeModuleCode,
+            jsx: options.jsx,
+            mangle: options.mangle,
+            mappings: options.mappings,
+            maxBundleModules: options.maxBundleModules,
+            outputDir: options.outputDir,
+            timeout: options.timeout,
+            unpack: options.unpack,
+            unminify: options.unminify,
+            useASTOptimization: options.useASTOptimization,
+        });
+        return crypto.createHash('md5').update(key).digest('hex');
+    }
     async deobfuscate(options) {
+        const cacheKey = this.generateCacheKey(options);
+        const cached = this.resultCache.get(cacheKey);
+        if (cached) {
+            logger.debug('Advanced deobfuscation result from cache');
+            return { ...cached, cached: true };
+        }
         logger.info('Starting advanced webcrack deobfuscation...');
         const detectedTechniques = detectObfuscationTypeUtil(options.code);
         const warnings = [];
@@ -16,7 +44,7 @@ export class AdvancedDeobfuscator {
             warnings.push('timeout is currently ignored; webcrack controls its own execution flow.');
         }
         if (options.detectOnly) {
-            return {
+            const result = {
                 code: options.code,
                 detectedTechniques,
                 confidence: Math.min(0.6 + detectedTechniques.length * 0.05, 0.9),
@@ -28,6 +56,8 @@ export class AdvancedDeobfuscator {
                 engine: 'webcrack',
                 webcrackApplied: false,
             };
+            this.storeCacheEntry(cacheKey, result);
+            return { ...result, cached: false };
         }
         const webcrackResult = await runWebcrack(options.code, {
             unpack: options.unpack,
@@ -58,7 +88,7 @@ export class AdvancedDeobfuscator {
             detectedTechniques.push('mangle');
         }
         detectedTechniques.push('webcrack');
-        return {
+        const result = {
             code: webcrackResult.code,
             detectedTechniques: Array.from(new Set(detectedTechniques)),
             confidence: this.calculateConfidence(webcrackResult, detectedTechniques),
@@ -70,6 +100,17 @@ export class AdvancedDeobfuscator {
             engine: 'webcrack',
             webcrackApplied: true,
         };
+        this.storeCacheEntry(cacheKey, result);
+        return { ...result, cached: false };
+    }
+    storeCacheEntry(cacheKey, result) {
+        if (this.resultCache.size >= this.maxCacheSize) {
+            const firstKey = this.resultCache.keys().next().value;
+            if (firstKey) {
+                this.resultCache.delete(firstKey);
+            }
+        }
+        this.resultCache.set(cacheKey, result);
     }
     calculateConfidence(webcrackResult, detectedTechniques) {
         let confidence = 0.72 + detectedTechniques.length * 0.03;

package/dist/src/modules/deobfuscator/Deobfuscator.d.ts

@@ -1,15 +1,12 @@
 import type { DeobfuscateOptions, DeobfuscateResult } from '../../types/index.js';
-import { type LLMService } from '../../services/LLMService.js';
 export declare class Deobfuscator {
-    private llm?;
     private resultCache;
     private maxCacheSize;
-    constructor(llm?: LLMService);
+    constructor(legacyDependency?: unknown);
     private generateCacheKey;
     deobfuscate(options: DeobfuscateOptions): Promise<DeobfuscateResult>;
     private detectObfuscationType;
     private calculateReadabilityScore;
     private calculateConfidence;
     private buildAnalysis;
-    private llmAnalysis;
 }

package/dist/src/modules/deobfuscator/Deobfuscator.js

@@ -1,28 +1,27 @@
 import crypto from 'crypto';
 import { logger } from '../../utils/logger.js';
-import { DEOBF_LLM_MAX_TOKENS } from '../../constants.js';
-import {} from '../../services/LLMService.js';
-import { generateDeobfuscationPrompt } from '../../services/prompts/deobfuscation.js';
 import { calculateReadabilityScore as calculateReadabilityScoreUtil, detectObfuscationType as detectObfuscationTypeUtil, } from '../deobfuscator/Deobfuscator.utils.js';
 import { runWebcrack } from '../deobfuscator/webcrack.js';
 export class Deobfuscator {
-    llm;
     resultCache = new Map();
     maxCacheSize = 100;
-    constructor(llm) {
-        this.llm = llm;
+    constructor(legacyDependency) {
+        void legacyDependency;
     }
     generateCacheKey(options) {
         const key = JSON.stringify({
+            aggressive: options.aggressive,
             code: options.code.substring(0, 2000),
             forceOutput: options.forceOutput,
             includeModuleCode: options.includeModuleCode,
+            inlineFunctions: options.inlineFunctions,
             jsx: options.jsx,
-            llm: options.llm,
+            llm: false,
             mangle: options.mangle ?? options.renameVariables,
             mappings: options.mappings,
             maxBundleModules: options.maxBundleModules,
             outputDir: options.outputDir,
+            preserveLogic: options.preserveLogic,
             unpack: options.unpack,
             unminify: options.unminify,
         });
@@ -33,6 +32,7 @@ export class Deobfuscator {
         const cached = this.resultCache.get(cacheKey);
         if (cached) {
             logger.debug('Deobfuscation result from cache');
+            cached.cached = true;
             return cached;
         }
         logger.info('Starting webcrack deobfuscation...');
@@ -64,13 +64,7 @@ export class Deobfuscator {
             logger.error(`webcrack deobfuscation failed: ${reason}`);
             throw new Error(reason);
         }
-        let analysis = this.buildAnalysis(webcrackResult, obfuscationType);
-        if (this.llm && options.llm) {
-            const llmResult = await this.llmAnalysis(webcrackResult.code);
-            if (llmResult) {
-                analysis = llmResult;
-            }
-        }
+        const analysis = this.buildAnalysis(webcrackResult, obfuscationType);
         const transformations = [
             {
                 type: 'webcrack',
@@ -95,15 +89,6 @@ export class Deobfuscator {
                     },
                 ]
                 : []),
-            ...(this.llm && options.llm
-                ? [
-                    {
-                        type: 'llm-analysis',
-                        description: 'AI-assisted analysis completed after webcrack deobfuscation',
-                        success: true,
-                    },
-                ]
-                : []),
         ];
         const readabilityScore = this.calculateReadabilityScore(webcrackResult.code);
         const confidence = this.calculateConfidence(webcrackResult, readabilityScore);
@@ -129,6 +114,7 @@ export class Deobfuscator {
                 this.resultCache.delete(firstKey);
             }
         }
+        result.cached = false;
         this.resultCache.set(cacheKey, result);
         return result;
     }
@@ -161,20 +147,4 @@ export class Deobfuscator {
         }
         return parts.join(' ');
     }
-    async llmAnalysis(code) {
-        if (!this.llm)
-            return null;
-        try {
-            const messages = generateDeobfuscationPrompt(code);
-            const response = await this.llm.chat(messages, {
-                temperature: 0.3,
-                maxTokens: DEOBF_LLM_MAX_TOKENS,
-            });
-            return response.content;
-        }
-        catch (error) {
-            logger.warn('LLM analysis failed after webcrack deobfuscation', error);
-            return null;
-        }
-    }
 }

package/dist/src/modules/deobfuscator/JSVMPDeobfuscator.d.ts

@@ -1,9 +1,6 @@
 import type { JSVMPDeobfuscatorOptions, JSVMPDeobfuscatorResult } from '../../types/index.js';
-import type { LLMService } from '../../services/LLMService.js';
 export declare class JSVMPDeobfuscator {
-    private llm?;
     private readonly sandbox;
-    constructor(llm?: LLMService);
     deobfuscate(options: JSVMPDeobfuscatorOptions): Promise<JSVMPDeobfuscatorResult>;
     private detectJSVMP;
     private detectJSVMPWithRegex;