@qvac/harness 0.1.0 → 0.1.1

package/dist-lib/lib/web-fetch/embedded-state.js

@@ -0,0 +1,131 @@
+import { decodeHtmlEntities } from "../web-search/html-helpers.js";
+const LDJSON_SCRIPT = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+const JSON_SCRIPT = /<script[^>]*type=["']application\/json["'][^>]*>([\s\S]*?)<\/script>/gi;
+const INLINE_SCRIPT = /<script\b(?![^>]*\bsrc=)(?![^>]*type=["']application\/(?:ld\+)?json["'])[^>]*>([\s\S]*?)<\/script>/gi;
+const STRING_LITERAL = /"(?:\\.|[^"\\])*"/g;
+const META_TAG = /<meta\s[^>]*>/gi;
+const META_ATTR = /(?:property|name)=["'](og:title|og:description|og:site_name|description)["']/i;
+const META_CONTENT = /content=["']([^"']+)["']/i;
+const MAX_HARVESTED_STRINGS = 200;
+const MIN_PROSE_CHARS = 40;
+const STRUCTURED_PROSE_KEYS = new Set(['headline', 'articleBody', 'description', 'text', 'name']);
+export function extractEmbeddedState(html) {
+    const parts = [
+        ...structuredData(html),
+        ...hydrationProse(html),
+        ...scriptLiteralProse(html),
+        ...metaTags(html)
+    ];
+    return dedupe(parts).join('\n');
+}
+function structuredData(html) {
+    const out = [];
+    for (const match of html.matchAll(LDJSON_SCRIPT)) {
+        const value = parseJson(match[1] ?? '');
+        if (value === null)
+            continue;
+        walk(value, (key, text) => {
+            if (STRUCTURED_PROSE_KEYS.has(key))
+                out.push(text);
+        });
+    }
+    return out;
+}
+function hydrationProse(html) {
+    const out = [];
+    for (const match of html.matchAll(JSON_SCRIPT)) {
+        const value = parseJson(match[1] ?? '');
+        if (value === null)
+            continue;
+        walk(value, (_key, text) => {
+            if (looksLikeProse(text))
+                out.push(text);
+        });
+    }
+    return out;
+}
+function scriptLiteralProse(html) {
+    const out = [];
+    for (const match of html.matchAll(INLINE_SCRIPT)) {
+        for (const literal of (match[1] ?? '').match(STRING_LITERAL) ?? []) {
+            if (literal.length < MIN_PROSE_CHARS)
+                continue;
+            const decoded = parseJson(literal);
+            if (typeof decoded !== 'string')
+                continue;
+            const inner = decoded.trimStart().startsWith('{') ? parseJson(decoded) : null;
+            if (inner !== null) {
+                walk(inner, (_key, text) => {
+                    if (looksLikeProse(text))
+                        out.push(text);
+                });
+            }
+            else if (looksLikeProse(decoded.trim())) {
+                out.push(decoded.trim());
+            }
+        }
+    }
+    return out;
+}
+function metaTags(html) {
+    const out = [];
+    for (const match of html.matchAll(META_TAG)) {
+        const tag = match[0];
+        if (!META_ATTR.test(tag))
+            continue;
+        const content = META_CONTENT.exec(tag)?.[1];
+        if (content)
+            out.push(decodeHtmlEntities(content).trim());
+    }
+    return out;
+}
+function parseJson(raw) {
+    if (!raw.trim())
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function walk(value, visit, key = '') {
+    if (typeof value === 'string') {
+        const text = value.trim();
+        if (text)
+            visit(key, text);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            walk(entry, visit, key);
+        return;
+    }
+    if (value && typeof value === 'object') {
+        for (const [k, v] of Object.entries(value))
+            walk(v, visit, k);
+    }
+}
+function looksLikeProse(text) {
+    if (text.length < MIN_PROSE_CHARS)
+        return false;
+    if (/^(?:https?:|data:|\/|#|\.)/.test(text))
+        return false;
+    const letters = text.match(/\p{L}/gu)?.length ?? 0;
+    if (letters / text.length <= 0.6)
+        return false;
+    return text.includes(' ') || /[\u3000-\u9fff\u3040-\u30ff\uac00-\ud7af]/.test(text);
+}
+function dedupe(parts) {
+    const seen = new Set();
+    const out = [];
+    for (const part of parts) {
+        if (out.length >= MAX_HARVESTED_STRINGS)
+            break;
+        if (seen.has(part))
+            continue;
+        seen.add(part);
+        out.push(part);
+    }
+    return out;
+}

package/dist-lib/lib/web-fetch/extract.d.ts

@@ -0,0 +1,6 @@
+export interface ExtractedPage {
+    readonly title: string | null;
+    readonly text: string;
+}
+export declare function looksLikeHtml(body: string): boolean;
+export declare function extractPageText(html: string): ExtractedPage;

package/dist-lib/lib/web-fetch/extract.js

@@ -0,0 +1,65 @@
+import { decodeHtmlEntities, stripHtmlTags } from "../web-search/html-helpers.js";
+const NOISE_BLOCKS = [
+    'script',
+    'style',
+    'noscript',
+    'template',
+    'svg',
+    'iframe',
+    'head',
+    'header',
+    'nav',
+    'footer',
+    'aside'
+];
+const NOISE_ROLES = /<(\w+)[^>]*\brole=["'](?:navigation|banner|contentinfo|complementary|search)["'][^>]*>[\s\S]*?<\/\1>/gi;
+const BLOCK_END_TAGS = /<\/(?:p|div|li|section|article|main|tr|h[1-6]|blockquote|pre|ul|ol|table|figcaption|dd|dt)>/gi;
+export function looksLikeHtml(body) {
+    return (/^\s*(?:<!doctype\s|<html[\s>]|<head[\s>]|<body[\s>])/i.test(body) ||
+        /<\w+[^>]*>[\s\S]*<\/\w+>/.test(body.slice(0, 2000)));
+}
+export function extractPageText(html) {
+    const title = extractTitle(html);
+    const text = collapseLines(stripHtmlTags(toLineBreaks(stripNoise(pickMainRegion(html)))));
+    return { title, text: decodeHtmlEntities(text) };
+}
+function extractTitle(html) {
+    const match = /<title[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+    if (!match?.[1])
+        return null;
+    const title = decodeHtmlEntities(stripHtmlTags(match[1])).replace(/\s+/g, ' ').trim();
+    return title.length > 0 ? title : null;
+}
+function pickMainRegion(html) {
+    for (const tag of ['main', 'article']) {
+        const match = new RegExp(`<${tag}[\\s>][\\s\\S]*?</${tag}>`, 'i').exec(html);
+        if (match)
+            return match[0];
+    }
+    return html;
+}
+function stripNoise(html) {
+    let out = html;
+    let prev = '';
+    while (out !== prev) {
+        prev = out;
+        out = out.replace(/<!--[\s\S]*?-->/g, '');
+    }
+    for (const tag of NOISE_BLOCKS) {
+        out = out.replace(new RegExp(`<${tag}[\\s>][\\s\\S]*?</${tag}>`, 'gi'), ' ');
+    }
+    return out.replace(NOISE_ROLES, ' ');
+}
+function toLineBreaks(html) {
+    return html
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<li\b[^>]*>/gi, '\n- ')
+        .replace(BLOCK_END_TAGS, '\n');
+}
+function collapseLines(text) {
+    return text
+        .split('\n')
+        .map((line) => line.replace(/\s+/g, ' ').trim())
+        .filter((line) => line.length > 0)
+        .join('\n');
+}

package/dist-lib/lib/web-fetch/images.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_PAGE_IMAGES = 2;
+export declare function pageImageUrls(html: string, pageUrl: URL): string[];
+export declare function imageFileName(url: URL, mimeType: string): string;

package/dist-lib/lib/web-fetch/images.js

@@ -0,0 +1,43 @@
+import { decodeHtmlEntities } from "../web-search/html-helpers.js";
+const META_TAG = /<meta\s[^>]*>/gi;
+const IMAGE_ATTR = /(?:property|name)=["'](?:og:image(?::secure_url|:url)?|twitter:image)["']/i;
+const META_CONTENT = /content=["']([^"']+)["']/i;
+export const MAX_PAGE_IMAGES = 2;
+export function pageImageUrls(html, pageUrl) {
+    const out = [];
+    for (const match of html.matchAll(META_TAG)) {
+        if (out.length >= MAX_PAGE_IMAGES)
+            break;
+        const tag = match[0];
+        if (!IMAGE_ATTR.test(tag))
+            continue;
+        const content = META_CONTENT.exec(tag)?.[1];
+        if (!content)
+            continue;
+        let resolved;
+        try {
+            resolved = new URL(decodeHtmlEntities(content).trim(), pageUrl);
+        }
+        catch {
+            continue;
+        }
+        if (resolved.protocol !== 'http:' && resolved.protocol !== 'https:')
+            continue;
+        const href = resolved.toString();
+        if (!out.some((seen) => seen.replace(/^https?:/, '') === href.replace(/^https?:/, ''))) {
+            out.push(href);
+        }
+    }
+    return out;
+}
+export function imageFileName(url, mimeType) {
+    let last = url.pathname.split('/').filter(Boolean).pop() ?? '';
+    try {
+        last = decodeURIComponent(last);
+    }
+    catch { }
+    if (/\.(png|jpe?g|gif|webp|avif)$/i.test(last))
+        return last;
+    const ext = mimeType.split('/')[1]?.split('+')[0] ?? 'img';
+    return `${url.hostname}.${ext}`;
+}

package/dist-lib/lib/web-fetch/video.d.ts

@@ -0,0 +1,5 @@
+export type PageVideoRef = {
+    readonly provider: string;
+    readonly url: string;
+};
+export declare function pageVideoRef(html: string, pageUrl: URL): PageVideoRef | null;

package/dist-lib/lib/web-fetch/video.js

@@ -0,0 +1,42 @@
+import { decodeHtmlEntities } from "../web-search/html-helpers.js";
+const META_TAG = /<meta\s[^>]*>/gi;
+const VIDEO_ATTR = /(?:property|name)=["']og:video(?::secure_url|:url)?["']/i;
+const META_CONTENT = /content=["']([^"']+)["']/i;
+const YOUTUBE_HOSTS = new Set(['youtube.com', 'youtube-nocookie.com', 'youtu.be']);
+export function pageVideoRef(html, pageUrl) {
+    for (const match of html.matchAll(META_TAG)) {
+        const tag = match[0];
+        if (!VIDEO_ATTR.test(tag))
+            continue;
+        const content = META_CONTENT.exec(tag)?.[1];
+        if (!content)
+            continue;
+        let resolved;
+        try {
+            resolved = new URL(decodeHtmlEntities(content).trim(), pageUrl);
+        }
+        catch {
+            continue;
+        }
+        if (resolved.protocol !== 'http:' && resolved.protocol !== 'https:')
+            continue;
+        return classify(resolved);
+    }
+    return null;
+}
+function classify(url) {
+    const host = url.hostname.replace(/^www\./, '');
+    if (YOUTUBE_HOSTS.has(host)) {
+        return { provider: 'youtube', url: watchUrl(url) };
+    }
+    if (host === 'vimeo.com' || host === 'player.vimeo.com') {
+        return { provider: 'vimeo', url: url.toString() };
+    }
+    return { provider: host, url: url.toString() };
+}
+function watchUrl(url) {
+    const embed = /^\/embed\/([\w-]+)/.exec(url.pathname);
+    if (!embed)
+        return url.toString();
+    return `https://www.youtube.com/watch?v=${embed[1]}`;
+}

package/dist-lib/lib/web-search/engine-registry.d.ts

@@ -0,0 +1,7 @@
+import type { SearchEngine } from './types.ts';
+export type EngineEntry = {
+    readonly name: string;
+    readonly fn: SearchEngine;
+};
+export declare const DEFAULT_MAX_RESULTS = 8;
+export declare const ENGINES: ReadonlyArray<EngineEntry>;

package/dist-lib/lib/web-search/engine-registry.js

@@ -0,0 +1,17 @@
+import { searchAol } from "./engines/aol.js";
+import { searchBing } from "./engines/bing.js";
+import { searchBrave } from "./engines/brave.js";
+import { searchDuckDuckGo } from "./engines/duckduckgo.js";
+import { searchGoogle } from "./engines/google.js";
+import { searchWikipedia } from "./engines/wikipedia.js";
+import { searchYahoo } from "./engines/yahoo.js";
+export const DEFAULT_MAX_RESULTS = 8;
+export const ENGINES = [
+    { name: 'duckduckgo', fn: searchDuckDuckGo },
+    { name: 'brave', fn: searchBrave },
+    { name: 'google', fn: searchGoogle },
+    { name: 'yahoo', fn: searchYahoo },
+    { name: 'aol', fn: searchAol },
+    { name: 'bing', fn: searchBing },
+    { name: 'wikipedia', fn: searchWikipedia }
+];

package/dist-lib/lib/web-search/engines/aol.d.ts

@@ -0,0 +1,3 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { Fetcher, RankedResult } from '../types.ts';
+export declare function searchAol(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;

package/dist-lib/lib/web-search/engines/aol.js

@@ -0,0 +1,81 @@
+import { fetchHtml } from "../fetch-html.js";
+import { clean } from "../html-helpers.js";
+import { urlMatchesHost } from "../url-helpers.js";
+function decodeRuUrl(encoded) {
+    try {
+        const href = decodeURIComponent(encoded);
+        if (!href.startsWith('http')) {
+            return null;
+        }
+        if (urlMatchesHost(href, 'search.aol.com') || urlMatchesHost(href, 'shopping.yahoo.com')) {
+            return null;
+        }
+        return href;
+    }
+    catch {
+        return null;
+    }
+}
+function parseAlgoBlock(inner) {
+    const ruMatch = inner.match(/\/RU=(https?%3a%2f%2f[^/]*?)\/RK/i);
+    if (!ruMatch) {
+        return null;
+    }
+    const href = decodeRuUrl(ruMatch[1] || '');
+    if (!href) {
+        return null;
+    }
+    const titleMatch = inner.match(/<a[^>]*class="[^"]*fz-[^"]*"[^>]*>([\s\S]*?)<\/a>/i);
+    const title = titleMatch ? clean(titleMatch[1] || '') : '';
+    if (!title) {
+        return null;
+    }
+    const snippetMatch = inner.match(/class="compText[^"]*"[^>]*>[\s\S]*?<p[^>]*>([\s\S]*?)<\/p>/i);
+    const content = snippetMatch ? clean(snippetMatch[1] || '') : title;
+    return { title, url: href, content, position: 0 };
+}
+function parseAlgoBlocks(html) {
+    const results = [];
+    const blocks = html.split(/algo algo-sr/i);
+    for (let i = 1; i < blocks.length; i++) {
+        const inner = blocks[i]?.slice(0, 5000) || '';
+        const parsed = parseAlgoBlock(inner);
+        if (parsed) {
+            results.push({ ...parsed, position: results.length + 1 });
+        }
+    }
+    return results;
+}
+function parseRuFallback(html) {
+    const results = [];
+    const seen = new Set();
+    const ruGlobal = /\/RU=(https?%3a%2f%2f[^/]*?)\/RK/gi;
+    for (const rm of html.matchAll(ruGlobal)) {
+        const href = decodeRuUrl(rm[1] || '');
+        if (!href || seen.has(href)) {
+            continue;
+        }
+        seen.add(href);
+        const host = new URL(href).hostname;
+        results.push({
+            title: host,
+            url: href,
+            content: `Result from ${host}`,
+            position: results.length + 1,
+            weak: true
+        });
+        if (results.length >= 15) {
+            break;
+        }
+    }
+    return results;
+}
+export async function searchAol(query, fetcher, signal) {
+    const url = `https://search.aol.com/aol/search?q=${encodeURIComponent(query)}`;
+    const html = await fetchHtml(fetcher, url, undefined, signal);
+    const primary = parseAlgoBlocks(html);
+    if (primary.length > 0) {
+        return primary;
+    }
+    return parseRuFallback(html);
+}

package/dist-lib/lib/web-search/engines/bing.d.ts

@@ -0,0 +1,3 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { Fetcher, RankedResult } from '../types.ts';
+export declare function searchBing(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;

package/dist-lib/lib/web-search/engines/bing.js

@@ -0,0 +1,111 @@
+import { fetchHtml } from "../fetch-html.js";
+import { clean } from "../html-helpers.js";
+import { urlMatchesHost } from "../url-helpers.js";
+import { SAFARI_UA } from "../user-agents.js";
+function isOrganicBingUrl(url) {
+    return url.startsWith('http') && !urlMatchesHost(url, 'bing.com') && !url.includes('msockid=');
+}
+function tryBase64Decode(encoded) {
+    try {
+        const padded = encoded + '='.repeat((4 - (encoded.length % 4)) % 4);
+        const decoded = atob(padded.replace(/-/g, '+').replace(/_/g, '/'));
+        return decoded.startsWith('http') ? decoded : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractCiteUrl(blockHtml) {
+    const citeMatch = blockHtml.match(/<cite[^>]*>([\s\S]*?)<\/cite>/i);
+    if (!citeMatch) {
+        return null;
+    }
+    const citeText = clean(citeMatch[1] || '')
+        .replace(/\s*›\s*/g, '/')
+        .replace(/\s+/g, '');
+    return citeText.startsWith('http') ? citeText : `https://${citeText}`;
+}
+function decodeBingRedirect(rawUrl, blockHtml) {
+    const uMatch = rawUrl.replace(/&amp;/g, '&').match(/[&?]u=a1([^&]+)/);
+    if (uMatch?.[1]) {
+        const decoded = tryBase64Decode(uMatch[1]);
+        if (decoded) {
+            return decoded;
+        }
+    }
+    if (!rawUrl.startsWith('http') && blockHtml) {
+        return extractCiteUrl(blockHtml) ?? rawUrl;
+    }
+    return rawUrl;
+}
+function parseBAlgoBlock(inner) {
+    const linkMatch = inner.match(/<h2[^>]*>[\s\S]*?<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<\/h2>/i);
+    if (!linkMatch) {
+        return null;
+    }
+    let rawUrl = linkMatch[1] || '';
+    const title = clean(linkMatch[2] || '');
+    if (!title || title.length < 3) {
+        return null;
+    }
+    rawUrl = decodeBingRedirect(rawUrl, inner);
+    if (!isOrganicBingUrl(rawUrl)) {
+        return null;
+    }
+    const snippetMatch = inner.match(/<p[^>]*>([\s\S]*?)<\/p>/i);
+    const content = snippetMatch ? clean(snippetMatch[1] || '') : title;
+    return { title, url: rawUrl, content, position: 0 };
+}
+function parseBAlgoBlocks(html) {
+    const results = [];
+    const blocks = html.split(/class="b_algo"/i);
+    for (let i = 1; i < blocks.length; i++) {
+        const inner = blocks[i]?.slice(0, 5000) || '';
+        const parsed = parseBAlgoBlock(inner);
+        if (parsed) {
+            results.push({ ...parsed, position: results.length + 1 });
+        }
+    }
+    return results;
+}
+function parseH2Match(hm) {
+    let rawUrl = hm[1] || '';
+    const title = clean(hm[2] || '');
+    if (!title || title.length < 3) {
+        return null;
+    }
+    rawUrl = decodeBingRedirect(rawUrl, '');
+    if (!isOrganicBingUrl(rawUrl)) {
+        return null;
+    }
+    return { title, url: rawUrl, content: title, position: 0 };
+}
+function parseH2Fallback(html) {
+    const results = [];
+    const h2Pat = /<h2[^>]*>[\s\S]*?<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<\/h2>/gi;
+    const seen = new Set();
+    for (const hm of html.matchAll(h2Pat)) {
+        const parsed = parseH2Match(hm);
+        if (!parsed || seen.has(parsed.url)) {
+            continue;
+        }
+        seen.add(parsed.url);
+        results.push({ ...parsed, position: results.length + 1 });
+        if (results.length >= 15) {
+            break;
+        }
+    }
+    return results;
+}
+export async function searchBing(query, fetcher, signal) {
+    const url = `https://www.bing.com/search?q=${encodeURIComponent(query)}`;
+    const html = await fetchHtml(fetcher, url, { headers: { 'User-Agent': SAFARI_UA } }, signal);
+    if (html.includes('captcha') || html.includes('challenge/verify') || html.includes('Turnstile')) {
+        throw new Error('Bing CAPTCHA detected');
+    }
+    const primary = parseBAlgoBlocks(html);
+    if (primary.length > 0) {
+        return primary;
+    }
+    return parseH2Fallback(html);
+}

package/dist-lib/lib/web-search/engines/brave.d.ts

@@ -0,0 +1,3 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { Fetcher, RankedResult } from '../types.ts';
+export declare function searchBrave(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;

package/dist-lib/lib/web-search/engines/brave.js

@@ -0,0 +1,59 @@
+import { fetchHtml } from "../fetch-html.js";
+import { clean } from "../html-helpers.js";
+function parseSnippetBlock(inner) {
+    const urlMatch = inner.match(/<a[^>]*href="(https?:\/\/(?!imgs\.search\.brave)[^"]*)"[^>]*>/i);
+    if (!urlMatch) {
+        return null;
+    }
+    const href = urlMatch[1] || '';
+    if (!href) {
+        return null;
+    }
+    const titleMatch = inner.match(/<div[^>]*class="[^"]*title[^"]*search-snippet-title[^"]*"[^>]*(?:title="([^"]*)"[^>]*)?>([^<]*)<\/div>/i);
+    const title = titleMatch ? clean(titleMatch[1] || titleMatch[2] || '') : '';
+    if (!title) {
+        return null;
+    }
+    const contentMatch = inner.match(/<div[^>]*class="[^"]*generic-snippet[^"]*"[^>]*>[\s\S]*?<div[^>]*class="[^"]*content[^"]*"[^>]*>([\s\S]*?)<\/div>/i);
+    const content = contentMatch ? clean(contentMatch[1] || '') : title;
+    return { title, url: href, content, position: 0 };
+}
+function parseSnippetBlocks(html) {
+    const results = [];
+    const blocks = html.split(/<div[^>]*class="snippet\s[^"]*"[^>]*data-type="web"[^>]*>/i);
+    for (let i = 1; i < blocks.length; i++) {
+        const inner = blocks[i] || '';
+        const parsed = parseSnippetBlock(inner);
+        if (parsed) {
+            results.push({ ...parsed, position: results.length + 1 });
+        }
+    }
+    return results;
+}
+function parseLinkFallback(html) {
+    const results = [];
+    const seen = new Set();
+    const linkPat = /<a[^>]*href="(https?:\/\/(?!search\.brave\.com|imgs\.search\.brave|brave\.com)[^"]*)"[^>]*>([\s\S]*?)<\/a>/gi;
+    for (const lm of html.matchAll(linkPat)) {
+        const href = lm[1] || '';
+        const text = clean(lm[2] || '');
+        if (!href.startsWith('http') || text.length < 5 || seen.has(href)) {
+            continue;
+        }
+        seen.add(href);
+        results.push({ title: text, url: href, content: text, position: results.length + 1 });
+        if (results.length >= 15) {
+            break;
+        }
+    }
+    return results;
+}
+export async function searchBrave(query, fetcher, signal) {
+    const url = `https://search.brave.com/search?q=${encodeURIComponent(query)}&source=web`;
+    const html = await fetchHtml(fetcher, url, { cookies: { safesearch: 'off', useLocation: '0', summarizer: '0', country: 'us' } }, signal);
+    const primary = parseSnippetBlocks(html);
+    if (primary.length > 0) {
+        return primary;
+    }
+    return parseLinkFallback(html);
+}

package/dist-lib/lib/web-search/engines/duckduckgo.d.ts

@@ -0,0 +1,3 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { Fetcher, RankedResult } from '../types.ts';
+export declare function searchDuckDuckGo(query: string, fetcher: Fetcher, signal?: BareAbortSignal): Promise<ReadonlyArray<RankedResult>>;