protoagent 0.0.4 → 0.1.0

package/dist/cli.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * CLI entry point for ProtoAgent.
+ *
+ * Parses command-line flags and launches either the main chat UI
+ * or the configuration wizard.
+ */
+import process from 'node:process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+import { render } from 'ink';
+import { Command } from 'commander';
+import { App } from './App.js';
+import { ConfigureComponent } from './config.js';
+// Get package.json version
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const packageJson = JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'));
+const program = new Command();
+program
+    .description('ProtoAgent — a simple, hackable coding agent CLI')
+    .version(packageJson.version)
+    .option('--dangerously-accept-all', 'Auto-approve all file writes and shell commands')
+    .option('--log-level <level>', 'Log level: TRACE, DEBUG, INFO, WARN, ERROR', 'INFO')
+    .option('--session <id>', 'Resume a previous session by ID')
+    .action((options) => {
+    // Default action - start the main app
+    render(_jsx(App, { dangerouslyAcceptAll: options.dangerouslyAcceptAll || false, logLevel: options.logLevel, sessionId: options.session }));
+});
+// Configure subcommand
+program
+    .command('configure')
+    .description('Configure AI model and API key settings')
+    .action(() => {
+    render(_jsx(ConfigureComponent, {}));
+});
+program.parse(process.argv);

package/dist/components/CollapsibleBox.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export const CollapsibleBox = ({ title, content, titleColor, dimColor = false, maxPreviewLines = 3, maxPreviewChars = 500, expanded = false, marginBottom = 0, }) => {
+    const lines = content.split('\n');
+    const isTooManyLines = lines.length > maxPreviewLines;
+    const isTooManyChars = content.length > maxPreviewChars;
+    const isLong = isTooManyLines || isTooManyChars;
+    // If content is short, always show it
+    if (!isLong) {
+        return (_jsxs(Box, { flexDirection: "column", marginBottom: marginBottom, borderStyle: "round", borderColor: titleColor || 'white', children: [_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: titleColor, dimColor: dimColor, bold: true, children: title }) }), _jsx(Box, { marginLeft: 2, paddingRight: 1, children: _jsx(Text, { dimColor: dimColor, children: content }) })] }));
+    }
+    // For long content, show preview or full content
+    let preview;
+    if (expanded) {
+        preview = content;
+    }
+    else {
+        // Truncate by lines first, then by characters
+        const linesTruncated = lines.slice(0, maxPreviewLines).join('\n');
+        preview = linesTruncated.length > maxPreviewChars
+            ? linesTruncated.slice(0, maxPreviewChars)
+            : linesTruncated;
+    }
+    const hasMore = !expanded;
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: marginBottom, borderStyle: "round", borderColor: titleColor || 'white', children: [_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: titleColor, dimColor: dimColor, bold: true, children: [expanded ? '▼' : '▶', " ", title] }) }), _jsxs(Box, { flexDirection: "column", marginLeft: 2, paddingRight: 1, children: [_jsx(Text, { dimColor: dimColor, children: preview }), hasMore && _jsx(Text, { dimColor: true, children: "... (use /expand to see all)" })] })] }));
+};

package/dist/components/ConfigDialog.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * ConfigDialog — Modal-like dialog for changing config mid-conversation
+ *
+ * Allows users to update provider, model, or API key without losing chat history.
+ */
+import { useState } from 'react';
+import { Box, Text } from 'ink';
+import { PasswordInput, Select } from '@inkjs/ui';
+import { getProvider, SUPPORTED_MODELS } from '../providers.js';
+export const ConfigDialog = ({ currentConfig, onComplete, onCancel, }) => {
+    const [step, setStep] = useState('select_provider');
+    const [selectedProviderId, setSelectedProviderId] = useState(currentConfig.provider);
+    const [selectedModelId, setSelectedModelId] = useState(currentConfig.model);
+    const providerItems = SUPPORTED_MODELS.flatMap((provider) => provider.models.map((model) => ({
+        label: `${provider.name} - ${model.name}`,
+        value: `${provider.id}:::${model.id}`,
+    })));
+    const currentProvider = getProvider(currentConfig.provider);
+    // Provider selection step
+    if (step === 'select_provider') {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { color: "green", bold: true, children: "Change Configuration" }), _jsxs(Text, { dimColor: true, children: ["Current: ", currentProvider?.name, " / ", currentConfig.model] }), _jsx(Text, { dimColor: true, children: "Select a new provider and model:" }), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: providerItems.map((item) => ({ value: item.value, label: item.label })), onChange: (value) => {
+                            const [providerId, modelId] = value.split(':::');
+                            setSelectedProviderId(providerId);
+                            setSelectedModelId(modelId);
+                            setStep('enter_api_key');
+                        } }) })] }));
+    }
+    // API key entry step
+    const provider = getProvider(selectedProviderId);
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "green", paddingX: 1, children: [_jsx(Text, { color: "green", bold: true, children: "Confirm Configuration" }), _jsxs(Text, { dimColor: true, children: ["Provider: ", provider?.name, " / ", selectedModelId] }), _jsx(Text, { children: "Enter your API key (or leave empty to keep current/env var):" }), _jsx(PasswordInput, { placeholder: `Paste your ${provider?.apiKeyEnvVar || 'API'} key`, onSubmit: (value) => {
+                    const finalApiKey = value.trim().length > 0 ? value.trim() : currentConfig.apiKey;
+                    const newConfig = {
+                        provider: selectedProviderId,
+                        model: selectedModelId,
+                        apiKey: finalApiKey,
+                    };
+                    onComplete(newConfig);
+                } })] }));
+};

