ethagent 0.2.1 → 1.0.1

package/src/chat/textCursor.ts

@@ -0,0 +1,202 @@
+export type TextCursor = {
+  value: string
+  offset: number
+}
+
+export type CursorMoveResult = {
+  cursor: TextCursor
+  moved: boolean
+}
+
+export type VisualLine = {
+  start: number
+  end: number
+}
+
+export type VisualLineWindow = {
+  start: number
+  end: number
+}
+
+export function normalizeCursor(value: string, offset: number): TextCursor {
+  return { value, offset: clampOffset(value, offset) }
+}
+
+export function moveLeft(cursor: TextCursor): TextCursor {
+  return normalizeCursor(cursor.value, cursor.offset - 1)
+}
+
+export function moveRight(cursor: TextCursor): TextCursor {
+  return normalizeCursor(cursor.value, cursor.offset + 1)
+}
+
+export function moveVerticalCursor(
+  cursor: TextCursor,
+  direction: 1 | -1,
+  preferredColumn?: number,
+): CursorMoveResult {
+  const lines = getLogicalLines(cursor.value)
+  const position = positionFromOffset(lines, cursor.offset)
+  const targetLine = position.line + direction
+  if (targetLine < 0 || targetLine >= lines.length) {
+    return { cursor, moved: false }
+  }
+  const targetOffset = offsetFromPosition(lines, targetLine, preferredColumn ?? position.column)
+  return {
+    cursor: normalizeCursor(cursor.value, targetOffset),
+    moved: targetOffset !== cursor.offset,
+  }
+}
+
+export function getVisualLines(value: string, wrapWidth: number): VisualLine[] {
+  const safeWrapWidth = Math.max(1, Math.floor(wrapWidth))
+  const lines: VisualLine[] = []
+  let start = 0
+
+  for (let index = 0; index <= value.length; index += 1) {
+    if (index !== value.length && value[index] !== '\n') continue
+
+    const end = index
+    if (start === end) {
+      lines.push({ start, end })
+    } else {
+      for (let chunkStart = start; chunkStart < end; chunkStart += safeWrapWidth) {
+        lines.push({ start: chunkStart, end: Math.min(chunkStart + safeWrapWidth, end) })
+      }
+      if (end === value.length && (end - start) % safeWrapWidth === 0) {
+        lines.push({ start: end, end })
+      }
+    }
+    start = index + 1
+  }
+
+  return lines.length > 0 ? lines : [{ start: 0, end: 0 }]
+}
+
+export function getVisualLineIndex(lines: VisualLine[], offset: number): number {
+  return visualPositionFromOffset(lines, offset).line
+}
+
+export function getVisibleVisualLineWindow(
+  totalLines: number,
+  cursorLine: number,
+  maxVisibleLines: number,
+): VisualLineWindow {
+  const safeTotal = Math.max(0, Math.floor(totalLines))
+  if (safeTotal === 0) return { start: 0, end: 0 }
+
+  const safeMaxVisible = Math.max(1, Math.floor(maxVisibleLines))
+  if (safeTotal <= safeMaxVisible) return { start: 0, end: safeTotal }
+
+  const safeCursorLine = Math.max(0, Math.min(Math.floor(cursorLine), safeTotal - 1))
+  const half = Math.floor(safeMaxVisible / 2)
+  const start = Math.max(0, Math.min(
+    safeCursorLine - half,
+    safeTotal - safeMaxVisible,
+  ))
+
+  return { start, end: start + safeMaxVisible }
+}
+
+export function moveVerticalVisualCursor(
+  cursor: TextCursor,
+  direction: 1 | -1,
+  wrapWidth: number,
+  preferredColumn?: number,
+): CursorMoveResult {
+  const lines = getVisualLines(cursor.value, wrapWidth)
+  const position = visualPositionFromOffset(lines, cursor.offset)
+  const targetLine = position.line + direction
+  if (targetLine < 0 || targetLine >= lines.length) {
+    return { cursor, moved: false }
+  }
+  const target = lines[targetLine]!
+  const targetColumn = Math.min(preferredColumn ?? position.column, target.end - target.start)
+  const targetOffset = target.start + Math.max(0, targetColumn)
+  return {
+    cursor: normalizeCursor(cursor.value, targetOffset),
+    moved: targetOffset !== cursor.offset,
+  }
+}
+
+export function cursorOnLastLine(value: string, offset: number): TextCursor {
+  const lines = getLogicalLines(value)
+  const lastLine = Math.max(0, lines.length - 1)
+  return normalizeCursor(value, offsetFromPosition(lines, lastLine, 0))
+}
+
+export function cursorOnLastLineAtColumn(value: string, column: number): TextCursor {
+  const lines = getLogicalLines(value)
+  const lastLine = Math.max(0, lines.length - 1)
+  return normalizeCursor(value, offsetFromPosition(lines, lastLine, column))
+}
+
+export function cursorColumn(value: string, offset: number): number {
+  return positionFromOffset(getLogicalLines(value), clampOffset(value, offset)).column
+}
+
+type LogicalLine = {
+  start: number
+  end: number
+}
+
+function getLogicalLines(value: string): LogicalLine[] {
+  const lines: LogicalLine[] = []
+  let start = 0
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] === '\n') {
+      lines.push({ start, end: index })
+      start = index + 1
+    }
+  }
+  lines.push({ start, end: value.length })
+  return lines
+}
+
+function positionFromOffset(lines: LogicalLine[], rawOffset: number): { line: number; column: number } {
+  const offset = Math.max(0, rawOffset)
+  for (let line = 0; line < lines.length; line += 1) {
+    const entry = lines[line]!
+    const next = lines[line + 1]
+    if (!next || offset < next.start) {
+      return {
+        line,
+        column: Math.max(0, Math.min(offset, entry.end) - entry.start),
+      }
+    }
+  }
+  const last = lines[lines.length - 1]!
+  return { line: lines.length - 1, column: last.end - last.start }
+}
+
+function offsetFromPosition(lines: LogicalLine[], line: number, column: number): number {
+  const entry = lines[Math.max(0, Math.min(line, lines.length - 1))]!
+  return entry.start + Math.min(Math.max(0, column), entry.end - entry.start)
+}
+
+function visualPositionFromOffset(lines: VisualLine[], rawOffset: number): { line: number; column: number } {
+  const offset = Math.max(0, rawOffset)
+  for (let line = 0; line < lines.length; line += 1) {
+    const entry = lines[line]!
+    if (entry.start === entry.end && offset === entry.start) {
+      return { line, column: 0 }
+    }
+    if (offset >= entry.start && offset < entry.end) {
+      return { line, column: offset - entry.start }
+    }
+  }
+
+  for (let line = lines.length - 1; line >= 0; line -= 1) {
+    const entry = lines[line]!
+    if (offset === entry.end) {
+      return { line, column: entry.end - entry.start }
+    }
+  }
+
+  const last = lines[lines.length - 1]!
+  return { line: lines.length - 1, column: last.end - last.start }
+}
+
+function clampOffset(value: string, offset: number): number {
+  return Math.max(0, Math.min(value.length, offset))
+}

