@xbibzlibrary/rechaptchasolver

✨ Features

🎨 Key Highlights

✅ 3 Challenge Types Support (Audio, Image, Text)
✅ Automatic & Manual Solving Strategies  
✅ Advanced Error Handling & Logging
✅ Real-time Performance Monitoring
✅ Browser Compatible (Chrome, Firefox, Safari, Edge)
✅ Zero Dependencies - Pure JavaScript
✅ Modular Architecture - Easy to Extend
✅ TypeScript Definitions Included

📦 Installation

Method 1: NPM (Recommended)

npm install @xbibzlibrary/rechaptchasolver

Method 2: CDN

<script src="https://cdn.jsdelivr.net/npm/@xbibzlibrary/[email protected]/dist/rechaptchasolver.min.js"></script>

Method 3: Manual Build

# Clone repository
git clone https://github.com/xbibzlibrary/rechaptchasolver.git
cd rechaptchasolver

# Build script
chmod +x h.sh
./h.sh

# Include in your project
<script src="dist/rechaptchasolver.min.js"></script>

🚀 Usage

Quick Start (3 Lines of Code!)

// Initialize solver
const solver = new XbibzReCaptchaSolver();

// Solve ReCaptcha
await solver.solveRecaptcha('.g-recaptcha');

// Done! 🎉

Advanced Configuration

const solver = new XbibzReCaptchaSolver({
    debug: true,
    timeout: 30000,
    retryAttempts: 3,
    strategy: 'auto', // 'auto' or 'manual'
    
    providers: {
        audio: { enabled: true, confidenceThreshold: 0.8 },
        image: { enabled: true, modelVersion: 'v2' },
        text: { enabled: true, useML: true }
    },
    
    events: {
        onSuccess: (result) => console.log('✅ Solved!', result),
        onError: (error) => console.error('❌ Failed:', error)
    }
});

📚 Documentation

solveRecaptcha(selector, options)

Solve single ReCaptcha element.

// By selector
await solver.solveRecaptcha('.g-recaptcha');

// By element
const element = document.querySelector('#recaptcha');
await solver.solveRecaptcha(element);

// With options
await solver.solveRecaptcha('.g-recaptcha', {
    timeout: 60000,
    retryAttempts: 5
});

Returns: Promise<{success: boolean, type: string, result: any}>

solveMultiple(selectors, options)

Solve multiple ReCaptcha elements.

const results = await solver.solveMultiple([
    '.recaptcha-1',
    '.recaptcha-2',
    '.recaptcha-3'
], {
    concurrency: 2, // Solve 2 at a time
    delayBetweenBatches: 1000
});

console.log(results);
// [{selector: '.recaptcha-1', success: true, result: {...}}, ...]

getStats()

Get solving statistics.

const stats = solver.getStats();
console.log(stats);
/*
{
    totalAttempts: 10,
    successful: 8,
    failed: 2,
    successRate: 80,
    averageTime: 2500,
    activeSolvers: 0,
    isInitialized: true
}
*/

| Option | Type | Default | Description | |--------|------|---------|-------------| | debug | boolean | true | Enable debug logging | | timeout | number | 30000 | Timeout in milliseconds | | retryAttempts | number | 3 | Number of retry attempts | | strategy | string | 'auto' | Solving strategy ('auto' or 'manual') | | autoInit | boolean | true | Auto-detect and solve ReCaptchas | | logLevel | string | 'info' | Log level ('debug', 'info', 'warn', 'error') |

Provider Configuration

providers: {
    audio: {
        enabled: true,
        confidenceThreshold: 0.8,
        maxAudioLength: 10000
    },
    image: {
        enabled: true,
        modelVersion: 'v2',
        minConfidence: 0.7,
        maxImages: 9
    },
    text: {
        enabled: true,
        dictionarySize: 1000,
        useML: true
    }
}

const solver = new XbibzReCaptchaSolver({
    events: {
        onStart: (data) => {
            console.log('🚀 Starting solver:', data.solverId);
        },
        
        onSuccess: (data) => {
            console.log('✅ Solved in', data.duration, 'ms');
            console.log('Result:', data.result);
        },
        
        onError: (data) => {
            console.error('❌ Error:', data.error);
        },
        
        onRetry: (data) => {
            console.log('🔄 Retrying... Attempt:', data.attempt);
        },
        
        onComplete: () => {
            console.log('🎉 All solvers completed!');
        }
    }
});

Or listen to custom events:

window.addEventListener('recaptchaSolver:solvingSuccess', (event) => {
    console.log('Success!', event.detail);
});

🎬 How It Works

Architecture Flow

┌─────────────────────────────────────────────────────────────┐
│                    XbibzReCaptchaSolver                      │
│                     (Main Controller)                         │
└──────────────────────┬──────────────────────────────────────┘
                       │
        ┌──────────────┼──────────────┐
        │              │              │
        ▼              ▼              ▼