package/dist/components/ConsolidatedToolMessage.js

@@ -0,0 +1,41 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Table } from './Table.js';
+import { FormattedMessage } from './FormattedMessage.js';
+export const ConsolidatedToolMessage = ({ toolCalls, toolResults, expanded = false, }) => {
+    const toolNames = toolCalls.map((toolCall) => toolCall.name);
+    const title = `Called: ${toolNames.join(', ')}`;
+    const containsTodoTool = toolCalls.some((toolCall) => toolCall.name === 'todo_read' || toolCall.name === 'todo_write');
+    const titleColor = containsTodoTool ? 'green' : 'white';
+    const isExpanded = expanded || containsTodoTool;
+    if (isExpanded) {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "white", children: [_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: titleColor, bold: true, children: ["\u25BC ", title] }) }), _jsx(Box, { flexDirection: "column", marginLeft: 2, paddingRight: 1, children: toolCalls.map((toolCall, idx) => {
+                        const result = toolResults.get(toolCall.id);
+                        if (!result)
+                            return null;
+                        // Try to see if it's JSON that could be a table
+                        let isJsonTable = false;
+                        try {
+                            const parsed = JSON.parse(result.content);
+                            isJsonTable = typeof parsed === 'object' && parsed !== null;
+                        }
+                        catch (e) { }
+                        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "cyan", bold: true, children: ["[", result.name, "]:"] }), isJsonTable ? (_jsx(Table, { data: result.content })) : (_jsx(FormattedMessage, { content: result.content }))] }, idx));
+                    }) })] }));
+    }
+    const compactLines = toolCalls.flatMap((toolCall) => {
+        const result = toolResults.get(toolCall.id);
+        if (!result)
+            return [];
+        const compactContent = result.content
+            .replace(/\s+/g, ' ')
+            .trim();
+        return [`[${result.name}] ${compactContent}`];
+    });
+    const compactPreview = compactLines.join(' | ');
+    const previewLimit = 180;
+    const preview = compactPreview.length > previewLimit
+        ? `${compactPreview.slice(0, previewLimit).trimEnd()}... (use /expand)`
+        : compactPreview;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: titleColor || 'white', children: [_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: titleColor, dimColor: true, bold: true, children: ["\u25B6 ", title] }) }), _jsx(Box, { marginLeft: 2, paddingRight: 1, children: _jsx(Text, { dimColor: true, children: preview }) })] }));
+};