package/src/chat/toolResultDisplay.ts

@@ -0,0 +1,8 @@
+const COMPACT_SUCCESS_TOOL_RESULTS = new Set([
+  'read_file',
+  'read_private_continuity_file',
+])
+
+export function hidesSuccessfulToolResultContent(name: string, isError?: boolean): boolean {
+  return !isError && COMPACT_SUCCESS_TOOL_RESULTS.has(name)
+}

package/src/chat/transcriptViewport.ts

@@ -0,0 +1,247 @@
+import type { MessageRow } from './MessageList.js'
+import { hidesSuccessfulToolResultContent } from './toolResultDisplay.js'
+
+export type TranscriptAnchor = {
+  rowId: string
+  offset: number
+}
+
+export type TranscriptViewportState = {
+  scrollTopLine: number
+  followTail: boolean
+  anchor: TranscriptAnchor | null
+}
+
+export function buildLineOffsets(rowHeights: number[]): number[] {
+  const out = new Array<number>(rowHeights.length + 1).fill(0)
+  for (let i = 0; i < rowHeights.length; i += 1) {
+    out[i + 1] = out[i]! + (rowHeights[i] ?? 1)
+  }
+  return out
+}
+
+export function findRowIndexAtLine(offsets: number[], line: number): number {
+  let low = 0
+  let high = offsets.length - 1
+  while (low < high) {
+    const mid = Math.floor((low + high + 1) / 2)
+    if ((offsets[mid] ?? 0) <= line) low = mid
+    else high = mid - 1
+  }
+  return low
+}
+
+export function anchorForScrollTop(
+  rowIds: string[],
+  offsets: number[],
+  scrollTopLine: number,
+): TranscriptAnchor | null {
+  if (rowIds.length === 0) return null
+  const rowIndex = Math.min(rowIds.length - 1, findRowIndexAtLine(offsets, scrollTopLine))
+  const rowId = rowIds[rowIndex]
+  if (!rowId) return null
+  return {
+    rowId,
+    offset: Math.max(0, scrollTopLine - (offsets[rowIndex] ?? 0)),
+  }
+}
+
+export function resolveScrollTopFromAnchor(
+  rowIds: string[],
+  offsets: number[],
+  anchor: TranscriptAnchor | null,
+  maxScrollTop: number,
+): number | null {
+  if (!anchor) return null
+  const rowIndex = rowIds.indexOf(anchor.rowId)
+  if (rowIndex === -1) return null
+  return clampLine((offsets[rowIndex] ?? 0) + anchor.offset, maxScrollTop)
+}
+
+export function clampLine(line: number, maxScrollTop: number): number {
+  return Math.max(0, Math.min(maxScrollTop, Math.floor(line)))
+}
+
+export type TranscriptTailSelection<T> = {
+  rows: T[]
+  hiddenCount: number
+}
+
+export type TranscriptWindowSelection<T> = {
+  rows: T[]
+  hiddenBefore: number
+  hiddenAfter: number
+  totalLines: number
+  maxScrollOffset: number
+}
+
+export function selectTailRowsForViewport<T>(
+  rows: T[],
+  maxLines: number,
+  estimateHeight: (row: T) => number,
+): TranscriptTailSelection<T> {
+  if (rows.length === 0) return { rows: [], hiddenCount: 0 }
+
+  const budget = Math.max(1, Math.floor(maxLines))
+  let used = 0
+  let start = rows.length - 1
+
+  for (; start >= 0; start -= 1) {
+    const row = rows[start]
+    if (!row) break
+    const height = Math.max(1, estimateHeight(row))
+    if (used > 0 && used + height > budget) break
+    used += height
+  }
+
+  const firstVisible = Math.max(0, start + 1)
+  return {
+    rows: rows.slice(firstVisible),
+    hiddenCount: firstVisible,
+  }
+}
+
+export function selectRowsForScrollOffset<T>(
+  rows: T[],
+  maxLines: number,
+  scrollOffsetFromTail: number,
+  estimateHeight: (row: T) => number,
+): TranscriptWindowSelection<T> {
+  if (rows.length === 0) {
+    return { rows: [], hiddenBefore: 0, hiddenAfter: 0, totalLines: 0, maxScrollOffset: 0 }
+  }
+
+  const budget = Math.max(1, Math.floor(maxLines))
+  const heights = rows.map(row => Math.max(1, estimateHeight(row)))
+  const offsets = buildLineOffsets(heights)
+  const totalLines = offsets[offsets.length - 1] ?? 0
+  const maxScrollOffset = Math.max(0, totalLines - budget)
+  const scrollOffset = clampLine(scrollOffsetFromTail, maxScrollOffset)
+  const startLine = Math.max(0, totalLines - budget - scrollOffset)
+
+  return selectRowsForLineWindow(rows, offsets, budget, startLine, totalLines, maxScrollOffset)
+}
+
+export function selectRowsForScrollTop<T>(
+  rows: T[],
+  maxLines: number,
+  scrollTopLine: number,
+  estimateHeight: (row: T) => number,
+): TranscriptWindowSelection<T> {
+  if (rows.length === 0) {
+    return { rows: [], hiddenBefore: 0, hiddenAfter: 0, totalLines: 0, maxScrollOffset: 0 }
+  }
+
+  const budget = Math.max(1, Math.floor(maxLines))
+  const heights = rows.map(row => Math.max(1, estimateHeight(row)))
+  const offsets = buildLineOffsets(heights)
+  const totalLines = offsets[offsets.length - 1] ?? 0
+  const maxScrollOffset = Math.max(0, totalLines - budget)
+  const startLine = clampLine(scrollTopLine, maxScrollOffset)
+
+  return selectRowsForLineWindow(rows, offsets, budget, startLine, totalLines, maxScrollOffset)
+}
+
+export function promptScrollTopForPageUp(
+  rows: MessageRow[],
+  offsets: number[],
+  scrollTopLine: number,
+  maxScrollTop: number,
+  followTail: boolean,
+): number {
+  const promptStarts = promptScrollTops(rows, offsets)
+  if (promptStarts.length === 0) return clampLine(scrollTopLine, maxScrollTop)
+  if (followTail) return clampLine(promptStarts[promptStarts.length - 1]!, maxScrollTop)
+
+  const currentLine = clampLine(scrollTopLine, maxScrollTop)
+  for (let index = promptStarts.length - 1; index >= 0; index -= 1) {
+    const line = promptStarts[index]!
+    if (line < currentLine) return clampLine(line, maxScrollTop)
+  }
+  return 0
+}
+
+export function promptScrollTopForPageDown(
+  rows: MessageRow[],
+  offsets: number[],
+  scrollTopLine: number,
+  maxScrollTop: number,
+): number {
+  const promptStarts = promptScrollTops(rows, offsets)
+  if (promptStarts.length === 0) return clampLine(scrollTopLine, maxScrollTop)
+
+  const currentLine = clampLine(scrollTopLine, maxScrollTop)
+  const next = promptStarts.find(line => line > currentLine)
+  return next === undefined ? maxScrollTop : clampLine(next, maxScrollTop)
+}
+
+function promptScrollTops(rows: MessageRow[], offsets: number[]): number[] {
+  const starts: number[] = []
+  for (let index = 0; index < rows.length; index += 1) {
+    if (rows[index]?.role === 'user') starts.push(offsets[index] ?? 0)
+  }
+  return starts
+}
+
+function selectRowsForLineWindow<T>(
+  rows: T[],
+  offsets: number[],
+  budget: number,
+  startLine: number,
+  totalLines: number,
+  maxScrollOffset: number,
+): TranscriptWindowSelection<T> {
+  const endLine = Math.min(totalLines, startLine + budget)
+
+  const startIndex = Math.min(rows.length - 1, findRowIndexAtLine(offsets, startLine))
+  const lastVisibleLine = Math.max(startLine, endLine - 1)
+  const endIndex = endLine >= totalLines
+    ? rows.length
+    : Math.min(rows.length, findRowIndexAtLine(offsets, lastVisibleLine) + 1)
+
+  return {
+    rows: rows.slice(startIndex, endIndex),
+    hiddenBefore: startIndex,
+    hiddenAfter: rows.length - endIndex,
+    totalLines,
+    maxScrollOffset,
+  }
+}
+
+export function estimateMessageRowHeight(row: MessageRow, columns = 80): number {
+  const contentWidth = Math.max(20, columns - 8)
+  switch (row.role) {
+    case 'user':
+      return 1 + wrappedLineCount(row.content, contentWidth)
+    case 'assistant':
+      return 1 + wrappedLineCount([row.content, row.liveTail ?? ''].filter(Boolean).join('\n'), contentWidth)
+    case 'thinking':
+      return row.expanded
+        ? 3 + wrappedLineCount([row.content, row.liveTail ?? ''].filter(Boolean).join('\n'), contentWidth)
+        : 3 + wrappedLineCount(reasoningPreview(row), contentWidth)
+    case 'tool_use':
+      return 3 + (row.input ? wrappedLineCount(row.input, contentWidth) : 0)
+    case 'tool_result':
+      return hidesSuccessfulToolResultContent(row.name, row.isError)
+        ? 3
+        : 3 + wrappedLineCount(row.content, contentWidth)
+    case 'note':
+      return 1 + wrappedLineCount(row.content, contentWidth)
+    case 'progress':
+      return 4
+  }
+}
+
+function reasoningPreview(row: Extract<MessageRow, { role: 'thinking' }>): string {
+  const normalized = [row.content, row.liveTail ?? ''].filter(Boolean).join('').replace(/\s+/g, ' ').trim()
+  if (!normalized) return 'thinking...'
+  if (normalized.length <= 120) return normalized
+  return `${normalized.slice(0, 117)}...`
+}
+
+function wrappedLineCount(text: string, width: number): number {
+  if (!text) return 1
+  return text
+    .split(/\r?\n/)
+    .reduce((total, line) => total + Math.max(1, Math.ceil(line.length / width)), 0)
+}

