@minko-ai/minko 0.1.0 → 0.1.1

package/dist/ui/transcript.js

@@ -0,0 +1,287 @@
+import { charWidth, stripAnsi, truncateVisible, visibleWidth, wrapText } from "./ansi.js";
+import { StreamRenderer } from "./md.js";
+import { PURPLE } from "../theme.js";
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const TOOL_OUTPUT_TAIL = 2;
+const TOOL_OUTPUT_ERROR_TAIL = 6;
+const TOOL_OUTPUT_EXPANDED = 20;
+const REASONING_PREVIEW_LINES = 2;
+const REASONING_EXPANDED_LINES = 30;
+export function renderEntry(entry, width, painter, spinnerFrame = 0, expandDetails = false) {
+    if (entry.kind === 'tool') {
+        return renderTool(entry, width, painter, spinnerFrame, expandDetails);
+    }
+    if (entry.kind === 'reasoning') {
+        return renderReasoning(entry, width, painter, spinnerFrame, expandDetails);
+    }
+    if (entry.kind === 'permission') {
+        return renderPermission(entry, width, painter);
+    }
+    const rail = painter.fg(PURPLE.rail, '│ ');
+    if (entry.kind === 'banner') {
+        return entry.text.split('\n');
+    }
+    if (entry.kind === 'stats') {
+        return ['  ' + painter.dimmed(truncateVisible(entry.text, Math.max(10, width - 2)))];
+    }
+    if (entry.kind === 'user') {
+        const inner = Math.max(10, width - 4);
+        const lines = wrapText(entry.text, inner);
+        const out = [rail + painter.primary('› ') + painter.bold(lines[0] ?? '')];
+        for (let index = 1; index < lines.length; index += 1) {
+            out.push(rail + '  ' + painter.bold(lines[index]));
+        }
+        return out;
+    }
+    return renderAssistant(entry.text, Math.max(10, width - 4), painter)
+        .map((line) => rail + line);
+}
+/** Permission prompt shown inside the conversation, Claude-Code style. */
+function renderPermission(entry, width, painter) {
+    if (entry.state !== 'pending') {
+        const mark = entry.state === 'allowed' ? '✓ 已允许' : '✗ 已拒绝';
+        return ['  ' + painter.dimmed(mark + ' · ' + entry.title)];
+    }
+    const boxWidth = Math.max(34, Math.min(width - 2, 68));
+    const inner = boxWidth - 4;
+    const border = (text) => painter.fg(PURPLE.rail, text);
+    const row = (content) => {
+        const padding = ' '.repeat(Math.max(0, inner - visibleWidth(content)));
+        return border('│') + ' ' + content + padding + ' ' + border('│');
+    };
+    const lines = [border('╭' + '─'.repeat(boxWidth - 2) + '╮')];
+    lines.push(row(painter.bold(painter.soft(entry.title))));
+    lines.push(row(''));
+    for (const line of entry.detail.split('\n').slice(0, 4)) {
+        lines.push(row(painter.dim('  ' + truncateVisible(line, inner - 2))));
+    }
+    lines.push(row(''));
+    lines.push(row(painter.muted('是否继续？')));
+    const options = ['允许', '允许，本次会话不再询问', '拒绝（Esc）'];
+    options.forEach((label, index) => {
+        const active = index === entry.choice;
+        const pointer = active ? painter.primary('❯ ') : '  ';
+        const text = index + 1 + '. ' + label;
+        lines.push(row(pointer + (active ? painter.primary(text) : painter.dim(text))));
+    });
+    lines.push(border('╰' + '─'.repeat(boxWidth - 2) + '╯'));
+    return lines;
+}
+/** A tool call as one compact status line plus a short output tail.
+ * Visual grammar modeled on Gemini CLI's DenseToolMessage / ToolShared
+ * (Apache-2.0): status icon, name, one-line metadata, collapsed output. */
+function renderTool(entry, width, painter, spinnerFrame, expandDetails) {
+    const room = Math.max(10, width - 24);
+    const args = entry.args.length > room ? entry.args.slice(0, room) + '…' : entry.args;
+    const icon = entry.status === 'running'
+        ? painter.primary(SPINNER[spinnerFrame % SPINNER.length])
+        : entry.status === 'ok' ? painter.ok('●') : painter.error('✕');
+    const head = '  ' + icon + ' ' + painter.soft(entry.name)
+        + (args.length > 0 ? '  ' + painter.dim(args) : '');
+    const elapsed = entry.status === 'running'
+        ? Math.max(0, Math.round((Date.now() - entry.started) / 1000)) + 's'
+        : formatMs(entry.ms);
+    const bytes = outputBytes(entry.output);
+    const lines = [head + painter.dimmed(' · ' + elapsed + (bytes > 0 ? ' · ' + formatBytes(bytes) : ''))];
+    appendOutputTail(lines, entry, width, painter, outputLineLimit(entry, expandDetails), expandDetails);
+    return lines;
+}
+/** Collapses consecutive calls of the same finished tool into one line. */
+function renderToolGroup(entries, width, painter) {
+    const failed = entries.some((entry) => entry.status === 'error');
+    const ms = entries.reduce((sum, entry) => sum + entry.ms, 0);
+    const bytes = entries.reduce((sum, entry) => sum + outputBytes(entry.output), 0);
+    const head = '  ' + (failed ? painter.error('✕') : painter.ok('●')) + ' '
+        + painter.soft(entries[0].name) + painter.muted(' ×' + entries.length)
+        + painter.dimmed(' · ' + formatMs(ms) + (bytes > 0 ? ' · ' + formatBytes(bytes) : ''));
+    const lines = [head];
+    const source = failed
+        ? [...entries].reverse().find((entry) => entry.status === 'error') ?? entries[entries.length - 1]
+        : entries[entries.length - 1];
+    appendOutputTail(lines, source, width, painter, TOOL_OUTPUT_TAIL, false);
+    return lines;
+}
+function outputLineLimit(entry, expandDetails) {
+    if (expandDetails) {
+        return TOOL_OUTPUT_EXPANDED;
+    }
+    return entry.status === 'error' ? TOOL_OUTPUT_ERROR_TAIL : TOOL_OUTPUT_TAIL;
+}
+function appendOutputTail(lines, entry, width, painter, limit, expanded) {
+    if (entry.output.length === 0) {
+        return;
+    }
+    const output = entry.output.replace(/\r\n/g, '\n').split('\n').filter((line) => line.length > 0);
+    const shown = output.slice(-limit);
+    const hidden = output.length - shown.length;
+    for (const line of shown) {
+        lines.push('    ' + painter.fg(PURPLE.rail, '│ ')
+            + painter.dim(truncateVisible(line, Math.max(10, width - 8))));
+    }
+    if (hidden > 0) {
+        lines.push('    ' + painter.fg(PURPLE.rail, '│ ')
+            + painter.dimmed('… 还有 ' + hidden + ' 行' + (expanded ? '' : ' · Ctrl+O 展开')));
+    }
+}
+/** Thinking is streamed dim/italic, then folded into a one-line duration.
+ * Layout modeled on Gemini CLI's ThinkingMessage (Apache-2.0): left border
+ * rail, first lines visible while streaming, collapsed once finished. */
+function renderReasoning(entry, width, painter, spinnerFrame, expandDetails) {
+    const elapsed = entry.done ? entry.ms : Math.max(0, Date.now() - entry.started);
+    const icon = entry.done ? painter.primary('✻') : painter.primary(SPINNER[spinnerFrame % SPINNER.length]);
+    const label = entry.done ? '思考了 ' : '思考中';
+    const hint = entry.done
+        ? (expandDetails ? ' · Ctrl+O 收起' : ' · Ctrl+O 展开')
+        : '';
+    const lines = ['  ' + icon + ' ' + painter.muted(label + formatMs(elapsed))
+            + (entry.text.trim().length > 0 ? painter.dimmed(hint) : '')];
+    if (entry.done && !expandDetails) {
+        return lines;
+    }
+    const text = entry.text.replace(/\r\n/g, '\n').split('\n').filter((line) => line.trim().length > 0);
+    const limit = expandDetails ? REASONING_EXPANDED_LINES : REASONING_PREVIEW_LINES;
+    for (const line of text.slice(-limit)) {
+        lines.push('  ' + painter.fg(PURPLE.rail, '│ ')
+            + painter.italic(painter.dim(truncateVisible(line, Math.max(10, width - 6)))));
+    }
+    return lines;
+}
+function outputBytes(output) {
+    return Buffer.byteLength(output, 'utf8');
+}
+function formatBytes(bytes) {
+    if (bytes < 1024) {
+        return bytes + ' B';
+    }
+    if (bytes < 1024 * 1024) {
+        return (bytes / 1024).toFixed(1) + ' KB';
+    }
+    return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+}
+function formatMs(ms) {
+    return ms < 1000 ? ms + 'ms' : (ms / 1000).toFixed(1) + 's';
+}
+/** Renders assistant markdown (code bands included) into display lines. */ export function renderAssistant(text, width, painter) {
+    const lines = [];
+    let current = '';
+    const sink = (chunk) => {
+        for (const char of chunk) {
+            if (char === '\n') {
+                lines.push(current);
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+    };
+    const renderer = new StreamRenderer(painter, sink, { width, indent: '' });
+    renderer.push(text);
+    renderer.finish();
+    if (current.length > 0) {
+        lines.push(current);
+    }
+    return lines.map((line) => '  ' + line);
+}
+export function renderEntries(entries, width, painter, spinnerFrame = 0, expandDetails = false) {
+    const out = [];
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (!expandDetails && entry.kind === 'tool' && entry.status !== 'running') {
+            let end = index + 1;
+            while (end < entries.length) {
+                const next = entries[end];
+                if (next.kind !== 'tool' || next.name !== entry.name || next.status === 'running') {
+                    break;
+                }
+                end += 1;
+            }
+            if (end - index >= 2) {
+                out.push(...renderToolGroup(entries.slice(index, end), width, painter));
+                index = end - 1;
+                continue;
+            }
+        }
+        out.push(...renderEntry(entry, width, painter, spinnerFrame, expandDetails));
+    }
+    return out;
+}
+/** Scroll position measured in lines from the bottom of the transcript. */
+export class Viewport {
+    scroll = 0;
+    get atBottom() {
+        return this.scroll === 0;
+    }
+    clamp(total, height) {
+        const max = Math.max(0, total - height);
+        this.scroll = Math.max(0, Math.min(max, this.scroll));
+    }
+    scrollBy(delta, total, height) {
+        const max = Math.max(0, total - height);
+        this.scroll = Math.max(0, Math.min(max, this.scroll + delta));
+    }
+    visible(all, height) {
+        this.clamp(all.length, height);
+        const start = Math.max(0, all.length - height - this.scroll);
+        return all.slice(start, start + height);
+    }
+}
+export function lineWidth(line) {
+    return visibleWidth(line);
+}
+/** Plain text of the lines between anchor and cursor, inclusive. */
+export function selectionText(lines, anchor, cursor) {
+    const start = Math.max(0, Math.min(anchor, cursor));
+    const end = Math.min(lines.length - 1, Math.max(anchor, cursor));
+    const out = [];
+    for (let index = start; index <= end; index += 1) {
+        out.push(stripAnsi(lines[index]).replace(/\s+$/, ''));
+    }
+    return out.join('\n');
+}
+function columnToIndex(text, column) {
+    let width = 0;
+    let index = 0;
+    for (const char of text) {
+        if (width >= column) {
+            return index;
+        }
+        width += charWidth(char);
+        index += char.length;
+    }
+    return text.length;
+}
+/** Plain text between two display columns of one line. */
+export function sliceColumns(text, from, to) {
+    const plain = stripAnsi(text);
+    if (to <= from) {
+        return '';
+    }
+    const start = columnToIndex(plain, from);
+    const end = to >= Number.MAX_SAFE_INTEGER ? plain.length : columnToIndex(plain, to);
+    return plain.slice(start, end);
+}
+/** Text selected by dragging between two screen cells. */
+export function selectionByCells(lines, a, b) {
+    const startLine = Math.max(0, Math.min(a.line, b.line));
+    const endLine = Math.min(lines.length - 1, Math.max(a.line, b.line));
+    const first = a.line <= b.line ? a : b;
+    const last = a.line <= b.line ? b : a;
+    const out = [];
+    for (let line = startLine; line <= endLine; line += 1) {
+        const from = line === first.line ? first.col : 0;
+        const to = line === last.line ? last.col : Number.MAX_SAFE_INTEGER;
+        out.push(sliceColumns(lines[line] ?? '', from, to).replace(/\s+$/, ''));
+    }
+    return out.join('\n');
+}
+/** Rebuilds a line with the given column range shown in reverse video. */
+export function highlightColumns(line, from, to) {
+    const plain = stripAnsi(line);
+    const start = columnToIndex(plain, from);
+    const end = to >= Number.MAX_SAFE_INTEGER ? plain.length : columnToIndex(plain, to);
+    if (end <= start) {
+        return plain;
+    }
+    return plain.slice(0, start) + '\x1b[7m' + plain.slice(start, end) + '\x1b[27m' + plain.slice(end);
+}

package/dist/util/clipboard.js

@@ -0,0 +1,53 @@
+import { spawnSync } from 'node:child_process';
+/**
+ * Puts text on the system clipboard without touching the console code page.
+ *
+ * On Windows, clip.exe decodes piped stdin with the OEM code page, which turns
+ * Chinese into mojibake; PowerShell's Set-Clipboard gets the text as base64 so
+ * the encoding never depends on the console.
+ */
+export function copyToClipboard(text) {
+    if (process.platform === 'win32' && copyWindows(text)) {
+        return true;
+    }
+    if (process.platform === 'darwin') {
+        if (run('pbcopy', [], text)) {
+            return true;
+        }
+    }
+    else if (process.platform !== 'win32') {
+        if (run('wl-copy', [], text)) {
+            return true;
+        }
+        if (run('xclip', ['-selection', 'clipboard'], text)) {
+            return true;
+        }
+    }
+    // OSC 52: the terminal itself writes the clipboard, so UTF-8 stays intact.
+    try {
+        process.stdout.write('\x1b]52;c;' + Buffer.from(text, 'utf8').toString('base64') + '\x07');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function copyWindows(text) {
+    const encoded = Buffer.from(text, 'utf8').toString('base64');
+    const script = 'Set-Clipboard -Value ([Text.Encoding]::UTF8.GetString('
+        + '[Convert]::FromBase64String(\'' + encoded + '\')))';
+    if (run('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], '')) {
+        return true;
+    }
+    // Older systems without PowerShell: clip.exe still works for plain ASCII.
+    return run('clip', [], text);
+}
+function run(command, args, input) {
+    try {
+        const result = spawnSync(command, args, { input, timeout: 4000, windowsHide: true });
+        return result.status === 0;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/util/errors.js

@@ -0,0 +1,50 @@
+export class HttpError extends Error {
+    status;
+    body;
+    /** Parsed Retry-After, when the server sent one. */
+    retryAfterMs;
+    constructor(status, body, retryAfterMs) {
+        super('HTTP ' + status + '：' + summarize(body));
+        this.name = 'HttpError';
+        this.status = status;
+        this.body = body;
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+function summarize(body) {
+    const compact = body.replace(/\s+/g, ' ').trim();
+    return compact.length > 400 ? compact.slice(0, 400) + '…' : compact;
+}
+/** Turns provider failures into something a person can act on. */
+export function friendlyError(error) {
+    if (error instanceof HttpError) {
+        if (error.status === 401 || error.status === 403) {
+            return 'API Key 被拒绝（HTTP ' + error.status + '）。运行 minko config --api-key <key> 更新。';
+        }
+        if (error.status === 404) {
+            return '接口地址或模型名不对（HTTP 404）。检查 minko config --model 与 --base-url。';
+        }
+        if (error.status === 429) {
+            return '请求太频繁或额度不足（HTTP 429）。稍后重试。';
+        }
+        if (error.status === 400) {
+            return '服务端拒绝了这次请求（HTTP 400）：' + summarize(error.body);
+        }
+        if (error.status >= 500) {
+            return '服务端出错（HTTP ' + error.status + '）：' + summarize(error.body);
+        }
+        return error.message;
+    }
+    if (error instanceof Error) {
+        if (error.name === 'AbortError') {
+            return '已中断';
+        }
+        const cause = error.cause;
+        if (error.message.includes('fetch failed')) {
+            const detail = cause instanceof Error ? cause.message : '';
+            return '连不上服务地址' + (detail ? '（' + detail + '）' : '') + '，检查网络和 --base-url。';
+        }
+        return error.message;
+    }
+    return String(error);
+}

package/dist/util/version.js

@@ -0,0 +1,12 @@
+import fs from 'node:fs';
+/** Version string straight from package.json. */
+export function readVersion() {
+    try {
+        const file = new URL('../../package.json', import.meta.url);
+        const pkg = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/dist/web/fetch.js

@@ -0,0 +1,168 @@
+import { readVersion } from "../util/version.js";
+const MAX_BYTES = 2 * 1024 * 1024;
+const MAX_OUTPUT = 20_000;
+const TIMEOUT_MS = 20_000;
+/** Fetches a URL with a timeout and a hard response-size cap. */
+export async function fetchWeb(url, signal) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error('URL 不合法：' + url);
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new Error('只支持 http/https URL');
+    }
+    if (signal.aborted) {
+        throw new Error('已中断');
+    }
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+    }, TIMEOUT_MS);
+    timer.unref?.();
+    const onAbort = () => controller.abort();
+    signal.addEventListener('abort', onAbort, { once: true });
+    try {
+        const response = await fetch(parsed.href, {
+            redirect: 'follow',
+            signal: controller.signal,
+            headers: {
+                'user-agent': 'Minko/' + readVersion(),
+                accept: 'text/html,application/xhtml+xml,text/plain,application/json;q=0.9,*/*;q=0.5',
+            },
+        });
+        if (!response.ok) {
+            throw new Error('HTTP ' + response.status);
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        const body = await readLimited(response);
+        return { body, contentType, finalUrl: response.url || parsed.href };
+    }
+    catch (error) {
+        if (timedOut) {
+            throw new Error('抓取超时（20 秒）');
+        }
+        if (signal.aborted) {
+            throw new Error('已中断');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+        signal.removeEventListener('abort', onAbort);
+    }
+}
+export const webFetchTool = {
+    readOnly: true,
+    spec: {
+        name: 'web_fetch',
+        description: '抓取一个网页并转成可读文本（HTML 会去掉脚本/样式）。需要联网。',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'http/https 地址' },
+            },
+            required: ['url'],
+            additionalProperties: false,
+        },
+    },
+    async run(args, ctx) {
+        const raw = typeof args.url === 'string' ? args.url.trim() : '';
+        if (raw.length === 0) {
+            throw new Error('缺少 url 参数');
+        }
+        const page = await fetchWeb(raw, ctx.signal);
+        const type = page.contentType.toLowerCase();
+        let text;
+        if (type.includes('text/html') || type.includes('application/xhtml')) {
+            text = htmlToText(page.body);
+        }
+        else if (type.startsWith('text/') || type.includes('json')
+            || type.includes('xml') || type.includes('javascript') || type.length === 0) {
+            text = page.body;
+        }
+        else {
+            throw new Error('不支持的内容类型：' + (page.contentType || 'unknown'));
+        }
+        text = text.trim();
+        if (text.length === 0) {
+            return '（页面没有可读文本）';
+        }
+        if (text.length > MAX_OUTPUT) {
+            return text.slice(0, MAX_OUTPUT) + '\n…（内容过长，已截断）';
+        }
+        return text;
+    },
+};
+export function htmlToText(html) {
+    let text = html
+        .replace(/<!--[\s\S]*?-->/g, '')
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, '')
+        .replace(/<noscript\b[^>]*>[\s\S]*?<\/noscript>/gi, '')
+        .replace(/<\/(p|div|section|article|header|footer|h[1-6]|tr|ul|ol|table)>/gi, '\n')
+        .replace(/<br\s*\/?>/gi, '\n')
+        .replace(/<li\b[^>]*>/gi, '- ')
+        .replace(/<[^>]+>/g, ' ');
+    text = decodeEntities(text);
+    return text
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/[ \t]{2,}/g, ' ')
+        .trim();
+}
+export function decodeEntities(text) {
+    const named = {
+        amp: '&',
+        lt: '<',
+        gt: '>',
+        quot: '"',
+        apos: "'",
+        nbsp: ' ',
+    };
+    return text
+        .replace(/&#(\d+);/g, (_, value) => safeCodePoint(Number(value)))
+        .replace(/&#x([0-9a-f]+);/gi, (_, value) => safeCodePoint(parseInt(value, 16)))
+        .replace(/&([a-z]+);/gi, (match, name) => named[name.toLowerCase()] ?? match);
+}
+function safeCodePoint(value) {
+    try {
+        return Number.isFinite(value) ? String.fromCodePoint(value) : '';
+    }
+    catch {
+        return '';
+    }
+}
+async function readLimited(response) {
+    if (!response.body) {
+        return '';
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            total += value.byteLength;
+            if (total > MAX_BYTES) {
+                await reader.cancel().catch(() => { });
+                throw new Error('页面太大（超过 2MB）');
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch { /* already released */ }
+    }
+    return new TextDecoder('utf-8').decode(Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))));
+}

package/dist/web/search.js

@@ -0,0 +1,97 @@
+import { decodeEntities, fetchWeb, htmlToText } from "./fetch.js";
+const DEFAULT_SEARCH_URL = 'https://html.duckduckgo.com/html/';
+export const webSearchTool = {
+    readOnly: true,
+    spec: {
+        name: 'web_search',
+        description: '用 HTML 搜索页查资料（默认 DuckDuckGo），返回标题、链接和摘要。需要联网。',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                max_results: { type: 'number', description: '1-10，默认 5' },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
+    async run(args, ctx) {
+        const query = typeof args.query === 'string' ? args.query.trim() : '';
+        if (query.length === 0) {
+            throw new Error('缺少 query 参数');
+        }
+        const maxResults = typeof args.max_results === 'number' && Number.isFinite(args.max_results)
+            ? Math.min(10, Math.max(1, Math.floor(args.max_results)))
+            : 5;
+        const base = ctx.config?.web?.searchUrl || DEFAULT_SEARCH_URL;
+        let url;
+        try {
+            url = new URL(base);
+        }
+        catch {
+            throw new Error('web.searchUrl 不是合法 URL：' + base);
+        }
+        url.searchParams.set('q', query);
+        const page = await fetchWeb(url.href, ctx.signal);
+        const results = parseResults(page.body).slice(0, maxResults);
+        if (results.length === 0) {
+            return '没有找到搜索结果。';
+        }
+        return results.map((result, index) => (index + 1) + '. ' + result.title
+            + '\n' + result.url + (result.snippet ? '\n' + result.snippet : '')).join('\n\n');
+    },
+};
+function parseResults(html) {
+    const titles = [];
+    const snippets = [];
+    for (const match of html.matchAll(/<a\b([^>]*)>([\s\S]*?)<\/a>/gi)) {
+        const attrs = match[1];
+        const inner = match[2];
+        const className = attribute(attrs, 'class');
+        if (/result__a/i.test(className)) {
+            const href = attribute(attrs, 'href');
+            const url = cleanUrl(href);
+            const title = stripText(inner);
+            if (title.length > 0 && url.length > 0) {
+                titles.push({ title, url });
+            }
+        }
+        else if (/result__snippet/i.test(className)) {
+            snippets.push(stripText(inner));
+        }
+    }
+    return titles.map((entry, index) => ({
+        ...entry,
+        snippet: snippets[index] ?? '',
+    }));
+}
+function attribute(attrs, name) {
+    const doubleQuoted = new RegExp('\\b' + name + '\\s*=\\s*"([^"]*)"', 'i').exec(attrs);
+    if (doubleQuoted) {
+        return decodeEntities(doubleQuoted[1]);
+    }
+    const singleQuoted = new RegExp("\\b" + name + "\\s*=\\s*'([^']*)'", 'i').exec(attrs);
+    return singleQuoted ? decodeEntities(singleQuoted[1]) : '';
+}
+function cleanUrl(href) {
+    if (href.length === 0) {
+        return '';
+    }
+    try {
+        const parsed = new URL(href, 'https://duckduckgo.com');
+        const redirect = parsed.searchParams.get('uddg');
+        if (redirect) {
+            return decodeURIComponent(redirect);
+        }
+        if (href.startsWith('//')) {
+            return 'https:' + href;
+        }
+        return parsed.href;
+    }
+    catch {
+        return href;
+    }
+}
+function stripText(html) {
+    return htmlToText(html).replace(/\s+/g, ' ').trim();
+}