@jshookmcp/jshook 0.2.6 → 0.2.7

package/dist/src/modules/browser/UnifiedBrowserManager.js

@@ -1,287 +0,0 @@
-import { BrowserModeManager } from '../browser/BrowserModeManager.js';
-import { CamoufoxBrowserManager, } from '../browser/CamoufoxBrowserManager.js';
-import { BrowserDiscovery } from '../browser/BrowserDiscovery.js';
-import { logger } from '../../utils/logger.js';
-export class UnifiedBrowserManager {
-    driver;
-    config;
-    chromeManager = null;
-    camoufoxManager = null;
-    browserDiscovery;
-    activePage = null;
-    chromeLaunchPromise;
-    camoufoxLaunchPromise;
-    isClosing = false;
-    _chromeIsAttached = false;
-    constructor(config = {}) {
-        this.config = config;
-        this.driver = config.driver ?? 'chrome';
-        this.browserDiscovery = new BrowserDiscovery();
-    }
-    async launch() {
-        if (this.driver === 'camoufox') {
-            return this.launchCamoufox();
-        }
-        return this.launchChrome();
-    }
-    async launchChrome() {
-        if (this.isClosing) {
-            throw new Error('Cannot launch browser while closing');
-        }
-        const existingBrowser = this.chromeManager?.getBrowser();
-        if (existingBrowser?.isConnected()) {
-            return existingBrowser;
-        }
-        if (this.chromeLaunchPromise) {
-            return this.chromeLaunchPromise;
-        }
-        this.chromeLaunchPromise = this.doLaunchChrome();
-        try {
-            return await this.chromeLaunchPromise;
-        }
-        finally {
-            this.chromeLaunchPromise = undefined;
-        }
-    }
-    async doLaunchChrome() {
-        logger.info(`Launching Chrome [headless=${this.config.headless ?? true}]...`);
-        const modeConfig = {
-            autoDetectCaptcha: this.config.autoDetectCaptcha,
-            autoSwitchHeadless: this.config.autoSwitchHeadless,
-            captchaTimeout: this.config.captchaTimeout,
-            defaultHeadless: this.getHeadlessBoolean(),
-        };
-        const launchOptions = {
-            headless: this.normalizeChromeHeadless(),
-            executablePath: this.config.executablePath,
-            args: this.config.args,
-        };
-        if (this.config.proxy) {
-            const proxyArgs = [`--proxy-server=${this.config.proxy.server}`];
-            launchOptions.args = [...(launchOptions.args || []), ...proxyArgs];
-        }
-        if (this.config.debugPort) {
-            launchOptions.args = [
-                ...(launchOptions.args || []),
-                `--remote-debugging-port=${this.config.debugPort}`,
-            ];
-        }
-        this.chromeManager = new BrowserModeManager(modeConfig, launchOptions);
-        const browser = await this.chromeManager.launch();
-        logger.info('Chrome browser launched successfully');
-        return browser;
-    }
-    async launchCamoufox() {
-        if (this.isClosing) {
-            throw new Error('Cannot launch browser while closing');
-        }
-        const existingBrowser = this.camoufoxManager?.getBrowser();
-        if (existingBrowser?.isConnected()) {
-            return existingBrowser;
-        }
-        if (this.camoufoxLaunchPromise) {
-            return this.camoufoxLaunchPromise;
-        }
-        this.camoufoxLaunchPromise = this.doLaunchCamoufox();
-        try {
-            return await this.camoufoxLaunchPromise;
-        }
-        finally {
-            this.camoufoxLaunchPromise = undefined;
-        }
-    }
-    async doLaunchCamoufox() {
-        const headless = this.normalizeCamoufoxHeadless();
-        logger.info(`Launching Camoufox (Firefox) [os=${this.config.os ?? 'windows'}, headless=${headless}]...`);
-        const camoufoxConfig = {
-            headless,
-            os: this.config.os,
-            geoip: this.config.geoip,
-            humanize: this.config.humanize,
-            proxy: this.config.proxy,
-            blockImages: this.config.blockImages,
-            blockWebrtc: this.config.blockWebrtc,
-        };
-        this.camoufoxManager = new CamoufoxBrowserManager(camoufoxConfig);
-        const browser = await this.camoufoxManager.launch();
-        logger.info('Camoufox browser launched successfully');
-        return browser;
-    }
-    async connect(wsEndpoint) {
-        if (this.driver === 'camoufox') {
-            return this.connectCamoufox(wsEndpoint);
-        }
-        return this.connectChrome(wsEndpoint);
-    }
-    async connectChrome(wsEndpoint) {
-        logger.info(`Connecting to Chrome browser: ${wsEndpoint}`);
-        const puppeteer = await import('rebrowser-puppeteer-core');
-        const browser = await puppeteer.connect({
-            browserWSEndpoint: wsEndpoint,
-            defaultViewport: null,
-        });
-        this.chromeManager = new BrowserModeManager({}, {});
-        Reflect.set(this.chromeManager, 'browser', browser);
-        this._chromeIsAttached = true;
-        logger.info('Connected to Chrome browser successfully');
-        return browser;
-    }
-    async connectCamoufox(wsEndpoint) {
-        logger.info(`Connecting to Camoufox browser: ${wsEndpoint}`);
-        this.camoufoxManager = new CamoufoxBrowserManager({});
-        const browser = await this.camoufoxManager.connectToServer(wsEndpoint);
-        logger.info('Connected to Camoufox browser successfully');
-        return browser;
-    }
-    async newPage() {
-        if (this.driver === 'camoufox') {
-            if (!this.camoufoxManager) {
-                await this.launchCamoufox();
-            }
-            this.activePage = await this.camoufoxManager.newPage();
-            return this.activePage;
-        }
-        if (!this.chromeManager) {
-            await this.launchChrome();
-        }
-        this.activePage = await this.chromeManager.newPage();
-        return this.activePage;
-    }
-    async goto(url, page) {
-        const targetPage = page ?? this.activePage;
-        if (this.driver === 'camoufox') {
-            if (!this.camoufoxManager) {
-                await this.launchCamoufox();
-            }
-            return this.camoufoxManager.goto(url, targetPage);
-        }
-        if (!this.chromeManager) {
-            await this.launchChrome();
-        }
-        return this.chromeManager.goto(url, targetPage);
-    }
-    async close() {
-        this.isClosing = true;
-        try {
-            const camoufoxManager = this.camoufoxManager;
-            const chromeManager = this.chromeManager;
-            this.camoufoxManager = null;
-            this.chromeManager = null;
-            this.chromeLaunchPromise = undefined;
-            this.camoufoxLaunchPromise = undefined;
-            this.activePage = null;
-            const chromeWasAttached = this._chromeIsAttached;
-            this._chromeIsAttached = false;
-            const closeTasks = [];
-            if (camoufoxManager) {
-                closeTasks.push(camoufoxManager.close().then(() => {
-                    logger.info('Camoufox browser closed');
-                }));
-            }
-            if (chromeManager) {
-                if (chromeWasAttached) {
-                    const browser = chromeManager.getBrowser();
-                    if (browser) {
-                        closeTasks.push(browser.disconnect().then(() => {
-                            logger.info('Detached from Chrome browser (not killed)');
-                        }));
-                    }
-                }
-                else {
-                    closeTasks.push(chromeManager.close().then(() => {
-                        logger.info('Chrome browser closed');
-                    }));
-                }
-            }
-            await Promise.all(closeTasks);
-        }
-        finally {
-            this.isClosing = false;
-        }
-    }
-    getBrowser() {
-        if (this.driver === 'camoufox') {
-            return this.camoufoxManager?.getBrowser() ?? null;
-        }
-        return this.chromeManager?.getBrowser() ?? null;
-    }
-    getActivePage() {
-        return this.activePage;
-    }
-    getDriver() {
-        return this.driver;
-    }
-    setDriver(driver) {
-        this.driver = driver;
-    }
-    getStatus() {
-        const browser = this.getBrowser();
-        const running = browser !== null && browser.isConnected();
-        return {
-            driver: this.driver,
-            running,
-            hasActivePage: this.activePage !== null,
-            headless: this.config.headless,
-            debugPort: this.config.debugPort,
-        };
-    }
-    async discoverBrowsers() {
-        return this.browserDiscovery.discoverBrowsers();
-    }
-    async findChromeWithDebugPort(preferredPorts = [9222, 9229, 9333]) {
-        const browsers = await this.discoverBrowsers();
-        const chromeBrowsers = browsers.filter((b) => b.type === 'chrome' || b.type === 'edge');
-        for (const browser of chromeBrowsers) {
-            if (browser.debugPort && preferredPorts.includes(browser.debugPort)) {
-                return browser;
-            }
-        }
-        return null;
-    }
-    async attachToExistingChrome(preferredPorts = [9222, 9229, 9333]) {
-        const browserInfo = await this.findChromeWithDebugPort(preferredPorts);
-        if (!browserInfo?.debugPort) {
-            logger.info('No existing Chrome browser with debug port found');
-            return null;
-        }
-        const wsEndpoint = `ws://127.0.0.1:${browserInfo.debugPort}`;
-        logger.info(`Found existing Chrome browser on port ${browserInfo.debugPort}, connecting...`);
-        try {
-            return await this.connectChrome(wsEndpoint);
-        }
-        catch (error) {
-            logger.error('Failed to connect to existing Chrome browser', error);
-            return null;
-        }
-    }
-    normalizeChromeHeadless() {
-        const headless = this.config.headless;
-        if (headless === 'virtual') {
-            return true;
-        }
-        if (headless === 'shell') {
-            return 'shell';
-        }
-        return headless ?? true;
-    }
-    normalizeCamoufoxHeadless() {
-        const headless = this.config.headless;
-        if (headless === 'shell') {
-            return true;
-        }
-        if (headless === 'virtual') {
-            return 'virtual';
-        }
-        return headless ?? true;
-    }
-    getHeadlessBoolean() {
-        const headless = this.config.headless;
-        if (headless === 'shell' || headless === 'virtual') {
-            return true;
-        }
-        return headless ?? true;
-    }
-}
-export { BrowserModeManager } from '../browser/BrowserModeManager.js';
-export { CamoufoxBrowserManager } from '../browser/CamoufoxBrowserManager.js';
-export { BrowserDiscovery } from '../browser/BrowserDiscovery.js';

