is-antibot 1.3.6 → 1.4.1

package/README.md

@@ -67,14 +67,14 @@ const isAntibot = require('is-antibot')
 const response = await fetch('https://www.linkedin.com/in/kikobeats/')
 const html = await response.text()
 
-const { detected, provider } = isAntibot({
+const { detected, provider, detection } = isAntibot({
   headers: response.headers,
   html,
   url: response.url
 })
 
 if (detected) {
-  console.log(`Antibot detected: ${provider}`)
+  console.log(`Antibot detected: ${provider} via ${detection}`)
 }
 ```
 
@@ -84,10 +84,10 @@ It also works with [got](https://github.com/sindresorhus/got) or any library whe
 const response = await got('https://www.linkedin.com/in/kikobeats/')
   .catch(error => errorresponse)
 
-const { detected, provider } = isAntibot(response)
+const { detected, provider, detection } = isAntibot(response)
 
 if (detected) {
-  console.log(`Antibot detected: ${provider}`)
+  console.log(`Antibot detected: ${provider} via ${detection}`)
 }
 ```
 
@@ -95,6 +95,7 @@ The library returns an object with the following properties:
 
 - `detected` (boolean): Whether an antibot challenge was detected
 - `provider` (string|null): The name of the detected provider (e.g., 'cloudflare', 'recaptcha')
+- `detection` (string|null): Where the signal came from: `'headers'`, `'cookies'`, `'html'`, or `'url'`
 
 ## License
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "is-antibot",
   "description": "Identify if a response is an antibot challenge from CloudFlare, Akamai, DataDome, Vercel, PerimeterX, Shape Security, and more, including CAPTCHA providers like reCAPTCHA and hCaptcha.",
   "homepage": "https://github.com/microlinkhq/is-antibot",
-  "version": "1.3.6",
+  "version": "1.4.1",
   "exports": {
     ".": "./src/index.js"
   },

package/src/index.js

@@ -3,6 +3,13 @@
 const { splitSetCookieString } = require('cookie-es')
 const debug = require('debug-logfmt')('is-antibot')
 
+const DETECTION = {
+  HEADERS: 'headers',
+  COOKIES: 'cookies',
+  HTML: 'html',
+  URL: 'url'
+}
+
 const createGetHeader = headers =>
   typeof headers.get === 'function'
     ? name => headers.get(name)
@@ -12,6 +19,14 @@ const createTestPattern = value => {
   if (!value) return () => false
   const lowerValue = value.toLowerCase()
   return (pattern, isRegex = false) => {
+    if (pattern instanceof RegExp) {
+      try {
+        return pattern.test(value)
+      } catch {
+        return false
+      }
+    }
+
     if (isRegex) {
       try {
         return new RegExp(pattern, 'i').test(value)
@@ -23,9 +38,9 @@ const createTestPattern = value => {
   }
 }
 
-const createResult = (detected, provider) => {
-  debug({ detected, provider })
-  return { detected, provider }
+const createResult = (detected, provider, detection = null) => {
+  debug({ detected, provider, detection })
+  return { detected, provider, detection }
 }
 
 const createHasCookie = headers => {
@@ -36,351 +51,370 @@ const createHasCookie = headers => {
     )
 }
 
+const getHeaderNames = headers =>
+  typeof headers.keys === 'function'
+    ? Array.from(headers.keys())
+    : Object.keys(headers)
+
 const detect = ({ headers = {}, html = '', url = '' } = {}) => {
   const getHeader = createGetHeader(headers)
   const hasCookie = createHasCookie(headers)
   const htmlHas = createTestPattern(html)
   const urlHas = createTestPattern(url)
 
+  const hasAnyHeader = headerNames =>
+    headerNames.some(headerName => getHeader(headerName))
+
+  const hasAnyCookie = cookieNames =>
+    cookieNames.some(cookieName => hasCookie(cookieName))
+
+  const hasAnyHtml = patterns => patterns.some(pattern => htmlHas(pattern))
+
+  const hasAnyUrl = patterns => patterns.some(pattern => urlHas(pattern))
+
+  const byHeaders = provider => createResult(true, provider, DETECTION.HEADERS)
+
+  const byCookies = provider => createResult(true, provider, DETECTION.COOKIES)
+
+  const byHtml = provider => createResult(true, provider, DETECTION.HTML)
+
+  const byUrl = provider => createResult(true, provider, DETECTION.URL)
+
   // CloudFlare: Check for cf-mitigated header with 'challenge' value
   // Official docs: https://developers.cloudflare.com/cloudflare-challenges/challenge-types/challenge-pages/detect-response/
   if (getHeader('cf-mitigated') === 'challenge') {
-    return createResult(true, 'cloudflare')
+    return byHeaders('cloudflare')
   }
 
   // Cloudflare: cf_clearance cookie indicates Cloudflare challenge flow
-  if (hasCookie('cf_clearance=')) {
-    return createResult(true, 'cloudflare')
+  if (hasAnyCookie(['cf_clearance='])) {
+    return byCookies('cloudflare')
   }
 
   // Vercel: Check for x-vercel-mitigated header with 'challenge' value
   // Solver reference: https://github.com/glizzykingdreko/Vercel-Attack-Mode-Solver
   if (getHeader('x-vercel-mitigated') === 'challenge') {
-    return createResult(true, 'vercel')
+    return byHeaders('vercel')
   }
 
   // Akamai: Check for akamai-cache-status header starting with 'Error'
   // Official docs: https://techdocs.akamai.com/property-mgr/docs/return-cache-status
   if (getHeader('akamai-cache-status')?.startsWith('Error')) {
-    return createResult(true, 'akamai')
+    return byHeaders('akamai')
   }
 
   // Akamai: Check for additional identifying headers (akamai-grn, x-akamai-session-info)
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-akamai.json
-  if (getHeader('akamai-grn') || getHeader('x-akamai-session-info')) {
-    return createResult(true, 'akamai')
+  if (hasAnyHeader(['akamai-grn', 'x-akamai-session-info'])) {
+    return byHeaders('akamai')
   }
 
   // Akamai: _abck bot manager tracking cookie
-  if (hasCookie('_abck=')) {
-    return createResult(true, 'akamai')
+  if (hasAnyCookie(['_abck='])) {
+    return byCookies('akamai')
   }
 
   // Akamai: Bot Manager API namespace (bmak) in html
-  if (htmlHas('bmak.')) {
-    return createResult(true, 'akamai')
+  if (hasAnyHtml(['bmak.'])) {
+    return byHtml('akamai')
   }
 
   // DataDome: Check for x-dd-b header with values '1' (soft challenge) or '2' (hard challenge/CAPTCHA)
   // Official docs: https://docs.datadome.co/reference/validate-request
   if (['1', '2'].includes(getHeader('x-dd-b'))) {
-    return createResult(true, 'datadome')
+    return byHeaders('datadome')
   }
 
-  // DataDome: Check for x-datadome or x-datadome-cid header presence
-  // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-datadome.json
-  if (getHeader('x-datadome') || getHeader('x-datadome-cid')) {
-    return createResult(true, 'datadome')
+  // DataDome: x-datadome header presence.
+  // Note: `x-datadome: protected` can appear on successful responses.
+  const xDatadome = getHeader('x-datadome')
+  if (xDatadome && String(xDatadome).toLowerCase() !== 'protected') {
+    return byHeaders('datadome')
+  }
+
+  // DataDome: x-datadome-cid header presence
+  if (hasAnyHeader(['x-datadome-cid'])) {
+    return byHeaders('datadome')
   }
 
   // DataDome: datadome tracking cookie
-  if (hasCookie('datadome=')) {
-    return createResult(true, 'datadome')
+  if (hasAnyCookie(['datadome='])) {
+    return byCookies('datadome')
   }
 
   // PerimeterX: Check for X-PX-Authorization header (primary indicator)
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-perimeterx.json
   if (getHeader('x-px-authorization')) {
-    return createResult(true, 'perimeterx')
+    return byHeaders('perimeterx')
   }
 
   // PerimeterX: Check for window._pxAppId, pxInit, or _pxAction in html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-perimeterx.json
-  if (htmlHas('window._pxAppId') || htmlHas('pxInit') || htmlHas('_pxAction')) {
-    return createResult(true, 'perimeterx')
+  if (hasAnyHtml(['window._pxAppId', 'pxInit', '_pxAction'])) {
+    return byHtml('perimeterx')
   }
 
   // PerimeterX: _px3 or _pxhd cookies
-  if (hasCookie('_px3=') || hasCookie('_pxhd=')) {
-    return createResult(true, 'perimeterx')
+  if (hasAnyCookie(['_px3=', '_pxhd='])) {
+    return byCookies('perimeterx')
   }
 
   // Shape Security: Check for dynamic header patterns x-[8chars]-[abcdfz]
   // These headers use 8 random characters followed by suffixes like -a, -b, -c, -d, -f, or -z
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-shapesecurity.json
-  const headerNames = Object.keys(headers)
+  const headerNames = getHeaderNames(headers)
   for (const name of headerNames) {
     if (/^x-[a-z0-9]{8}-[abcdfz]$/i.test(name)) {
-      return createResult(true, 'shapesecurity')
+      return byHeaders('shapesecurity')
     }
   }
 
   // Shape Security: Check for 'shapesecurity' text in response html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-shapesecurity.json
-  if (htmlHas('shapesecurity')) {
-    return createResult(true, 'shapesecurity')
+  if (hasAnyHtml(['shapesecurity'])) {
+    return byHtml('shapesecurity')
   }
 
   // Kasada: Check for x-kasada or x-kasada-challenge headers
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-kasada.json
-  if (getHeader('x-kasada') || getHeader('x-kasada-challenge')) {
-    return createResult(true, 'kasada')
+  if (hasAnyHeader(['x-kasada', 'x-kasada-challenge'])) {
+    return byHeaders('kasada')
   }
 
   // Kasada: Check for __kasada global object or kasada.js script in html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-kasada.json
-  if (htmlHas('__kasada') || htmlHas('kasada.js')) {
-    return createResult(true, 'kasada')
+  if (hasAnyHtml(['__kasada', 'kasada.js'])) {
+    return byHtml('kasada')
   }
 
   // Imperva/Incapsula: Check for x-cdn header with 'Incapsula' value or x-iinfo header
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-incapsula.json
-  if (getHeader('x-cdn') === 'Incapsula' || getHeader('x-iinfo')) {
-    return createResult(true, 'imperva')
+  if (getHeader('x-cdn') === 'Incapsula' || hasAnyHeader(['x-iinfo'])) {
+    return byHeaders('imperva')
   }
 
   // Imperva/Incapsula: Check for 'incapsula' or 'imperva' text in response html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-incapsula.json
-  if (htmlHas('incapsula') || htmlHas('imperva')) {
-    return createResult(true, 'imperva')
+  if (hasAnyHtml(['incapsula', 'imperva'])) {
+    return byHtml('imperva')
   }
 
   // Imperva/Incapsula: incap_ses_, visid_incap_, or reese84 cookies
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-incapsula.json
-  if (
-    hasCookie('incap_ses_') ||
-    hasCookie('visid_incap_') ||
-    hasCookie('reese84=')
-  ) {
-    return createResult(true, 'imperva')
+  if (hasAnyCookie(['incap_ses_', 'visid_incap_', 'reese84='])) {
+    return byCookies('imperva')
   }
 
   // Reblaze: rbzid or rbzsessionid cookies
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-reblaze.json
-  if (hasCookie('rbzid=') || hasCookie('rbzsessionid=')) {
-    return createResult(true, 'reblaze')
+  if (hasAnyCookie(['rbzid=', 'rbzsessionid='])) {
+    return byCookies('reblaze')
   }
 
   // Reblaze: Check for 'reblaze' text in response html
-  if (htmlHas('reblaze')) {
-    return createResult(true, 'reblaze')
+  if (hasAnyHtml(['reblaze'])) {
+    return byHtml('reblaze')
   }
 
   // Cheq: Check for CheqSdk or cheqzone.com in html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-cheq.json
-  if (htmlHas('CheqSdk') || htmlHas('cheqzone.com')) {
-    return createResult(true, 'cheq')
+  if (hasAnyHtml(['CheqSdk', 'cheqzone.com'])) {
+    return byHtml('cheq')
   }
 
   // Cheq: Check for cheqzone.com or cheq.ai in URL
-  if (urlHas('cheqzone\\.com', true) || urlHas('cheq\\.ai', true)) {
-    return createResult(true, 'cheq')
+  if (hasAnyUrl([/cheqzone\.com/i, /cheq\.ai/i])) {
+    return byUrl('cheq')
   }
 
   // Sucuri: Check for 'sucuri' text in response html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-sucuri.json
-  if (htmlHas('sucuri')) {
-    return createResult(true, 'sucuri')
+  if (hasAnyHtml(['sucuri'])) {
+    return byHtml('sucuri')
   }
 
   // ThreatMetrix: Check for 'ThreatMetrix' in html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-threatmetrix.json
-  if (htmlHas('ThreatMetrix')) {
-    return createResult(true, 'threatmetrix')
+  if (hasAnyHtml(['ThreatMetrix'])) {
+    return byHtml('threatmetrix')
   }
 
   // ThreatMetrix: Check for fp/check.js fingerprint endpoint in URL
-  if (urlHas('fp/check.js')) {
-    return createResult(true, 'threatmetrix')
+  if (hasAnyUrl(['fp/check.js'])) {
+    return byUrl('threatmetrix')
   }
 
   // Meetrics: Check for 'meetrics' text in response html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-meetrics.json
-  if (htmlHas('meetrics')) {
-    return createResult(true, 'meetrics')
+  if (hasAnyHtml(['meetrics'])) {
+    return byHtml('meetrics')
   }
 
   // Meetrics: Check for meetrics.com in URL
-  if (urlHas('meetrics\\.com', true)) {
-    return createResult(true, 'meetrics')
+  if (hasAnyUrl([/meetrics\.com/i])) {
+    return byUrl('meetrics')
   }
 
   // Ocule: Check for ocule.co.uk in html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-ocule.json
-  if (htmlHas('ocule.co.uk')) {
-    return createResult(true, 'ocule')
+  if (hasAnyHtml(['ocule.co.uk'])) {
+    return byHtml('ocule')
   }
 
   // Ocule: Check for ocule.co.uk in URL
-  if (urlHas('ocule\\.co\\.uk', true)) {
-    return createResult(true, 'ocule')
+  if (hasAnyUrl([/ocule\.co\.uk/i])) {
+    return byUrl('ocule')
   }
 
   // reCAPTCHA: Check for recaptcha/api, google.com/recaptcha, gstatic.com/recaptcha, or recaptcha.net in URL
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-recaptcha.json
   if (
-    urlHas('recaptcha/api') ||
-    urlHas('google\\.com/recaptcha', true) ||
-    urlHas('gstatic.com/recaptcha') ||
-    urlHas('recaptcha.net')
+    hasAnyUrl(['recaptcha/api', 'gstatic.com/recaptcha', 'recaptcha.net']) ||
+    hasAnyUrl([/google\.com\/recaptcha/i])
   ) {
-    return createResult(true, 'recaptcha')
+    return byUrl('recaptcha')
   }
 
   // reCAPTCHA: Check for grecaptcha API usage in html (JavaScript indicator)
   // Note: plain "grecaptcha" is too broad (e.g. ".grecaptcha-badge" CSS appears on normal YouTube pages)
   if (
-    htmlHas(
-      '\\b(?:window\\.)?grecaptcha\\s*\\.(?:execute|render|ready|getResponse|enterprise)\\b',
-      true
-    ) ||
-    htmlHas('\\b(?:window\\.)?grecaptcha\\s*\\(', true) ||
-    htmlHas('\\b__grecaptcha_cfg\\b', true)
+    hasAnyHtml([
+      /\b(?:window\.)?grecaptcha\s*\.(?:execute|render|ready|getResponse|enterprise)\b/i,
+      /\b(?:window\.)?grecaptcha\s*\(/i,
+      /\b__grecaptcha_cfg\b/i
+    ])
   ) {
-    return createResult(true, 'recaptcha')
+    return byHtml('recaptcha')
   }
 
   // reCAPTCHA: Check for g-recaptcha container class in html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-recaptcha.json
-  if (htmlHas('g-recaptcha')) {
-    return createResult(true, 'recaptcha')
+  if (hasAnyHtml(['g-recaptcha'])) {
+    return byHtml('recaptcha')
   }
 
   // hCaptcha: Check for hcaptcha.com domain in URL
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-hcaptcha.json
-  if (urlHas('hcaptcha\\.com', true)) {
-    return createResult(true, 'hcaptcha')
+  if (hasAnyUrl([/hcaptcha\.com/i])) {
+    return byUrl('hcaptcha')
   }
 
   // hCaptcha: Check for hcaptcha.com API domain or h-captcha container class in html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-hcaptcha.json
   // Note: bare 'hcaptcha' matches too broadly (could appear in articles discussing hCaptcha)
-  if (htmlHas('hcaptcha.com') || htmlHas('h-captcha')) {
-    return createResult(true, 'hcaptcha')
+  if (hasAnyHtml(['hcaptcha.com', 'h-captcha'])) {
+    return byHtml('hcaptcha')
   }
 
   // FunCaptcha (Arkose Labs): Check for arkoselabs.com or funcaptcha in URL
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-funcaptcha.json
-  if (urlHas('arkoselabs\\.com', true) || urlHas('funcaptcha')) {
-    return createResult(true, 'funcaptcha')
+  if (hasAnyUrl([/arkoselabs\.com/i]) || hasAnyUrl(['funcaptcha'])) {
+    return byUrl('funcaptcha')
   }
 
   // FunCaptcha (Arkose Labs): Check for arkoselabs.com API domain or funcaptcha in html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-funcaptcha.json
   // Note: bare 'arkose' matches too broadly (e.g. Facebook bundles Arkose SDK for login without blocking content)
-  if (htmlHas('arkoselabs.com') || htmlHas('funcaptcha')) {
-    return createResult(true, 'funcaptcha')
+  if (hasAnyHtml(['arkoselabs.com', 'funcaptcha'])) {
+    return byHtml('funcaptcha')
   }
 
   // GeeTest: Check for geetest.com domain in URL
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-geetest.json
-  if (urlHas('geetest\\.com', true)) {
-    return createResult(true, 'geetest')
+  if (hasAnyUrl([/geetest\.com/i])) {
+    return byUrl('geetest')
   }
 
   // GeeTest: Check for geetest object or text in html
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-geetest.json
   // Note: bare 'gt.js' removed (too generic, any script named gt.js would match)
-  if (htmlHas('geetest')) {
-    return createResult(true, 'geetest')
+  if (hasAnyHtml(['geetest'])) {
+    return byHtml('geetest')
   }
 
   // Cloudflare Turnstile: Check for challenges.cloudflare.com/turnstile in URL
-  if (urlHas('challenges\\.cloudflare\\.com/turnstile', true)) {
-    return createResult(true, 'cloudflare-turnstile')
+  if (hasAnyUrl([/challenges\.cloudflare\.com\/turnstile/i])) {
+    return byUrl('cloudflare-turnstile')
   }
 
   // Cloudflare Turnstile: Check for cf-turnstile class or turnstile API script in html
   // Note: bare 'turnstile' matches too broadly (common English word)
-  if (
-    htmlHas('cf-turnstile') ||
-    htmlHas('challenges.cloudflare.com/turnstile')
-  ) {
-    return createResult(true, 'cloudflare-turnstile')
+  if (hasAnyHtml(['cf-turnstile', 'challenges.cloudflare.com/turnstile'])) {
+    return byHtml('cloudflare-turnstile')
   }
 
   // Friendly Captcha: Check for friendlycaptcha.com in URL
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-friendlycaptcha.json
-  if (urlHas('friendlycaptcha\\.com', true)) {
-    return createResult(true, 'friendly-captcha')
+  if (hasAnyUrl([/friendlycaptcha\.com/i])) {
+    return byUrl('friendly-captcha')
   }
 
   // Friendly Captcha: Check for frc-captcha container or friendlyChallenge object in html
-  if (htmlHas('frc-captcha') || htmlHas('friendlyChallenge')) {
-    return createResult(true, 'friendly-captcha')
+  if (hasAnyHtml(['frc-captcha', 'friendlyChallenge'])) {
+    return byHtml('friendly-captcha')
   }
 
   // Captcha.eu: Check for captcha.eu in URL
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-captchaeu.json
-  if (urlHas('captcha\\.eu', true)) {
-    return createResult(true, 'captcha-eu')
+  if (hasAnyUrl([/captcha\.eu/i])) {
+    return byUrl('captcha-eu')
   }
 
   // Captcha.eu: Check for CaptchaEU or captchaeu in html
-  if (htmlHas('CaptchaEU') || htmlHas('captchaeu')) {
-    return createResult(true, 'captcha-eu')
+  if (hasAnyHtml(['CaptchaEU', 'captchaeu'])) {
+    return byHtml('captcha-eu')
   }
 
   // QCloud Captcha (Tencent): Check for turing.captcha.qcloud.com in URL
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-qcloud.json
-  if (urlHas('turing\\.captcha\\.qcloud\\.com', true)) {
-    return createResult(true, 'qcloud-captcha')
+  if (hasAnyUrl([/turing\.captcha\.qcloud\.com/i])) {
+    return byUrl('qcloud-captcha')
   }
 
   // QCloud Captcha: Check for TencentCaptcha or turing.captcha in html
-  if (htmlHas('TencentCaptcha') || htmlHas('turing.captcha')) {
-    return createResult(true, 'qcloud-captcha')
+  if (hasAnyHtml(['TencentCaptcha', 'turing.captcha'])) {
+    return byHtml('qcloud-captcha')
   }
 
   // AliExpress CAPTCHA: Check for punish?x5secdata in URL
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/captcha/detect-aliexpress.json
-  if (urlHas('punish\\?x5secdata', true)) {
-    return createResult(true, 'aliexpress-captcha')
+  if (hasAnyUrl([/punish\?x5secdata/i])) {
+    return byUrl('aliexpress-captcha')
   }
 
   // AliExpress CAPTCHA: Check for x5secdata in html
-  if (htmlHas('x5secdata')) {
-    return createResult(true, 'aliexpress-captcha')
+  if (hasAnyHtml(['x5secdata'])) {
+    return byHtml('aliexpress-captcha')
   }
 
   // LinkedIn: trkCode=bf cookie ("bot filter") is set when LinkedIn blocks a request
-  if (hasCookie('trkCode=bf')) {
-    return createResult(true, 'linkedin')
+  if (hasAnyCookie(['trkCode=bf'])) {
+    return byCookies('linkedin')
   }
 
   // YouTube: empty title pattern indicates a degraded response requiring BotGuard JS attestation
   // Normal pages have `<title>Video Title - YouTube</title>`, bots get `<title> - YouTube</title>`
-  if (htmlHas('<title>\\s*-\\s*YouTube<\\/title>', true)) {
-    return createResult(true, 'youtube')
+  if (hasAnyHtml([/<title>\s*-\s*YouTube<\/title>/i])) {
+    return byHtml('youtube')
   }
 
   // AWS WAF: Check for x-amzn-waf-action or x-amzn-requestid headers
   // Reference: https://github.com/scrapfly/Antibot-Detector/blob/main/detectors/antibot/detect-aws-waf.json
-  if (getHeader('x-amzn-waf-action') || getHeader('x-amzn-requestid')) {
-    return createResult(true, 'aws-waf')
+  if (hasAnyHeader(['x-amzn-waf-action', 'x-amzn-requestid'])) {
+    return byHeaders('aws-waf')
   }
 
   // AWS WAF: Check for aws-waf or awswaf text in html
-  if (htmlHas('aws-waf') || htmlHas('awswaf')) {
-    return createResult(true, 'aws-waf')
+  if (hasAnyHtml(['aws-waf', 'awswaf'])) {
+    return byHtml('aws-waf')
   }
 
   // AWS WAF: aws-waf-token cookie
-  if (hasCookie('aws-waf-token=')) {
-    return createResult(true, 'aws-waf')
+  if (hasAnyCookie(['aws-waf-token='])) {
+    return byCookies('aws-waf')
   }
 
-  return createResult(false, null)
+  return createResult(false, null, null)
 }
 
 const isAntibot = (input = {}) => {