@postalsys/email-text-tools 2.4.26 → 2.6.0

package/benchmark/concurrency-benchmark.js

@@ -1,176 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const mimeHtml = require('../lib/mime-html');
-
-async function concurrencyBenchmark() {
-    console.log('Concurrency Benchmark - Real-World HTML');
-    console.log('='.repeat(80));
-    console.log('Testing concurrent processing with problematic HTML\n');
-
-    // Load the real-world HTML
-    const realWorldHtml = fs.readFileSync(path.join(__dirname, '../examples/failing.html'), 'utf8');
-
-    console.log(`HTML size: ${(realWorldHtml.length / 1024).toFixed(1)} KB`);
-    console.log('Testing different concurrency levels...\n');
-
-    const concurrencyLevels = [1, 5, 10, 20, 50];
-    const totalRequests = 100;
-
-    const results = [];
-
-    for (const concurrency of concurrencyLevels) {
-        console.log(`Testing with concurrency level: ${concurrency}`);
-        console.log('-'.repeat(40));
-
-        // Test sync (sequential only)
-        if (concurrency === 1) {
-            console.log('  Sync version (sequential)...');
-            const syncStart = process.hrtime.bigint();
-            for (let i = 0; i < totalRequests; i++) {
-                mimeHtml.sync({ html: realWorldHtml });
-                if ((i + 1) % 20 === 0) {
-                    process.stdout.write(`    Progress: ${i + 1}/${totalRequests}\r`);
-                }
-            }
-            const syncEnd = process.hrtime.bigint();
-            const syncTime = Number(syncEnd - syncStart) / 1000000;
-            process.stdout.write(`    Progress: ${totalRequests}/${totalRequests} - Done!\n`);
-
-            results.push({
-                method: 'Sync (sequential)',
-                concurrency: 1,
-                totalRequests,
-                totalTime: syncTime.toFixed(2),
-                avgTime: (syncTime / totalRequests).toFixed(2),
-                reqPerSec: (totalRequests / (syncTime / 1000)).toFixed(0)
-            });
-        }
-
-        // Test async with pool
-        console.log('  Async with pool...');
-        const asyncPoolStart = process.hrtime.bigint();
-        const poolPromises = [];
-
-        for (let i = 0; i < totalRequests; i++) {
-            poolPromises.push(
-                mimeHtml.async(
-                    { html: realWorldHtml },
-                    {
-                        useWorkerPool: true,
-                        timeout: 5000,
-                        minWorkers: 2,
-                        maxWorkers: 4,
-                        logErrors: false
-                    }
-                )
-            );
-
-            // Control concurrency
-            if (poolPromises.length >= concurrency) {
-                await Promise.race(poolPromises).then(() => {
-                    const index = poolPromises.findIndex(
-                        p => p.constructor.name !== 'Promise' || Promise.race([p, Promise.resolve('done')]).then(v => v === 'done')
-                    );
-                    if (index > -1) poolPromises.splice(index, 1);
-                });
-            }
-
-            if ((i + 1) % 20 === 0) {
-                process.stdout.write(`    Progress: ${i + 1}/${totalRequests}\r`);
-            }
-        }
-
-        // Wait for remaining promises
-        await Promise.all(poolPromises);
-        const asyncPoolEnd = process.hrtime.bigint();
-        const asyncPoolTime = Number(asyncPoolEnd - asyncPoolStart) / 1000000;
-        process.stdout.write(`    Progress: ${totalRequests}/${totalRequests} - Done!\n`);
-
-        results.push({
-            method: 'Async (pool)',
-            concurrency,
-            totalRequests,
-            totalTime: asyncPoolTime.toFixed(2),
-            avgTime: (asyncPoolTime / totalRequests).toFixed(2),
-            reqPerSec: (totalRequests / (asyncPoolTime / 1000)).toFixed(0)
-        });
-
-        // Show worker pool stats at peak concurrency
-        if (concurrency === 20) {
-            const stats = mimeHtml.getWorkerPoolStats();
-            console.log(`    Worker pool stats: ${stats.totalWorkers} workers, ${stats.busyWorkers} busy`);
-        }
-
-        console.log();
-    }
-
-    // Display results table
-    console.log('='.repeat(80));
-    console.log('RESULTS');
-    console.log('='.repeat(80) + '\n');
-
-    console.table(
-        results.map(r => ({
-            Method: r.method,
-            Concurrency: r.concurrency,
-            'Total Time': `${r.totalTime}ms`,
-            'Avg per Request': `${r.avgTime}ms`,
-            Throughput: `${r.reqPerSec} req/s`
-        }))
-    );
-
-    // Analysis
-    console.log('Performance Analysis:');
-    console.log('-'.repeat(40));
-
-    const syncResult = results.find(r => r.method === 'Sync (sequential)');
-    const bestAsync = results.filter(r => r.method === 'Async (pool)').sort((a, b) => parseFloat(a.totalTime) - parseFloat(b.totalTime))[0];
-
-    if (syncResult && bestAsync) {
-        const speedup = (parseFloat(syncResult.totalTime) / parseFloat(bestAsync.totalTime)).toFixed(2);
-        console.log(`• Best async configuration: Concurrency ${bestAsync.concurrency}`);
-        console.log(`• Async is ${speedup}x faster than sync for batch processing`);
-        console.log(`• Sync throughput: ${syncResult.reqPerSec} req/s`);
-        console.log(`• Best async throughput: ${bestAsync.reqPerSec} req/s`);
-    }
-
-    // Throughput graph
-    console.log('\nThroughput by Concurrency Level:');
-    console.log('-'.repeat(40));
-
-    const asyncResults = results.filter(r => r.method === 'Async (pool)');
-    const maxThroughput = Math.max(...asyncResults.map(r => parseInt(r.reqPerSec, 10)));
-
-    asyncResults.forEach(r => {
-        const barLength = Math.round((parseInt(r.reqPerSec, 10) / maxThroughput) * 30);
-        const bar = '█'.repeat(barLength);
-        console.log(`  ${String(r.concurrency).padStart(2)}: ${bar} ${r.reqPerSec} req/s`);
-    });
-
-    // Memory usage
-    const memUsage = process.memoryUsage();
-    console.log('\nFinal Memory Usage:');
-    console.log('-'.repeat(40));
-    console.log(`• RSS: ${(memUsage.rss / 1024 / 1024).toFixed(1)} MB`);
-    console.log(`• Heap Used: ${(memUsage.heapUsed / 1024 / 1024).toFixed(1)} MB`);
-
-    // Cleanup
-    await mimeHtml.closeWorkerPool();
-
-    console.log('\n' + '='.repeat(80));
-    console.log('Summary:');
-    console.log('• Async with worker pool provides significant speedup for concurrent processing');
-    console.log('• Pre-filtering prevents timeouts even under high load');
-    console.log('• Worker pool efficiently handles concurrent requests');
-    console.log('• Optimal concurrency depends on CPU cores and workload');
-    console.log('='.repeat(80));
-}
-
-// Run benchmark
-concurrencyBenchmark().catch(err => {
-    console.error('Benchmark failed:', err);
-    process.exit(1);
-});

