@jshookmcp/jshook 0.2.6 → 0.2.8

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

@@ -1,495 +0,0 @@
-import {} from 'rebrowser-puppeteer-core';
-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

@@ -1,11 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

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