package/dist/components/FormattedMessage.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Table } from './Table.js';
+import { formatMessage } from '../utils/format-message.js';
+/**
+ * FormattedMessage component
+ *
+ * Parses a markdown string and renders:
+ * - Standard text with ANSI formatting
+ * - Markdown tables using ink-table
+ * - Code blocks (rendered in a box)
+ */
+export const FormattedMessage = ({ content }) => {
+    if (!content)
+        return null;
+    const lines = content.split('\n');
+    const blocks = [];
+    let currentBlockContent = [];
+    let currentBlockType = 'text';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmedLine = line.trim();
+        // 1. Handle Code Blocks
+        if (currentBlockType === 'code') {
+            currentBlockContent.push(line);
+            // Check for end of code block
+            if (trimmedLine.startsWith('```')) {
+                blocks.push({ type: 'code', content: currentBlockContent.join('\n') });
+                currentBlockContent = [];
+                currentBlockType = 'text';
+            }
+            continue;
+        }
+        // Start Code Block
+        if (trimmedLine.startsWith('```')) {
+            // Finish pending text block
+            if (currentBlockContent.length > 0) {
+                blocks.push({ type: 'text', content: currentBlockContent.join('\n') });
+            }
+            currentBlockContent = [line];
+            currentBlockType = 'code';
+            continue;
+        }
+        // 2. Handle Tables
+        if (currentBlockType === 'table') {
+            if (trimmedLine.startsWith('|')) {
+                currentBlockContent.push(line);
+                continue;
+            }
+            else {
+                // End of table block found (line doesn't start with |)
+                blocks.push({ type: 'table', content: currentBlockContent.join('\n') });
+                // Reset to text and fall through to re-process this line
+                currentBlockContent = [];
+                currentBlockType = 'text';
+            }
+        }
+        // Start Table Block check
+        // A table start requires a pipe AND a subsequent separator line
+        const isTableStart = trimmedLine.startsWith('|');
+        const nextLine = lines[i + 1];
+        const isNextLineSeparator = nextLine && nextLine.trim().startsWith('|') && nextLine.includes('---');
+        if (isTableStart && isNextLineSeparator) {
+            // Finish pending text block
+            if (currentBlockContent.length > 0) {
+                blocks.push({ type: 'text', content: currentBlockContent.join('\n') });
+            }
+            currentBlockContent = [line];
+            currentBlockType = 'table';
+            continue;
+        }
+        // 3. Handle Text
+        currentBlockContent.push(line);
+    }
+    // Push final block
+    if (currentBlockContent.length > 0) {
+        blocks.push({ type: currentBlockType, content: currentBlockContent.join('\n') });
+    }
+    return (_jsx(Box, { flexDirection: "column", children: blocks.map((block, index) => {
+            if (block.type === 'table') {
+                if (!block.content.trim())
+                    return null;
+                return _jsx(Table, { data: block.content }, index);
+            }
+            if (block.type === 'code') {
+                return (_jsx(Box, { marginY: 1, paddingX: 1, borderStyle: "round", borderColor: "gray", children: _jsx(Text, { dimColor: true, children: block.content }) }, index));
+            }
+            // Text Block
+            if (!block.content.trim())
+                return null;
+            return (_jsx(Box, { marginBottom: 0, children: _jsx(Text, { children: formatMessage(block.content) }) }, index));
+        }) }));
+};

package/dist/components/Table.js