package/benchmark/quick-benchmark.js

@@ -1,200 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const mimeHtml = require('../lib/mime-html');
-
-// Quick performance comparison
-async function quickBenchmark() {
-    const testHtml = `
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <style>
-                body { font-family: Arial, sans-serif; }
-                .container { max-width: 600px; margin: 0 auto; padding: 20px; }
-                h1 { color: #333; }
-                p { line-height: 1.6; }
-                .button { background: #007bff; color: white; padding: 10px 20px; }
-            </style>
-        </head>
-        <body>
-            <div class="container">
-                <h1>Test Email</h1>
-                <p>This is a test email with moderate complexity.</p>
-                <a href="#" class="button">Click Here</a>
-            </div>
-        </body>
-        </html>
-    `;
-
-    console.log('Quick Performance Comparison');
-    console.log('============================\n');
-
-    const iterations = 50;
-
-    // Test Sync
-    console.log('Testing Sync version...');
-    const syncTimes = [];
-    for (let i = 0; i < iterations; i++) {
-        const start = process.hrtime.bigint();
-        mimeHtml.sync({ html: testHtml });
-        const end = process.hrtime.bigint();
-        syncTimes.push(Number(end - start) / 1000000);
-    }
-
-    // Test Async with Pool
-    console.log('Testing Async with worker pool...');
-    const asyncPoolTimes = [];
-    for (let i = 0; i < iterations; i++) {
-        const start = process.hrtime.bigint();
-        await mimeHtml.async(
-            { html: testHtml },
-            {
-                useWorkerPool: true,
-                timeout: 5000
-            }
-        );
-        const end = process.hrtime.bigint();
-        asyncPoolTimes.push(Number(end - start) / 1000000);
-    }
-
-    // Test Async without Pool (just first 5 to avoid long wait)
-    console.log('Testing Async without pool (5 iterations only)...');
-    const asyncNoPoolTimes = [];
-    for (let i = 0; i < 5; i++) {
-        const start = process.hrtime.bigint();
-        await mimeHtml.async(
-            { html: testHtml },
-            {
-                useWorkerPool: false,
-                timeout: 5000
-            }
-        );
-        const end = process.hrtime.bigint();
-        asyncNoPoolTimes.push(Number(end - start) / 1000000);
-    }
-
-    // Calculate stats
-    const getStats = times => {
-        const avg = times.reduce((a, b) => a + b, 0) / times.length;
-        times.sort((a, b) => a - b);
-        const median = times[Math.floor(times.length / 2)];
-        const min = times[0];
-        const max = times[times.length - 1];
-        return { avg, median, min, max };
-    };
-
-    const syncStats = getStats(syncTimes);
-    const asyncPoolStats = getStats(asyncPoolTimes);
-    const asyncNoPoolStats = getStats(asyncNoPoolTimes);
-
-    // Display results
-    console.log('\nResults (all times in milliseconds):');
-    console.log('=====================================\n');
-
-    console.log('Sync Version:');
-    console.log(`  Average:   ${syncStats.avg.toFixed(2)} ms`);
-    console.log(`  Median:    ${syncStats.median.toFixed(2)} ms`);
-    console.log(`  Min:       ${syncStats.min.toFixed(2)} ms`);
-    console.log(`  Max:       ${syncStats.max.toFixed(2)} ms`);
-
-    console.log('\nAsync with Worker Pool:');
-    console.log(`  Average:   ${asyncPoolStats.avg.toFixed(2)} ms`);
-    console.log(`  Median:    ${asyncPoolStats.median.toFixed(2)} ms`);
-    console.log(`  Min:       ${asyncPoolStats.min.toFixed(2)} ms`);
-    console.log(`  Max:       ${asyncPoolStats.max.toFixed(2)} ms`);
-
-    console.log('\nAsync without Pool (single worker per call):');
-    console.log(`  Average:   ${asyncNoPoolStats.avg.toFixed(2)} ms`);
-    console.log(`  Median:    ${asyncNoPoolStats.median.toFixed(2)} ms`);
-    console.log(`  Min:       ${asyncNoPoolStats.min.toFixed(2)} ms`);
-    console.log(`  Max:       ${asyncNoPoolStats.max.toFixed(2)} ms`);
-
-    console.log('\nPerformance Summary:');
-    console.log('====================');
-
-    if (asyncPoolStats.avg < syncStats.avg) {
-        const speedup = (syncStats.avg / asyncPoolStats.avg).toFixed(2);
-        console.log(`✓ Async with pool is ${speedup}x faster than sync`);
-    } else {
-        const slowdown = (asyncPoolStats.avg / syncStats.avg).toFixed(2);
-        console.log(`✗ Async with pool is ${slowdown}x slower than sync`);
-    }
-
-    const poolVsNoPool = (asyncNoPoolStats.avg / asyncPoolStats.avg).toFixed(1);
-    console.log(`✓ Worker pool is ${poolVsNoPool}x faster than single workers`);
-
-    // Worker pool stats
-    const poolStats = mimeHtml.getWorkerPoolStats();
-    if (poolStats) {
-        console.log('\nWorker Pool Statistics:');
-        console.log('======================');
-        console.log(`  Total Workers:  ${poolStats.totalWorkers}`);
-        console.log(`  Busy Workers:   ${poolStats.busyWorkers}`);
-        console.log(`  Free Workers:   ${poolStats.freeWorkers}`);
-        console.log(`  Queued Tasks:   ${poolStats.queuedTasks}`);
-        console.log(`  Min Workers:    ${poolStats.minWorkers}`);
-        console.log(`  Max Workers:    ${poolStats.maxWorkers}`);
-    }
-
-    // Test with problematic CSS
-    console.log('\nTesting Problematic CSS Handling:');
-    console.log('=================================');
-
-    const problematicHtml = `
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <style>
-                /* These selectors would cause juice to hang */
-                .item:is(.active, .selected) { background: yellow; }
-                .element:where(.primary) { color: blue; }
-                .parent:has(> .child) { border: 1px solid red; }
-            </style>
-        </head>
-        <body>
-            <div class="item active">Active Item</div>
-            <div class="parent"><div class="child">Child</div></div>
-        </body>
-        </html>
-    `;
-
-    try {
-        console.log('  Sync version... ');
-        const syncStart = process.hrtime.bigint();
-        const _syncResult = mimeHtml.sync({ html: problematicHtml });
-        const syncEnd = process.hrtime.bigint();
-        const syncTime = Number(syncEnd - syncStart) / 1000000;
-        console.log(`    ✓ Success (${syncTime.toFixed(2)} ms) - problematic selectors removed`);
-    } catch (err) {
-        console.log(`    ✗ Failed: ${err.message}`);
-    }
-
-    try {
-        console.log('  Async version...');
-        const asyncStart = process.hrtime.bigint();
-        const _asyncResult = await mimeHtml.async(
-            { html: problematicHtml },
-            {
-                timeout: 2000,
-                logErrors: false
-            }
-        );
-        const asyncEnd = process.hrtime.bigint();
-        const asyncTime = Number(asyncEnd - asyncStart) / 1000000;
-        console.log(`    ✓ Success (${asyncTime.toFixed(2)} ms) - handled with timeout protection`);
-    } catch (err) {
-        console.log(`    ✗ Failed: ${err.message}`);
-    }
-
-    // Clean up
-    await mimeHtml.closeWorkerPool();
-
-    console.log('\n✓ Benchmark complete!');
-}
-
-// Run the benchmark
-quickBenchmark().catch(err => {
-    console.error('Benchmark failed:', err);
-    process.exit(1);
-});

