@spec-wave/cli 0.6.0 → 0.7.1

package/src/lib/code-digest.mjs

@@ -0,0 +1,183 @@
+// Digest do estado atual do código — anexado ao contexto do `implement` para o
+// agente NÃO reimplementar o que já existe (caso real: módulo `landing` criado
+// duplicando o módulo `waves`). Duas fontes, ambas best-effort:
+//   • commits recentes (git log desde a criação da Feature);
+//   • árvore rasa dos módulos citados no plan.md.
+// Contrato: buildCodeDigest NUNCA lança — cada seção tem seu try/catch e, se
+// tudo falhar, retorna null (o chamador simplesmente omite a seção).
+
+import { execSync } from 'node:child_process';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+
+// Limites — o digest é contexto auxiliar, não pode dominar o arquivo.
+const MAX_PATHS = 30;
+const MAX_LOG_LINES = 50;
+const MAX_TREE_ENTRIES = 40;
+const MAX_TREE_DEPTH = 2;
+
+// Extensões comuns de código/config — usadas para aceitar nomes sem "/" como
+// caminho (ex.: `config.mjs`).
+const COMMON_EXT_RE = /\.(mjs|cjs|jsx?|tsx?|json|ya?ml|md|css|scss|html|vue|svelte|py|rb|go|rs|java|kt|sql|sh|prisma|toml)$/i;
+
+// Prefixos de diretório que aparecem "soltos" no texto do plan (fora de backticks).
+const LOOSE_PATH_RE = /(?:^|[\s(])((?:src|server|client|packages)\/[\w./@-]+)/gm;
+
+// Caracteres que denunciam código inline, não caminho: chamadas, objetos, aspas…
+const NON_PATH_CHARS_RE = /[(){}<>|"'`\\=,;!?*\s]/;
+
+function normalizePath(raw) {
+  return String(raw)
+    .trim()
+    .replace(/^\.\//, '')     // sem "./" inicial
+    .replace(/\/+$/, '')      // sem "/" final
+    .replace(/\.+$/, '');     // pontuação de fim de frase colada ("src/lib.")
+}
+
+function looksLikePath(candidate) {
+  if (!candidate || candidate.startsWith('-') || candidate.includes('://')) return false;
+  if (NON_PATH_CHARS_RE.test(candidate)) return false;
+  return candidate.includes('/') || COMMON_EXT_RE.test(candidate);
+}
+
+/**
+ * Extrai caminhos de arquivo/diretório citados no plan.md: conteúdo de
+ * backticks que pareça caminho (tem "/" ou extensão comum) e padrões soltos
+ * tipo `src/...`, `server/...`, `client/...`, `packages/...`.
+ *
+ * @param {string|null|undefined} planText conteúdo do plan.md
+ * @returns {string[]} caminhos normalizados, sem duplicatas, no máx. 30
+ */
+export function extractPathsFromPlan(planText) {
+  if (!planText) return [];
+  const paths = [];
+  const push = (raw) => {
+    const candidate = normalizePath(raw);
+    if (looksLikePath(candidate) && !paths.includes(candidate)) paths.push(candidate);
+  };
+  for (const m of planText.matchAll(/`([^`\n]+)`/g)) push(m[1]);
+  for (const m of planText.matchAll(LOOSE_PATH_RE)) push(m[1]);
+  return paths.slice(0, MAX_PATHS);
+}
+
+// exec padrão: execSync capturando stdout (stderr descartado — falha vira
+// exceção e a seção é omitida).
+function defaultExec(command, options = {}) {
+  return execSync(command, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'], ...options });
+}
+
+// Listagem rasa de um diretório (profundidade máx. 2, orçamento de entradas
+// compartilhado), formato indentado. Erros de leitura interrompem só o ramo.
+function listDirTree(absDir, budget) {
+  const lines = [];
+  const walk = (dir, depth) => {
+    if (depth > MAX_TREE_DEPTH) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (entry.name === 'node_modules' || entry.name === '.git') continue;
+      if (budget.remaining <= 0) {
+        budget.truncated = true;
+        return;
+      }
+      budget.remaining--;
+      const indent = '  '.repeat(depth + 1);
+      if (entry.isDirectory()) {
+        lines.push(`${indent}${entry.name}/`);
+        walk(path.join(dir, entry.name), depth + 1);
+      } else {
+        lines.push(`${indent}${entry.name}`);
+      }
+    }
+  };
+  walk(absDir, 0);
+  return lines;
+}
+
+// Seção "Commits desde a criação da feature" — null se a seção falhar.
+function buildCommitsSection({ sinceIso, cwd, exec }) {
+  if (!sinceIso) return null;
+  try {
+    // Sanitiza o ISO antes de interpolar no shell (só chars de data/hora).
+    const safeSince = String(sinceIso).replace(/[^\w:+.-]/g, '');
+    const out = exec(`git log --oneline --no-merges --since="${safeSince}"`, { cwd });
+    const commits = String(out).split('\n').filter(l => l.trim()).slice(0, MAX_LOG_LINES);
+    const lines = ['### Commits desde a criação da feature', ''];
+    if (commits.length === 0) {
+      lines.push('nenhum commit no período.');
+    } else {
+      lines.push('```', ...commits, '```');
+    }
+    return lines.join('\n');
+  } catch {
+    return null;
+  }
+}
+
+// Seção "Árvore dos módulos citados no plan" — null se não houver paths ou se
+// a seção falhar.
+function buildTreeSection({ paths, cwd }) {
+  if (!paths || paths.length === 0) return null;
+  try {
+    const lines = ['### Árvore dos módulos citados no plan', ''];
+    const missing = [];
+    const budget = { remaining: MAX_TREE_ENTRIES, truncated: false };
+    for (const rel of paths) {
+      let stat;
+      try {
+        stat = statSync(path.join(cwd, rel));
+      } catch {
+        missing.push(rel);
+        continue;
+      }
+      if (stat.isDirectory()) {
+        lines.push(`- \`${rel}/\` (diretório):`);
+        lines.push('```');
+        lines.push(...listDirTree(path.join(cwd, rel), budget));
+        lines.push('```');
+      } else {
+        let lineCount = null;
+        try {
+          const content = readFileSync(path.join(cwd, rel), 'utf-8');
+          lineCount = content.split('\n').length;
+        } catch { /* tamanho é opcional */ }
+        lines.push(`- \`${rel}\` — arquivo existente${lineCount != null ? ` (${lineCount} linhas)` : ''}`);
+      }
+    }
+    if (budget.truncated) lines.push(`_(listagem truncada em ${MAX_TREE_ENTRIES} entradas)_`);
+    if (missing.length > 0) {
+      lines.push(`- não existem ainda (a criar): ${missing.map(m => `\`${m}\``).join(', ')}`);
+    }
+    return lines.join('\n');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Monta o digest do estado do código em markdown. Best-effort: cada seção tem
+ * try/catch próprio; NUNCA lança — se nada puder ser gerado, retorna null.
+ *
+ * @param {object} opts
+ * @param {string|null} [opts.sinceIso] ISO da criação da Feature (limite do git log)
+ * @param {string[]} [opts.paths] caminhos citados no plan (ver extractPathsFromPlan)
+ * @param {string} [opts.cwd] raiz do repo alvo
+ * @param {Function} [opts.exec] injetável para testes (default: execSync utf-8)
+ * @returns {Promise<string|null>} markdown do digest, ou null
+ */
+export async function buildCodeDigest({ sinceIso, paths = [], cwd = process.cwd(), exec = defaultExec } = {}) {
+  try {
+    const sections = [
+      buildCommitsSection({ sinceIso, cwd, exec }),
+      buildTreeSection({ paths, cwd }),
+    ].filter(Boolean);
+    return sections.length > 0 ? sections.join('\n\n') : null;
+  } catch {
+    return null;
+  }
+}

package/src/lib/critique.mjs

@@ -0,0 +1,160 @@
+// Crítica adversarial dos artefatos gerados por IA (plan e stories).
+//
+// Um segundo passe de IA, com papel de revisor cético, audita o documento
+// recém-gerado contra a spec/regras de negócio/tech_context e classifica cada
+// contradição como GRAVE ou MENOR. Findings graves aplicam a label
+// `spec-wave:critique-failed`, que bloqueia o `spec-wave:ready` até correção.
+//
+// Contrato: a crítica NUNCA deve derrubar o fluxo principal — parse tolerante
+// a JSON sujo, e falhas de API são tratadas pelo chamador como não-fatais.
+
+import { generateDocument } from './claude.mjs';
+import { LABEL_CRITIQUE_FAILED } from '../config.mjs';
+
+// Tamanho máximo da resposta bruta preservada no fallback de parse.
+const RAW_FALLBACK_MAX = 400;
+
+// Redação específica por tipo de auditoria. 'plan' audita o plan.md contra a
+// spec; 'stories' audita as stories propostas contra spec + plan.
+const KIND_FOCUS = {
+  plan:
+    'Audite o plan.md contra o spec.md, as regras de negócio e o tech_context fornecidos. ' +
+    'Procure decisões técnicas que contradizem ou ignoram requisitos da spec e ' +
+    'tecnologias/serviços fora do tech_context.',
+  stories:
+    'Audite as Stories propostas (JSON) contra o spec.md e o plan.md fornecidos. ' +
+    'Procure stories que contradizem, invertem ou ignoram requisitos da spec ou ' +
+    'decisões do plan, e critérios de aceite incompatíveis com as regras de negócio.',
+};
+
+function buildSystemPrompt(kind) {
+  const focus = KIND_FOCUS[kind] || KIND_FOCUS.plan;
+  return `Você é um revisor técnico CÉTICO e adversarial. Seu papel é encontrar problemas, não elogiar.
+
+${focus}
+
+Liste:
+- contradições diretas entre os documentos;
+- inversões de requisito (ex.: consentimento→persistência invertidos: a spec exige consentimento ANTES de persistir e o documento persiste antes de pedir consentimento);
+- violações de restrições explícitas (ex.: minimização de dados LGPD, limites de retenção, campos proibidos);
+- itens que contradizem ou ignoram a spec.
+
+Classifique cada finding:
+- "grave": contradiz um requisito ou regra explícita — causaria implementação errada;
+- "menor": inconsistência, omissão ou ambiguidade que merece atenção mas não inverte requisito.
+
+NÃO invente problemas: se os documentos estiverem consistentes, retorne a lista vazia.
+Escreva os findings em português (pt-BR).
+
+Responda APENAS com JSON neste formato, sem texto adicional:
+{"findings": [{"severity": "grave"|"menor", "text": "..."}]}`;
+}
+
+/**
+ * Interpreta a resposta do modelo crítico (função PURA — testável).
+ *
+ * Tolerante a JSON sujo: fences de código, texto ao redor do objeto e
+ * severities em maiúsculas/variantes ("GRAVE", "Grave"). Qualquer severity que
+ * não comece com "grave" vira "menor". Se nada parseável for encontrado,
+ * retorna a resposta bruta (truncada) como um único finding menor — a crítica
+ * nunca deve explodir.
+ *
+ * @param {string} text resposta bruta do modelo
+ * @returns {{ grave: boolean, findings: Array<{ severity: 'grave'|'menor', text: string }> }}
+ */
+export function parseCritiqueResponse(text) {
+  const raw = (text || '').trim();
+
+  // Candidatos a JSON, do mais provável ao mais permissivo: conteúdo de fence
+  // de código, resposta inteira, primeiro objeto {...} encontrado no texto.
+  const candidates = [];
+  const fence = raw.match(/```[a-zA-Z]*\s*\n?([\s\S]*?)```/);
+  if (fence) candidates.push(fence[1]);
+  candidates.push(raw);
+  const obj = raw.match(/\{[\s\S]*\}/);
+  if (obj) candidates.push(obj[0]);
+
+  for (const candidate of candidates) {
+    let parsed;
+    try {
+      parsed = JSON.parse(candidate.trim());
+    } catch {
+      continue; // tenta o próximo candidato
+    }
+    const list = Array.isArray(parsed?.findings) ? parsed.findings
+      : Array.isArray(parsed) ? parsed
+      : null;
+    if (!list) continue;
+    const findings = list
+      .filter(f => f && typeof f.text === 'string' && f.text.trim())
+      .map(f => ({
+        severity: /^grave/i.test(String(f.severity || '').trim()) ? 'grave' : 'menor',
+        text: f.text.trim(),
+      }));
+    return { grave: findings.some(f => f.severity === 'grave'), findings };
+  }
+
+  // Fallback: resposta não-parseável → finding menor com a resposta bruta.
+  if (!raw) return { grave: false, findings: [] };
+  const truncated = raw.length > RAW_FALLBACK_MAX ? `${raw.slice(0, RAW_FALLBACK_MAX)}…` : raw;
+  return { grave: false, findings: [{ severity: 'menor', text: truncated }] };
+}
+
+// Monta o comentário de issue a partir dos findings classificados.
+function renderMarkdown(findings) {
+  const header = '🔎 **Crítica adversarial (spec-wave)**';
+  if (findings.length === 0) {
+    return `${header}\n\n✅ crítica não encontrou contradições.`;
+  }
+
+  const graves = findings.filter(f => f.severity === 'grave');
+  const menores = findings.filter(f => f.severity === 'menor');
+  const parts = [header];
+  if (graves.length > 0) {
+    parts.push(`### ❌ Graves\n\n${graves.map(f => `- ${f.text}`).join('\n')}`);
+  }
+  if (menores.length > 0) {
+    parts.push(`### ⚠️ Menores\n\n${menores.map(f => `- ${f.text}`).join('\n')}`);
+  }
+  parts.push(graves.length > 0
+    ? `⛔ Há findings **graves**: a label \`${LABEL_CRITIQUE_FAILED}\` bloqueia o ` +
+      `\`spec-wave:ready\` até ser removida após a correção dos pontos acima.`
+    : `_Findings menores não bloqueiam o fluxo. Se houvesse graves, a label ` +
+      `\`${LABEL_CRITIQUE_FAILED}\` bloquearia o \`spec-wave:ready\` até ser removida após correção._`);
+  return parts.join('\n\n');
+}
+
+/**
+ * Roda a crítica adversarial sobre os artefatos fornecidos.
+ *
+ * Seções ausentes (spec/plan/tech_context/stories) são simplesmente omitidas
+ * do prompt. Erros de API PROPAGAM — o chamador deve tratar com try/catch e
+ * seguir o fluxo principal (crítica indisponível não é fatal).
+ *
+ * @param {object} params
+ * @param {'plan'|'stories'} params.kind o que está sendo auditado
+ * @param {string} [params.spec] conteúdo do spec.md
+ * @param {string} [params.plan] conteúdo do plan.md
+ * @param {string} [params.techContextYaml] tech_context serializado em YAML
+ * @param {object[]} [params.stories] stories propostas (antes da criação)
+ * @param {object[]} [params.usage] coletor de uso de IA (repassado ao generateDocument)
+ * @returns {Promise<{ grave: boolean, findings: Array<{ severity: string, text: string }>, markdown: string }>}
+ */
+export async function runCritique({ kind, spec, plan, techContextYaml, stories, usage } = {}) {
+  const sections = [];
+  if (spec) sections.push(`## spec.md\n\n${spec}`);
+  if (plan) sections.push(`## plan.md\n\n${plan}`);
+  if (techContextYaml) sections.push(`## tech_context\n\n\`\`\`yaml\n${techContextYaml}\n\`\`\``);
+  if (stories) sections.push(`## Stories propostas (JSON)\n\n\`\`\`json\n${JSON.stringify(stories, null, 2)}\n\`\`\``);
+  const userContent = sections.join('\n\n') || '(nenhum documento fornecido)';
+
+  const raw = await generateDocument(buildSystemPrompt(kind), userContent, {
+    action: 'critique',
+    temperature: 0,
+    maxTokens: 4096,
+    usage,
+  });
+
+  const { grave, findings } = parseCritiqueResponse(raw);
+  return { grave, findings, markdown: renderMarkdown(findings) };
+}

