@jshookmcp/jshook 0.2.5 → 0.2.7

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

@@ -1,179 +0,0 @@
-import { readdir, rm, stat } from 'node:fs/promises';
-import path from 'node:path';
-import vm from 'node:vm';
-import { logger } from '../../utils/logger.js';
-const DEFAULT_OPTIONS = {
-    jsx: true,
-    mangle: false,
-    unminify: true,
-    unpack: true,
-};
-const MAX_BUNDLE_MODULES = 100;
-function normalizeOptions(options) {
-    return {
-        jsx: options.jsx ?? DEFAULT_OPTIONS.jsx,
-        mangle: options.mangle ?? DEFAULT_OPTIONS.mangle,
-        unminify: options.unminify ?? DEFAULT_OPTIONS.unminify,
-        unpack: options.unpack ?? DEFAULT_OPTIONS.unpack,
-    };
-}
-function isSupportedNodeVersion() {
-    const major = Number.parseInt(process.versions.node.split('.')[0] ?? '0', 10);
-    return Number.isFinite(major) && major >= 22;
-}
-function matchesRule(module, rule) {
-    const target = rule.target === 'path' ? module.path : module.code;
-    const matchType = rule.matchType ?? 'includes';
-    if (matchType === 'exact') {
-        return target === rule.pattern;
-    }
-    if (matchType === 'regex') {
-        try {
-            return new RegExp(rule.pattern, 'm').test(target);
-        }
-        catch {
-            return false;
-        }
-    }
-    return target.includes(rule.pattern);
-}
-function applyBundleMappings(bundle, mappings) {
-    const remapped = new Map();
-    if (!mappings || mappings.length === 0) {
-        return remapped;
-    }
-    for (const module of bundle.modules.values()) {
-        for (const rule of mappings) {
-            if (!rule.path || !rule.pattern) {
-                continue;
-            }
-            if (matchesRule(module, rule)) {
-                if (module.path !== rule.path) {
-                    remapped.set(module.id, { fromPath: module.path });
-                    module.path = rule.path;
-                }
-                break;
-            }
-        }
-    }
-    return remapped;
-}
-function summarizeBundle(bundle, options, remapped) {
-    const maxBundleModules = options.maxBundleModules ?? MAX_BUNDLE_MODULES;
-    const modules = Array.from(bundle.modules.values())
-        .toSorted((left, right) => {
-        if (left.isEntry !== right.isEntry) {
-            return left.isEntry ? -1 : 1;
-        }
-        return left.path.localeCompare(right.path);
-    })
-        .slice(0, maxBundleModules)
-        .map((module) => ({
-        id: module.id,
-        path: module.path,
-        isEntry: module.isEntry,
-        size: module.code.length,
-        code: options.includeModuleCode ? module.code : undefined,
-        mappedPathFrom: remapped.get(module.id)?.fromPath,
-    }));
-    return {
-        type: bundle.type,
-        entryId: bundle.entryId,
-        moduleCount: bundle.modules.size,
-        truncated: bundle.modules.size > maxBundleModules,
-        mappingsApplied: remapped.size,
-        modules,
-    };
-}
-async function collectSavedArtifacts(rootDir, currentDir = rootDir) {
-    const entries = await readdir(currentDir, { withFileTypes: true });
-    const artifacts = [];
-    for (const entry of entries) {
-        const fullPath = path.join(currentDir, entry.name);
-        if (entry.isDirectory()) {
-            artifacts.push(...(await collectSavedArtifacts(rootDir, fullPath)));
-            continue;
-        }
-        if (!entry.isFile()) {
-            continue;
-        }
-        const metadata = await stat(fullPath);
-        artifacts.push({
-            path: path.relative(rootDir, fullPath).replace(/\\/g, '/'),
-            size: metadata.size,
-            type: 'file',
-        });
-    }
-    return artifacts.toSorted((left, right) => left.path.localeCompare(right.path));
-}
-export async function runWebcrack(code, options) {
-    const optionsUsed = normalizeOptions(options);
-    if (!isSupportedNodeVersion()) {
-        const reason = `webcrack requires Node.js 22+; current runtime is ${process.versions.node}`;
-        logger.warn(reason);
-        return {
-            applied: false,
-            code,
-            optionsUsed,
-            reason,
-        };
-    }
-    let sandboxOption;
-    try {
-        await import('isolated-vm');
-    }
-    catch {
-        logger.warn('isolated-vm is unavailable (likely Node 24 incompatibility). Falling back to native node:vm for deobfuscation sandbox.');
-        sandboxOption = async (evalCode) => {
-            const context = vm.createContext(Object.create(null));
-            return vm.runInContext(evalCode, context, { timeout: 8000 });
-        };
-    }
-    try {
-        const { webcrack } = (await import('webcrack'));
-        const result = await webcrack(code, {
-            jsx: optionsUsed.jsx,
-            unpack: optionsUsed.unpack,
-            deobfuscate: true,
-            unminify: optionsUsed.unminify,
-            mangle: optionsUsed.mangle,
-            ...(sandboxOption ? { sandbox: sandboxOption } : {}),
-        });
-        const remapped = result.bundle
-            ? applyBundleMappings(result.bundle, options.mappings)
-            : new Map();
-        let savedTo;
-        let savedArtifacts;
-        if (typeof options.outputDir === 'string' && options.outputDir.trim().length > 0) {
-            savedTo = path.resolve(options.outputDir);
-            if (options.forceOutput) {
-                await rm(savedTo, { recursive: true, force: true });
-            }
-            await result.save(savedTo);
-            savedArtifacts = await collectSavedArtifacts(savedTo);
-        }
-        return {
-            applied: true,
-            code: result.code,
-            bundle: result.bundle
-                ? summarizeBundle(result.bundle, {
-                    includeModuleCode: options.includeModuleCode,
-                    maxBundleModules: options.maxBundleModules,
-                }, remapped)
-                : undefined,
-            savedTo,
-            savedArtifacts,
-            optionsUsed,
-        };
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        logger.warn('webcrack execution failed, falling back to legacy pipeline', error);
-        return {
-            applied: false,
-            code,
-            optionsUsed,
-            reason,
-        };
-    }
-}