package/dist/src/modules/browser/index.d.ts

@@ -1,4 +0,0 @@
-export { UnifiedBrowserManager, type BrowserDriver, type HeadlessMode, type ProxyConfig, type UnifiedBrowserConfig, type IBrowserManager, type BrowserStatus, } from '../browser/UnifiedBrowserManager.js';
-export { BrowserModeManager, type BrowserModeConfig } from '../browser/BrowserModeManager.js';
-export { CamoufoxBrowserManager, type CamoufoxBrowserConfig, } from '../browser/CamoufoxBrowserManager.js';
-export { BrowserDiscovery, type BrowserInfo, type BrowserSignature, } from '../browser/BrowserDiscovery.js';

package/dist/src/modules/browser/index.js

@@ -1,4 +0,0 @@
-export { UnifiedBrowserManager, } from '../browser/UnifiedBrowserManager.js';
-export { BrowserModeManager } from '../browser/BrowserModeManager.js';
-export { CamoufoxBrowserManager, } from '../browser/CamoufoxBrowserManager.js';
-export { BrowserDiscovery, } from '../browser/BrowserDiscovery.js';

package/dist/src/modules/captcha/AICaptchaDetector.d.ts

@@ -1,19 +0,0 @@
-import { type Page } from 'rebrowser-puppeteer-core';
-import type { AICaptchaDetectionResult, CaptchaProviderHint, CaptchaType, CaptchaPageInfo } from '../captcha/types.js';
-export type { AICaptchaDetectionResult } from '../captcha/types.js';
-export declare class AICaptchaDetector {
-    protected screenshotDir: string;
-    constructor(screenshotDir?: string);
-    protected saveScreenshot(screenshotBase64: string): Promise<string>;
-    detect(page: Page): Promise<AICaptchaDetectionResult>;
-    protected getPageInfo(page: Page): Promise<CaptchaPageInfo>;
-    protected normalizeCaptchaType(type: unknown, detected: boolean): CaptchaType;
-    protected normalizeProviderHint(providerHint: unknown, detected: boolean): CaptchaProviderHint | undefined;
-    protected normalizeDetected(value: unknown): boolean;
-    protected normalizeConfidence(confidence: unknown): number;
-    protected applyLocalGuardrails(pageInfo: CaptchaPageInfo, aiResult: AICaptchaDetectionResult): AICaptchaDetectionResult;
-    protected hasStrongCaptchaElementSignals(elements: string[]): boolean;
-    protected hasStrongOverrideSignals(pageInfo: CaptchaPageInfo): boolean;
-    protected evaluateFallbackTextAnalysis(pageInfo: CaptchaPageInfo): AICaptchaDetectionResult;
-    waitForCompletion(page: Page, timeout?: number): Promise<boolean>;
-}

