@erclx/canon 4.0.0

package/src/deps/audit.ts

@@ -0,0 +1,153 @@
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { execa } from 'execa'
+
+/**
+ * The severities the advisory index publishes, worst first.
+ *
+ * `info` is this module's own floor rather than one of theirs. An advisory
+ * arriving under a severity nothing here recognizes still exists, and dropping
+ * it would shrink the count on the day the vocabulary changed.
+ */
+export const SEVERITIES = [
+  'critical',
+  'high',
+  'moderate',
+  'low',
+  'info',
+] as const
+
+export type Severity = (typeof SEVERITIES)[number]
+
+export interface Advisory {
+  readonly package: string
+  readonly id: number
+  readonly title: string
+  readonly url: string
+  readonly severity: Severity
+  readonly vulnerableVersions?: string
+}
+
+/**
+ * Why no advisory list was produced, which is never the same as a clean one.
+ *
+ * `no-lockfile` is split out from `no-record` because the two take different
+ * remedies. An unreachable index is retried, and a project whose dependencies
+ * were never resolved is installed first, so one message naming the network
+ * would send half the readers at the wrong cause.
+ */
+export type AuditRefusal = 'no-manifest' | 'no-lockfile' | 'no-record'
+
+/** The lockfiles a resolved dependency set leaves behind, in any manager. */
+const LOCKFILES = [
+  'bun.lock',
+  'bun.lockb',
+  'package-lock.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+]
+
+export type DepsAudit =
+  | { readonly kind: 'audited'; readonly advisories: readonly Advisory[] }
+  | {
+      readonly kind: 'refused'
+      readonly reason: AuditRefusal
+      readonly message?: string
+    }
+
+function severityOf(value: unknown): Severity {
+  return SEVERITIES.includes(value as Severity) ? (value as Severity) : 'info'
+}
+
+/**
+ * Reads the record `bun audit --json` writes to stdout.
+ *
+ * The shape is an object keyed by package name, each holding that package's
+ * advisories, which this flattens into one list carrying the name on every
+ * entry. Returning nothing on unreadable output is what keeps an unreachable
+ * index from reporting as a clean tree, and the caller turns it into a stated
+ * refusal rather than a zero.
+ */
+export function parseAdvisories(stdout: string): Advisory[] | undefined {
+  let record: unknown
+  try {
+    record = JSON.parse(stdout)
+  } catch {
+    return undefined
+  }
+
+  if (typeof record !== 'object' || record === null || Array.isArray(record)) {
+    return undefined
+  }
+
+  const advisories: Advisory[] = []
+  for (const [name, entries] of Object.entries(record)) {
+    if (!Array.isArray(entries)) return undefined
+
+    for (const raw of entries) {
+      if (typeof raw !== 'object' || raw === null) return undefined
+      const entry = raw as Record<string, unknown>
+
+      advisories.push({
+        package: name,
+        id: typeof entry.id === 'number' ? entry.id : 0,
+        title: typeof entry.title === 'string' ? entry.title : '',
+        url: typeof entry.url === 'string' ? entry.url : '',
+        severity: severityOf(entry.severity),
+        ...(typeof entry.vulnerable_versions === 'string' && {
+          vulnerableVersions: entry.vulnerable_versions,
+        }),
+      })
+    }
+  }
+
+  return advisories
+}
+
+export function countBySeverity(
+  advisories: readonly Advisory[],
+): Record<Severity, number> {
+  const counts = Object.fromEntries(
+    SEVERITIES.map((severity) => [severity, 0]),
+  ) as Record<Severity, number>
+
+  for (const advisory of advisories) counts[advisory.severity] += 1
+  return counts
+}
+
+/**
+ * Shells the runtime's own advisory command rather than carrying an index.
+ *
+ * A vendored advisory database is a second corpus to keep current, and what
+ * this check is worth is the report rather than the data. The cost is the one
+ * failure mode no other audit here carries: the command reaches a network, so
+ * an unreachable index has to be told from a tree with nothing against it.
+ * That split is the return value, and the exit code is deliberately not read.
+ * `bun audit` exits non-zero on advisories found and on a lookup that failed,
+ * so the record on stdout is the only thing that separates them.
+ */
+export async function auditDependencies(root: string): Promise<DepsAudit> {
+  if (!existsSync(join(root, 'package.json'))) {
+    return { kind: 'refused', reason: 'no-manifest' }
+  }
+
+  if (!LOCKFILES.some((name) => existsSync(join(root, name)))) {
+    return { kind: 'refused', reason: 'no-lockfile' }
+  }
+
+  const result = await execa('bun', ['audit', '--json'], {
+    cwd: root,
+    reject: false,
+  })
+
+  const advisories = parseAdvisories(result.stdout)
+  if (advisories === undefined) {
+    return {
+      kind: 'refused',
+      reason: 'no-record',
+      message: result.stderr.trim().split('\n').pop() ?? 'no output on stdout',
+    }
+  }
+
+  return { kind: 'audited', advisories }
+}

package/src/design/parse.ts

@@ -0,0 +1,116 @@
+import { readFileSync } from 'node:fs'
+
+/**
+ * One table cell, split into the value a renderer emits and whether the record
+ * marked it as unsourced.
+ *
+ * The marker sits inside the cell rather than in a trailing column, because a
+ * trailing marker breaks the table parse. Splitting it out here is what keeps a
+ * swatch or a font sample built from the value alone.
+ */
+export interface Cell {
+  value: string
+  tagged: boolean
+}
+
+export type Row = Record<string, Cell>
+
+export interface DesignDoc {
+  personality: string
+  color: Row[]
+  typography: Row[]
+  spacing: Row[]
+  borders: Row[]
+  motion: string
+  iconography: string
+}
+
+const VERIFY_TAG = /\s*\?\s*verify\s*$/
+
+/** A cell whose whole content is one balanced code span and nothing else. */
+const CODE_SPAN = /^`([^`]*)`$/
+
+export function parseDesignDoc(path: string): DesignDoc {
+  const raw = readFileSync(path, 'utf8')
+  const sections = splitSections(raw)
+  return {
+    personality: prose(sections['Personality']),
+    color: table(sections['Color']),
+    typography: table(sections['Typography']),
+    spacing: table(sections['Spacing']),
+    borders: table(sections['Borders']),
+    motion: prose(sections['Motion']),
+    iconography: prose(sections['Iconography']),
+  }
+}
+
+function splitSections(raw: string): Record<string, string> {
+  const out: Record<string, string> = {}
+  const lines = raw.split('\n')
+  let current: string | null = null
+  let buffer: string[] = []
+  for (const line of lines) {
+    const match = line.match(/^##\s+(.+?)\s*$/)
+    if (match) {
+      if (current) out[current] = buffer.join('\n')
+      current = match[1]
+      buffer = []
+    } else if (current) {
+      buffer.push(line)
+    }
+  }
+  if (current) out[current] = buffer.join('\n')
+  return out
+}
+
+function prose(body: string | undefined): string {
+  if (!body) return ''
+  return body
+    .split('\n')
+    .filter((l) => l.trim() && !l.startsWith('|') && !l.startsWith('<'))
+    .join('\n')
+    .trim()
+}
+
+function table(body: string | undefined): Row[] {
+  if (!body) return []
+  const rows = body.split('\n').filter((l) => l.trim().startsWith('|'))
+  if (rows.length < 2) return []
+  const headers = splitRow(rows[0]).map((c) => c.value)
+  const data = rows.slice(2)
+  return data.map((line) => {
+    const cells = splitRow(line)
+    const row: Row = {}
+    headers.forEach((h, i) => {
+      row[h] = cells[i] ?? emptyCell()
+    })
+    return row
+  })
+}
+
+function emptyCell(): Cell {
+  return { value: '', tagged: false }
+}
+
+function splitRow(line: string): Cell[] {
+  return line
+    .replace(/^\s*\|/, '')
+    .replace(/\|\s*$/, '')
+    .split('|')
+    .map(parseCell)
+}
+
+/**
+ * The tag is tested against the cell with any surrounding code span removed,
+ * since a value wrapping itself in backticks puts one after the tag and an
+ * end-anchored test misses it there. The span is restored around the clean
+ * value so an untagged cell and a tagged one carry the same formatting.
+ */
+function parseCell(raw: string): Cell {
+  const trimmed = raw.trim()
+  const span = trimmed.match(CODE_SPAN)
+  const inner = span ? span[1] : trimmed
+  if (!VERIFY_TAG.test(inner)) return { value: trimmed, tagged: false }
+  const value = inner.replace(VERIFY_TAG, '')
+  return { value: span ? `\`${value}\`` : value, tagged: true }
+}

