@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/lib/chat-artifact-summary.ts

@@ -0,0 +1,165 @@
+export type ChatArtifactKind = 'image' | 'pdf' | 'markdown' | 'file' | 'site'
+
+export interface ChatArtifactItem {
+  label: string
+  href: string
+  kind: ChatArtifactKind
+  filename: string
+}
+
+export interface ChatArtifactSection {
+  title: string
+  items: ChatArtifactItem[]
+}
+
+export interface ChatArtifactSummary {
+  title: string | null
+  intro: string[]
+  sections: ChatArtifactSection[]
+  liveSitesTitle: string | null
+  liveSites: ChatArtifactItem[]
+  counts: {
+    images: number
+    pdfs: number
+    markdown: number
+    files: number
+    sites: number
+  }
+}
+
+const TITLE_RE = /^##+\s+(.+?)\s*$/
+const SECTION_RE = /^###\s+(.+?)\s*$/
+const LINK_BULLET_RE = /^-\s+\[([^\]]+)\]\(([^)]+)\)\s*$/
+const BOLD_URL_BULLET_RE = /^-\s+\*\*([^*]+)\*\*:\s+(https?:\/\/\S+)\s*$/
+
+function stripMarkdown(text: string): string {
+  return text
+    .replace(/[*_`#]/g, '')
+    .replace(/\[(.*?)\]\([^)]+\)/g, '$1')
+    .trim()
+}
+
+function inferArtifactKind(href: string): ChatArtifactKind {
+  const normalized = href.trim().toLowerCase()
+  if (/^https?:\/\/localhost:\d+/.test(normalized)) return 'site'
+  if (/\.(png|jpe?g|gif|webp|svg|avif)(?:[?#]|$)/.test(normalized)) return 'image'
+  if (/\.pdf(?:[?#]|$)/.test(normalized)) return 'pdf'
+  if (/\.(md|markdown)(?:[?#]|$)/.test(normalized)) return 'markdown'
+  return 'file'
+}
+
+function buildArtifactItem(label: string, href: string): ChatArtifactItem {
+  const filename = href.split('/').pop()?.split('?')[0] || href
+  return {
+    label: stripMarkdown(label),
+    href: href.trim(),
+    kind: inferArtifactKind(href),
+    filename,
+  }
+}
+
+function pushSection(sections: ChatArtifactSection[], current: ChatArtifactSection | null) {
+  if (!current || current.items.length === 0) return
+  sections.push(current)
+}
+
+function countItems(sections: ChatArtifactSection[], liveSites: ChatArtifactItem[]) {
+  const counts = {
+    images: 0,
+    pdfs: 0,
+    markdown: 0,
+    files: 0,
+    sites: liveSites.length,
+  }
+
+  for (const item of sections.flatMap((section) => section.items)) {
+    if (item.kind === 'image') counts.images += 1
+    else if (item.kind === 'pdf') counts.pdfs += 1
+    else if (item.kind === 'markdown') counts.markdown += 1
+    else if (item.kind === 'site') counts.sites += 1
+    else counts.files += 1
+  }
+
+  return counts
+}
+
+export function parseChatArtifactSummary(markdown: string): ChatArtifactSummary | null {
+  const text = markdown.trim()
+  if (!text) return null
+
+  const lines = text.split(/\r?\n/)
+  let title: string | null = null
+  let currentSection: ChatArtifactSection | null = null
+  const sections: ChatArtifactSection[] = []
+  const intro: string[] = []
+  const liveSites: ChatArtifactItem[] = []
+  let liveSitesTitle: string | null = null
+  let seenSection = false
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim()
+    if (!line) continue
+
+    const titleMatch = !seenSection ? line.match(TITLE_RE) : null
+    if (titleMatch) {
+      title = stripMarkdown(titleMatch[1])
+      continue
+    }
+
+    const sectionMatch = line.match(SECTION_RE)
+    if (sectionMatch) {
+      pushSection(sections, currentSection)
+      currentSection = { title: stripMarkdown(sectionMatch[1]), items: [] }
+      seenSection = true
+      continue
+    }
+
+    const linkMatch = line.match(LINK_BULLET_RE)
+    if (linkMatch) {
+      const item = buildArtifactItem(linkMatch[1], linkMatch[2])
+      if (currentSection) currentSection.items.push(item)
+      else if (item.kind === 'site') liveSites.push(item)
+      else intro.push(stripMarkdown(line))
+      continue
+    }
+
+    const liveSiteMatch = line.match(BOLD_URL_BULLET_RE)
+    if (liveSiteMatch) {
+      liveSites.push({
+        label: stripMarkdown(liveSiteMatch[1]),
+        href: liveSiteMatch[2],
+        kind: 'site',
+        filename: liveSiteMatch[2],
+      })
+      continue
+    }
+
+    if (!seenSection) {
+      intro.push(stripMarkdown(line))
+      continue
+    }
+
+    if (currentSection?.items.length === 0 && !liveSites.length) {
+      liveSitesTitle = stripMarkdown(line)
+      continue
+    }
+
+    if (!liveSites.length) {
+      liveSitesTitle = stripMarkdown(line)
+    }
+  }
+
+  pushSection(sections, currentSection)
+
+  const totalSectionItems = sections.reduce((sum, section) => sum + section.items.length, 0)
+  if (totalSectionItems < 3 || sections.length === 0) return null
+
+  return {
+    title,
+    intro,
+    sections,
+    liveSitesTitle,
+    liveSites,
+    counts: countItems(sections, liveSites),
+  }
+}

package/src/lib/chat-display.test.ts

@@ -0,0 +1,91 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { dedupeMessagesForDisplay, formatMessageTimestamp } from './chat-display'
+import type { Message } from '@/types'
+
+function baseMessage(overrides: Partial<Message> = {}): Message {
+  return {
+    role: 'user',
+    text: 'hello',
+    time: Date.now(),
+    ...overrides,
+  }
+}
+
+test('dedupeMessagesForDisplay removes exact connector duplicates by message id', () => {
+  const first = baseMessage({
+    source: {
+      platform: 'whatsapp',
+      connectorId: 'conn-1',
+      connectorName: 'WhatsApp',
+      messageId: 'wamid-1',
+      senderName: 'Alice',
+    },
+    historyExcluded: true,
+  })
+  const duplicate = { ...first }
+  const unrelated = baseMessage({
+    text: 'reply',
+    role: 'assistant',
+    source: {
+      platform: 'whatsapp',
+      connectorId: 'conn-1',
+      connectorName: 'WhatsApp',
+      messageId: 'wamid-2',
+      senderName: 'Alice',
+    },
+    historyExcluded: true,
+  })
+
+  const result = dedupeMessagesForDisplay([first, duplicate, unrelated])
+
+  assert.equal(result.length, 2)
+  assert.equal(result[0].source?.messageId, 'wamid-1')
+  assert.equal(result[1].source?.messageId, 'wamid-2')
+})
+
+test('dedupeMessagesForDisplay keeps identical connector text from distinct message ids', () => {
+  const first = baseMessage({
+    source: {
+      platform: 'whatsapp',
+      connectorId: 'conn-1',
+      connectorName: 'WhatsApp',
+      messageId: 'wamid-1',
+      senderName: 'Alice',
+    },
+    historyExcluded: true,
+  })
+  const second = baseMessage({
+    source: {
+      platform: 'whatsapp',
+      connectorId: 'conn-1',
+      connectorName: 'WhatsApp',
+      messageId: 'wamid-2',
+      senderName: 'Alice',
+    },
+    historyExcluded: true,
+  })
+
+  const result = dedupeMessagesForDisplay([first, second])
+
+  assert.equal(result.length, 2)
+  assert.deepEqual(result.map((message) => message.source?.messageId), ['wamid-1', 'wamid-2'])
+})
+
+test('formatMessageTimestamp uses exact time formatting for connector transcript entries', () => {
+  const now = new Date()
+  now.setHours(14, 5, 0, 0)
+  const timestamp = now.getTime()
+  const formatted = formatMessageTimestamp({
+    time: timestamp,
+    source: {
+      platform: 'whatsapp',
+      connectorId: 'conn-1',
+      connectorName: 'WhatsApp',
+    },
+  })
+
+  assert.match(formatted, /\d{1,2}:\d{2}/)
+  assert.doesNotMatch(formatted, /ago|just now/)
+})

package/src/lib/chat-display.ts

@@ -0,0 +1,58 @@
+import type { Message } from '@/types'
+
+function formatClock(ts: number): string {
+  return new Date(ts).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })
+}
+
+function formatConnectorTimestamp(ts: number): string {
+  const d = new Date(ts)
+  const today = new Date()
+  if (d.toDateString() === today.toDateString()) return formatClock(ts)
+  return d.toLocaleDateString([], { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })
+}
+
+function formatRelativeTimestamp(ts: number): string {
+  const now = Date.now()
+  const diff = now - ts
+  if (diff < 60_000) return 'just now'
+  if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}m ago`
+  if (diff < 86_400_000) return `${Math.floor(diff / 3_600_000)}h ago`
+  const d = new Date(ts)
+  const today = new Date()
+  if (d.toDateString() === today.toDateString()) return formatClock(ts)
+  if (diff < 604_800_000) return d.toLocaleDateString([], { weekday: 'short', hour: '2-digit', minute: '2-digit' })
+  return d.toLocaleDateString([], { month: 'short', day: 'numeric' })
+}
+
+export function formatMessageTimestamp(message: Pick<Message, 'time' | 'source'>): string {
+  if (!message.time) return ''
+  if (message.source?.connectorId) return formatConnectorTimestamp(message.time)
+  return formatRelativeTimestamp(message.time)
+}
+
+function buildDisplayDedupKey(message: Message): string | null {
+  const source = message.source
+  if (source?.connectorId && source.messageId) {
+    return [
+      message.role,
+      source.connectorId,
+      source.messageId,
+      message.historyExcluded === true ? 'history-excluded' : 'normal',
+    ].join('|')
+  }
+  return null
+}
+
+export function dedupeMessagesForDisplay(messages: Message[]): Message[] {
+  const seen = new Set<string>()
+  const deduped: Message[] = []
+  for (const message of messages) {
+    const key = buildDisplayDedupKey(message)
+    if (key) {
+      if (seen.has(key)) continue
+      seen.add(key)
+    }
+    deduped.push(message)
+  }
+  return deduped
+}

package/src/lib/chat-streaming-state.test.ts

@@ -2,6 +2,7 @@ import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import type { Message } from '@/types'
 import {
+  materializeStreamingAssistantArtifacts,
   mergeCompletedAssistantMessage,
   messagesDiffer,
   pruneStreamingAssistantArtifacts,
@@ -24,7 +25,7 @@ describe('chat-streaming-state', () => {
     )
     assert.equal(
       shouldHidePersistedStreamingAssistantMessage(message, { localStreaming: true, displayText: '' }),
-      true,
+      false,
     )
   })
 
@@ -81,6 +82,51 @@ describe('chat-streaming-state', () => {
     ])
   })
 