package/benchmark/quick-concurrency.js

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const mimeHtml = require('../lib/mime-html');
-
-async function quickConcurrencyTest() {
-    console.log('Quick Concurrency Test - Real-World HTML');
-    console.log('='.repeat(60));
-
-    const realWorldHtml = fs.readFileSync(path.join(__dirname, '../examples/failing.html'), 'utf8');
-
-    console.log(`Testing with ${(realWorldHtml.length / 1024).toFixed(1)} KB of problematic HTML\n`);
-
-    const iterations = 30;
-
-    // Test 1: Sequential Sync
-    console.log(`Test 1: Sequential Sync (${iterations} requests)`);
-    const syncStart = process.hrtime.bigint();
-    for (let i = 0; i < iterations; i++) {
-        mimeHtml.sync({ html: realWorldHtml });
-    }
-    const syncTime = Number(process.hrtime.bigint() - syncStart) / 1000000;
-    console.log(`  Time: ${syncTime.toFixed(2)}ms`);
-    console.log(`  Throughput: ${(iterations / (syncTime / 1000)).toFixed(0)} req/s\n`);
-
-    // Test 2: Concurrent Async with Pool (concurrency = 10)
-    console.log(`Test 2: Concurrent Async with Pool (${iterations} requests, concurrency=10)`);
-    const asyncStart = process.hrtime.bigint();
-    const promises = [];
-    for (let i = 0; i < iterations; i++) {
-        promises.push(
-            mimeHtml.async(
-                { html: realWorldHtml },
-                {
-                    useWorkerPool: true,
-                    timeout: 5000,
-                    logErrors: false
-                }
-            )
-        );
-    }
-    await Promise.all(promises);
-    const asyncTime = Number(process.hrtime.bigint() - asyncStart) / 1000000;
-    console.log(`  Time: ${asyncTime.toFixed(2)}ms`);
-    console.log(`  Throughput: ${(iterations / (asyncTime / 1000)).toFixed(0)} req/s\n`);
-
-    // Show speedup
-    const speedup = (syncTime / asyncTime).toFixed(2);
-    console.log('='.repeat(60));
-    console.log('Results:');
-    console.log(`• Concurrent processing is ${speedup}x faster than sequential`);
-    console.log(`• No timeouts occurred (pre-filtering working correctly)`);
-
-    const stats = mimeHtml.getWorkerPoolStats();
-    if (stats) {
-        console.log(`• Worker pool used ${stats.totalWorkers} workers efficiently`);
-    }
-
-    await mimeHtml.closeWorkerPool();
-}
-
-quickConcurrencyTest().catch(console.error);