@@ -0,0 +1,275 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Table — Simple table renderer using basic ink components
+ *
+ * No external table library needed. Renders data as aligned columns.
+ */
+import React, { useEffect, useState } from 'react';
+import { Box, Text, useStdout } from 'ink';
+const graphemeSegmenter = typeof Intl !== 'undefined' && 'Segmenter' in Intl
+    ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+    : null;
+const COMBINING_MARK_PATTERN = /\p{Mark}/u;
+const ZERO_WIDTH_PATTERN = /[\u200B-\u200D\uFE0E\uFE0F]/u;
+const DOUBLE_WIDTH_PATTERN = /[\u1100-\u115F\u2329\u232A\u2E80-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE10-\uFE19\uFE30-\uFE6F\uFF00-\uFF60\uFFE0-\uFFE6\u{1F300}-\u{1FAFF}\u{1F900}-\u{1F9FF}\u{1F1E6}-\u{1F1FF}]/u;
+function splitGraphemes(text) {
+    if (!text)
+        return [];
+    if (graphemeSegmenter) {
+        return Array.from(graphemeSegmenter.segment(text), (segment) => segment.segment);
+    }
+    return Array.from(text);
+}
+function getGraphemeWidth(grapheme) {
+    if (!grapheme)
+        return 0;
+    if (ZERO_WIDTH_PATTERN.test(grapheme))
+        return 0;
+    if (COMBINING_MARK_PATTERN.test(grapheme))
+        return 0;
+    if (/^[\u0000-\u001F\u007F-\u009F]$/.test(grapheme))
+        return 0;
+    if (DOUBLE_WIDTH_PATTERN.test(grapheme))
+        return 2;
+    return 1;
+}
+function getTextWidth(text) {
+    return splitGraphemes(text).reduce((width, grapheme) => width + getGraphemeWidth(grapheme), 0);
+}
+function takeByDisplayWidth(text, maxWidth) {
+    if (maxWidth <= 0) {
+        return { slice: '', remainder: text };
+    }
+    const graphemes = splitGraphemes(text);
+    let consumed = 0;
+    let width = 0;
+    while (consumed < graphemes.length) {
+        const nextWidth = getGraphemeWidth(graphemes[consumed]);
+        if (width + nextWidth > maxWidth)
+            break;
+        width += nextWidth;
+        consumed++;
+    }
+    return {
+        slice: graphemes.slice(0, consumed).join(''),
+        remainder: graphemes.slice(consumed).join(''),
+    };
+}
+function parseInlineMarkdown(text) {
+    const segments = [];
+    const pattern = /\*\*\*([\s\S]+?)\*\*\*|\*\*([\s\S]+?)\*\*|\*([\s\S]+?)\*/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+        if (match.index > lastIndex) {
+            segments.push({ text: text.slice(lastIndex, match.index) });
+        }
+        if (match[1] !== undefined) {
+            segments.push({ text: match[1], bold: true, italic: true });
+        }
+        else if (match[2] !== undefined) {
+            segments.push({ text: match[2], bold: true });
+        }
+        else if (match[3] !== undefined) {
+            segments.push({ text: match[3], italic: true });
+        }
+        lastIndex = pattern.lastIndex;
+    }
+    if (lastIndex < text.length) {
+        segments.push({ text: text.slice(lastIndex) });
+    }
+    return segments.length > 0 ? segments : [{ text }];
+}
+function getDisplayWidth(text) {
+    return text
+        .split('\n')
+        .reduce((maxWidth, line) => {
+        const lineWidth = parseInlineMarkdown(line)
+            .reduce((width, segment) => width + getTextWidth(segment.text), 0);
+        return Math.max(maxWidth, lineWidth);
+    }, 0);
+}
+function wrapStyledText(text, width) {
+    if (width <= 0) {
+        return [[{ text }]];
+    }
+    const lines = [];
+    const paragraphs = String(text).split('\n');
+    for (const paragraph of paragraphs) {
+        if (paragraph.trim() === '') {
+            lines.push([]);
+            continue;
+        }
+        const words = parseInlineMarkdown(paragraph).flatMap((segment) => segment.text
+            .split(/\s+/)
+            .filter(Boolean)
+            .map((word) => ({
+            text: word,
+            bold: segment.bold,
+            italic: segment.italic,
+        })));
+        let currentLine = [];
+        let currentLength = 0;
+        const pushCurrentLine = () => {
+            lines.push(currentLine);
+            currentLine = [];
+            currentLength = 0;
+        };
+        for (const word of words) {
+            let remainingWord = word.text;
+            while (remainingWord.length > 0) {
+                const availableWidth = currentLength === 0 ? width : width - currentLength - 1;
+                const remainingWidth = getTextWidth(remainingWord);
+                if (remainingWidth <= availableWidth) {
+                    if (currentLength > 0) {
+                        currentLine.push({ text: ' ' });
+                        currentLength++;
+                    }
+                    currentLine.push({ ...word, text: remainingWord });
+                    currentLength += remainingWidth;
+                    remainingWord = '';
+                    continue;
+                }
+                if (currentLength > 0) {
+                    pushCurrentLine();
+                    continue;
+                }
+                const { slice, remainder } = takeByDisplayWidth(remainingWord, width);
+                currentLine.push({ ...word, text: slice });
+                remainingWord = remainder;
+                pushCurrentLine();
+            }
+        }
+        if (currentLine.length > 0) {
+            pushCurrentLine();
+        }
+    }
+    return lines.length === 0 ? [[{ text: '' }]] : lines;
+}
+function getLineWidth(segments) {
+    return segments.reduce((width, segment) => width + getTextWidth(segment.text), 0);
+}
+/**
+ * Simple parser for Markdown tables.
+ */
+function parseMarkdownTable(markdown) {
+    const lines = markdown.trim().split('\n');
+    if (lines.length < 3)
+        return null;
+    const hasPipes = lines[0].includes('|');
+    const hasSeparator = lines[1].includes('|') && lines[1].includes('-');
+    if (!hasPipes || !hasSeparator)
+        return null;
+    try {
+        const parseRow = (row) => row.split('|')
+            .map(cell => cell.trim())
+            .filter((cell, index, array) => {
+            if (index === 0 && cell === '')
+                return false;
+            if (index === array.length - 1 && cell === '')
+                return false;
+            return true;
+        });
+        const headers = parseRow(lines[0]);
+        const rows = lines.slice(2).map(parseRow);
+        return rows.map(row => {
+            const obj = {};
+            headers.forEach((header, i) => {
+                obj[header || `Column ${i + 1}`] = row[i] || '';
+            });
+            return obj;
+        });
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Normalize input data into an array of objects for display.
+ */
+function normalizeData(data) {
+    let processedData = data;
+    if (typeof data === 'string') {
+        try {
+            const parsed = JSON.parse(data);
+            if (typeof parsed === 'object' && parsed !== null) {
+                processedData = parsed;
+            }
+        }
+        catch (e) {
+            const parsedMarkdown = parseMarkdownTable(data);
+            if (parsedMarkdown) {
+                processedData = parsedMarkdown;
+            }
+        }
+    }
+    if (Array.isArray(processedData)) {
+        return processedData.map(item => typeof item === 'object' && item !== null ? item : { value: String(item) });
+    }
+    else if (typeof processedData === 'object' && processedData !== null) {
+        return Object.entries(processedData).map(([key, value]) => ({
+            property: key,
+            value: typeof value === 'object' ? JSON.stringify(value) : String(value),
+        }));
+    }
+    return [{ value: String(processedData) }];
+}
+export const Table = ({ data, title, titleColor = 'cyan' }) => {
+    const { stdout } = useStdout();
+    const [terminalWidth, setTerminalWidth] = useState(stdout?.columns ?? 80);
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const updateWidth = () => {
+            setTerminalWidth(stdout.columns ?? 80);
+        };
+        updateWidth();
+        stdout.on('resize', updateWidth);
+        return () => {
+            stdout.off('resize', updateWidth);
+        };
+    }, [stdout]);
+    const displayData = normalizeData(data);
+    if (displayData.length === 0) {
+        return (_jsx(Box, { marginY: 1, children: _jsx(Text, { italic: true, dimColor: true, children: "No data to display in table." }) }));
+    }
+    // Get all column keys
+    const columns = Array.from(new Set(displayData.flatMap(row => Object.keys(row))));
+    // Calculate column widths
+    const colWidths = columns.map(col => {
+        const headerLen = getDisplayWidth(String(col));
+        const maxCellLen = Math.max(...displayData.map(row => getDisplayWidth(String(row[col] ?? ''))));
+        return Math.max(headerLen, Math.min(maxCellLen, 100)) + 2;
+    });
+    // Adjust widths to fit terminal
+    let currentTotal = colWidths.reduce((a, b) => a + b, 0) + columns.length + 1;
+    const targetTotal = Math.max(40, terminalWidth - 2);
+    if (currentTotal > targetTotal) {
+        while (currentTotal > targetTotal) {
+            const widestIdx = colWidths.reduce((best, cur, idx) => cur > colWidths[best] ? idx : best, 0);
+            if (colWidths[widestIdx] <= 10)
+                break;
+            colWidths[widestIdx]--;
+            currentTotal--;
+        }
+    }
+    // Box-drawing lines
+    const topBorder = '┌' + colWidths.map(w => '─'.repeat(w)).join('┬') + '┐';
+    const headerSep = '├' + colWidths.map(w => '─'.repeat(w)).join('┼') + '┤';
+    const rowSep = '├' + colWidths.map(w => '─'.repeat(w)).join('┼') + '┤';
+    const bottomBorder = '└' + colWidths.map(w => '─'.repeat(w)).join('┴') + '┘';
+    const renderRowLines = (cells, rowKey, isHeader = false) => {
+        const wrappedCells = cells.map((cell, i) => wrapStyledText(cell, colWidths[i] - 2));
+        const maxLines = Math.max(...wrappedCells.map(c => c.length));
+        const lines = [];
+        for (let lineIdx = 0; lineIdx < maxLines; lineIdx++) {
+            lines.push(_jsxs(Text, { bold: isHeader, children: ['│', wrappedCells.map((wrappedCell, i) => {
+                        const segments = wrappedCell[lineIdx] ?? [];
+                        const padding = Math.max(0, colWidths[i] - 1 - getLineWidth(segments));
+                        return (_jsxs(React.Fragment, { children: [' ', segments.map((segment, segmentIdx) => (_jsx(Text, { bold: isHeader || segment.bold, italic: segment.italic, children: segment.text }, `${rowKey}-${lineIdx}-${i}-${segmentIdx}`))), ' '.repeat(padding), '│'] }, `${rowKey}-${lineIdx}-${i}`));
+                    })] }, `${rowKey}-${lineIdx}`));
+        }
+        return lines;
+    };
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [title && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: titleColor, bold: true, underline: true, children: title }) })), _jsx(Text, { children: topBorder }), renderRowLines(columns.map(String), 'header', true), _jsx(Text, { children: headerSep }), displayData.map((row, rowIdx) => (_jsxs(React.Fragment, { children: [rowIdx > 0 && _jsx(Text, { dimColor: true, children: rowSep }), renderRowLines(columns.map(col => String(row[col] ?? '')), `row-${rowIdx}`)] }, rowIdx))), _jsx(Text, { children: bottomBorder })] }));
+};