+  it('materializes stale streaming artifacts into ordinary assistant messages', () => {
+    const messages: Message[] = [
+      { role: 'user', text: 'hello', time: 1 },
+      {
+        role: 'assistant',
+        text: 'partial result',
+        time: 2,
+        streaming: true,
+        toolEvents: [{ name: 'browser', input: '{"action":"screenshot"}', output: '/api/uploads/wiki.png' }],
+      },
+    ]
+
+    const changed = materializeStreamingAssistantArtifacts(messages)
+
+    assert.equal(changed, true)
+    assert.deepEqual(messages, [
+      { role: 'user', text: 'hello', time: 1 },
+      {
+        role: 'assistant',
+        text: 'partial result',
+        time: 2,
+        streaming: false,
+        toolEvents: [{ name: 'browser', input: '{"action":"screenshot"}', output: '/api/uploads/wiki.png' }],
+      },
+    ])
+  })
+
+  it('summarizes tool-only stale streaming artifacts instead of dropping them', () => {
+    const messages: Message[] = [
+      { role: 'user', text: 'hello', time: 1 },
+      {
+        role: 'assistant',
+        text: '',
+        time: 2,
+        streaming: true,
+        toolEvents: [{ name: 'browser', input: '{"action":"screenshot"}' }],
+      },
+    ]
+
+    materializeStreamingAssistantArtifacts(messages)
+
+    assert.match(messages[1].text, /Started 1 tool call/)
+    assert.equal(messages[1].streaming, false)
+  })
+
   it('reuses the previous assistant slot when the server already persisted the same final text', () => {
     const messages: Message[] = [
       { role: 'user', text: 'hello', time: 1 },

package/src/lib/chat-streaming-state.ts

@@ -1,4 +1,5 @@
 import type { Message } from '@/types'
+import { buildToolEventAssistantSummary } from '@/lib/tool-event-summary'
 
 interface StreamingArtifactWindow {
   minIndex?: number
@@ -26,6 +27,7 @@ export function shouldHidePersistedStreamingAssistantMessage(
     opts.localStreaming
     && message.role === 'assistant'
     && message.streaming === true
+    && opts.displayText.trim().length > 0
   )
 }
 
@@ -52,6 +54,46 @@ export function upsertStreamingAssistantArtifact(
   return true
 }
 
+export function materializeStreamingAssistantArtifacts(
+  messages: Message[],
+  opts: StreamingArtifactWindow = {},
+): boolean {
+  let changed = false
+  const nextMessages: Message[] = []
+
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index]
+    if (!isStreamingAssistantMessage(message, index, opts)) {
+      nextMessages.push(message)
+      continue
+    }
+
+    const trimmedText = typeof message.text === 'string' ? message.text.trim() : ''
+    const toolEvents = Array.isArray(message.toolEvents) ? message.toolEvents : []
+    const thinking = typeof message.thinking === 'string' ? message.thinking.trim() : ''
+    const fallbackText = !trimmedText && toolEvents.length > 0
+      ? buildToolEventAssistantSummary(toolEvents, { interrupted: true })
+      : ''
+    const nextText = trimmedText || fallbackText
+
+    if (!nextText && !thinking && toolEvents.length === 0) {
+      changed = true
+      continue
+    }
+
+    nextMessages.push({
+      ...message,
+      text: nextText,
+      streaming: false,
+    })
+    changed = true
+  }
+
+  if (!changed) return false
+  messages.splice(0, messages.length, ...nextMessages)
+  return true
+}
+
 export function mergeCompletedAssistantMessage(messages: Message[], assistantMessage: Message): Message[] {
   let end = messages.length
   while (end > 0) {

package/src/lib/ollama-model.ts

@@ -0,0 +1,10 @@
+export const OLLAMA_CLOUD_MODEL_SUFFIX = ':cloud'
+
+export function isOllamaCloudModel(model: string | null | undefined): boolean {
+  return typeof model === 'string' && /:cloud$/i.test(model.trim())
+}
+
+export function stripOllamaCloudModelSuffix(model: string | null | undefined): string {
+  if (typeof model !== 'string') return ''
+  return model.trim().replace(/:cloud$/i, '')
+}

package/src/lib/openclaw-endpoint.test.ts

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict'
 import { test } from 'node:test'
 import {
   deriveOpenClawWsUrl,
+  isLocalOpenClawEndpoint,
   normalizeOpenClawEndpoint,
   normalizeProviderEndpoint,
 } from './openclaw-endpoint.ts'
@@ -46,3 +47,10 @@ test('normalizeProviderEndpoint only rewrites openclaw provider', () => {
     null,
   )
 })
+
+test('isLocalOpenClawEndpoint detects loopback hosts', () => {
+  assert.equal(isLocalOpenClawEndpoint('ws://localhost:18789'), true)
+  assert.equal(isLocalOpenClawEndpoint('http://127.0.0.1:18789/v1'), true)
+  assert.equal(isLocalOpenClawEndpoint('http://[::1]:18789/v1'), true)
+  assert.equal(isLocalOpenClawEndpoint('https://openclaw.example.com/v1'), false)
+})

package/src/lib/openclaw-endpoint.ts

@@ -57,6 +57,12 @@ export function deriveOpenClawWsUrl(input?: string | null): string {
   return value.endsWith('/') ? value.slice(0, -1) : value
 }
 
+export function isLocalOpenClawEndpoint(input?: string | null): boolean {
+  const parsed = parseUrl(input || '') || parseUrl(DEFAULT_OPENCLAW_ENDPOINT)!
+  const host = parsed.hostname.trim().toLowerCase().replace(/^\[(.*)\]$/, '$1')
+  return host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '0.0.0.0'
+}
+
 export function normalizeProviderEndpoint(provider: string | null | undefined, endpoint: string | null | undefined): string | null {
   if (typeof endpoint !== 'string') return null
   const trimmed = endpoint.trim()
@@ -64,4 +70,3 @@ export function normalizeProviderEndpoint(provider: string | null | undefined, e
   if (provider === 'openclaw') return normalizeOpenClawEndpoint(trimmed)
   return trimmed.replace(/\/+$/, '')
 }
-

package/src/lib/plugin-install-cors.ts

@@ -0,0 +1,46 @@
+const DEFAULT_ALLOWED_ORIGINS = [
+  'https://swarmclaw.ai',
+  'https://www.swarmclaw.ai',
+  'http://localhost:3000',
+  'http://127.0.0.1:3000',
+]
+
+function parseAllowedOrigins(raw: string | undefined): string[] {
+  if (!raw) return DEFAULT_ALLOWED_ORIGINS
+  const parsed = raw
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+  return parsed.length > 0 ? parsed : DEFAULT_ALLOWED_ORIGINS
+}
+
+function normalizeOrigin(raw: string | null | undefined): string {
+  if (!raw) return ''
+  try {
+    return new URL(raw).origin
+  } catch {
+    return ''
+  }
+}
+
+export function resolvePluginInstallCorsOrigin(rawOrigin: string | null | undefined): string | null {
+  const origin = normalizeOrigin(rawOrigin)
+  if (!origin) return null
+  const allowed = parseAllowedOrigins(process.env.SWARMCLAW_PLUGIN_INSTALL_ORIGINS)
+  return allowed.includes(origin) ? origin : null
+}
+
+export function buildPluginInstallCorsHeaders(origin: string | null): HeadersInit {
+  const headers = new Headers()
+  headers.set('Vary', 'Origin')
+  if (!origin) return headers
+  headers.set('Access-Control-Allow-Origin', origin)
+  headers.set('Access-Control-Allow-Headers', 'Content-Type, X-Access-Key')
+  headers.set('Access-Control-Allow-Methods', 'POST, OPTIONS')
+  headers.set('Access-Control-Max-Age', '600')
+  return headers
+}
+
+export function isPluginInstallCorsPath(pathname: string): boolean {
+  return pathname === '/api/plugins/install'
+}

package/src/lib/plugin-sources.test.ts

@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  getPluginSourceLabel,
+  inferPluginInstallSourceFromUrl,
+  inferPluginPublisherSourceFromUrl,
+  isMarketplaceInstallSource,
+  normalizePluginCatalogSource,
+  normalizePluginInstallSource,
+  normalizePluginPublisherSource,
+} from './plugin-sources'
+
+describe('plugin source helpers', () => {
+  it('normalizes publisher, catalog, and install source values', () => {
+    assert.equal(normalizePluginPublisherSource('SwarmForge'), 'swarmforge')
+    assert.equal(normalizePluginCatalogSource('swarmclaw-site'), 'swarmclaw-site')
+    assert.equal(normalizePluginInstallSource('ClawHub'), 'clawhub')
+    assert.equal(normalizePluginInstallSource('unknown-source'), undefined)
+  })
+
+  it('infers plugin provenance from known marketplace URLs', () => {
+    assert.equal(
+      inferPluginPublisherSourceFromUrl('https://raw.githubusercontent.com/swarmclawai/swarmforge/main/tool-logger.js'),
+      'swarmforge',
+    )
+    assert.equal(
+      inferPluginInstallSourceFromUrl('https://clawhub.ai/skills/openclaw-gmail'),
+      'clawhub',
+    )
+    assert.equal(
+      inferPluginPublisherSourceFromUrl('https://swarmclaw.ai/plugins/demo.js'),
+      'swarmclaw',
+    )
+  })
+
+  it('labels marketplace sources consistently', () => {
+    assert.equal(isMarketplaceInstallSource('swarmclaw-site'), true)
+    assert.equal(isMarketplaceInstallSource('manual'), false)
+    assert.equal(getPluginSourceLabel('swarmclaw-site'), 'SwarmClaw Site')
+    assert.equal(getPluginSourceLabel('swarmforge'), 'SwarmForge')
+  })
+})

package/src/lib/plugin-sources.ts

@@ -0,0 +1,77 @@
+import type {
+  PluginCatalogSource,
+  PluginInstallSource,
+  PluginPublisherSource,
+} from '@/types'
+
+const PUBLISHER_SOURCES = ['builtin', 'local', 'manual', 'swarmclaw', 'swarmforge', 'clawhub'] as const
+const CATALOG_SOURCES = ['swarmclaw', 'swarmclaw-site', 'swarmforge', 'clawhub'] as const
+const INSTALL_SOURCES = ['builtin', 'local', 'manual', ...CATALOG_SOURCES] as const
+
+const SOURCE_LABELS: Record<PluginInstallSource | PluginPublisherSource, string> = {
+  builtin: 'Built-in',
+  local: 'Local file',
+  manual: 'Manual URL',
+  swarmclaw: 'SwarmClaw',
+  'swarmclaw-site': 'SwarmClaw Site',
+  swarmforge: 'SwarmForge',
+  clawhub: 'ClawHub',
+}
+
+export function normalizePluginPublisherSource(raw: unknown): PluginPublisherSource | undefined {
+  const value = typeof raw === 'string' ? raw.trim().toLowerCase() : ''
+  if (!value) return undefined
+  return (PUBLISHER_SOURCES as readonly string[]).includes(value)
+    ? value as PluginPublisherSource
+    : undefined
+}
+
+export function normalizePluginCatalogSource(raw: unknown): PluginCatalogSource | undefined {
+  const value = typeof raw === 'string' ? raw.trim().toLowerCase() : ''
+  if (!value) return undefined
+  return (CATALOG_SOURCES as readonly string[]).includes(value)
+    ? value as PluginCatalogSource
+    : undefined
+}
+
+export function normalizePluginInstallSource(raw: unknown): PluginInstallSource | undefined {
+  const value = typeof raw === 'string' ? raw.trim().toLowerCase() : ''
+  if (!value) return undefined
+  return (INSTALL_SOURCES as readonly string[]).includes(value)
+    ? value as PluginInstallSource
+    : undefined
+}
+
+export function inferPluginPublisherSourceFromUrl(url: string | null | undefined): PluginPublisherSource | undefined {
+  const normalized = typeof url === 'string' ? url.trim().toLowerCase() : ''
+  if (!normalized) return undefined
+  if (normalized.includes('clawhub.ai')) return 'clawhub'
+  if (normalized.includes('swarmclaw.ai/')) return 'swarmclaw'
+  if (
+    normalized.includes('raw.githubusercontent.com/swarmclawai/swarmforge/')
+    || normalized.includes('github.com/swarmclawai/swarmforge/')
+    || normalized.includes('/swarmclawai/plugins/')
+  ) {
+    return 'swarmforge'
+  }
+  return undefined
+}
+
+export function inferPluginInstallSourceFromUrl(url: string | null | undefined): PluginInstallSource | undefined {
+  const publisherSource = inferPluginPublisherSourceFromUrl(url)
+  if (publisherSource === 'swarmclaw' || publisherSource === 'swarmforge' || publisherSource === 'clawhub') {
+    return publisherSource
+  }
+  return undefined
+}
+
+export function isMarketplaceInstallSource(source: PluginInstallSource | null | undefined): boolean {
+  return source === 'swarmclaw' || source === 'swarmclaw-site' || source === 'swarmforge' || source === 'clawhub'
+}
+
+export function getPluginSourceLabel(
+  source: PluginInstallSource | PluginPublisherSource | PluginCatalogSource | null | undefined,
+): string {
+  if (!source) return 'Unknown'
+  return SOURCE_LABELS[source as keyof typeof SOURCE_LABELS] || source
+}