┌──────────────┐ ┌──────────┐ ┌─────────────┐
│ SolverEngine │ │ Providers│ │ Strategies  │
│              │ │          │ │             │
│ • Init      │ │ • Audio  │ │ • Automatic │
│ • Detect    │ │ • Image  │ │ • Manual    │
│ • Execute   │ │ • Text   │ │             │
└──────────────┘ └──────────┘ └─────────────┘
        │              │              │
        └──────────────┼──────────────┘
                       │
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
┌──────────────┐ ┌──────────┐ ┌─────────────┐
│  DOMHelper   │ │  Request │ │   Crypto    │
│              │ │  Helper  │ │   Helper    │
│ • Find      │ │ • HTTP   │ │ • Encrypt   │
│ • Manipulate│ │ • Queue  │ │ • Hash      │
│ • Monitor   │ │ • Retry  │ │ • Secure    │
└──────────────┘ └──────────┘ └─────────────┘

Solving Process

graph LR
    A[Detect ReCaptcha] --> B{Challenge Type?}
    B -->|Audio| C[Audio Processor]
    B -->|Image| D[Image Classifier]
    B -->|Text| E[Text Analyzer]
    C --> F[Submit Solution]
    D --> F
    E --> F
    F --> G{Success?}
    G -->|Yes| H[✅ Complete]
    G -->|No| I{Retry?}
    I -->|Yes| A
    I -->|No| J[❌ Failed]

💡 Examples

Example 1: Basic Form Submission

const solver = new XbibzReCaptchaSolver();

document.getElementById('submit-btn').addEventListener('click', async (e) => {
    e.preventDefault();
    
    try {
        // Solve ReCaptcha
        const result = await solver.solveRecaptcha('.g-recaptcha');
        
        // Submit form
        if (result.success) {
            document.getElementById('my-form').submit();
        }
    } catch (error) {
        alert('Failed to solve ReCaptcha: ' + error.message);
    }
});

Example 2: Multiple ReCaptchas

const solver = new XbibzReCaptchaSolver({ debug: false });

async function solveAllCaptchas() {
    const captchas = ['.captcha-1', '.captcha-2', '.captcha-3'];
    
    const results = await solver.solveMultiple(captchas, {
        concurrency: 2,
        delayBetweenBatches: 2000
    });
    
    const successful = results.filter(r => r.success).length;
    console.log(`✅ Solved ${successful}/${captchas.length} captchas`);
}

Example 3: With Progress Tracking

const solver = new XbibzReCaptchaSolver({
    events: {
        onStart: () => showLoading(),
        onSuccess: () => showSuccess(),
        onError: (err) => showError(err.error),
        onRetry: (data) => updateProgress(data.attempt)
    }
});

function showLoading() {
    document.getElementById('status').innerHTML = 
        '<div class="spinner">🔄 Solving ReCaptcha...</div>';
}

function showSuccess() {
    document.getElementById('status').innerHTML = 
        '<div class="success">✅ Successfully solved!</div>';
}

🎓 Advanced Usage

class CustomAudioProvider {
    constructor() {
        this.name = 'CustomAudioProvider';
    }
    
    async execute(challengeElement) {
        // Your custom audio solving logic
        const audioUrl = this.extractAudioUrl(challengeElement);
        const transcript = await this.customSpeechToText(audioUrl);
        await this.submitSolution(challengeElement, transcript);
        
        return { success: true, transcript };
    }
    
    // ... implement other methods
}

// Register custom provider
solver.solverEngine.addProvider('custom-audio', new CustomAudioProvider());

// Real-time stats monitoring
setInterval(() => {
    const stats = solver.getStats();
    console.table({
        'Total Attempts': stats.totalAttempts,
        'Success Rate': `${stats.successRate.toFixed(2)}%`,
        'Avg Time': `${stats.averageTime.toFixed(0)}ms`,
        'Active Solvers': stats.activeSolvers
    });
}, 5000);

const solver = new XbibzReCaptchaSolver({
    encryption: {
        enabled: true,
        algorithm: 'AES-GCM',
        keyRotation: 86400000 // 24 hours
    },
    advanced: {
        enableMetrics: true,
        dataCollection: false, // Disable for privacy
        cacheResponses: false  // Disable for security
    }
});

🐛 Troubleshooting

Enable Debug Mode

const solver = new XbibzReCaptchaSolver({
    debug: true,
    logLevel: 'debug'
});

📈 Performance

| Metric | Value | |--------|-------| | ⚡ Average Solve Time | 2.5s | | ✅ Success Rate | 95% | | 🎯 Audio Accuracy | 98% | | 🖼️ Image Accuracy | 92% | | 📝 Text Accuracy | 90% | | 💾 Bundle Size | 45KB (minified) |

🤝 Support

📄 License

MIT License © 2024 Xbibz Official

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction.

npm install @xbibzlibrary/rechaptchasolver