package/src/cli/ResetConfirmView.tsx

@@ -0,0 +1,61 @@
+import React from 'react'
+import { Box, Text, useApp } from 'ink'
+import { Surface } from '../ui/Surface.js'
+import { Select } from '../ui/Select.js'
+import { theme } from '../ui/theme.js'
+import type { FactoryResetPlan } from '../storage/factoryReset.js'
+
+export const ResetConfirmView: React.FC<{
+  plan: FactoryResetPlan
+  onDone: (confirmed: boolean) => void
+}> = ({ plan, onDone }) => {
+  const { exit } = useApp()
+  const finish = (confirmed: boolean) => {
+    onDone(confirmed)
+    exit()
+  }
+
+  return (
+    <Surface title="reset ethagent?" subtitle="are you sure? this only affects this machine." footer="enter select · esc cancel">
+      <Box flexDirection="column">
+        <Section title="will delete" lines={[
+          localDataLine(plan.deletePaths.length),
+          'identity metadata, markdown vaults, sessions, prompt history',
+          'rewind history, permissions, credentials',
+        ]} />
+        <Section title="will keep" lines={[
+          'installed local LLM assets',
+          ...(plan.preservedPaths.length > 0 ? [`${plan.preservedPaths.length} local model path${plan.preservedPaths.length === 1 ? '' : 's'}`] : ['no local model assets found']),
+        ]} />
+        <Section title="not touched" lines={[
+          'onchain agent tokens',
+          'IPFS-pinned snapshots and public metadata',
+        ]} />
+      </Box>
+      <Box marginTop={1}>
+        <Select<'confirm' | 'cancel'>
+          options={[
+            { value: 'confirm', label: 'reset local data', hint: 'delete local ethagent data now' },
+            { value: 'cancel', label: 'cancel', hint: 'leave local data unchanged' },
+          ]}
+          onSubmit={choice => finish(choice === 'confirm')}
+          onCancel={() => finish(false)}
+        />
+      </Box>
+    </Surface>
+  )
+}
+
+const Section: React.FC<{ title: string; lines: string[] }> = ({ title, lines }) => (
+  <Box flexDirection="column" marginBottom={1}>
+    <Text color={theme.accentMint}>{title}</Text>
+    {lines.map(line => (
+      <Text key={line} color={theme.textSubtle}>- {line}</Text>
+    ))}
+  </Box>
+)
+
+function localDataLine(count: number): string {
+  if (count === 0) return 'no local ethagent data found'
+  return `${count} local path${count === 1 ? '' : 's'} under ~/.ethagent`
+}