package/dist/src/modules/detector/ObfuscationDetector.d.ts

@@ -1,40 +0,0 @@
-import type { ObfuscationType, VMFeatures } from '../../types/index.js';
-export interface DetectionResult {
-    types: ObfuscationType[];
-    confidence: Record<ObfuscationType, number>;
-    features: string[];
-    recommendations: string[];
-    toolRecommendations: Array<{
-        tool: string;
-        reason: string;
-        suggestedArgs?: Record<string, unknown>;
-    }>;
-    vmFeatures?: VMFeatures;
-}
-export declare class ObfuscationDetector {
-    private jsvmpDetector;
-    constructor();
-    detect(code: string): DetectionResult;
-    private buildToolRecommendations;
-    private detectVMProtectionDetailed;
-    private detectJavaScriptObfuscator;
-    private detectWebpack;
-    private detectUglify;
-    private detectVMProtection;
-    private detectInvisibleUnicode;
-    private detectControlFlowFlattening;
-    private detectStringArrayRotation;
-    private detectDeadCodeInjection;
-    private detectOpaquePredicates;
-    private detectJSFuck;
-    private detectAAEncode;
-    private detectJJEncode;
-    private detectPacker;
-    private detectEvalObfuscation;
-    private detectBase64Encoding;
-    private detectHexEncoding;
-    private detectSelfModifying;
-    private detectJScrambler;
-    private detectURLEncode;
-    generateReport(result: DetectionResult): string;
-}

package/dist/src/modules/detector/ObfuscationDetector.js

