@omnicross/core 0.2.0 → 0.2.1

package/dist/chunk-NLUOTJWB.js

@@ -0,0 +1,673 @@
+import {
+  getSearchProxyDispatcher,
+  resolveSearchProxySettings,
+  validateEgressUrl
+} from "./chunk-DBBR6RHF.js";
+
+// src/search/http/errors.ts
+import {
+  isSearchProviderError,
+  SearchProviderError
+} from "@omnicross/contracts/search-types";
+
+// src/search/http/types.ts
+var SEARCH_HTTP_TRANSPORT_ID = "undici";
+
+// src/search/http/errors.ts
+function searchHttpError(code, message, init) {
+  return new SearchProviderError(code, message, {
+    providerId: init.providerId,
+    retryable: init.retryable,
+    cause: init.cause,
+    // transport/stage last so a caller-supplied `details` can never shadow them.
+    details: { ...init.details, transport: SEARCH_HTTP_TRANSPORT_ID, stage: init.stage }
+  });
+}
+function asSearchProviderError(value, providerId, fallbackStage) {
+  if (isSearchProviderError(value)) {
+    const complete = value.providerId !== void 0 && value.details?.transport !== void 0 && value.details?.stage !== void 0;
+    if (complete) return value;
+    return searchHttpError(value.code, value.message, {
+      stage: value.details?.stage ?? fallbackStage,
+      providerId: value.providerId ?? providerId,
+      retryable: value.retryable,
+      cause: value,
+      details: value.details
+    });
+  }
+  return searchHttpError("upstream_unavailable", describeError(value), {
+    stage: fallbackStage,
+    providerId,
+    retryable: true,
+    cause: value
+  });
+}
+function describeError(value) {
+  if (value instanceof Error && value.message) return value.message;
+  if (typeof value === "string" && value) return value;
+  return "search request failed";
+}
+function hostOf(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "unknown-host";
+  }
+}
+
+// src/search/http/engine.ts
+var SEARCH_RESPONSE_BYTES = 2 * 1024 * 1024;
+var DEFAULT_SEARCH_TIMEOUT_MS = 15e3;
+var DEFAULT_MAX_RESULTS = 5;
+var MAX_RESULTS = 10;
+function clampMaxResults(maxResults) {
+  return Math.min(Math.max(maxResults ?? DEFAULT_MAX_RESULTS, 1), MAX_RESULTS);
+}
+async function runHttpSearch(engine, transport, query, options = {}) {
+  const providerId = engine.providerId;
+  if (options.signal?.aborted) {
+    throw searchHttpError("cancelled", "search was cancelled before it started", {
+      stage: "fetch",
+      providerId,
+      retryable: false
+    });
+  }
+  const maxResults = clampMaxResults(options.maxResults);
+  const timeoutMs = options.timeout ?? DEFAULT_SEARCH_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  const urls = engine.buildUrls(query);
+  let sawRecognizedEmpty = false;
+  let lastError = searchHttpError(
+    "timeout",
+    "search deadline expired before any request was attempted",
+    { stage: "fetch", providerId, retryable: true }
+  );
+  for (const [index, url] of urls.entries()) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) break;
+    const attemptTimeoutMs = Math.max(1, Math.floor(remainingMs / (urls.length - index)));
+    try {
+      const resource = await transport(url, {
+        timeoutMs: attemptTimeoutMs,
+        maxResponseBytes: SEARCH_RESPONSE_BYTES,
+        signal: options.signal,
+        providerId
+      });
+      if (engine.isChallengeStatus(resource.status)) {
+        throw searchHttpError(
+          "upstream_unavailable",
+          `server returned a bot-challenge response (HTTP ${resource.status})`,
+          { stage: "challenge", providerId, retryable: false, details: { status: String(resource.status) } }
+        );
+      }
+      const trustError = engine.trustError?.(resource.finalUrl, resource.rawText);
+      if (trustError) {
+        throw searchHttpError("upstream_unavailable", trustError, {
+          stage: "trust",
+          providerId,
+          retryable: false
+        });
+      }
+      const parsed = engine.parse(resource.rawText, maxResults);
+      if (parsed.results.length > 0) return parsed.results;
+      if (parsed.recognized) {
+        sawRecognizedEmpty = true;
+        continue;
+      }
+      throw searchHttpError(
+        "parse_failed",
+        `response is not recognizable as a ${engine.label} search result page`,
+        { stage: "parse", providerId, retryable: false }
+      );
+    } catch (error) {
+      const normalized = asSearchProviderError(error, providerId, "fetch");
+      if (normalized.code === "cancelled") throw normalized;
+      lastError = normalized;
+    }
+  }
+  if (sawRecognizedEmpty) return [];
+  throw lastError;
+}
+
+// src/search/http/parsers/bing.ts
+import { JSDOM } from "jsdom";
+
+// src/search/http/text.ts
+import { decodeHTML } from "entities";
+var MAX_TEXT_LENGTH = 500;
+function cleanText(value) {
+  return decodeHTML(value ?? "").replace(/\s+/g, " ").trim().slice(0, MAX_TEXT_LENGTH);
+}
+function isUsableResult(result) {
+  return Boolean(result.title && /^https?:\/\//i.test(result.url));
+}
+
+// src/search/http/parsers/bing.ts
+var BING_SERP_URL = "https://www.bing.com/search";
+var BING_SERP_MARKERS = "#b_results, .b_algo";
+function bingResultLinks(document) {
+  const scoped = [
+    ...document.querySelectorAll("li.b_algo h2 a, #b_results .b_algo h2 a")
+  ];
+  return scoped.length > 0 ? scoped : [...document.querySelectorAll("h2 a[href]")];
+}
+function isBingSerp(document) {
+  return document.querySelector(BING_SERP_MARKERS) !== null;
+}
+function parseBingSerp(html, maxResults) {
+  const document = new JSDOM(html, { url: BING_SERP_URL }).window.document;
+  const results = bingResultLinks(document).map((link) => {
+    const container = link.closest("li.b_algo, .b_algo");
+    return {
+      title: cleanText(link.textContent),
+      url: cleanBingUrl(link.href),
+      content: cleanText(container?.querySelector(".b_caption p, .b_algoSlug, p")?.textContent)
+    };
+  }).filter(isUsableResult).slice(0, maxResults);
+  return { recognized: isBingSerp(document), results };
+}
+function cleanBingUrl(rawUrl) {
+  try {
+    const url = new URL(rawUrl, "https://www.bing.com");
+    const hostname = url.hostname.toLowerCase();
+    if ((hostname === "bing.com" || hostname.endsWith(".bing.com")) && url.pathname === "/ck/a") {
+      const encodedTarget = url.searchParams.get("u");
+      if (encodedTarget?.startsWith("a1")) {
+        const decoded = Buffer.from(encodedTarget.slice(2), "base64url").toString("utf8");
+        if (/^https?:\/\//i.test(decoded)) return decoded;
+      }
+    }
+    return url.href;
+  } catch {
+    return rawUrl;
+  }
+}
+
+// src/search/http/trust.ts
+import { JSDOM as JSDOM2 } from "jsdom";
+var QUERY_STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "at",
+  "by",
+  "for",
+  "from",
+  "in",
+  "of",
+  "on",
+  "or",
+  "the",
+  "to",
+  "with",
+  "site",
+  "filetype",
+  "inurl",
+  "intitle"
+]);
+function bingSearchPageTrustError(finalUrl, html) {
+  let parsed;
+  try {
+    parsed = new URL(finalUrl);
+  } catch {
+    return null;
+  }
+  if (parsed.pathname !== "/search") return null;
+  const hostname = parsed.hostname.toLowerCase();
+  if (hostname !== "bing.com" && !hostname.endsWith(".bing.com")) return null;
+  return bingTrustError(parsed.searchParams.get("q") ?? "", html);
+}
+function bingTrustError(query, html) {
+  const document = new JSDOM2(html).window.document;
+  const links = bingResultLinks(document);
+  if (links.length === 0) return null;
+  const terms = meaningfulQueryTerms(query);
+  if (terms.length === 0) return null;
+  const titleSearchable = links.map((link) => link.textContent ?? "").join(" ").normalize("NFKC").toLocaleLowerCase();
+  if (!terms.some((term) => titleSearchable.includes(term))) {
+    return "Bing returned an untrusted search result page with zero query-term hits in result titles; refusing to return possible bot-decoy content.";
+  }
+  const searchable = links.map((link) => {
+    const container = link.closest("li.b_algo, .b_algo");
+    return `${link.textContent ?? ""} ${link.getAttribute("href") ?? ""} ${container?.querySelector(".b_caption p, .b_algoSlug, p")?.textContent ?? ""}`;
+  }).join(" ").normalize("NFKC").toLocaleLowerCase();
+  const coveredTerms = terms.filter((term) => searchable.includes(term));
+  const requiredCoverage = terms.length === 1 ? 1 : 2;
+  return new Set(coveredTerms).size >= requiredCoverage ? null : "Bing returned an untrusted search result page; refusing to return possible bot-decoy content.";
+}
+function meaningfulQueryTerms(query) {
+  const terms = query.normalize("NFKC").toLocaleLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? [];
+  const expanded = terms.flatMap((term) => {
+    if (QUERY_STOP_WORDS.has(term) || !/\p{Script=Han}/u.test(term)) return [term];
+    const characters = [...term];
+    const bigrams = characters.slice(0, -1).map((character, index) => {
+      return character + characters[index + 1];
+    });
+    return [term, ...bigrams];
+  });
+  return [...new Set(expanded.filter((term) => !QUERY_STOP_WORDS.has(term)))];
+}
+
+// src/search/http/transport.ts
+import { isSearchProviderError as isSearchProviderError2 } from "@omnicross/contracts/search-types";
+import { fetch as undiciFetch } from "undici";
+
+// src/search/http/body-decode.ts
+var META_SNIFF_BYTES = 4096;
+var UTF8_LABELS = /* @__PURE__ */ new Set(["utf-8", "utf8", "unicode-1-1-utf-8", "x-unicode20utf8"]);
+function charsetFromContentType(contentType) {
+  const match = /charset\s*=\s*["']?([\w:.-]+)/i.exec(contentType);
+  return match ? match[1].toLowerCase() : null;
+}
+function charsetFromMeta(bytes) {
+  const head = Buffer.from(bytes.subarray(0, META_SNIFF_BYTES)).toString("latin1");
+  const metaCharset = /<meta[^>]+charset\s*=\s*["']?\s*([\w:.-]+)/i.exec(head);
+  return metaCharset ? metaCharset[1].toLowerCase() : null;
+}
+function decodeSearchBody(bytes, contentType = "") {
+  const declared = charsetFromContentType(contentType) ?? charsetFromMeta(bytes);
+  if (declared && !UTF8_LABELS.has(declared)) {
+    const decoder = decoderFor(declared);
+    if (decoder) return decoder.decode(bytes);
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return new TextDecoder("windows-1252").decode(bytes);
+  }
+}
+function decoderFor(label) {
+  try {
+    return new TextDecoder(label);
+  } catch {
+    return null;
+  }
+}
+
+// src/search/http/headers.ts
+var CHROME_VERSION = "144.0.0.0";
+var CHROME_MAJOR = CHROME_VERSION.split(".")[0];
+var SEARCH_BROWSER_HEADERS = Object.freeze({
+  "User-Agent": `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${CHROME_VERSION} Safari/537.36`,
+  Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+  "Accept-Language": "en-US,en;q=0.9",
+  "Cache-Control": "no-cache",
+  Pragma: "no-cache",
+  "Sec-CH-UA": `"Chromium";v="${CHROME_MAJOR}", "Not=A?Brand";v="24"`,
+  "Sec-CH-UA-Mobile": "?0",
+  "Sec-CH-UA-Platform": '"Windows"',
+  "Sec-Fetch-Dest": "document",
+  "Sec-Fetch-Mode": "navigate",
+  "Sec-Fetch-Site": "none",
+  "Sec-Fetch-User": "?1",
+  "Upgrade-Insecure-Requests": "1"
+});
+function searchBrowserHeaders() {
+  return { ...SEARCH_BROWSER_HEADERS };
+}
+
+// src/search/http/transport.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+var MAX_REDIRECTS = 5;
+var REFUSED_STATUSES = /* @__PURE__ */ new Set([401, 403, 407, 429]);
+function createSearchHttpTransport(options = {}) {
+  const fetchImpl = options.fetch ?? createUndiciFetch(options.env);
+  const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS;
+  const egressPolicy = options.egressPolicy;
+  return async (url, request) => {
+    const context = {
+      providerId: request.providerId,
+      host: hostOf(url)
+    };
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(request.signal?.reason);
+    request.signal?.addEventListener("abort", onAbort, { once: true });
+    if (request.signal?.aborted) onAbort();
+    const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    let deadlineExpired = false;
+    const timer = setTimeout(() => {
+      deadlineExpired = true;
+      controller.abort();
+    }, timeoutMs);
+    try {
+      const { response, finalUrl } = await fetchWithRedirectLimit(
+        fetchImpl,
+        url,
+        controller.signal,
+        maxRedirects,
+        context,
+        egressPolicy
+      );
+      context.host = hostOf(finalUrl);
+      const contentType = response.headers.get("content-type") ?? "";
+      const rawText = await readBodyWithLimit(
+        response,
+        request.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES,
+        context
+      );
+      assertStatusUsable(response.status, context);
+      assertNoBotChallenge(rawText, context);
+      return { finalUrl, status: response.status, contentType, rawText };
+    } catch (error) {
+      if (request.signal?.aborted) {
+        throw searchHttpError("cancelled", "search request was cancelled by the caller", {
+          stage: "fetch",
+          providerId: context.providerId,
+          retryable: false,
+          cause: error,
+          details: { host: context.host }
+        });
+      }
+      if (deadlineExpired) {
+        throw searchHttpError("timeout", `search request exceeded its ${timeoutMs}ms budget`, {
+          stage: "fetch",
+          providerId: context.providerId,
+          retryable: true,
+          cause: error,
+          details: { host: context.host }
+        });
+      }
+      throw asSearchProviderError(error, context.providerId, "fetch");
+    } finally {
+      clearTimeout(timer);
+      request.signal?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+var defaultSearchHttpTransport = createSearchHttpTransport();
+function createUndiciFetch(env) {
+  return async (url, init) => {
+    const proxy = resolveSearchProxySettings(env);
+    const dispatcher = proxy ? getSearchProxyDispatcher(proxy) : void 0;
+    const requestInit = dispatcher ? { ...init, dispatcher } : init;
+    return await undiciFetch(
+      url,
+      requestInit
+    );
+  };
+}
+async function fetchWithRedirectLimit(fetchImpl, url, signal, maxRedirects, context, egressPolicy) {
+  let currentUrl = url;
+  assertEgressAllowed(currentUrl, egressPolicy, "connect", context);
+  for (let redirects = 0; redirects <= maxRedirects; redirects += 1) {
+    let response;
+    context.host = hostOf(currentUrl);
+    try {
+      response = await fetchImpl(currentUrl, {
+        signal,
+        redirect: "manual",
+        headers: searchBrowserHeaders()
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+      throw searchHttpError("upstream_unavailable", networkFailureMessage(error), {
+        stage: "connect",
+        providerId: context.providerId,
+        retryable: true,
+        cause: error,
+        details: { host: context.host }
+      });
+    }
+    if (response.status < 300 || response.status >= 400) {
+      return { response, finalUrl: response.url || currentUrl };
+    }
+    const location = response.headers.get("location");
+    if (!location) return { response, finalUrl: currentUrl };
+    void response.body?.cancel().catch(() => void 0);
+    if (redirects === maxRedirects) throw tooManyRedirects(maxRedirects, context);
+    const nextUrl = new URL(location, currentUrl).href;
+    assertEgressAllowed(nextUrl, egressPolicy, "redirect", context);
+    currentUrl = nextUrl;
+  }
+  throw tooManyRedirects(maxRedirects, context);
+}
+function assertEgressAllowed(url, policy, stage, context) {
+  try {
+    validateEgressUrl(url, policy, context.providerId);
+  } catch (error) {
+    if (!isSearchProviderError2(error)) throw error;
+    throw searchHttpError(error.code, error.message, {
+      stage,
+      providerId: context.providerId,
+      retryable: false,
+      cause: error,
+      details: error.details
+    });
+  }
+}
+function tooManyRedirects(maxRedirects, context) {
+  return searchHttpError("upstream_unavailable", `too many redirects (>${maxRedirects})`, {
+    stage: "redirect",
+    providerId: context.providerId,
+    retryable: false,
+    details: { host: context.host, maxRedirects: String(maxRedirects) }
+  });
+}
+async function readBodyWithLimit(response, maxResponseBytes, context) {
+  const reader = response.body?.getReader();
+  if (!reader) return "";
+  const chunks = [];
+  let totalBytes = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    totalBytes += value.byteLength;
+    if (totalBytes > maxResponseBytes) {
+      await reader.cancel().catch(() => void 0);
+      throw searchHttpError(
+        "upstream_unavailable",
+        `search response exceeded the ${maxResponseBytes} byte cap`,
+        {
+          stage: "body-cap",
+          providerId: context.providerId,
+          retryable: false,
+          details: { host: context.host, maxResponseBytes: String(maxResponseBytes) }
+        }
+      );
+    }
+    chunks.push(value);
+  }
+  const rawBytes = new Uint8Array(chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    rawBytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return decodeSearchBody(rawBytes, response.headers.get("content-type") ?? "");
+}
+function assertStatusUsable(status, context) {
+  if (!REFUSED_STATUSES.has(status)) return;
+  throw searchHttpError(
+    "upstream_unavailable",
+    `server refused the browser-shaped request (HTTP ${status})`,
+    {
+      stage: "fetch",
+      providerId: context.providerId,
+      retryable: false,
+      details: { host: context.host, status: String(status) }
+    }
+  );
+}
+function assertNoBotChallenge(html, context) {
+  if (!/<(?:html|body|title|script)\b/i.test(html)) return;
+  const title = html.match(/<title[^>]*>(.*?)<\/title>/is)?.[1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  const challengeTitle = /^(?:just a moment|attention required|access denied|robot check|security check)/i.test(
+    title ?? ""
+  );
+  const challengeInfrastructure = /cdn-cgi\/challenge-platform|cf-chl-|cf-turnstile|px-captcha|hcaptcha-container/i.test(html);
+  const challengeCopy = /verify (?:you are|that you are) human|unusual traffic from your computer|enable javascript and cookies to continue/i.test(
+    html
+  );
+  const duckDuckGoChallenge = /unfortunately, bots use duckduckgo too|complete the following challenge to confirm this search was made by a human/i.test(
+    html
+  );
+  if (challengeTitle || duckDuckGoChallenge || challengeInfrastructure && challengeCopy) {
+    throw searchHttpError(
+      "upstream_unavailable",
+      "server returned a bot-challenge page instead of the requested content",
+      {
+        stage: "challenge",
+        providerId: context.providerId,
+        retryable: false,
+        details: { host: context.host }
+      }
+    );
+  }
+}
+function isAbortError(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+function networkFailureMessage(error) {
+  const code = nestedErrorCode(error);
+  return code ? `network request failed (${code})` : "network request failed";
+}
+function nestedErrorCode(error) {
+  let current = error;
+  for (let depth = 0; depth < 4 && current instanceof Error; depth += 1) {
+    const code = current.code;
+    if (typeof code === "string" && /^[A-Z][A-Z0-9_]+$/.test(code)) return code;
+    current = current.cause;
+  }
+  return void 0;
+}
+
+// src/search/http/HttpBingProvider.ts
+var HTTP_BING_PROVIDER_ID = "http-bing";
+var BING_ENGINE = {
+  providerId: HTTP_BING_PROVIDER_ID,
+  label: "Bing",
+  buildUrls: (query) => [`https://www.bing.com/search?q=${encodeURIComponent(query)}`],
+  // Bing has no challenge status of its own; it serves decoy CONTENT instead,
+  // which the trust check catches.
+  isChallengeStatus: () => false,
+  trustError: bingSearchPageTrustError,
+  parse: parseBingSerp
+};
+var HttpBingProvider = class {
+  id = HTTP_BING_PROVIDER_ID;
+  transport;
+  constructor(transport = defaultSearchHttpTransport) {
+    this.transport = transport;
+  }
+  search(query, options) {
+    return runHttpSearch(BING_ENGINE, this.transport, query, options);
+  }
+};
+
+// src/search/http/parsers/duckduckgo.ts
+import { JSDOM as JSDOM3 } from "jsdom";
+var DUCKDUCKGO_SERP_URL = "https://html.duckduckgo.com/html/";
+var DUCKDUCKGO_SERP_MARKERS = "#links, .results, a.result-link";
+function isDuckDuckGoSerp(document) {
+  return document.querySelector(DUCKDUCKGO_SERP_MARKERS) !== null;
+}
+function parseDuckDuckGoSerp(html, maxResults) {
+  const document = new JSDOM3(html, { url: DUCKDUCKGO_SERP_URL }).window.document;
+  const htmlResults = [
+    ...document.querySelectorAll(".result, .result--web, .web-result")
+  ].map((container) => {
+    const link = container.querySelector("a.result__a, .result__a");
+    return {
+      title: cleanText(link?.textContent),
+      url: cleanDuckDuckGoUrl(link?.href ?? ""),
+      content: cleanText(container.querySelector(".result__snippet, .result__body")?.textContent)
+    };
+  }).filter(isUsableResult);
+  if (htmlResults.length > 0) {
+    return { recognized: true, results: htmlResults.slice(0, maxResults) };
+  }
+  const liteResults = [
+    ...document.querySelectorAll("a.result-link")
+  ].map((link) => {
+    const row = link.closest("tr");
+    const snippet = row?.nextElementSibling?.querySelector(".result-snippet");
+    return {
+      title: cleanText(link.textContent),
+      url: cleanDuckDuckGoUrl(link.href),
+      content: cleanText(snippet?.textContent)
+    };
+  }).filter(isUsableResult).slice(0, maxResults);
+  return { recognized: isDuckDuckGoSerp(document), results: liteResults };
+}
+function cleanDuckDuckGoUrl(rawUrl) {
+  try {
+    const absoluteUrl = rawUrl.startsWith("//") ? `https:${rawUrl}` : rawUrl;
+    const url = new URL(absoluteUrl, "https://html.duckduckgo.com");
+    return url.searchParams.get("uddg") ?? url.href;
+  } catch {
+    return rawUrl;
+  }
+}
+
+// src/search/http/HttpDuckDuckGoProvider.ts
+var HTTP_DUCKDUCKGO_PROVIDER_ID = "http-duckduckgo";
+var DUCKDUCKGO_CHALLENGE_STATUS = 202;
+var DUCKDUCKGO_ENGINE = {
+  providerId: HTTP_DUCKDUCKGO_PROVIDER_ID,
+  label: "DuckDuckGo",
+  buildUrls: (query) => [
+    `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
+    `https://lite.duckduckgo.com/lite/?q=${encodeURIComponent(query)}`
+  ],
+  isChallengeStatus: (status) => status === DUCKDUCKGO_CHALLENGE_STATUS,
+  parse: parseDuckDuckGoSerp
+};
+var HttpDuckDuckGoProvider = class {
+  id = HTTP_DUCKDUCKGO_PROVIDER_ID;
+  transport;
+  constructor(transport = defaultSearchHttpTransport) {
+    this.transport = transport;
+  }
+  search(query, options) {
+    return runHttpSearch(DUCKDUCKGO_ENGINE, this.transport, query, options);
+  }
+};
+
+// src/search/http/contributions.ts
+var HTTP_SEARCH_CAPABILITIES = Object.freeze({
+  requiresApiKey: false,
+  supportsRegion: false,
+  supportsLanguage: false,
+  supportsTimeRange: false,
+  supportsUrlRead: false,
+  supportsCancellation: true,
+  maxResults: MAX_RESULTS
+});
+function builtinHttpSearchContributions(transport) {
+  return [
+    {
+      id: HTTP_BING_PROVIDER_ID,
+      source: "builtin",
+      kind: "http",
+      provider: new HttpBingProvider(transport),
+      capabilities: { ...HTTP_SEARCH_CAPABILITIES }
+    },
+    {
+      id: HTTP_DUCKDUCKGO_PROVIDER_ID,
+      source: "builtin",
+      kind: "http",
+      provider: new HttpDuckDuckGoProvider(transport),
+      capabilities: { ...HTTP_SEARCH_CAPABILITIES }
+    }
+  ];
+}
+
+export {
+  SEARCH_HTTP_TRANSPORT_ID,
+  SEARCH_RESPONSE_BYTES,
+  DEFAULT_SEARCH_TIMEOUT_MS,
+  DEFAULT_MAX_RESULTS,
+  MAX_RESULTS,
+  clampMaxResults,
+  SEARCH_BROWSER_HEADERS,
+  MAX_REDIRECTS,
+  createSearchHttpTransport,
+  defaultSearchHttpTransport,
+  HTTP_BING_PROVIDER_ID,
+  HttpBingProvider,
+  HTTP_DUCKDUCKGO_PROVIDER_ID,
+  HttpDuckDuckGoProvider,
+  HTTP_SEARCH_CAPABILITIES,
+  builtinHttpSearchContributions
+};