package/benchmark/real-world-benchmark.js

@@ -1,257 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const mimeHtml = require('../lib/mime-html');
-
-class RealWorldBenchmark {
-    constructor() {
-        this.results = [];
-    }
-
-    async runTest(name, fn, iterations = 50) {
-        const times = [];
-        const errors = [];
-
-        // Warmup
-        console.log(`  Warming up ${name}...`);
-        for (let i = 0; i < 3; i++) {
-            try {
-                await fn();
-            } catch (_err) {
-                // Ignore warmup errors
-            }
-        }
-
-        // Actual test
-        console.log(`  Running ${name} (${iterations} iterations)...`);
-        for (let i = 0; i < iterations; i++) {
-            if (i % 10 === 0) {
-                process.stdout.write(`    Progress: ${i}/${iterations}\r`);
-            }
-            const start = process.hrtime.bigint();
-            try {
-                await fn();
-                const end = process.hrtime.bigint();
-                times.push(Number(end - start) / 1000000); // Convert to milliseconds
-            } catch (err) {
-                errors.push(err.message);
-            }
-        }
-        process.stdout.write(`    Progress: ${iterations}/${iterations} - Done!\n`);
-
-        if (times.length > 0) {
-            times.sort((a, b) => a - b);
-            const avg = times.reduce((a, b) => a + b, 0) / times.length;
-            const median = times[Math.floor(times.length / 2)];
-            const min = times[0];
-            const max = times[times.length - 1];
-            const p95 = times[Math.floor(times.length * 0.95)];
-            const p99 = times[Math.floor(times.length * 0.99)];
-
-            return {
-                name,
-                iterations,
-                successful: times.length,
-                failed: errors.length,
-                avg: avg.toFixed(2),
-                median: median.toFixed(2),
-                min: min.toFixed(2),
-                max: max.toFixed(2),
-                p95: p95.toFixed(2),
-                p99: p99.toFixed(2),
-                errors: errors.length > 0 ? errors[0] : null
-            };
-        } else {
-            return {
-                name,
-                iterations,
-                successful: 0,
-                failed: errors.length,
-                errors: errors[0] || 'All iterations failed'
-            };
-        }
-    }
-
-    formatTable(results) {
-        const table = [];
-        results.forEach(test => {
-            if (test.successful > 0) {
-                table.push({
-                    Method: test.name,
-                    Success: `${test.successful}/${test.iterations}`,
-                    Avg: `${test.avg}ms`,
-                    Median: `${test.median}ms`,
-                    Min: `${test.min}ms`,
-                    Max: `${test.max}ms`,
-                    P95: `${test.p95}ms`,
-                    P99: `${test.p99}ms`
-                });
-            } else {
-                table.push({
-                    Method: test.name,
-                    Success: `${test.successful}/${test.iterations}`,
-                    Error: test.errors
-                });
-            }
-        });
-
-        console.table(table);
-    }
-
-    async runBenchmarks() {
-        console.log('Real-World HTML Benchmark');
-        console.log('='.repeat(80));
-        console.log('Testing with actual problematic HTML that contains :is(), :where(), :has() selectors');
-        console.log('Both sync and async versions now pre-filter these selectors\n');
-
-        // Load the real-world HTML
-        const realWorldHtml = fs.readFileSync(path.join(__dirname, '../examples/failing.html'), 'utf8');
-
-        console.log(`HTML size: ${(realWorldHtml.length / 1024).toFixed(1)} KB`);
-        console.log(`Contains modern CSS selectors that would cause juice to hang\n`);
-
-        const results = [];
-
-        // Test 1: Sync version
-        console.log('Test 1: Sync Version');
-        console.log('-'.repeat(40));
-        results.push(await this.runTest('Sync', () => Promise.resolve(mimeHtml.sync({ html: realWorldHtml })), 50));
-
-        // Test 2: Async with worker pool
-        console.log('\nTest 2: Async with Worker Pool');
-        console.log('-'.repeat(40));
-        results.push(
-            await this.runTest(
-                'Async (pool)',
-                async () =>
-                    await mimeHtml.async(
-                        { html: realWorldHtml },
-                        {
-                            useWorkerPool: true,
-                            timeout: 5000,
-                            minWorkers: 2,
-                            maxWorkers: 4,
-                            logErrors: false
-                        }
-                    ),
-                50
-            )
-        );
-
-        // Test 3: Async without pool (fewer iterations due to overhead)
-        console.log('\nTest 3: Async without Worker Pool');
-        console.log('-'.repeat(40));
-        results.push(
-            await this.runTest(
-                'Async (no pool)',
-                async () =>
-                    await mimeHtml.async(
-                        { html: realWorldHtml },
-                        {
-                            useWorkerPool: false,
-                            timeout: 5000,
-                            logErrors: false
-                        }
-                    ),
-                10
-            )
-        );
-
-        // Display results
-        console.log('\n' + '='.repeat(80));
-        console.log('RESULTS');
-        console.log('='.repeat(80) + '\n');
-
-        this.formatTable(results);
-
-        // Performance comparison
-        console.log('\nPerformance Analysis:');
-        console.log('-'.repeat(40));
-
-        const sync = results.find(r => r.name === 'Sync');
-        const asyncPool = results.find(r => r.name === 'Async (pool)');
-        const asyncNoPool = results.find(r => r.name === 'Async (no pool)');
-
-        if (sync && asyncPool && sync.successful > 0 && asyncPool.successful > 0) {
-            const overhead = (((parseFloat(asyncPool.avg) - parseFloat(sync.avg)) / parseFloat(sync.avg)) * 100).toFixed(1);
-            if (overhead > 0) {
-                console.log(`• Async with pool adds ${overhead}% overhead vs sync`);
-            } else {
-                console.log(`• Async with pool is ${Math.abs(overhead)}% faster than sync`);
-            }
-        }
-
-        if (asyncPool && asyncNoPool && asyncPool.successful > 0 && asyncNoPool.successful > 0) {
-            const poolAdvantage = (parseFloat(asyncNoPool.avg) / parseFloat(asyncPool.avg)).toFixed(1);
-            console.log(`• Worker pool is ${poolAdvantage}x faster than creating workers per request`);
-        }
-
-        if (sync && sync.successful > 0) {
-            console.log(`• Sync processes at ~${(1000 / parseFloat(sync.avg)).toFixed(0)} requests/second`);
-        }
-
-        if (asyncPool && asyncPool.successful > 0) {
-            console.log(`• Async with pool processes at ~${(1000 / parseFloat(asyncPool.avg)).toFixed(0)} requests/second`);
-        }
-
-        // Check if any timeouts occurred
-        const anyTimeouts = results.some(r => r.failed > 0);
-        if (!anyTimeouts) {
-            console.log('\n✅ No timeouts occurred - pre-filtering is working correctly!');
-        } else {
-            console.log('\n⚠️ Some timeouts occurred:');
-            results
-                .filter(r => r.failed > 0)
-                .forEach(r => {
-                    console.log(`  - ${r.name}: ${r.failed} failures`);
-                });
-        }
-
-        // Worker pool stats
-        const stats = mimeHtml.getWorkerPoolStats();
-        if (stats) {
-            console.log('\nWorker Pool Final Stats:');
-            console.log('-'.repeat(40));
-            console.log(`• Total Workers: ${stats.totalWorkers}`);
-            console.log(`• Busy Workers: ${stats.busyWorkers}`);
-            console.log(`• Free Workers: ${stats.freeWorkers}`);
-            console.log(`• Queued Tasks: ${stats.queuedTasks}`);
-        }
-
-        // Memory usage
-        const memUsage = process.memoryUsage();
-        console.log('\nMemory Usage:');
-        console.log('-'.repeat(40));
-        console.log(`• RSS: ${(memUsage.rss / 1024 / 1024).toFixed(1)} MB`);
-        console.log(`• Heap Used: ${(memUsage.heapUsed / 1024 / 1024).toFixed(1)} MB`);
-        console.log(`• External: ${(memUsage.external / 1024 / 1024).toFixed(1)} MB`);
-
-        // Cleanup
-        await mimeHtml.closeWorkerPool();
-
-        console.log('\n' + '='.repeat(80));
-        console.log('Benchmark Complete!');
-        console.log('='.repeat(80));
-
-        // Summary
-        console.log('\nKey Takeaways:');
-        console.log('• Both versions successfully handle problematic CSS by pre-filtering');
-        console.log('• No timeouts needed when selectors are filtered before processing');
-        console.log('• Worker pool provides efficient concurrent processing');
-        console.log('• Async timeout serves as safety net for unknown edge cases');
-    }
-}
-
-// Run benchmark
-const benchmark = new RealWorldBenchmark();
-benchmark
-    .runBenchmarks()
-    .then(() => {
-        process.exit(0);
-    })
-    .catch(err => {
-        console.error('Benchmark failed:', err);
-        process.exit(1);
-    });