@@ -1,329 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { JSVMPDeobfuscator } from '../deobfuscator/JSVMPDeobfuscator.js';
-export class ObfuscationDetector {
-    jsvmpDetector;
-    constructor() {
-        this.jsvmpDetector = new JSVMPDeobfuscator();
-    }
-    detect(code) {
-        const types = [];
-        const confidence = {};
-        const features = [];
-        const recommendations = [];
-        let vmFeatures;
-        if (this.detectJavaScriptObfuscator(code)) {
-            types.push('javascript-obfuscator');
-            confidence['javascript-obfuscator'] = 0.9;
-            features.push('String array with rotation');
-            features.push('Control flow flattening');
-            recommendations.push('Use deobfuscate/advanced_deobfuscate with webcrack enabled');
-        }
-        if (this.detectWebpack(code)) {
-            types.push('webpack');
-            confidence['webpack'] = 0.85;
-            features.push('__webpack_require__');
-            recommendations.push('Use deobfuscate/advanced_deobfuscate with unpack=true to recover modules');
-        }
-        if (this.detectUglify(code)) {
-            types.push('uglify');
-            confidence['uglify'] = 0.7;
-            features.push('Minified variable names');
-            recommendations.push('Use prettier or beautifier');
-        }
-        const vmDetectionResult = this.detectVMProtectionDetailed(code);
-        if (vmDetectionResult) {
-            types.push('vm-protection');
-            confidence['vm-protection'] = 0.95;
-            vmFeatures = vmDetectionResult;
-            features.push(`JSVMP with ${vmDetectionResult.instructionCount} instructions`);
-            features.push(`Complexity: ${vmDetectionResult.complexity}`);
-            recommendations.push('Use JSVMPDeobfuscator for advanced deobfuscation');
-        }
-        if (this.detectInvisibleUnicode(code)) {
-            types.push('invisible-unicode');
-            confidence['invisible-unicode'] = 1.0;
-            features.push('Zero-width characters');
-            recommendations.push('Use AdvancedDeobfuscator.decodeInvisibleUnicode()');
-        }
-        if (this.detectControlFlowFlattening(code)) {
-            types.push('control-flow-flattening');
-            confidence['control-flow-flattening'] = 0.8;
-            features.push('Switch-case state machine');
-            recommendations.push('Requires symbolic execution');
-        }
-        if (this.detectStringArrayRotation(code)) {
-            types.push('string-array-rotation');
-            confidence['string-array-rotation'] = 0.85;
-            features.push('Rotated string array');
-            recommendations.push('Extract and derotate string array');
-        }
-        if (this.detectDeadCodeInjection(code)) {
-            types.push('dead-code-injection');
-            confidence['dead-code-injection'] = 0.75;
-            features.push('Unreachable code blocks');
-            recommendations.push('Use AST-based dead code elimination');
-        }
-        if (this.detectOpaquePredicates(code)) {
-            types.push('opaque-predicates');
-            confidence['opaque-predicates'] = 0.7;
-            features.push('Always-true/false conditions');
-            recommendations.push('Use constant folding');
-        }
-        if (this.detectJSFuck(code)) {
-            types.push('jsfuck');
-            confidence['jsfuck'] = 1.0;
-            features.push('Only uses []()!+');
-            recommendations.push('Use jsfuck decoder');
-        }
-        if (this.detectAAEncode(code)) {
-            types.push('aaencode');
-            confidence['aaencode'] = 1.0;
-            features.push('Japanese emoticons');
-            recommendations.push('Use aaencode decoder');
-        }
-        if (this.detectJJEncode(code)) {
-            types.push('jjencode');
-            confidence['jjencode'] = 1.0;
-            features.push('$={___:++$');
-            recommendations.push('Use jjencode decoder');
-        }
-        if (this.detectPacker(code)) {
-            types.push('packer');
-            confidence['packer'] = 0.95;
-            features.push('eval(function(p,a,c,k,e,d)');
-            recommendations.push('Use unpacker tools');
-        }
-        if (this.detectEvalObfuscation(code)) {
-            types.push('eval-obfuscation');
-            confidence['eval-obfuscation'] = 0.8;
-            features.push('Multiple eval() calls');
-            recommendations.push('Hook eval() and log arguments');
-        }
-        if (this.detectBase64Encoding(code)) {
-            types.push('base64-encoding');
-            confidence['base64-encoding'] = 0.9;
-            features.push('atob() or Base64 strings');
-            recommendations.push('Decode Base64 strings');
-        }
-        if (this.detectHexEncoding(code)) {
-            types.push('hex-encoding');
-            confidence['hex-encoding'] = 0.85;
-            features.push('\\x hex sequences');
-            recommendations.push('Decode hex strings');
-        }
-        if (this.detectSelfModifying(code)) {
-            types.push('self-modifying');
-            confidence['self-modifying'] = 0.9;
-            features.push('Dynamic code generation');
-            recommendations.push('Requires runtime analysis');
-        }
-        if (this.detectJScrambler(code)) {
-            types.push('jscrambler');
-            confidence['jscrambler'] = 0.85;
-            features.push('Control flow flattening + Self-defending');
-            recommendations.push('Use JScrambler deobfuscator');
-        }
-        if (this.detectURLEncode(code)) {
-            types.push('urlencoded');
-            confidence['urlencoded'] = 0.95;
-            features.push('URL encoded strings');
-            recommendations.push('Decode URL encoding');
-        }
-        if (types.length === 0) {
-            types.push('unknown');
-            confidence['unknown'] = 0.5;
-            recommendations.push('Code may be clean or use custom obfuscation');
-        }
-        logger.info(`Detected obfuscation types: ${types.join(', ')}`);
-        return {
-            types,
-            confidence: confidence,
-            features,
-            recommendations,
-            toolRecommendations: this.buildToolRecommendations(types, code),
-            vmFeatures,
-        };
-    }
-    buildToolRecommendations(types, code) {
-        const recommendations = new Map();
-        const addRecommendation = (tool, reason, suggestedArgs) => {
-            if (!recommendations.has(tool)) {
-                recommendations.set(tool, { tool, reason, suggestedArgs });
-            }
-        };
-        if (types.includes('webpack') || types.includes('packer')) {
-            addRecommendation('webcrack_unpack', 'Bundle or wrapper markers detected; unpacking modules is likely the highest-value first step.', { code, unpack: true, unminify: true });
-        }
-        if (types.some((type) => [
-            'javascript-obfuscator',
-            'string-array-rotation',
-            'hex-encoding',
-            'base64-encoding',
-            'urlencoded',
-            'unknown',
-        ].includes(type))) {
-            addRecommendation('deobfuscate', 'Static cleanup is likely sufficient; start with the standard webcrack-backed deobfuscation path.', { code, unminify: true });
-        }
-        if (types.some((type) => [
-            'vm-protection',
-            'control-flow-flattening',
-            'dead-code-injection',
-            'opaque-predicates',
-            'invisible-unicode',
-            'jscrambler',
-            'jsfuck',
-            'aaencode',
-            'jjencode',
-        ].includes(type))) {
-            addRecommendation('advanced_deobfuscate', 'Complex protections detected; use the advanced webcrack-backed flow for deeper cleanup.', { code, detectOnly: false, unminify: true });
-        }
-        if (types.includes('eval-obfuscation') || types.includes('self-modifying')) {
-            addRecommendation('manage_hooks', 'Runtime-generated code is present; capture or hook execution points before static cleanup if analysis stalls.', { action: 'create', target: 'eval', type: 'function' });
-        }
-        if (recommendations.size === 0) {
-            addRecommendation('deobfuscate', 'No strong signature matched; start with the standard webcrack-backed path.', { code });
-        }
-        return Array.from(recommendations.values());
-    }
-    detectVMProtectionDetailed(code) {
-        try {
-            const detector = this.jsvmpDetector;
-            const result = detector.detectJSVMP(code);
-            return result;
-        }
-        catch (error) {
-            logger.warn('VM Protection detection failed', error);
-            if (this.detectVMProtection(code)) {
-                return {
-                    instructionCount: 0,
-                    interpreterLocation: 'Unknown',
-                    complexity: 'medium',
-                    hasSwitch: true,
-                    hasInstructionArray: false,
-                    hasProgramCounter: false,
-                };
-            }
-            return null;
-        }
-    }
-    detectJavaScriptObfuscator(code) {
-        const patterns = [
-            /_0x[a-f0-9]{4,6}/i,
-            /var\s+_0x[a-f0-9]+\s*=\s*\[/i,
-            /\(function\s*\(_0x[a-f0-9]+,\s*_0x[a-f0-9]+\)/i,
-            /while\s*\(!!\[\]\)/i,
-        ];
-        return patterns.filter((p) => p.test(code)).length >= 2;
-    }
-    detectWebpack(code) {
-        return (code.includes('__webpack_require__') ||
-            code.includes('webpackJsonp') ||
-            /\/\*\*\*\*\*\*\/\s*\(/m.test(code));
-    }
-    detectUglify(code) {
-        const singleLetterVars = code.match(/\b[a-z]\b/g);
-        return (singleLetterVars?.length || 0) > 50;
-    }
-    detectVMProtection(code) {
-        const vmPatterns = [
-            /while\s*\(\s*true\s*\)\s*\{[\s\S]*?switch\s*\(/i,
-            /var\s+\w+\s*=\s*\[\s*\d+(?:\s*,\s*\d+){10,}\s*\]/i,
-            /\w+\[pc\+\+\]/i,
-            /stack\.push|stack\.pop/i,
-        ];
-        return vmPatterns.filter((p) => p.test(code)).length >= 2;
-    }
-    detectInvisibleUnicode(code) {
-        const invisibleChars = ['\u200B', '\u200C', '\u200D', '\u2060', '\uFEFF'];
-        return invisibleChars.some((char) => code.includes(char));
-    }
-    detectControlFlowFlattening(code) {
-        return /while\s*\(\s*!!\s*\[\s*\]\s*\)\s*\{[\s\S]*?switch\s*\(/i.test(code);
-    }
-    detectStringArrayRotation(code) {
-        return (/var\s+\w+\s*=\s*\[.*?\];[\s\S]*?\(\s*function\s*\(\s*\w+,\s*\w+\s*\)/i.test(code) &&
-            /\w+\s*=\s*\w+\s*\+\s*0x[0-9a-f]+/i.test(code));
-    }
-    detectDeadCodeInjection(code) {
-        return (/if\s*\(\s*false\s*\)\s*\{/i.test(code) || /if\s*\(\s*!!\s*\[\s*\]\s*\)\s*\{/i.test(code));
-    }
-    detectOpaquePredicates(code) {
-        return /if\s*\(\s*\d+\s*[<>!=]+\s*\d+\s*\)/i.test(code);
-    }
-    detectJSFuck(code) {
-        const jsfuckChars = /^[[\]()!+\s]+$/;
-        return jsfuckChars.test(code.substring(0, 1000));
-    }
-    detectAAEncode(code) {
-        return /゚ω゚|ﾟωﾟ/.test(code);
-    }
-    detectJJEncode(code) {
-        return /\$=\{___:\+\+\$/.test(code);
-    }
-    detectPacker(code) {
-        return /eval\s*\(\s*function\s*\(\s*p\s*,\s*a\s*,\s*c\s*,\s*k\s*,\s*e\s*,\s*d\s*\)/i.test(code);
-    }
-    detectEvalObfuscation(code) {
-        const evalCount = (code.match(/\beval\s*\(/g) || []).length;
-        return evalCount >= 3;
-    }
-    detectBase64Encoding(code) {
-        return code.includes('atob(') || /[A-Za-z0-9+/]{50,}={0,2}/.test(code);
-    }
-    detectHexEncoding(code) {
-        const hexCount = (code.match(/\\x[0-9a-f]{2}/gi) || []).length;
-        return hexCount > 20;
-    }
-    detectSelfModifying(code) {
-        return (code.includes('Function(') ||
-            code.includes('new Function') ||
-            /eval\s*\(\s*[^)]*\+/.test(code));
-    }
-    detectJScrambler(code) {
-        let score = 0;
-        if (/while\s*\(\s*!!\s*\[\s*\]\s*\)/.test(code) ||
-            /while\s*\(\s*true\s*\)\s*{[\s\S]*?switch/.test(code)) {
-            score += 3;
-        }
-        if (code.includes('debugger') && code.includes('constructor')) {
-            score += 2;
-        }
-        if (/function\s+\w+\s*\([^)]*\)\s*{[\s\S]*?charCodeAt[\s\S]*?fromCharCode/.test(code)) {
-            score += 2;
-        }
-        if (code.includes('Function.prototype.toString') || code.includes('.toString.call')) {
-            score += 1;
-        }
-        return score >= 3;
-    }
-    detectURLEncode(code) {
-        const percentMatches = code.match(/%[0-9A-Fa-f]{2}/g);
-        return (percentMatches?.length || 0) > 10;
-    }
-    generateReport(result) {
-        let report = '=== Obfuscation Detection Report ===\n\n';
-        report += `Detected Types (${result.types.length}):\n`;
-        result.types.forEach((type) => {
-            const conf = result.confidence[type] || 0;
-            report += `  - ${type}: ${(conf * 100).toFixed(0)}% confidence\n`;
-        });
-        report += `\nFeatures:\n`;
-        result.features.forEach((feature) => {
-            report += `  - ${feature}\n`;
-        });
-        report += `\nRecommendations:\n`;
-        result.recommendations.forEach((rec) => {
-            report += `  - ${rec}\n`;
-        });
-        if (result.toolRecommendations.length > 0) {
-            report += `\nSuggested Tools:\n`;
-            result.toolRecommendations.forEach((item) => {
-                report += `  - ${item.tool}: ${item.reason}\n`;
-                if (item.suggestedArgs) {
-                    report += `    args: ${JSON.stringify(item.suggestedArgs)}\n`;
-                }
-            });
-        }
-        return report;
-    }
-}

package/dist/src/modules/emulator/AIEnvironmentAnalyzer.d.ts

@@ -1,27 +0,0 @@
-import type { DetectedEnvironmentVariables, MissingAPI } from '../../types/index.js';
-import type { BrowserType } from '../emulator/BrowserEnvironmentRules.js';
-export interface AIAnalysisResult {
-    recommendedVariables: Record<string, unknown>;
-    recommendedAPIs: Array<{
-        path: string;
-        implementation: string;
-        reason: string;
-    }>;
-    antiCrawlFeatures: Array<{
-        feature: string;
-        severity: 'low' | 'medium' | 'high' | 'critical';
-        description: string;
-        mitigation: string;
-    }>;
-    suggestions: string[];
-    confidence: number;
-}
-export declare class AIEnvironmentAnalyzer {
-    constructor(legacyDependency?: unknown);
-    analyze(_code: string, _detected: DetectedEnvironmentVariables, _missing: MissingAPI[], _browserType?: BrowserType): Promise<AIAnalysisResult>;
-    private getEmptyResult;
-    analyzeAntiCrawl(_code: string): Promise<AIAnalysisResult['antiCrawlFeatures']>;
-    inferAPIImplementation(_apiPath: string, _context: string): Promise<string | null>;
-    generateSuggestions(detected: DetectedEnvironmentVariables, missing: MissingAPI[], _browserType: BrowserType): Promise<string[]>;
-    private getDefaultSuggestions;
-}

package/dist/src/modules/emulator/AIEnvironmentAnalyzer.js

@@ -1,46 +0,0 @@
-export class AIEnvironmentAnalyzer {
-    constructor(legacyDependency) {
-        void legacyDependency;
-    }
-    async analyze(_code, _detected, _missing, _browserType = 'chrome') {
-        return this.getEmptyResult();
-    }
-    getEmptyResult() {
-        return {
-            recommendedVariables: {},
-            recommendedAPIs: [],
-            antiCrawlFeatures: [],
-            suggestions: [],
-            confidence: 0,
-        };
-    }
-    async analyzeAntiCrawl(_code) {
-        return [];
-    }
-    async inferAPIImplementation(_apiPath, _context) {
-        return null;
-    }
-    async generateSuggestions(detected, missing, _browserType) {
-        return this.getDefaultSuggestions(detected, missing);
-    }
-    getDefaultSuggestions(detected, missing) {
-        const suggestions = [];
-        const totalVars = Object.values(detected).flat().length;
-        if (totalVars > 50) {
-            suggestions.push('Enable environment emulation for better compatibility');
-        }
-        if (missing.length > 10) {
-            suggestions.push(`${missing.length} browser APIs missing, enable API emulation`);
-        }
-        if (detected.navigator.some((v) => v.includes('webdriver'))) {
-            suggestions.push('webdriver flag detected, set navigator.webdriver = false');
-        }
-        if (detected.navigator.some((v) => v.includes('plugins'))) {
-            suggestions.push('Empty plugins list detected, enable plugin emulation');
-        }
-        if (detected.window.some((v) => v.includes('chrome'))) {
-            suggestions.push('chrome property missing, inject window.chrome');
-        }
-        return suggestions;
-    }
-}

package/dist/src/modules/emulator/BrowserAPIDatabase.d.ts

@@ -1,33 +0,0 @@
-import type { BrowserType } from '../emulator/BrowserEnvironmentRules.js';
-export type APIType = 'property' | 'method' | 'constructor' | 'event';
-export interface APIDefinition {
-    name: string;
-    path: string;
-    type: APIType;
-    returnType?: string;
-    parameters?: Array<{
-        name: string;
-        type: string;
-        optional?: boolean;
-        defaultValue?: unknown;
-    }>;
-    implementation?: string | Function;
-    description?: string;
-    browsers?: BrowserType[];
-    minVersion?: Record<BrowserType, string>;
-    deprecated?: boolean;
-    replacement?: string;
-    antiCrawlImportance?: number;
-}
-export declare class BrowserAPIDatabase {
-    private apis;
-    constructor();
-    private initializeAPIs;
-    addAPI(api: APIDefinition): void;
-    getAPI(path: string): APIDefinition | undefined;
-    getAllAPIs(): APIDefinition[];
-    getAPIsByType(type: APIType): APIDefinition[];
-    searchAPIs(query: string): APIDefinition[];
-    exportToJSON(): string;
-    loadFromJSON(json: string): void;
-}