package/src/lib/dependencies.mjs

@@ -0,0 +1,92 @@
+// Dependências entre Stories (módulo puro — sem I/O, sem dependências).
+//
+// O decompose grava uma linha "Depende de: #4, #5" no corpo das Stories; os
+// comandos `order`/`task`/`story` (Fase 2) leem essa linha para ordenar o
+// trabalho e criar as relações blocked_by no GitHub.
+
+// Linha de dependência: começo de linha, opcionalmente com marcador de lista
+// (-, *, >) e/ou ênfase (_itálico_, **negrito**), "Depende de" case-insensitive,
+// com ou sem dois-pontos. Os números são capturados depois via /#\d+/g.
+const DEP_LINE_RE = /^[\s>*-]*[*_]{0,2}depende\s+de[*_]{0,2}\s*:?/i;
+
+/**
+ * Formata a linha de dependências gravada no corpo de uma Story.
+ *
+ * @param {number[]} numbers números das issues das quais a Story depende
+ * @returns {string} ex.: "Depende de: #4, #5" — string vazia para lista vazia
+ */
+export function formatDependencyLine(numbers) {
+  if (!numbers || numbers.length === 0) return '';
+  return `Depende de: ${numbers.map(n => `#${n}`).join(', ')}`;
+}
+
+/**
+ * Extrai os números de dependência do corpo de uma issue. Tolerante a
+ * variações de formatação: "Depende de: #4", "**Depende de** #4 e #5",
+ * "- _depende de_ #4, #5".
+ *
+ * @param {string|null|undefined} body corpo da issue
+ * @returns {number[]} números encontrados (sem duplicatas, na ordem do texto);
+ *          [] para body nulo ou sem linha de dependência
+ */
+export function parseDependencies(body) {
+  if (!body) return [];
+  const numbers = [];
+  for (const line of body.split(/\r?\n/)) {
+    if (!DEP_LINE_RE.test(line)) continue;
+    for (const m of line.matchAll(/#(\d+)/g)) {
+      const n = parseInt(m[1], 10);
+      if (n && !numbers.includes(n)) numbers.push(n);
+    }
+  }
+  return numbers;
+}
+
+/**
+ * Ordena Stories topologicamente pelas dependências (Kahn). Estável: entre as
+ * Stories liberadas ao mesmo tempo, vence a de menor number. Dependências que
+ * apontam para fora do conjunto (ex.: issue externa) são ignoradas.
+ *
+ * Contrato: NUNCA lança. Retorna sempre `{ order, cycle }`:
+ *  • sem ciclo → order = todos os numbers em ordem de execução, cycle = [];
+ *  • com ciclo → order = o que pôde ser ordenado, cycle = numbers restantes
+ *    (envolvidos no ciclo ou bloqueados por ele), ambos em ordem crescente.
+ * O chamador decide se trata cycle.length > 0 como erro.
+ *
+ * @param {Array<{ number: number, dependsOn: number[] }>} stories
+ * @returns {{ order: number[], cycle: number[] }}
+ */
+export function orderStories(stories) {
+  const known = new Set(stories.map(s => s.number));
+  // indegree = quantas dependências INTERNAS ainda não resolvidas.
+  const indegree = new Map();
+  const dependents = new Map(); // number → numbers que dependem dele
+  for (const s of stories) {
+    const deps = (s.dependsOn || []).filter(d => known.has(d) && d !== s.number);
+    indegree.set(s.number, deps.length);
+    for (const d of deps) {
+      if (!dependents.has(d)) dependents.set(d, []);
+      dependents.get(d).push(s.number);
+    }
+  }
+
+  const order = [];
+  // Fila de liberados; o menor number sai primeiro (ordenação estável).
+  const ready = [...indegree.entries()].filter(([, deg]) => deg === 0).map(([n]) => n);
+  while (ready.length > 0) {
+    ready.sort((a, b) => a - b);
+    const n = ready.shift();
+    order.push(n);
+    for (const dep of dependents.get(n) || []) {
+      const deg = indegree.get(dep) - 1;
+      indegree.set(dep, deg);
+      if (deg === 0) ready.push(dep);
+    }
+  }
+
+  const cycle = [...indegree.entries()]
+    .filter(([, deg]) => deg > 0)
+    .map(([n]) => n)
+    .sort((a, b) => a - b);
+  return { order, cycle };
+}

package/src/lib/output-lint.mjs

@@ -0,0 +1,92 @@
+// Lint de idioma da saída da IA (módulo puro — sem I/O, sem dependências).
+//
+// Modelos ocasionalmente "vazam" caracteres de outros alfabetos no meio do
+// texto (caso real: "Registration成功率" num spec pt-BR). Este lint detecta
+// scripts Unicode incompatíveis com idiomas latinos via property escapes.
+
+// Scripts que nunca aparecem em texto legítimo de idiomas latinos (pt-BR, en,
+// es...). Acentos, emoji, pontuação e code fences NÃO casam com nenhum deles.
+const FOREIGN_SCRIPTS = [
+  { script: 'Han',      re: /\p{Script=Han}/u },
+  { script: 'Hiragana', re: /\p{Script=Hiragana}/u },
+  { script: 'Katakana', re: /\p{Script=Katakana}/u },
+  { script: 'Hangul',   re: /\p{Script=Hangul}/u },
+  { script: 'Cyrillic', re: /\p{Script=Cyrillic}/u },
+  { script: 'Arabic',   re: /\p{Script=Arabic}/u },
+  { script: 'Thai',     re: /\p{Script=Thai}/u },
+];
+
+// Distância máxima (em caracteres) entre dois achados para agrupá-los num
+// mesmo finding — evita explodir a lista quando um parágrafo inteiro vaza.
+const GROUP_GAP = 20;
+
+// Identifica o script de um caractere (ou null se não for estrangeiro).
+function scriptOf(char) {
+  for (const s of FOREIGN_SCRIPTS) {
+    if (s.re.test(char)) return s.script;
+  }
+  return null;
+}
+
+/**
+ * Verifica se `text` contém caracteres de scripts incompatíveis com o
+ * idioma-alvo. Para pt-BR (e idiomas latinos em geral), qualquer caractere
+ * CJK, Hangul, cirílico, árabe ou tailandês é um finding.
+ *
+ * Findings contíguos (distância ≤ ~20 chars) são agrupados num único item
+ * para runs longas não gerarem um finding por caractere.
+ *
+ * @param {string} text texto a verificar
+ * @param {object} [opts]
+ * @param {string}   [opts.lang='pt-BR'] idioma-alvo (informativo; todos os
+ *                   idiomas suportados hoje são latinos)
+ * @param {string[]} [opts.allowlist=[]] substrings a ignorar (ex.: nomes
+ *                   próprios ou termos técnicos legítimos em outro alfabeto)
+ * @returns {{ ok: boolean, findings: Array<{ index: number, char: string, script: string, excerpt: string }> }}
+ *          index = posição do primeiro caractere do grupo; char = trecho do
+ *          grupo (do primeiro ao último caractere estrangeiro); script = script
+ *          do primeiro caractere; excerpt = ~40 chars ao redor do grupo.
+ */
+export function lintLanguage(text, { lang = 'pt-BR', allowlist = [] } = {}) {
+  const source = text || '';
+  // Substitui trechos da allowlist por espaços (mesmo comprimento) para
+  // preservar os índices/excerpts do texto original.
+  let scanned = source;
+  for (const allowed of allowlist) {
+    if (!allowed) continue;
+    scanned = scanned.split(allowed).join(' '.repeat(allowed.length));
+  }
+
+  // Coleta cada caractere estrangeiro com seu índice e script.
+  const hits = [];
+  for (const m of scanned.matchAll(/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Cyrillic}\p{Script=Arabic}\p{Script=Thai}]/gu)) {
+    hits.push({ index: m.index, char: m[0], script: scriptOf(m[0]) });
+  }
+
+  // Agrupa hits próximos num único finding.
+  const findings = [];
+  let group = null;
+  const flush = () => {
+    if (!group) return;
+    const start = Math.max(0, group.start - 20);
+    const end = Math.min(source.length, group.end + 20);
+    findings.push({
+      index: group.start,
+      char: source.slice(group.start, group.end),
+      script: group.script,
+      excerpt: source.slice(start, end),
+    });
+    group = null;
+  };
+  for (const hit of hits) {
+    if (group && hit.index - group.end <= GROUP_GAP) {
+      group.end = hit.index + hit.char.length;
+    } else {
+      flush();
+      group = { start: hit.index, end: hit.index + hit.char.length, script: hit.script };
+    }
+  }
+  flush();
+
+  return { ok: findings.length === 0, findings };
+}