@jshookmcp/jshook 0.1.8 → 0.1.9

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

@@ -0,0 +1,484 @@
+import { logger } from '../../utils/logger.js';
+import { CAPTCHA_MATCH_RULES, DOM_MATCH_RULES, EXCLUDE_MATCH_RULES, EXCLUDE_SELECTORS, } from '../captcha/CaptchaDetector.constants.js';
+export class CaptchaDetector {
+    static EXCLUDE_SELECTORS = EXCLUDE_SELECTORS;
+    static CAPTCHA_MATCH_RULES = CAPTCHA_MATCH_RULES;
+    static EXCLUDE_MATCH_RULES = EXCLUDE_MATCH_RULES;
+    static DOM_MATCH_RULES = DOM_MATCH_RULES;
+    async assess(page) {
+        const checks = [
+            { source: 'url', run: () => this.checkUrl(page) },
+            { source: 'title', run: () => this.checkTitle(page) },
+            { source: 'dom', run: () => this.checkDOMElements(page) },
+            { source: 'text', run: () => this.checkPageText(page) },
+            { source: 'vendor', run: () => this.checkVendorSpecific(page) },
+        ];
+        const signals = [];
+        const candidates = [];
+        let primaryDetection = {
+            detected: false,
+            type: 'none',
+            confidence: 0,
+        };
+        for (const check of checks) {
+            try {
+                const result = await check.run();
+                const signal = this.toAssessmentSignal(check.source, result);
+                if (signal) {
+                    signals.push(signal);
+                }
+                const candidate = this.toAssessmentCandidate(check.source, result);
+                if (candidate) {
+                    candidates.push(candidate);
+                }
+                if (result.detected && result.confidence >= primaryDetection.confidence) {
+                    primaryDetection = result;
+                }
+            }
+            catch (error) {
+                logger.warn(`CAPTCHA assessment check failed for source: ${check.source}`, error);
+            }
+        }
+        const score = signals
+            .filter((signal) => signal.kind === 'captcha')
+            .reduce((sum, signal) => sum + signal.confidence, 0);
+        const excludeScore = signals
+            .filter((signal) => signal.kind === 'exclude')
+            .reduce((sum, signal) => sum + signal.confidence, 0);
+        const confidence = primaryDetection.detected ? primaryDetection.confidence : 0;
+        const likelyCaptcha = candidates.length > 0 && (confidence >= 90 || score - excludeScore >= 70);
+        const recommendedNextStep = this.getRecommendedNextStep({
+            score,
+            excludeScore,
+            confidence,
+            candidateCount: candidates.length,
+            likelyCaptcha,
+        });
+        return {
+            signals,
+            candidates,
+            score,
+            excludeScore,
+            confidence,
+            likelyCaptcha,
+            recommendedNextStep,
+            primaryDetection: likelyCaptcha
+                ? primaryDetection
+                : {
+                    detected: false,
+                    type: 'none',
+                    confidence: 0,
+                    details: candidates.length > 0
+                        ? {
+                            candidates,
+                            reason: 'Signals were ambiguous and require higher-level policy or AI review.',
+                        }
+                        : undefined,
+                },
+        };
+    }
+    async detect(page) {
+        try {
+            logger.info('Starting CAPTCHA detection checks');
+            const urlCheck = await this.checkUrl(page);
+            if (urlCheck.detected) {
+                return urlCheck;
+            }
+            const titleCheck = await this.checkTitle(page);
+            if (titleCheck.detected) {
+                return titleCheck;
+            }
+            const domCheck = await this.checkDOMElements(page);
+            if (domCheck.detected) {
+                return domCheck;
+            }
+            const textCheck = await this.checkPageText(page);
+            if (textCheck.detected) {
+                return textCheck;
+            }
+            const vendorCheck = await this.checkVendorSpecific(page);
+            if (vendorCheck.detected) {
+                return vendorCheck;
+            }
+            logger.info('No CAPTCHA detected by current heuristics');
+            return { detected: false, type: 'none', confidence: 0 };
+        }
+        catch (error) {
+            logger.error('CAPTCHA detection failed', error);
+            return { detected: false, type: 'none', confidence: 0 };
+        }
+    }
+    toAssessmentSignal(source, result) {
+        if (result.detected) {
+            return {
+                source,
+                kind: 'captcha',
+                value: this.getSignalValue(source, result),
+                confidence: result.confidence,
+                typeHint: result.type,
+                providerHint: result.providerHint,
+                details: result.details,
+            };
+        }
+        if (result.falsePositiveReason) {
+            return {
+                source,
+                kind: 'exclude',
+                value: result.falsePositiveReason,
+                confidence: result.confidence,
+            };
+        }
+        return null;
+    }
+    toAssessmentCandidate(source, result) {
+        if (!result.detected || result.type === 'none') {
+            return null;
+        }
+        return {
+            source,
+            value: this.getSignalValue(source, result),
+            confidence: result.confidence,
+            type: result.type,
+            providerHint: result.providerHint,
+        };
+    }
+    getSignalValue(source, result) {
+        switch (source) {
+            case 'url':
+                return result.url ?? 'url-match';
+            case 'title':
+                return result.title ?? 'title-match';
+            case 'dom':
+                return result.selector ?? result.type;
+            case 'text':
+                return typeof result.details === 'object' && result.details && 'keyword' in result.details
+                    ? String(result.details.keyword)
+                    : result.type;
+            case 'vendor':
+            default:
+                return result.providerHint ?? result.type;
+        }
+    }
+    matchRule(value, rules) {
+        for (const rule of rules) {
+            const match = value.match(rule.pattern);
+            if (match?.[0]) {
+                return { rule, matchText: match[0] };
+            }
+        }
+        return null;
+    }
+    async confirmRuleWithDOM(page, rule) {
+        if (!rule.requiresDomConfirmation) {
+            return true;
+        }
+        return this.verifyByDOM(page);
+    }
+    buildExcludeResult(sourceLabel, rule, matchText) {
+        logger.debug(`${sourceLabel} matched exclusion rule: ${rule.id}`);
+        return {
+            detected: false,
+            type: 'none',
+            confidence: rule.confidence,
+            falsePositiveReason: `${sourceLabel} exclusion: ${matchText}`,
+        };
+    }
+    buildCaptchaResult(payload) {
+        return {
+            detected: true,
+            confidence: payload.confidence,
+            type: payload.type,
+            providerHint: payload.providerHint,
+            url: payload.url,
+            title: payload.title,
+            selector: payload.selector,
+            details: payload.details,
+        };
+    }
+    async evaluateDomRule(page, rule) {
+        for (const selector of rule.selectors) {
+            const element = await page.$(selector);
+            if (!element) {
+                continue;
+            }
+            if (rule.requiresVisibility) {
+                const isVisible = await element.isIntersectingViewport();
+                if (!isVisible) {
+                    continue;
+                }
+            }
+            if (rule.verifier === 'slider') {
+                const isRealSlider = await this.verifySliderElement(page, selector);
+                if (!isRealSlider) {
+                    logger.debug(`DOM rule ${rule.id} rejected selector after slider verification: ${selector}`);
+                    continue;
+                }
+            }
+            return { selector, rule };
+        }
+        return null;
+    }
+    getRecommendedNextStep(input) {
+        if (input.candidateCount === 0) {
+            return 'ignore';
+        }
+        if (!input.likelyCaptcha) {
+            return 'ask_ai';
+        }
+        if (input.confidence >= 95 || input.candidateCount >= 2 || input.score - input.excludeScore >= 120) {
+            return 'manual';
+        }
+        if (input.excludeScore > 0) {
+            return 'ask_ai';
+        }
+        return 'observe';
+    }
+    async checkUrl(page) {
+        const url = page.url();
+        const excludeRule = this.matchRule(url, CaptchaDetector.EXCLUDE_MATCH_RULES.url);
+        if (excludeRule) {
+            return this.buildExcludeResult('URL', excludeRule.rule, excludeRule.matchText);
+        }
+        const matchRule = this.matchRule(url, CaptchaDetector.CAPTCHA_MATCH_RULES.url);
+        if (matchRule) {
+            const domConfirmed = await this.confirmRuleWithDOM(page, matchRule.rule);
+            if (!domConfirmed) {
+                logger.debug(`URL rule required DOM confirmation but none was found: ${matchRule.rule.id}`);
+                return {
+                    detected: false,
+                    type: 'none',
+                    confidence: matchRule.rule.confidence,
+                    falsePositiveReason: `URLDOM exclusion: ${matchRule.matchText}`,
+                };
+            }
+            logger.warn(`CAPTCHA URL signal detected (confidence: ${matchRule.rule.confidence}%)`);
+            return this.buildCaptchaResult({
+                confidence: matchRule.rule.confidence,
+                type: matchRule.rule.typeHint ?? 'url_redirect',
+                providerHint: matchRule.rule.providerHint,
+                url,
+                details: { ruleId: matchRule.rule.id, ruleLabel: matchRule.rule.label, matchText: matchRule.matchText },
+            });
+        }
+        return { detected: false, type: 'none', confidence: 0 };
+    }
+    async checkTitle(page) {
+        const title = await page.title();
+        const excludeRule = this.matchRule(title, CaptchaDetector.EXCLUDE_MATCH_RULES.title);
+        if (excludeRule) {
+            return this.buildExcludeResult('Title', excludeRule.rule, excludeRule.matchText);
+        }
+        const matchRule = this.matchRule(title, CaptchaDetector.CAPTCHA_MATCH_RULES.title);
+        if (matchRule) {
+            const domConfirmed = await this.confirmRuleWithDOM(page, matchRule.rule);
+            if (!domConfirmed) {
+                logger.debug(`Title rule required DOM confirmation but none was found: ${matchRule.rule.id}`);
+                return {
+                    detected: false,
+                    type: 'none',
+                    confidence: matchRule.rule.confidence,
+                    falsePositiveReason: `TitleDOM exclusion: ${matchRule.matchText}`,
+                };
+            }
+            logger.warn(`CAPTCHA title rule detected: ${matchRule.rule.label}`);
+            return this.buildCaptchaResult({
+                confidence: matchRule.rule.confidence,
+                type: matchRule.rule.typeHint ?? 'page_redirect',
+                providerHint: matchRule.rule.providerHint,
+                title,
+                details: { ruleId: matchRule.rule.id, ruleLabel: matchRule.rule.label, matchText: matchRule.matchText },
+            });
+        }
+        return { detected: false, type: 'none', confidence: 0 };
+    }
+    async checkDOMElements(page) {
+        for (const rule of CaptchaDetector.DOM_MATCH_RULES) {
+            const matched = await this.evaluateDomRule(page, rule);
+            if (matched) {
+                logger.warn(`CAPTCHA DOM rule detected: ${rule.label} (${matched.selector})`);
+                return this.buildCaptchaResult({
+                    confidence: rule.confidence,
+                    type: rule.typeHint,
+                    providerHint: rule.providerHint,
+                    selector: matched.selector,
+                    details: {
+                        ruleId: rule.id,
+                        ruleLabel: rule.label,
+                    },
+                });
+            }
+        }
+        return { detected: false, type: 'none', confidence: 0 };
+    }
+    async checkPageText(page) {
+        const bodyText = await page.evaluate(() => document.body.innerText);
+        const excludeRule = this.matchRule(bodyText, CaptchaDetector.EXCLUDE_MATCH_RULES.text);
+        if (excludeRule) {
+            return this.buildExcludeResult('Text', excludeRule.rule, excludeRule.matchText);
+        }
+        const matchRule = this.matchRule(bodyText, CaptchaDetector.CAPTCHA_MATCH_RULES.text);
+        if (matchRule) {
+            const domConfirmed = await this.confirmRuleWithDOM(page, matchRule.rule);
+            if (!domConfirmed) {
+                logger.debug(`Text rule required DOM confirmation but none was found: ${matchRule.rule.id}`);
+                return {
+                    detected: false,
+                    type: 'none',
+                    confidence: matchRule.rule.confidence,
+                    falsePositiveReason: `TextDOM exclusion: ${matchRule.matchText}`,
+                };
+            }
+            logger.warn(`CAPTCHA text rule detected: ${matchRule.rule.label}`);
+            return this.buildCaptchaResult({
+                confidence: matchRule.rule.confidence,
+                type: matchRule.rule.typeHint ?? 'unknown',
+                providerHint: matchRule.rule.providerHint,
+                details: {
+                    keyword: matchRule.rule.label,
+                    ruleId: matchRule.rule.id,
+                    matchText: matchRule.matchText,
+                },
+            });
+        }
+        return { detected: false, type: 'none', confidence: 0 };
+    }
+    async checkVendorSpecific(_page) {
+        return { detected: false, type: 'none', confidence: 0 };
+    }
+    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) {
+                logger.info('CAPTCHA no longer detected; continuing workflow');
+                return true;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+        logger.error('Timed out while waiting for CAPTCHA completion');
+        return false;
+    }
+    async verifyByDOM(page) {
+        try {
+            const hasSlider = await page.evaluate(() => {
+                const sliderSelectors = [
+                    '.captcha-slider',
+                    '.slide-verify',
+                    '[class*="captcha"][class*="slider"]',
+                    '[class*="verify"][class*="slider"]',
+                ];
+                return sliderSelectors.some((sel) => document.querySelector(sel) !== null);
+            });
+            const hasWidget = await page.evaluate(() => {
+                return (!!document.querySelector('iframe[src*="captcha" i]') ||
+                    !!document.querySelector('iframe[src*="challenge" i]') ||
+                    !!document.querySelector('[data-sitekey]'));
+            });
+            const hasBrowserCheck = await page.evaluate(() => {
+                return (!!document.querySelector('#challenge-form') ||
+                    !!document.querySelector('[class*="browser-check"]') ||
+                    !!document.querySelector('[class*="security-check"]'));
+            });
+            return hasSlider || hasWidget || hasBrowserCheck;
+        }
+        catch (error) {
+            logger.error('DOM verification failed during CAPTCHA detection', error);
+            return false;
+        }
+    }
+    async verifySliderElement(page, selector) {
+        try {
+            const excludeSelectors = CaptchaDetector.EXCLUDE_SELECTORS;
+            const result = await page.evaluate((sel, excludeSels) => {
+                const element = document.querySelector(sel);
+                if (!element)
+                    return false;
+                for (const excludeSel of excludeSels) {
+                    if (element.matches(excludeSel)) {
+                        console.warn(`[CaptchaDetector] Excluded selector match: ${excludeSel}`);
+                        return false;
+                    }
+                    if (element.closest(excludeSel)) {
+                        console.warn(`[CaptchaDetector] Excluded selector ancestor: ${excludeSel}`);
+                        return false;
+                    }
+                }
+                const rect = element.getBoundingClientRect();
+                if (rect.width === 0 || rect.height === 0)
+                    return false;
+                const className = element.className.toLowerCase();
+                const id = element.id.toLowerCase();
+                const excludeKeywords = [
+                    'video',
+                    'player',
+                    'swiper',
+                    'carousel',
+                    'banner',
+                    'gallery',
+                    'douyin',
+                    'tiktok',
+                    'scroll',
+                    'progress',
+                    'range',
+                    'volume',
+                    'seek',
+                    'timeline',
+                ];
+                for (const keyword of excludeKeywords) {
+                    if (className.includes(keyword) || id.includes(keyword)) {
+                        console.warn(`[CaptchaDetector] Excluded class/id keyword: ${keyword}`);
+                        return false;
+                    }
+                }
+                const hasCaptchaKeyword = className.includes('captcha') ||
+                    className.includes('verify') ||
+                    className.includes('challenge') ||
+                    id.includes('captcha') ||
+                    id.includes('verify') ||
+                    id.includes('challenge');
+                const style = window.getComputedStyle(element);
+                const hasDraggableStyle = style.cursor === 'move' || style.cursor === 'grab' || style.cursor === 'grabbing';
+                const hasSliderClass = className.includes('slider') || className.includes('slide');
+                const hasDragAttribute = element.hasAttribute('draggable') ||
+                    element.hasAttribute('data-slide') ||
+                    element.hasAttribute('data-captcha') ||
+                    element.hasAttribute('data-verify');
+                let parent = element.parentElement;
+                let hasParentCaptcha = false;
+                for (let i = 0; i < 3 && parent; i++) {
+                    const parentClass = parent.className.toLowerCase();
+                    const parentId = parent.id.toLowerCase();
+                    if (parentClass.includes('captcha') ||
+                        parentClass.includes('verify') ||
+                        parentClass.includes('challenge') ||
+                        parentId.includes('captcha') ||
+                        parentId.includes('verify')) {
+                        hasParentCaptcha = true;
+                        break;
+                    }
+                    parent = parent.parentElement;
+                }
+                const width = rect.width;
+                const height = rect.height;
+                const hasReasonableSize = width >= 30 && width <= 500 && height >= 30 && height <= 200;
+                if (!hasReasonableSize) {
+                    console.warn(`[CaptchaDetector] Rejected by size heuristic: ${width}x${height}`);
+                    return false;
+                }
+                const conditionA = hasCaptchaKeyword && (hasSliderClass || hasDraggableStyle);
+                const conditionB = hasParentCaptcha && hasSliderClass && hasDragAttribute;
+                const isValid = conditionA || conditionB;
+                if (!isValid) {
+                    console.warn(`[CaptchaDetector] Slider verification rejected - captcha:${hasCaptchaKeyword}, slider:${hasSliderClass}, parent:${hasParentCaptcha}`);
+                }
+                return isValid;
+            }, selector, excludeSelectors);
+            return result;
+        }
+        catch (error) {
+            logger.error('Slider element verification failed', error);
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { CaptchaAssessment, CaptchaNextStep } from '../captcha/types.js';
+export interface CaptchaResolutionContext {
+    autoDetectCaptcha: boolean;
+    autoSwitchHeadless: boolean;
+    isHeadless: boolean;
+}
+export interface CaptchaResolution {
+    action: CaptchaNextStep;
+    reason: string;
+}
+export declare function determineCaptchaResolution(assessment: CaptchaAssessment, context: CaptchaResolutionContext): CaptchaResolution;

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

@@ -0,0 +1,46 @@
+export function determineCaptchaResolution(assessment, context) {
+    if (!context.autoDetectCaptcha) {
+        return {
+            action: 'ignore',
+            reason: 'Automatic CAPTCHA handling is disabled by configuration.',
+        };
+    }
+    switch (assessment.recommendedNextStep) {
+        case 'ignore':
+            return {
+                action: 'ignore',
+                reason: 'Rule-based assessment did not find strong CAPTCHA evidence.',
+            };
+        case 'ask_ai':
+            return {
+                action: 'ask_ai',
+                reason: 'Signals are mixed or ambiguous; escalate to AI/manual review instead of auto-acting.',
+            };
+        case 'observe':
+            return {
+                action: 'observe',
+                reason: 'There are weak CAPTCHA signals, but not enough to justify intervention yet.',
+            };
+        case 'switch_to_headed':
+            return context.isHeadless && context.autoSwitchHeadless
+                ? {
+                    action: 'switch_to_headed',
+                    reason: 'High-confidence CAPTCHA detected in headless mode; switch to headed mode for manual completion.',
+                }
+                : {
+                    action: 'manual',
+                    reason: 'CAPTCHA detected, but headed switching is disabled or already unnecessary.',
+                };
+        case 'manual':
+        default:
+            return context.isHeadless && context.autoSwitchHeadless
+                ? {
+                    action: 'switch_to_headed',
+                    reason: 'CAPTCHA detected and headed mode is allowed for manual completion.',
+                }
+                : {
+                    action: 'manual',
+                    reason: 'CAPTCHA detected; wait for manual completion in the current browser mode.',
+                };
+    }
+}

package/dist/src/modules/captcha/rules/assessment-rules.d.ts

@@ -0,0 +1,11 @@
+import type { CaptchaHeuristicRule } from '../../captcha/types.js';
+export declare const CAPTCHA_MATCH_RULES: Readonly<{
+    url: readonly CaptchaHeuristicRule[];
+    title: readonly CaptchaHeuristicRule[];
+    text: readonly CaptchaHeuristicRule[];
+}>;
+export declare const EXCLUDE_MATCH_RULES: Readonly<{
+    url: readonly CaptchaHeuristicRule[];
+    title: readonly CaptchaHeuristicRule[];
+    text: readonly CaptchaHeuristicRule[];
+}>;

package/dist/src/modules/captcha/rules/assessment-rules.js

@@ -0,0 +1,102 @@
+export const CAPTCHA_MATCH_RULES = {
+    url: [
+        {
+            id: 'edge-browser-check',
+            label: 'edge browser challenge',
+            pattern: /(cdn-cgi\/challenge|challenge-platform|browser-check|security-check|bot-check|interstitial)/i,
+            confidence: 95,
+            typeHint: 'browser_check',
+            providerHint: 'edge_service',
+        },
+        {
+            id: 'embedded-widget-url',
+            label: 'embedded widget challenge path',
+            pattern: /(captcha-frame|challenge-frame|widget-challenge|widget\/verify|siteverify|sitekey)/i,
+            confidence: 90,
+            typeHint: 'widget',
+            providerHint: 'embedded_widget',
+        },
+        {
+            id: 'generic-url-challenge',
+            label: 'generic captcha-like URL path',
+            pattern: /(captcha|challenge|verify|verification|robot-check|security-check|bot-check)/i,
+            confidence: 70,
+            requiresDomConfirmation: true,
+            typeHint: 'url_redirect',
+        },
+    ],
+    title: [
+        {
+            id: 'generic-title-en',
+            label: 'generic captcha title (english)',
+            pattern: /\b(captcha|challenge|verify|verification|robot|human|security check|bot check|anti-bot)\b/i,
+            confidence: 78,
+            requiresDomConfirmation: true,
+            typeHint: 'page_redirect',
+        },
+        {
+            id: 'generic-title-zh',
+            label: 'generic captcha title (chinese)',
+            pattern: /(验证码|安全验证|人机验证|滑动验证|身份验证|安全检测)/,
+            confidence: 82,
+            requiresDomConfirmation: true,
+            typeHint: 'page_redirect',
+        },
+    ],
+    text: [
+        {
+            id: 'generic-text-en',
+            label: 'generic captcha challenge text (english)',
+            pattern: /(Please verify|Verify you are human|Complete the security check|Slide to verify|Click to verify|Drag the slider|Prove you are human|I am not a robot|Checking your browser|Just a moment|Checking if the site connection is secure|This process is automatic|Protected by|Powered by|Are you a robot|Confirm you are human|Security verification required)/i,
+            confidence: 78,
+            requiresDomConfirmation: true,
+            typeHint: 'unknown',
+        },
+        {
+            id: 'generic-text-zh',
+            label: 'generic captcha challenge text (chinese)',
+            pattern: /(请完成安全验证|请滑动验证|拖动滑块|点击验证|人机验证|安全检测中|请证明您是人类|正在检查您的浏览器|请稍候|验证您的身份|请完成验证|滑动滑块|请拖动滑块完成验证)/,
+            confidence: 82,
+            requiresDomConfirmation: true,
+            typeHint: 'unknown',
+        },
+    ],
+};
+export const EXCLUDE_MATCH_RULES = {
+    url: [
+        {
+            id: 'otp-url-flow',
+            label: 'otp/account verification URL',
+            pattern: /(verify-email|verify-phone|email-verification|account-verification|verify-account|phone-verification|sms-verification|reset-password|forgot-password|验证邮箱|验证手机|重置密码)/i,
+            confidence: 95,
+        },
+    ],
+    title: [
+        {
+            id: 'otp-title-flow',
+            label: 'otp/account verification title',
+            pattern: /(verification code|enter code|sms code|email verification|phone verification|verify your email|verify your phone|短信验证|邮箱验证|输入验证码|手机验证|登录验证|双重验证)/i,
+            confidence: 88,
+        },
+        {
+            id: 'auth-title-flow',
+            label: '2fa/authenticator title',
+            pattern: /\b(two-factor|2fa|two-factor authentication)\b/i,
+            confidence: 84,
+        },
+    ],
+    text: [
+        {
+            id: 'otp-text-flow',
+            label: 'otp/account verification text',
+            pattern: /(Enter verification code|Get code|Send code|Enter the code|We sent a code|verification code sent|输入验证码|获取验证码|发送验证码|已发送验证码)/i,
+            confidence: 82,
+        },
+        {
+            id: '2fa-text-flow',
+            label: '2fa/authenticator text',
+            pattern: /(Enter your authenticator code|Two-factor authentication|双因素认证)/i,
+            confidence: 84,
+        },
+    ],
+};

package/dist/src/modules/captcha/rules/captcha-keywords.d.ts

@@ -0,0 +1,5 @@
+export declare const CAPTCHA_KEYWORDS: {
+    readonly title: string[];
+    readonly url: string[];
+    readonly text: string[];
+};