package/src/cli/main.tsx

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+import React, { useEffect, useState } from 'react'
+import { render, Box, Text, useApp } from 'ink'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { theme } from '../ui/theme.js'
+import { FirstRun } from '../app/FirstRun.js'
+import { ChatScreen } from '../chat/ChatScreen.js'
+import { KeybindingProvider } from '../app/keybindings/KeybindingProvider.js'
+import { AppInputProvider, useAppInput } from '../app/input/AppInputProvider.js'
+import { loadConfig, type EthagentConfig } from '../storage/config.js'
+import { runResetCommand } from './reset.js'
+import { runPreviewCommand } from './preview.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+function readVersion(): string {
+  try {
+    const pkgPath = path.resolve(__dirname, '..', '..', 'package.json')
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8')) as { version?: string }
+    return pkg.version ?? '0.0.0'
+  } catch {
+    return '0.0.0'
+  }
+}
+
+function printHelp(): void {
+  const lines = [
+    'ethagent: privacy-first AI agent with a portable Ethereum identity',
+    '',
+    'usage:',
+    '  ethagent             start the agent (first run triggers setup)',
+    '  ethagent preview     show the brand splash and exit',
+    '  ethagent reset       factory reset local data (local LLMs kept)',
+    '  ethagent reset --yes run reset without the confirm prompt',
+    '  ethagent --version   print version',
+    '  ethagent --help      print this help',
+    '',
+    'inside the agent, type /help for slash commands.',
+  ]
+  for (const line of lines) process.stdout.write(line + '\n')
+}
+
+type AppPhase =
+  | { kind: 'loading' }
+  | { kind: 'setup' }
+  | { kind: 'ready'; config: EthagentConfig }
+  | { kind: 'cancelled' }
+  | { kind: 'error'; message: string }
+
+const AppRoot: React.FC<{ setExitCode: (code: number) => void }> = ({ setExitCode }) => {
+  const [phase, setPhase] = useState<AppPhase>({ kind: 'loading' })
+  const { exit } = useApp()
+
+  useEffect(() => {
+    if (phase.kind !== 'loading') return
+    let cancelled = false
+    loadConfig()
+      .then(config => {
+        if (cancelled) return
+        setPhase(config ? { kind: 'ready', config } : { kind: 'setup' })
+      })
+      .catch((err: unknown) => {
+        if (cancelled) return
+        setPhase({ kind: 'error', message: (err as Error).message })
+      })
+    return () => { cancelled = true }
+  }, [phase])
+
+  useEffect(() => {
+    if (phase.kind === 'cancelled') {
+      setExitCode(1)
+      const t = setTimeout(() => exit(), 10)
+      return () => clearTimeout(t)
+    }
+    if (phase.kind === 'error') {
+      setExitCode(1)
+      const t = setTimeout(() => exit(), 10)
+      return () => clearTimeout(t)
+    }
+    return undefined
+  }, [phase, exit, setExitCode])
+
+  useAppInput((input, key) => {
+    if (phase.kind === 'ready') return
+    if (key.ctrl && (input === 'c' || input === 'd')) exit()
+  })
+
+  if (phase.kind === 'loading') {
+    return (
+      <Box padding={1}>
+        <Text color={theme.dim}>Preparing session...</Text>
+      </Box>
+    )
+  }
+  if (phase.kind === 'setup') {
+    return (
+      <FirstRun
+        onComplete={config => setPhase({ kind: 'ready', config })}
+        onCancel={() => setPhase({ kind: 'cancelled' })}
+      />
+    )
+  }
+  if (phase.kind === 'cancelled') {
+    return (
+      <Box padding={1}>
+        <Text color={theme.dim}>Setup cancelled.</Text>
+      </Box>
+    )
+  }
+  if (phase.kind === 'error') {
+    return (
+      <Box padding={1}>
+        <Text color="#e87070">Error: {phase.message}</Text>
+      </Box>
+    )
+  }
+  return (
+    <ChatScreen
+      config={phase.config}
+      onReplaceConfig={next => setPhase({ kind: 'ready', config: next })}
+    />
+  )
+}
+
+async function runDefault(): Promise<number> {
+  let exitCode = 0
+  const instance = render(
+    <AppInputProvider>
+      <KeybindingProvider>
+        <AppRoot setExitCode={code => { exitCode = code }} />
+      </KeybindingProvider>
+    </AppInputProvider>,
+    {
+      exitOnCtrlC: false,
+    },
+  )
+  try {
+    await instance.waitUntilExit()
+  } catch {
+    exitCode = 1
+  }
+  return exitCode
+}
+
+async function main(): Promise<number> {
+  const argv = process.argv.slice(2)
+  const [cmd, ...rest] = argv
+
+  if (!cmd) return runDefault()
+  if (cmd === '--version' || cmd === '-v') {
+    process.stdout.write(`ethagent ${readVersion()}\n`)
+    return 0
+  }
+  if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
+    printHelp()
+    return 0
+  }
+
+  switch (cmd) {
+    case 'preview':
+      return runPreviewCommand()
+    case 'reset':
+      return runResetCommand(rest)
+    default:
+      process.stderr.write(`unknown command: ${cmd}\nrun 'ethagent --help' for usage\n`)
+      return 2
+  }
+}
+
+main()
+  .then(code => process.exit(code))
+  .catch(err => {
+    process.stderr.write(`${(err as Error).message}\n`)
+    process.exit(1)
+  })