@omnicross/core 0.2.0 → 0.3.0

package/dist/chunk-BTBEJRGL.cjs

@@ -0,0 +1,781 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+
+
+
+var _chunk7RJI3NDIcjs = require('./chunk-7RJI3NDI.cjs');
+
+// src/search/http/errors.ts
+
+
+
+var _searchtypes = require('@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 (0, _searchtypes.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: _nullishCoalesce(init.transport, () => ( SEARCH_HTTP_TRANSPORT_ID)),
+      stage: init.stage
+    }
+  });
+}
+function asSearchProviderError(value, providerId, fallbackStage) {
+  if (_searchtypes.isSearchProviderError.call(void 0, value)) {
+    const complete = value.providerId !== void 0 && _optionalChain([value, 'access', _ => _.details, 'optionalAccess', _2 => _2.transport]) !== void 0 && _optionalChain([value, 'access', _3 => _3.details, 'optionalAccess', _4 => _4.stage]) !== void 0;
+    if (complete) return value;
+    return searchHttpError(value.code, value.message, {
+      stage: _nullishCoalesce(_optionalChain([value, 'access', _5 => _5.details, 'optionalAccess', _6 => _6.stage]), () => ( fallbackStage)),
+      providerId: _nullishCoalesce(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 (e) {
+    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(_nullishCoalesce(maxResults, () => ( DEFAULT_MAX_RESULTS)), 1), MAX_RESULTS);
+}
+async function runHttpSearch(engine, transport, query, options = {}) {
+  const providerId = engine.providerId;
+  if (_optionalChain([options, 'access', _7 => _7.signal, 'optionalAccess', _8 => _8.aborted])) {
+    throw searchHttpError("cancelled", "search was cancelled before it started", {
+      stage: "fetch",
+      providerId,
+      retryable: false
+    });
+  }
+  const maxResults = clampMaxResults(options.maxResults);
+  const timeoutMs = _nullishCoalesce(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 = _optionalChain([engine, 'access', _9 => _9.trustError, 'optionalCall', _10 => _10(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
+var _jsdom = require('jsdom');
+
+// src/search/http/text.ts
+var _entities = require('entities');
+var MAX_TEXT_LENGTH = 500;
+function cleanText(value) {
+  return _entities.decodeHTML.call(void 0, _nullishCoalesce(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 (0, _jsdom.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(_optionalChain([container, 'optionalAccess', _11 => _11.querySelector, 'call', _12 => _12(".b_caption p, .b_algoSlug, p"), 'optionalAccess', _13 => _13.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 (_optionalChain([encodedTarget, 'optionalAccess', _14 => _14.startsWith, 'call', _15 => _15("a1")])) {
+        const decoded = Buffer.from(encodedTarget.slice(2), "base64url").toString("utf8");
+        if (/^https?:\/\//i.test(decoded)) return decoded;
+      }
+    }
+    return url.href;
+  } catch (e2) {
+    return rawUrl;
+  }
+}
+
+// src/search/http/trust.ts
+
+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 (e3) {
+    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(_nullishCoalesce(parsed.searchParams.get("q"), () => ( "")), html);
+}
+function bingTrustError(query, html) {
+  const document = new (0, _jsdom.JSDOM)(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 = separatorFree(
+    links.map((link) => _nullishCoalesce(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 = separatorFree(
+    links.map((link) => {
+      const container = link.closest("li.b_algo, .b_algo");
+      return `${_nullishCoalesce(link.textContent, () => ( ""))} ${_nullishCoalesce(link.getAttribute("href"), () => ( ""))} ${_nullishCoalesce(_optionalChain([container, 'optionalAccess', _16 => _16.querySelector, 'call', _17 => _17(".b_caption p, .b_algoSlug, p"), 'optionalAccess', _18 => _18.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 separatorFree(text) {
+  return text.replace(/[^\p{L}\p{N}\s]/gu, "");
+}
+function meaningfulQueryTerms(query) {
+  const terms = _nullishCoalesce(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
+
+var _undici = require('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 = _nullishCoalesce(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 (e4) {
+    return new TextDecoder("windows-1252").decode(bytes);
+  }
+}
+function decoderFor(label) {
+  try {
+    return new TextDecoder(label);
+  } catch (e5) {
+    return null;
+  }
+}
+
+// src/search/http/headers.ts
+var CHROME_VERSION = _nullishCoalesce(process.versions.chrome, () => ( "152.0.7977.65"));
+var CHROME_MAJOR = CHROME_VERSION.split(".")[0] || "152";
+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/impit.ts
+var IMPIT_BROWSER = "chrome151";
+var IMPERSONATED_HEADERS = [
+  "sec-ch-ua",
+  "sec-ch-ua-mobile",
+  "sec-ch-ua-platform",
+  "user-agent"
+];
+var TRANSPORT_KIND = /* @__PURE__ */ Symbol("searchFetchKind");
+function tagFetchKind(error, kind) {
+  if (error instanceof Error) {
+    error[TRANSPORT_KIND] = kind;
+  }
+}
+function fetchKindOf(error) {
+  return _optionalChain([error, 'optionalAccess', _19 => _19[TRANSPORT_KIND]]);
+}
+var impitConstructorPromise;
+var impitClients = /* @__PURE__ */ new Map();
+function loadImpitConstructor() {
+  impitConstructorPromise ??= Promise.resolve().then(() => _interopRequireWildcard(require("impit"))).then((module) => module.Impit).catch(() => void 0);
+  return impitConstructorPromise;
+}
+async function getImpitClient(proxyUrl, load = loadImpitConstructor) {
+  const ImpitClient = await load();
+  if (!ImpitClient) return void 0;
+  const key = _nullishCoalesce(proxyUrl, () => ( "<direct>"));
+  const cached = impitClients.get(key);
+  if (cached) return cached;
+  const client = new ImpitClient({
+    browser: IMPIT_BROWSER,
+    followRedirects: false,
+    vanillaFallback: false,
+    ...proxyUrl ? { proxyUrl } : {}
+  });
+  impitClients.set(key, client);
+  return client;
+}
+function withImpersonatedHeaders(init) {
+  const headers = new Headers(init.headers);
+  for (const name of IMPERSONATED_HEADERS) headers.delete(name);
+  return { ...init, headers };
+}
+function proxyConfigToUrl(config) {
+  if ("url" in config) {
+    try {
+      const protocol = new URL(config.url).protocol;
+      if (protocol === "http:" || protocol === "https:") return config.url;
+      if (protocol === "socks5:" || protocol === "socks5h:") {
+        return `socks5h://${config.url.slice(protocol.length + 2)}`;
+      }
+      return void 0;
+    } catch (e6) {
+      return void 0;
+    }
+  }
+  if (!config.host || !Number.isFinite(config.port)) return void 0;
+  const auth = config.username ? `${encodeURIComponent(config.username)}:${encodeURIComponent(_nullishCoalesce(config.password, () => ( "")))}@` : "";
+  if (config.type !== "http" && config.type !== "https" && config.type !== "socks5") {
+    return void 0;
+  }
+  const scheme = config.type === "socks5" ? "socks5h" : config.type;
+  return `${scheme}://${auth}${config.host}:${config.port}`;
+}
+function impitProxyUrlFrom(resolve, url) {
+  const config = _optionalChain([resolve, 'optionalCall', _20 => _20(url)]);
+  return config ? proxyConfigToUrl(config) : void 0;
+}
+
+// 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 = _nullishCoalesce(options.fetch, () => ( createProductionSearchFetch(options)));
+  const maxRedirects = _nullishCoalesce(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(_optionalChain([request, 'access', _21 => _21.signal, 'optionalAccess', _22 => _22.reason]));
+    _optionalChain([request, 'access', _23 => _23.signal, 'optionalAccess', _24 => _24.addEventListener, 'call', _25 => _25("abort", onAbort, { once: true })]);
+    if (_optionalChain([request, 'access', _26 => _26.signal, 'optionalAccess', _27 => _27.aborted])) onAbort();
+    const timeoutMs = _nullishCoalesce(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 = _nullishCoalesce(response.headers.get("content-type"), () => ( ""));
+      const rawText = await readBodyWithLimit(
+        response,
+        _nullishCoalesce(request.maxResponseBytes, () => ( DEFAULT_MAX_RESPONSE_BYTES)),
+        context
+      );
+      assertStatusUsable(response.status, context);
+      assertNoBotChallenge(rawText, context);
+      return { finalUrl, status: response.status, contentType, rawText };
+    } catch (error) {
+      if (_optionalChain([request, 'access', _28 => _28.signal, 'optionalAccess', _29 => _29.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,
+          transport: fetchKindOf(error),
+          details: { host: context.host }
+        });
+      }
+      throw asSearchProviderError(error, context.providerId, "fetch");
+    } finally {
+      clearTimeout(timer);
+      _optionalChain([request, 'access', _30 => _30.signal, 'optionalAccess', _31 => _31.removeEventListener, 'call', _32 => _32("abort", onAbort)]);
+    }
+  };
+}
+var defaultSearchHttpTransport = createSearchHttpTransport();
+function createProductionSearchFetch(options) {
+  return async (url, init) => {
+    const client = await getImpitClient(
+      impitProxyUrlFrom(options.resolveProxyConfig, url),
+      options.loadImpit
+    ).catch(() => void 0);
+    if (client) {
+      try {
+        return await client.fetch(
+          url,
+          withImpersonatedHeaders(init)
+        );
+      } catch (error) {
+        tagFetchKind(error, "impit");
+        throw error;
+      }
+    }
+    try {
+      const dispatcher = selectHttpDispatcher(options.env, url, options.resolveProxyDispatcher);
+      const requestInit = dispatcher ? { ...init, dispatcher } : init;
+      return await _undici.fetch.call(void 0, 
+        url,
+        requestInit
+      );
+    } catch (error) {
+      tagFetchKind(error, "undici");
+      throw error;
+    }
+  };
+}
+function selectHttpDispatcher(env, url, resolveProxyDispatcher) {
+  return _nullishCoalesce(_optionalChain([resolveProxyDispatcher, 'optionalCall', _33 => _33(url)]), () => ( envProxyDispatcher(env)));
+}
+function envProxyDispatcher(env) {
+  const proxy = _chunk7RJI3NDIcjs.resolveSearchProxySettings.call(void 0, env);
+  return proxy ? _chunk7RJI3NDIcjs.getSearchProxyDispatcher.call(void 0, proxy) : void 0;
+}
+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,
+        transport: fetchKindOf(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 _optionalChain([response, 'access', _34 => _34.body, 'optionalAccess', _35 => _35.cancel, 'call', _36 => _36(), 'access', _37 => _37.catch, 'call', _38 => _38(() => 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 {
+    _chunk7RJI3NDIcjs.validateEgressUrl.call(void 0, url, policy, context.providerId);
+  } catch (error) {
+    if (!_searchtypes.isSearchProviderError.call(void 0, 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 = _optionalChain([response, 'access', _39 => _39.body, 'optionalAccess', _40 => _40.getReader, 'call', _41 => _41()]);
+  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, _nullishCoalesce(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 = _optionalChain([html, 'access', _42 => _42.match, 'call', _43 => _43(/<title[^>]*>(.*?)<\/title>/is), 'optionalAccess', _44 => _44[1], 'access', _45 => _45.replace, 'call', _46 => _46(/<[^>]+>/g, " "), 'access', _47 => _47.replace, 'call', _48 => _48(/\s+/g, " "), 'access', _49 => _49.trim, 'call', _50 => _50()]);
+  const challengeTitle = /^(?:just a moment|attention required|access denied|robot check|security check)/i.test(
+    _nullishCoalesce(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 = class {
+  __init() {this.id = HTTP_BING_PROVIDER_ID}
+  
+  constructor(transport = defaultSearchHttpTransport) {;_class.prototype.__init.call(this);
+    this.transport = transport;
+  }
+  search(query, options) {
+    return runHttpSearch(BING_ENGINE, this.transport, query, options);
+  }
+}, _class);
+
+// src/search/http/parsers/duckduckgo.ts
+
+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 (0, _jsdom.JSDOM)(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(_optionalChain([link, 'optionalAccess', _51 => _51.textContent])),
+      url: cleanDuckDuckGoUrl(_nullishCoalesce(_optionalChain([link, 'optionalAccess', _52 => _52.href]), () => ( ""))),
+      content: cleanText(_optionalChain([container, 'access', _53 => _53.querySelector, 'call', _54 => _54(".result__snippet, .result__body"), 'optionalAccess', _55 => _55.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 = _optionalChain([row, 'optionalAccess', _56 => _56.nextElementSibling, 'optionalAccess', _57 => _57.querySelector, 'call', _58 => _58(".result-snippet")]);
+    return {
+      title: cleanText(link.textContent),
+      url: cleanDuckDuckGoUrl(link.href),
+      content: cleanText(_optionalChain([snippet, 'optionalAccess', _59 => _59.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 _nullishCoalesce(url.searchParams.get("uddg"), () => ( url.href));
+  } catch (e7) {
+    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 = (_class2 = class {
+  __init2() {this.id = HTTP_DUCKDUCKGO_PROVIDER_ID}
+  
+  constructor(transport = defaultSearchHttpTransport) {;_class2.prototype.__init2.call(this);
+    this.transport = transport;
+  }
+  search(query, options) {
+    return runHttpSearch(DUCKDUCKGO_ENGINE, this.transport, query, options);
+  }
+}, _class2);
+
+// 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 }
+    }
+  ];
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.SEARCH_HTTP_TRANSPORT_ID = SEARCH_HTTP_TRANSPORT_ID; exports.SEARCH_RESPONSE_BYTES = SEARCH_RESPONSE_BYTES; exports.DEFAULT_SEARCH_TIMEOUT_MS = DEFAULT_SEARCH_TIMEOUT_MS; exports.DEFAULT_MAX_RESULTS = DEFAULT_MAX_RESULTS; exports.MAX_RESULTS = MAX_RESULTS; exports.clampMaxResults = clampMaxResults; exports.SEARCH_BROWSER_HEADERS = SEARCH_BROWSER_HEADERS; exports.MAX_REDIRECTS = MAX_REDIRECTS; exports.createSearchHttpTransport = createSearchHttpTransport; exports.defaultSearchHttpTransport = defaultSearchHttpTransport; exports.HTTP_BING_PROVIDER_ID = HTTP_BING_PROVIDER_ID; exports.HttpBingProvider = HttpBingProvider; exports.HTTP_DUCKDUCKGO_PROVIDER_ID = HTTP_DUCKDUCKGO_PROVIDER_ID; exports.HttpDuckDuckGoProvider = HttpDuckDuckGoProvider; exports.HTTP_SEARCH_CAPABILITIES = HTTP_SEARCH_CAPABILITIES; exports.builtinHttpSearchContributions = builtinHttpSearchContributions;