package/dist/src/modules/captcha/AICaptchaDetector.js

@@ -1,220 +0,0 @@
-import {} from 'rebrowser-puppeteer-core';
-import { writeFile, mkdir } from 'fs/promises';
-import { join } from 'path';
-import { logger } from '../../utils/logger.js';
-import { FALLBACK_CAPTCHA_KEYWORDS, FALLBACK_EXCLUDE_KEYWORDS, } from '../captcha/CaptchaDetector.constants.js';
-import { CAPTCHA_PROVIDER_HINTS, CAPTCHA_TYPES, LEGACY_CAPTCHA_PROVIDER_HINT_ALIASES, LEGACY_CAPTCHA_TYPE_ALIASES, } from '../captcha/types.js';
-const OVERRIDE_CAPTCHA_KEYWORDS = FALLBACK_CAPTCHA_KEYWORDS;
-const OVERRIDE_ELEMENT_SIGNALS = [
-    'captcha',
-    'challenge',
-    'slider',
-    'widget',
-    'checkbox',
-    'sitekey',
-    'browser-check',
-    'security-check',
-];
-export class AICaptchaDetector {
-    screenshotDir;
-    constructor(screenshotDir = './screenshots') {
-        this.screenshotDir = screenshotDir;
-    }
-    async saveScreenshot(screenshotBase64) {
-        try {
-            await mkdir(this.screenshotDir, { recursive: true });
-            const timestamp = Date.now();
-            const filename = `captcha-${timestamp}.png`;
-            const filepath = join(this.screenshotDir, filename);
-            const buffer = Buffer.from(screenshotBase64, 'base64');
-            await writeFile(filepath, buffer);
-            logger.info(`Screenshot saved: ${filepath}`);
-            return filepath;
-        }
-        catch (error) {
-            logger.error('Failed to persist CAPTCHA screenshot', error);
-            throw error;
-        }
-    }
-    async detect(page) {
-        try {
-            logger.info('Running rule-based captcha detection...');
-            const pageInfo = await this.getPageInfo(page);
-            const result = this.applyLocalGuardrails(pageInfo, this.evaluateFallbackTextAnalysis(pageInfo));
-            logger.info(`CAPTCHA detection result: ${result.detected ? 'detected' : 'not_detected'} (confidence: ${result.confidence}%)`);
-            return result;
-        }
-        catch (error) {
-            logger.error('CAPTCHA detection failed', error);
-            return {
-                detected: false,
-                type: 'none',
-                confidence: 0,
-                reasoning: `Detection error: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    async getPageInfo(page) {
-        const url = page.url();
-        const title = await page.title();
-        const info = await page.evaluate(() => {
-            const bodyText = document.body.innerText.substring(0, 1000);
-            const hasIframes = document.querySelectorAll('iframe').length > 0;
-            const suspiciousElements = [];
-            const captchaSelectors = [
-                '[class*="captcha"]',
-                '[id*="captcha"]',
-                '[class*="verify"]',
-                '[id*="verify"]',
-                '[class*="challenge"]',
-                'iframe[src*="captcha" i]',
-                'iframe[src*="challenge" i]',
-                '[data-sitekey]',
-                '[class*="browser-check"]',
-            ];
-            for (const selector of captchaSelectors) {
-                const elements = document.querySelectorAll(selector);
-                if (elements.length > 0) {
-                    suspiciousElements.push(`${selector} (${elements.length})`);
-                }
-            }
-            return {
-                bodyText,
-                hasIframes,
-                suspiciousElements,
-            };
-        });
-        return {
-            url,
-            title,
-            ...info,
-        };
-    }
-    normalizeCaptchaType(type, detected) {
-        if (!detected) {
-            return 'none';
-        }
-        if (typeof type === 'string') {
-            if (CAPTCHA_TYPES.includes(type)) {
-                return type;
-            }
-            const alias = LEGACY_CAPTCHA_TYPE_ALIASES[type.toLowerCase()];
-            if (alias) {
-                return alias;
-            }
-        }
-        return 'unknown';
-    }
-    normalizeProviderHint(providerHint, detected) {
-        if (typeof providerHint === 'string') {
-            if (CAPTCHA_PROVIDER_HINTS.includes(providerHint)) {
-                return providerHint;
-            }
-            const alias = LEGACY_CAPTCHA_PROVIDER_HINT_ALIASES[providerHint.toLowerCase()];
-            if (alias) {
-                return alias;
-            }
-        }
-        return detected ? 'unknown' : undefined;
-    }
-    normalizeDetected(value) {
-        if (typeof value === 'boolean') {
-            return value;
-        }
-        if (typeof value === 'string') {
-            const normalized = value.trim().toLowerCase();
-            if (normalized === 'true')
-                return true;
-            if (normalized === 'false')
-                return false;
-        }
-        if (typeof value === 'number') {
-            if (value === 1)
-                return true;
-            if (value === 0)
-                return false;
-        }
-        return false;
-    }
-    normalizeConfidence(confidence) {
-        const normalized = Number(confidence);
-        if (!Number.isFinite(normalized)) {
-            return 0;
-        }
-        return Math.max(0, Math.min(100, normalized));
-    }
-    applyLocalGuardrails(pageInfo, aiResult) {
-        if (aiResult.detected) {
-            return aiResult;
-        }
-        if (!this.hasStrongOverrideSignals(pageInfo)) {
-            return aiResult;
-        }
-        return {
-            ...this.evaluateFallbackTextAnalysis(pageInfo),
-            reasoning: 'AI reported no CAPTCHA, but local heuristics found strong CAPTCHA signals in the page context. / AI 判定为无验证码，但本地启发式在页面上下文中发现强信号。',
-            screenshotPath: aiResult.screenshotPath,
-        };
-    }
-    hasStrongCaptchaElementSignals(elements) {
-        return elements.some((element) => {
-            const lowerElement = element.toLowerCase();
-            return OVERRIDE_ELEMENT_SIGNALS.some((signal) => lowerElement.includes(signal));
-        });
-    }
-    hasStrongOverrideSignals(pageInfo) {
-        const searchableText = `${pageInfo.title}\n${pageInfo.bodyText}`.toLowerCase();
-        const hasStrongElementSignal = this.hasStrongCaptchaElementSignals(pageInfo.suspiciousElements);
-        if (!hasStrongElementSignal) {
-            return false;
-        }
-        return OVERRIDE_CAPTCHA_KEYWORDS.some((keyword) => searchableText.includes(keyword));
-    }
-    evaluateFallbackTextAnalysis(pageInfo) {
-        const searchableText = `${pageInfo.url}\n${pageInfo.title}\n${pageInfo.bodyText}`.toLowerCase();
-        const hasCaptchaElements = this.hasStrongCaptchaElementSignals(pageInfo.suspiciousElements);
-        const hasCaptchaKeywords = FALLBACK_CAPTCHA_KEYWORDS.some((keyword) => searchableText.includes(keyword));
-        const hasStrongCaptchaSignals = hasCaptchaElements && hasCaptchaKeywords;
-        const hasExcludedKeywords = FALLBACK_EXCLUDE_KEYWORDS.some((keyword) => searchableText.includes(keyword));
-        if (hasExcludedKeywords && !hasStrongCaptchaSignals) {
-            return {
-                detected: false,
-                type: 'none',
-                confidence: 95,
-                reasoning: 'Fallback heuristics matched OTP or account verification text, not a CAPTCHA. / 后备启发式匹配到一次性验证码或账户校验文本，不视为 CAPTCHA。',
-                suggestions: ['Continue the login or verification flow normally / 继续正常登录或验证流程'],
-            };
-        }
-        const detected = hasStrongCaptchaSignals;
-        return {
-            detected,
-            type: detected ? 'unknown' : 'none',
-            confidence: detected ? (hasExcludedKeywords ? 55 : 60) : 90,
-            reasoning: detected
-                ? hasExcludedKeywords
-                    ? 'Fallback heuristics found strong CAPTCHA signals despite OTP-like wording on the page. / 后备启发式发现了强 CAPTCHA 信号，优先于页面上的一次性验证码类文案。'
-                    : 'Fallback heuristics matched both suspicious elements and CAPTCHA keywords. / 后备启发式匹配到可疑元素和验证码关键词。'
-                : 'Fallback heuristics did not find strong CAPTCHA signals. / 后备启发式未找到强验证码信号。',
-            suggestions: detected
-                ? [
-                    'Switch to headed mode if needed / 如需要切换到有头模式',
-                    'Wait for manual completion before continuing / 等待手动完成后继续',
-                ]
-                : ['Solve the CAPTCHA manually if one is visible / 如有可见验证码请手动解决'],
-        };
-    }
-    async waitForCompletion(page, timeout = 300000) {
-        logger.info('Waiting for CAPTCHA to be solved...');
-        const startTime = Date.now();
-        while (Date.now() - startTime < timeout) {
-            const result = await this.detect(page);
-            if (!result.detected || result.confidence < 50) {
-                logger.info('CAPTCHA is no longer detected; continuing workflow');
-                return true;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 3000));
-        }
-        logger.error('Timed out while waiting for CAPTCHA completion');
-        return false;
-    }
-}

package/dist/src/modules/captcha/CaptchaDetector.constants.d.ts

@@ -1 +0,0 @@
-export { CAPTCHA_KEYWORDS, CAPTCHA_MATCH_RULES, DOM_MATCH_RULES, EXCLUDE_KEYWORDS, EXCLUDE_MATCH_RULES, FALLBACK_CAPTCHA_KEYWORDS, FALLBACK_EXCLUDE_KEYWORDS, CAPTCHA_SELECTORS, EXCLUDE_SELECTORS, } from '../captcha/rules/index.js';

package/dist/src/modules/captcha/CaptchaDetector.constants.js

@@ -1 +0,0 @@
-export { CAPTCHA_KEYWORDS, CAPTCHA_MATCH_RULES, DOM_MATCH_RULES, EXCLUDE_KEYWORDS, EXCLUDE_MATCH_RULES, FALLBACK_CAPTCHA_KEYWORDS, FALLBACK_EXCLUDE_KEYWORDS, CAPTCHA_SELECTORS, EXCLUDE_SELECTORS, } from '../captcha/rules/index.js';

package/dist/src/modules/captcha/CaptchaDetector.d.ts

@@ -1,42 +0,0 @@
-import { type Page } from 'rebrowser-puppeteer-core';
-import type { CaptchaAssessment, CaptchaCandidate, CaptchaDetectionResult, CaptchaDomRule, CaptchaHeuristicRule, CaptchaSignal, CaptchaSignalSource } from '../captcha/types.js';
-export type { CaptchaDetectionResult } from '../captcha/types.js';
-export declare class CaptchaDetector {
-    private static readonly EXCLUDE_SELECTORS;
-    private static readonly CAPTCHA_MATCH_RULES;
-    private static readonly EXCLUDE_MATCH_RULES;
-    private static readonly DOM_MATCH_RULES;
-    assess(page: Page): Promise<CaptchaAssessment>;
-    detect(page: Page): Promise<CaptchaDetectionResult>;
-    protected toAssessmentSignal(source: CaptchaSignalSource, result: CaptchaDetectionResult): CaptchaSignal | null;
-    protected toAssessmentCandidate(source: CaptchaSignalSource, result: CaptchaDetectionResult): CaptchaCandidate | null;
-    protected getSignalValue(source: CaptchaSignalSource, result: CaptchaDetectionResult): string;
-    protected matchRule(value: string, rules: readonly CaptchaHeuristicRule[]): {
-        rule: CaptchaHeuristicRule;
-        matchText: string;
-    } | null;
-    protected confirmRuleWithDOM(page: Page, rule: CaptchaHeuristicRule): Promise<boolean>;
-    protected buildExcludeResult(sourceLabel: string, rule: CaptchaHeuristicRule, matchText: string): CaptchaDetectionResult;
-    protected buildCaptchaResult(payload: {
-        confidence: number;
-        type: CaptchaDetectionResult['type'];
-        providerHint?: CaptchaDetectionResult['providerHint'];
-        url?: string;
-        title?: string;
-        selector?: string;
-        details?: unknown;
-    }): CaptchaDetectionResult;
-    protected evaluateDomRule(page: Page, rule: CaptchaDomRule): Promise<{
-        selector: string;
-        rule: CaptchaDomRule;
-    } | null>;
-    private getRecommendedNextStep;
-    protected checkUrl(page: Page): Promise<CaptchaDetectionResult>;
-    protected checkTitle(page: Page): Promise<CaptchaDetectionResult>;
-    protected checkDOMElements(page: Page): Promise<CaptchaDetectionResult>;
-    protected checkPageText(page: Page): Promise<CaptchaDetectionResult>;
-    protected checkVendorSpecific(_page: Page): Promise<CaptchaDetectionResult>;
-    waitForCompletion(page: Page, timeout?: number): Promise<boolean>;
-    protected verifyByDOM(page: Page): Promise<boolean>;
-    protected verifySliderElement(page: Page, selector: string): Promise<boolean>;
-}