package/src/design/render.ts

@@ -0,0 +1,249 @@
+import { mkdirSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { Cell, DesignDoc, Row } from '@/design/parse'
+import { parseDesignDoc } from '@/design/parse'
+
+export interface RenderResult {
+  htmlPath: string
+  cssPath: string
+}
+
+export function renderDesignDoc(
+  sourcePath: string,
+  outDir: string,
+): RenderResult {
+  const doc = parseDesignDoc(sourcePath)
+  mkdirSync(outDir, { recursive: true })
+  const cssPath = join(outDir, 'design.css')
+  const htmlPath = join(outDir, 'index.html')
+  writeFileSync(cssPath, buildCss(doc))
+  writeFileSync(htmlPath, buildHtml(doc))
+  return { htmlPath, cssPath }
+}
+
+function slug(s: string): string {
+  return s
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)/g, '')
+}
+
+function cell(row: Row, key: string): Cell {
+  return row[key] ?? { value: '', tagged: false }
+}
+
+/** The value alone. Every swatch, sample, and custom property is built from it. */
+function val(row: Row, key: string): string {
+  return cell(row, key).value
+}
+
+/** The marker, rendered beside a value rather than inside it. */
+function mark(row: Row, key: string): string {
+  return cell(row, key).tagged
+    ? ' <span class="verify" title="No source anchors this value">? verify</span>'
+    : ''
+}
+
+/** A displayed cell: its escaped text, then its marker when it carries one. */
+function cellText(row: Row, key: string): string {
+  return escape(val(row, key)) + mark(row, key)
+}
+
+interface Confidence {
+  tagged: number
+  total: number
+}
+
+/**
+ * The columns the confidence ratio reads, fixed by `standards/design.md`. The
+ * first column of each table names its row, and `Multiplier` and `When used`
+ * restate what the row already carries, so none of them is something a source
+ * could anchor and none belongs in the denominator.
+ */
+const ANCHORABLE = {
+  borders: ['Radius', 'Width'],
+  color: ['Intent', 'Value'],
+  spacing: ['Value'],
+  typography: ['Family', 'Weight', 'Size', 'Line height'],
+} as const
+
+/**
+ * A cell counts when it carries a tag, or when it holds a value in a column a
+ * source could anchor. A blank the record left unfilled is neither, and so is a
+ * row name. Counting a tagged cell whichever column it sits in is what keeps a
+ * marker the preview draws from sitting outside the ratio printed beside it.
+ */
+function confidence(doc: DesignDoc): Confidence {
+  const tables: ReadonlyArray<readonly [Row[], readonly string[]]> = [
+    [doc.color, ANCHORABLE.color],
+    [doc.typography, ANCHORABLE.typography],
+    [doc.spacing, ANCHORABLE.spacing],
+    [doc.borders, ANCHORABLE.borders],
+  ]
+  let tagged = 0
+  let total = 0
+  for (const [rows, columns] of tables) {
+    for (const row of rows) {
+      for (const [key, c] of Object.entries(row)) {
+        if (!c.tagged && (!c.value || !columns.includes(key))) continue
+        total += 1
+        if (c.tagged) tagged += 1
+      }
+    }
+  }
+  return { tagged, total }
+}
+
+function buildCss(doc: DesignDoc): string {
+  const lines: string[] = [':root {']
+  for (const row of doc.color) {
+    if (val(row, 'Value')) {
+      lines.push(`  --color-${slug(val(row, 'Role'))}: ${val(row, 'Value')};`)
+    }
+  }
+  for (const row of doc.spacing) {
+    if (val(row, 'Value')) {
+      lines.push(`  --space-${slug(val(row, 'Step'))}: ${val(row, 'Value')};`)
+    }
+  }
+  for (const row of doc.typography) {
+    if (val(row, 'Size')) {
+      lines.push(
+        `  --type-${slug(val(row, 'Role'))}-size: ${val(row, 'Size')};`,
+      )
+    }
+    if (val(row, 'Line height')) {
+      lines.push(
+        `  --type-${slug(val(row, 'Role'))}-lh: ${val(row, 'Line height')};`,
+      )
+    }
+  }
+  for (const row of doc.borders) {
+    if (val(row, 'Radius')) {
+      lines.push(`  --radius-${slug(val(row, 'Role'))}: ${val(row, 'Radius')};`)
+    }
+  }
+  lines.push('}')
+  return lines.join('\n') + '\n'
+}
+
+function escape(s: string): string {
+  return s
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+}
+
+function buildHtml(doc: DesignDoc): string {
+  const sections = [
+    sectionPersonality(doc.personality),
+    sectionColor(doc.color),
+    sectionTypography(doc.typography),
+    sectionSpacing(doc.spacing),
+    sectionBorders(doc.borders),
+    sectionLine('Motion', doc.motion),
+    sectionLine('Iconography', doc.iconography),
+  ]
+  const { tagged, total } = confidence(doc)
+  const verifyStyle = tagged
+    ? '\n  .verify { color: #a4471c; font-size: 12px; font-weight: 600; margin-left: 0.35rem; white-space: nowrap; }'
+    : ''
+  const verb = tagged === 1 ? 'carries' : 'carry'
+  const summary = tagged
+    ? `\n<p class="note">${total - tagged} of ${total} cells are anchored to a source. The other ${tagged} ${verb} <code>? verify</code>, so nothing anchors them yet.</p>`
+    : ''
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Design tokens</title>
+<link rel="stylesheet" href="design.css">
+<style>
+  body { font-family: system-ui, sans-serif; margin: 2rem; max-width: 960px; color: #222; }
+  h1 { margin-top: 0; }
+  h2 { margin-top: 2rem; border-bottom: 1px solid #ddd; padding-bottom: 0.25rem; }
+  table { border-collapse: collapse; width: 100%; margin-top: 0.5rem; }
+  th, td { text-align: left; padding: 0.5rem 0.75rem; border-bottom: 1px solid #eee; font-size: 14px; }
+  th { background: #f7f7f7; font-weight: 600; }
+  .swatch { display: inline-block; width: 1.5rem; height: 1.5rem; border-radius: 4px; border: 1px solid #ddd; vertical-align: middle; margin-right: 0.5rem; }
+  .bar { display: inline-block; height: 1rem; background: #888; border-radius: 2px; vertical-align: middle; }
+  .note { color: #666; font-size: 13px; margin-top: 0.5rem; }
+  .empty { color: #999; font-style: italic; }${verifyStyle}
+</style>
+</head>
+<body>
+<h1>Design tokens</h1>
+<p class="note">Generated from <code>.claude/DESIGN.md</code> by <code>canon design render</code>. Token preview only, not a screen mock.</p>${summary}
+${sections.join('\n')}
+</body>
+</html>
+`
+}
+
+function sectionPersonality(text: string): string {
+  if (!text) return ''
+  return `<h2>Personality</h2>\n<p>${escape(text)}</p>`
+}
+
+function sectionColor(rows: Row[]): string {
+  if (!rows.length) return ''
+  const body = rows
+    .map((r) => {
+      const value = val(r, 'Value')
+      const swatch = value
+        ? `<span class="swatch" style="background:${escape(value)}"></span>`
+        : '<span class="swatch"></span>'
+      const shown = value ? escape(value) : '<span class="empty">unset</span>'
+      return `<tr><td>${swatch}${cellText(r, 'Role')}</td><td>${cellText(r, 'Intent')}</td><td><code>${shown}</code>${mark(r, 'Value')}</td></tr>`
+    })
+    .join('\n')
+  return `<h2>Color</h2>\n<table><thead><tr><th>Role</th><th>Intent</th><th>Value</th></tr></thead><tbody>${body}</tbody></table>`
+}
+
+function sectionTypography(rows: Row[]): string {
+  if (!rows.length) return ''
+  const body = rows
+    .map((r) => {
+      const family = val(r, 'Family') || 'system-ui'
+      const weight = val(r, 'Weight') || '400'
+      const size = val(r, 'Size') || '16px'
+      const lh = val(r, 'Line height') || '1.4'
+      const sample = `<span style="font-family:${escape(family)};font-weight:${escape(weight)};font-size:${escape(size)};line-height:${escape(lh)}">The quick brown fox</span>`
+      return `<tr><td>${cellText(r, 'Role')}</td><td>${escape(family)}${mark(r, 'Family')}</td><td>${escape(weight)}${mark(r, 'Weight')}</td><td>${escape(size)}${mark(r, 'Size')}</td><td>${escape(lh)}${mark(r, 'Line height')}</td><td>${sample}</td></tr>`
+    })
+    .join('\n')
+  return `<h2>Typography</h2>\n<table><thead><tr><th>Role</th><th>Family</th><th>Weight</th><th>Size</th><th>Line height</th><th>Sample</th></tr></thead><tbody>${body}</tbody></table>`
+}
+
+function sectionSpacing(rows: Row[]): string {
+  if (!rows.length) return ''
+  const body = rows
+    .map((r) => {
+      const value = val(r, 'Value')
+      const bar = value
+        ? `<span class="bar" style="width:${escape(value)}"></span>`
+        : '<span class="empty">unset</span>'
+      return `<tr><td>${cellText(r, 'Step')}</td><td>${cellText(r, 'Multiplier')}</td><td><code>${escape(value || 'unset')}</code>${mark(r, 'Value')}</td><td>${bar}</td></tr>`
+    })
+    .join('\n')
+  return `<h2>Spacing</h2>\n<table><thead><tr><th>Step</th><th>Multiplier</th><th>Value</th><th>Sample</th></tr></thead><tbody>${body}</tbody></table>`
+}
+
+function sectionBorders(rows: Row[]): string {
+  if (!rows.length) return ''
+  const body = rows
+    .map((r) => {
+      const radius = val(r, 'Radius') || '0'
+      const width = val(r, 'Width') || '1px'
+      const sample = `<span style="display:inline-block;width:2rem;height:1.5rem;background:#eee;border:${escape(width)} solid #888;border-radius:${escape(radius)};vertical-align:middle"></span>`
+      return `<tr><td>${cellText(r, 'Role')}</td><td><code>${escape(radius)}</code>${mark(r, 'Radius')}</td><td><code>${escape(width)}</code>${mark(r, 'Width')}</td><td>${cellText(r, 'When used')}</td><td>${sample}</td></tr>`
+    })
+    .join('\n')
+  return `<h2>Borders</h2>\n<table><thead><tr><th>Role</th><th>Radius</th><th>Width</th><th>When used</th><th>Sample</th></tr></thead><tbody>${body}</tbody></table>`
+}
+
+function sectionLine(title: string, text: string): string {
+  if (!text) return ''
+  return `<h2>${title}</h2>\n<p>${escape(text)}</p>`
+}

package/src/docs/read.ts

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import { stripFrontmatter } from '@/frontmatter'
+
+const INDEX_TOPIC = 'index'
+
+/**
+ * The two roots a topic resolves against, in precedence order. `docs/` holds
+ * consumer-facing reference and `.claude/context/` holds per-domain internal
+ * narrative, so a name present in both resolves to the consumer-facing copy.
+ */
+const ROOTS: readonly string[] = ['docs', join('.claude', 'context')]
+
+export interface ResolvedTopic {
+  readonly path: string
+  readonly rel: string
+}
+
+/**
+ * A domain too large for one file splits into `<domain>/` with a generated
+ * `index.md`, so a topic names either a sibling file or such a folder. Both
+ * spellings resolve to the same name a caller types.
+ */
+export function resolveTopic(
+  root: string,
+  topic: string,
+): ResolvedTopic | undefined {
+  for (const dir of ROOTS) {
+    const candidates = [
+      join(dir, `${topic}.md`),
+      join(dir, topic, `${INDEX_TOPIC}.md`),
+    ]
+
+    for (const rel of candidates) {
+      const path = join(root, rel)
+      if (existsSync(path)) return { path, rel }
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Names every topic a `get` could resolve, listed per root in the order the
+ * roots are searched. Shown when a topic misses, so it doubles as the answer to
+ * what the caller should have typed.
+ */
+export function listTopics(root: string): string[] {
+  const topics: string[] = []
+
+  for (const dir of ROOTS) {
+    const cwd = join(root, dir)
+    if (!existsSync(cwd)) continue
+
+    const files = [
+      ...new Bun.Glob('*.md').scanSync({ cwd, onlyFiles: true, dot: true }),
+    ]
+      .map((name) => basename(name, '.md'))
+      .filter((name) => name !== INDEX_TOPIC)
+
+    const folders = [
+      ...new Bun.Glob(`*/${INDEX_TOPIC}.md`).scanSync({
+        cwd,
+        onlyFiles: true,
+        dot: true,
+      }),
+    ].map((name) => dirname(name))
+
+    topics.push(...[...files, ...folders].sort())
+  }
+
+  return topics
+}
+
+export function readTopic(topic: ResolvedTopic): string {
+  return stripFrontmatter(readFileSync(topic.path, 'utf8'))
+}

package/src/exec.ts

@@ -0,0 +1,16 @@
+import { join } from 'node:path'
+import { execa } from 'execa'
+import { PROJECT_ROOT } from '@/project-root'
+
+export async function execScript(
+  script: string,
+  args: string[],
+): Promise<void> {
+  const scriptPath = join(PROJECT_ROOT, 'scripts', script)
+  const result = await execa(scriptPath, args, {
+    stdio: 'inherit',
+    env: { ...process.env, PROJECT_ROOT },
+    reject: false,
+  })
+  process.exit(result.exitCode ?? 1)
+}

package/src/exempt-marker.ts

@@ -0,0 +1,43 @@
+/**
+ * Escapes every character a regular expression would read as syntax.
+ *
+ * The token became a parameter when this was extracted, and the two callers
+ * pass letters and hyphens alone. That is what makes escaping cheap here rather
+ * than a fix for a live defect: an unescaped token holding a dot matches the
+ * wrong lines and one holding a parenthesis throws, and neither failure is the
+ * caller's to anticipate.
+ */
+function escapeForPattern(token: string): string {
+  return token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+/**
+ * Whether the line at `index` carries `token` with a reason after it, reading
+ * itself and the line above.
+ *
+ * Extracted from `src/secrets/marker.ts`, which shaped it, so the two sweeps
+ * that mute a line share one answer to where a marker may sit. Two lines rather
+ * than one, because a value is as often introduced by a preceding comment as
+ * annotated inline, and a format taking no trailing comment has nowhere else to
+ * put the marker. Nothing further up counts, so a marker cannot silence a block
+ * it does not sit on.
+ *
+ * Only a marker naming a reason counts. A bare token is read as a line that
+ * meant to say something and did not, and honoring it would let a typo mute a
+ * finding, where the reason is the whole value of an exemption a later reader
+ * has to weigh.
+ */
+export function isMarked(
+  lines: readonly string[],
+  index: number,
+  token: string,
+): boolean {
+  const pattern = new RegExp(`${escapeForPattern(token)}:[ \\t]*\\S`)
+  const own = lines[index]
+  const above = index > 0 ? lines[index - 1] : undefined
+
+  return (
+    (own !== undefined && pattern.test(own)) ||
+    (above !== undefined && pattern.test(above))
+  )
+}

package/src/frontmatter.ts

@@ -0,0 +1,13 @@
+const FRONTMATTER = /^---\n[\s\S]*?\n---\n?/
+
+/**
+ * Drops a leading `---` block. Only a block starting on the first line counts,
+ * so a horizontal rule further down the document is left in place.
+ *
+ * The bash this replaced treated the first `---` on any line as an opening
+ * fence, which silently swallowed everything between two horizontal rules in a
+ * body. Anchoring to the first line is the correct reading.
+ */
+export function stripFrontmatter(source: string): string {
+  return source.replace(FRONTMATTER, '')
+}