hobots 0.3.1 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hobots
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,346 @@
+# hobots
+
+SDK JavaScript/TypeScript da **Hobots** para instrumentar funcionários digitais (RPAs) e integrações.
+
+- **Monitor** — telemetria que o programa **emite** sozinho: erros com stack trace, performance (transactions/spans), check-ins de cron e heartbeats de uptime.
+- **Manager** — execução **sob demanda**: o agente faz polling no app da Hobots, executa handlers registrados e reporta status, logs e resultado.
+
+Cliente HTTP puro, **sem dependências de runtime**. Requer **Node 18+** (usa o `fetch` global); o Monitor também roda no browser para captura de erros.
+
+---
+
+## Instalação
+
+```bash
+npm install hobots
+# ou: pnpm add hobots · yarn add hobots
+```
+
+```js
+import * as Monitor from 'hobots';          // capability Monitor (import raiz)
+import * as Manager from 'hobots/manager';  // capability Manager
+```
+
+Também funciona em CommonJS: `const Monitor = require('hobots')`.
+
+---
+
+## As duas capabilities
+
+O SDK expõe **duas capabilities independentes** — credenciais, entry points e ciclos de vida separados — que podem conviver no mesmo processo.
+
+| Capability | Import | Para quê | Ciclo de vida |
+| --- | --- | --- | --- |
+| **Monitor** | `hobots` | Telemetria emitida pelo próprio programa: erros, transactions/spans, crons, heartbeat. | Timers `unref`'d — **não** segura o processo. Chame `close()` no fim. |
+| **Manager** | `hobots/manager` | Execução remota sob demanda via polling. | `start()` **segura o processo vivo** até `stop()`. |
+
+Você usa **uma, outra ou as duas**:
+
+- Só saber se o robô quebrou, quanto demora e se está vivo? → **Monitor**.
+- Disparar o robô sob demanda a partir de um formulário no app? → **Manager**.
+- Ambos? Inicialize os dois no mesmo processo, com credenciais separadas.
+
+---
+
+## O DSN
+
+Toda credencial do SDK é um **DSN** no formato `<protocolo>://<key>@<host>[:porta]/<projeto>`. A `key` vai embutida na URL e o `host` aponta para o app da Hobots. Copie o DSN pronto na página do projeto no app.
+
+```
+Monitor:  https://<publicKey>@<host>/<projectId>     ← public key (ingestão), na URL
+Manager:  https://<managerKey>@<host>/<projectSlug>  ← manager key (secreta), via Bearer
+```
+
+- **Monitor** usa a **public key** (chave de ingestão) e o `projectId`. É a chave do snippet de integração em `/monitor`.
+- **Manager** usa a **manager key** (chave secreta do agente, criada em `/manager/agents`) e o `projectSlug`. **Não** é a chave de ingestão; nunca vai na URL da requisição, só no header `Authorization: Bearer`.
+
+---
+
+## Monitor
+
+```js
+import * as Monitor from 'hobots';
+```
+
+Todas as funções abaixo são **no-op seguras** se `Monitor.init()` não foi chamado (com aviso no console).
+
+### `init(options)`
+
+Inicialize **uma vez**, o mais cedo possível no processo. Cria o cliente, instala handlers globais de erro (a menos que `captureUnhandled: false`) e inicia o heartbeat se configurado.
+
+```js
+Monitor.init({
+  dsn: 'https://<publicKey>@<host>/<projectId>',
+  environment: 'production',
+  release: 'robo-nfe@1.4.2',
+  serverName: 'vm-cliente-01',
+  tags: { squad: 'automacoes' },
+  heartbeat: true, // "estou vivo" a cada 30s
+});
+```
+
+| Opção | Tipo | Default | Descrição |
+| --- | --- | --- | --- |
+| `dsn` | `string` | **obrigatório** | `https://<publicKey>@host/<projectId>` |
+| `environment` | `string` | `'production'` | ambiente lógico |
+| `release` | `string` | — | versão do programa, ex. `robo-nfe@1.4.2` |
+| `serverName` | `string` | hostname | identifica a máquina; também vira `instanceId` do heartbeat |
+| `tags` | `Record<string,string>` | — | tags aplicadas a todos os eventos |
+| `sampleRate` | `number` | `1` | amostragem de erros (0..1) |
+| `tracesSampleRate` | `number` | `1` | amostragem de transactions (0..1) |
+| `maxBreadcrumbs` | `number` | `100` | tamanho do buffer de breadcrumbs |
+| `captureUnhandled` | `boolean` | `true` | handlers globais de erro (`uncaughtException`/`unhandledRejection`) |
+| `heartbeat` | `boolean \| HeartbeatOptions` | `false` | heartbeat periódico (`true` usa defaults) |
+| `beforeSend` | `(event) => event \| null` | — | edita/descarta evento (retorne `null` para descartar) |
+| `debug` | `boolean` | `false` | loga atividade do SDK |
+| `flushIntervalMs` | `number` | `2000` | intervalo do flush automático do transport |
+| `maxBatchSize` | `number` | `10` | itens por envelope antes do flush imediato |
+
+### Captura de erros e mensagens
+
+```js
+try {
+  await processarNota(nota);
+} catch (error) {
+  Monitor.captureException(error, {
+    level: 'error',
+    tags: { cliente: 'acme' },
+    fingerprint: ['sefaz-timeout'], // agrupa manualmente; sem isso o servidor agrupa pelo stack
+  });
+  throw error;
+}
+
+Monitor.captureMessage('Lote processado com sucesso', 'info');
+```
+
+Ambas retornam o `event_id` (ou `undefined` se não inicializado). O hint aceita `level`, `tags`, `extra` e `fingerprint`. Erros **não tratados** são capturados e flushados automaticamente antes do processo sair — desligue com `captureUnhandled: false`.
+
+`Severity = 'fatal' | 'error' | 'warning' | 'info' | 'debug'`.
+
+### Breadcrumbs
+
+Trilha do que aconteceu antes do erro; enviada junto do próximo evento (buffer limitado por `maxBreadcrumbs`, mais antigos descartados).
+
+```js
+Monitor.addBreadcrumb({ category: 'nfe', message: 'Baixou XML da nota 123', level: 'info' });
+```
+
+### Escopo: tags, usuário, contexto, extras
+
+Dados anexados a **todos** os eventos seguintes:
+
+```js
+Monitor.setTag('regiao', 'nordeste');
+Monitor.setTags({ squad: 'automacoes', cliente: 'acme' });
+Monitor.setUser({ id: 'op-42', email: 'op@acme.com' });
+Monitor.setContext('vm', { cpu: 4, ram: '8GB' });
+Monitor.setExtra('ultimoLote', 128);
+```
+
+Para um escopo **isolado** (sem vazar para o global), use `withScope`:
+
+```js
+Monitor.withScope((scope) => {
+  scope.setTag('lote', '128').setFingerprint(['reprocessamento']);
+  Monitor.captureMessage('Reprocessando lote 128');
+});
+```
+
+### Performance: transactions e spans
+
+```js
+const tx = Monitor.startTransaction('processar-lote', 'rpa.job');
+
+const span = tx.startChild('http.client', 'GET /api/notas');
+await api.buscarNotas();
+span.setData('notas', 42).finish();
+
+const filho = span.startChild('db.query', 'INSERT INTO notas'); // spans aninham
+await gravar();
+filho.finish();
+
+tx.setStatus('ok');  // ou 'error'
+tx.finish();         // só aqui a transaction é enviada (respeitando tracesSampleRate)
+```
+
+- `startChild(op?, description?)` existe em `Transaction` **e** `Span` (aninhamento arbitrário).
+- Métodos encadeáveis: `setStatus`, `setData` (span), `setTag`/`setName` (transaction).
+- `finish()` na transaction fecha os spans abertos e envia o payload; nada é enviado se ela não foi amostrada.
+
+### Crons (check-ins)
+
+Monitora jobs agendados: check-in `in_progress` na entrada, `ok`/`error` na saída, com duração medida. O jeito recomendado é `withMonitor`, que faz o par e captura exceções:
+
+```js
+await Monitor.withMonitor(
+  'sync-notas',
+  () => executarSync(),
+  { schedule: '0 */2 * * *', timezone: 'America/Fortaleza' }
+);
+```
+
+O `schedule` (expressão cron) faz o servidor **criar/atualizar o monitor automaticamente** (upsert) e habilita a detecção de **execução perdida**. Para controle manual:
+
+```js
+const id = Monitor.checkIn({ monitorSlug: 'sync-notas', status: 'in_progress' });
+// … trabalho …
+Monitor.checkIn({ monitorSlug: 'sync-notas', status: 'ok', checkInId: id, durationMs: 1234 });
+```
+
+### Heartbeat (uptime)
+
+Bate "estou vivo" periodicamente; o servidor acusa o robô **offline** quando os batimentos param.
+
+```js
+Monitor.init({
+  dsn,
+  heartbeat: { intervalMs: 30_000, name: 'Robô NFe — VM 01' },
+});
+```
+
+`heartbeat: true` usa os defaults. Campos: `intervalMs` (30000), `instanceId` (default `serverName`/`HOSTNAME`/id aleatório), `name`, `metadata`.
+
+### Flush e close
+
+```js
+await Monitor.flush(2000); // envia o buffer, mantém o SDK vivo
+await Monitor.close(2000); // flush final + para o heartbeat + fecha o transport
+```
+
+Chame `close` antes do processo sair. Os timers do Monitor são `unref`'d — ele **não** segura o processo vivo sozinho.
+
+---
+
+## Manager
+
+```js
+import * as Manager from 'hobots/manager';
+```
+
+Capability de **execução remota sob demanda**. O agente faz polling no app, executa os handlers registrados quando aparece trabalho e reporta status, logs incrementais e resultado. Credencial própria (**manager key**), singletons próprios, nenhum handler global instalado.
+
+### Ciclo de vida
+
+```js
+Manager.init({ dsn: 'https://<managerKey>@<host>/<projectSlug>', agentName: 'VM Cliente 01' });
+
+Manager.register('processar-nfe', async (params, ctx) => {
+  ctx.log('info', `processando lote ${params.lote}…`);
+  if (ctx.signal.aborted) return;   // cancelamento cooperativo
+  return { processadas: 12 };       // vira o resultado da execução no app
+});
+
+Manager.start(); // começa o polling e MANTÉM O PROCESSO VIVO
+
+process.on('SIGINT', () => {
+  void Manager.stop(15_000).then(() => process.exit(0));
+});
+```
+
+- `init(options)` — cria o agente (singleton). Chamar de novo para o anterior e substitui.
+- `register(task, handler)` — `task` é o `task_slug` configurado no formulário do app. Registre **antes** de `start()`.
+- `start()` — começa o polling. Lança se `init()` não foi chamado ou se nenhuma task foi registrada.
+- `stop(timeoutMs?)` — para o polling e aguarda as runs ativas (default 30s). Retorna `false` se estourou o timeout.
+
+| Opção (`ManagerInitOptions`) | Tipo | Default | Descrição |
+| --- | --- | --- | --- |
+| `dsn` | `string` | **obrigatório** | com a **manager key** (não a chave de ingestão) |
+| `pollIntervalMs` | `number` | `5000` | intervalo entre polls sem trabalho (mínimo `1000`) |
+| `concurrency` | `number` | `1` | runs simultâneas (clamp 1..5) |
+| `agentName` | `string` | hostname | nome exibido no dashboard |
+| `taskTimeoutMs` | `number` | — | timeout client-side por run (não mata o handler; servidor é o backstop) |
+| `logFlushIntervalMs` | `number` | `2000` | intervalo do envio incremental de logs |
+| `debug` | `boolean` | `false` | loga atividade do agente |
+
+### O handler e o `RunContext`
+
+```ts
+type ManagerTaskHandler<P = Record<string, unknown>, R = unknown> =
+  (params: P, ctx: RunContext) => R | Promise<R>;
+
+interface RunContext {
+  runId: string;
+  task: string;
+  log(level: 'debug' | 'info' | 'warning' | 'error', message: string): void;
+  signal: AbortSignal;
+}
+```
+
+- **`params`** — os dados do formulário configurado no app (JSON validado). Tipável: `Manager.register<{ lote: number }, { processadas: number }>(...)`.
+- **`ctx.log(level, message)`** — logs enviados **incrementalmente** ao app (PATCHes com throttle), visíveis na run quase em tempo real.
+- **`ctx.signal`** — `AbortSignal` que dispara quando a run é **cancelada no app**, em **timeout** ou no **shutdown**.
+- **Retorno** — vira o resultado exibido no app (JSON, cap ~100KB; maiores/circulares são descartados com marcador `__truncated`).
+- **Erro lançado** — a run é reportada como `failed` (mensagem cap 10k, stack 20k).
+
+### Cancelamento cooperativo
+
+Uma run cancelada no app **não mata** o handler — o SDK apenas dispara `ctx.signal`. **Verifique `ctx.signal.aborted`** em loops longos:
+
+```js
+Manager.register('processar-nfe', async (params, ctx) => {
+  for (const nota of params.notas) {
+    if (ctx.signal.aborted) {
+      ctx.log('warning', 'cancelamento detectado — parando');
+      return { canceladas: true };
+    }
+    await processar(nota);
+  }
+});
+```
+
+### Concorrência
+
+`concurrency` (default 1, máx 5) controla quantas runs o agente executa em paralelo. Com 1, as runs são sequenciais. O agente só reivindica o que consegue rodar (`max = concurrency - runs ativas`) e entra em **drain mode**: re-pesquisa imediatamente enquanto vem trabalho; quando não vem, espera `pollIntervalMs`.
+
+### Timeout por run
+
+`taskTimeoutMs` é **client-side**. No estouro o SDK **não mata** o handler — dispara `ctx.signal`, libera o slot e reporta a run como falha (`TaskTimeout`). Respeite o `signal` para parar de verdade. Sem ele, o backstop é o servidor.
+
+### Idempotência (at-least-once)
+
+A entrega é **at-least-once**: se o agente morre logo após capturar uma run (antes de reportar o resultado), ela é re-entregue quando o agente voltar. Escreva handlers **idempotentes** (use uma chave de deduplicação sua, como o número da nota).
+
+---
+
+## Encerramento gracioso
+
+```js
+// Monitor: não segura o processo, mas faça o flush final para não perder eventos
+await Monitor.close(2000);
+
+// Manager: segura o processo por design — aguarde a run atual
+process.on('SIGINT', () => {
+  void Manager.stop(15_000).then(() => process.exit(0));
+});
+```
+
+---
+
+## Entry points / exports
+
+| Import | Conteúdo |
+| --- | --- |
+| `hobots` | Monitor: funções, `Client`, `Scope`, `Transaction`, `Span`, `parseDsn`, tipos. |
+| `hobots/protocol` | Tipos do wire format do Monitor. |
+| `hobots/manager` | Manager: `init`/`register`/`start`/`stop`, `ManagerAgent`, `ManagerApi`, `ManagerApiError`, `parseManagerDsn`, tipos. |
+| `hobots/manager/protocol` | Tipos do wire format do Manager. |
+
+Empacotado em **ESM e CommonJS** com **definições de tipos** (`.d.ts`) para todas as entradas.
+
+---
+
+## Documentação completa
+
+Guias detalhados acompanham o pacote em [`docs/`](./docs/README.md):
+
+- [Getting started](./docs/getting-started.md) — instalação, DSN, primeiro `init`, Monitor vs Manager.
+- [Monitor](./docs/monitor.md) — erros, breadcrumbs, escopo, transactions/spans, crons, heartbeat.
+- [Manager](./docs/manager.md) — handlers, `RunContext`, cancelamento, concorrência, idempotência.
+- [Referência de API](./docs/api-reference.md) — todas as funções e tabelas de opções com defaults.
+- [Protocolo & transporte](./docs/protocol.md) — DSNs, endpoints, envelope, retries.
+
+---
+
+## Licença
+
+[MIT](./LICENSE) © Hobots

package/dist/chunk-FW32OR7V.js

@@ -0,0 +1,75 @@
+// src/dsn.ts
+function parseDsnUrl(dsn, prefix) {
+  let url;
+  try {
+    url = new URL(dsn);
+  } catch {
+    throw new Error(`${prefix} DSN inv\xE1lido: "${dsn}"`);
+  }
+  const key = url.username;
+  const path = url.pathname.replace(/^\/+/, "");
+  if (!key || !path) {
+    throw new Error(`${prefix} DSN inv\xE1lido: "${dsn}" \u2014 esperado https://<key>@host/<projeto>`);
+  }
+  return { key, path, origin: `${url.protocol}//${url.host}` };
+}
+function parseDsn(dsn) {
+  const { key, path, origin } = parseDsnUrl(dsn, "[hobots-monitor]");
+  return {
+    publicKey: key,
+    projectId: path,
+    endpoint: `${origin}/api/ingest/${key}`
+  };
+}
+
+// src/utils.ts
+var SDK_NAME = "hobots";
+var SDK_VERSION = "1.0.0";
+function isNode() {
+  return typeof process !== "undefined" && typeof process.versions?.node === "string";
+}
+function uuid4() {
+  const cryptoRef = globalThis.crypto;
+  if (cryptoRef && typeof cryptoRef.randomUUID === "function") {
+    return cryptoRef.randomUUID().replace(/-/g, "");
+  }
+  let out = "";
+  for (let i = 0; i < 32; i++) {
+    out += Math.floor(Math.random() * 16).toString(16);
+  }
+  return out;
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function unrefTimer(timer) {
+  timer?.unref?.();
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    unrefTimer(timer);
+  });
+}
+var PREFIX = "[hobots-monitor]";
+function makeLogger(enabled, prefix = PREFIX) {
+  return {
+    debug: (...args) => enabled && console.debug(prefix, ...args),
+    warn: (...args) => enabled && console.warn(prefix, ...args),
+    error: (...args) => console.error(prefix, ...args)
+  };
+}
+
+export {
+  parseDsnUrl,
+  parseDsn,
+  SDK_NAME,
+  SDK_VERSION,
+  isNode,
+  uuid4,
+  nowISO,
+  unrefTimer,
+  sleep,
+  makeLogger
+};
+//# sourceMappingURL=chunk-FW32OR7V.js.map

package/dist/chunk-FW32OR7V.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dsn.ts","../src/utils.ts"],"sourcesContent":["export interface ParsedDsn {\n  publicKey: string;\n  projectId: string;\n  /** URL de ingestão derivada: <origin>/api/ingest/<publicKey> */\n  endpoint: string;\n}\n\ninterface ParsedDsnUrl {\n  key: string;\n  path: string;\n  origin: string;\n}\n\n/** Parser baixo nível compartilhado entre Monitor e Manager (não exportado no barrel). */\nexport function parseDsnUrl(dsn: string, prefix: string): ParsedDsnUrl {\n  let url: URL;\n  try {\n    url = new URL(dsn);\n  } catch {\n    throw new Error(`${prefix} DSN inválido: \"${dsn}\"`);\n  }\n\n  const key = url.username;\n  const path = url.pathname.replace(/^\\/+/, '');\n  if (!key || !path) {\n    throw new Error(`${prefix} DSN inválido: \"${dsn}\" — esperado https://<key>@host/<projeto>`);\n  }\n\n  return { key, path, origin: `${url.protocol}//${url.host}` };\n}\n\n/** Formato: https://<publicKey>@host[:porta]/<projectId> */\nexport function parseDsn(dsn: string): ParsedDsn {\n  const { key, path, origin } = parseDsnUrl(dsn, '[hobots-monitor]');\n  return {\n    publicKey: key,\n    projectId: path,\n    endpoint: `${origin}/api/ingest/${key}`,\n  };\n}\n","export const SDK_NAME = 'hobots';\nexport const SDK_VERSION = '1.0.0';\n\nexport function isNode(): boolean {\n  return typeof process !== 'undefined' && typeof process.versions?.node === 'string';\n}\n\n/** uuid v4 sem hífens (32 hex). Fallback para contextos sem crypto.randomUUID. */\nexport function uuid4(): string {\n  const cryptoRef = (globalThis as { crypto?: Crypto }).crypto;\n  if (cryptoRef && typeof cryptoRef.randomUUID === 'function') {\n    return cryptoRef.randomUUID().replace(/-/g, '');\n  }\n  let out = '';\n  for (let i = 0; i < 32; i++) {\n    out += Math.floor(Math.random() * 16).toString(16);\n  }\n  return out;\n}\n\nexport function nowISO(): string {\n  return new Date().toISOString();\n}\n\n/** Timers não devem segurar o processo Node aberto. */\nexport function unrefTimer(timer: unknown): void {\n  (timer as { unref?: () => void } | undefined)?.unref?.();\n}\n\nexport function sleep(ms: number): Promise<void> {\n  return new Promise(resolve => {\n    const timer = setTimeout(resolve, ms);\n    unrefTimer(timer);\n  });\n}\n\nexport interface Logger {\n  debug: (...args: unknown[]) => void;\n  warn: (...args: unknown[]) => void;\n  error: (...args: unknown[]) => void;\n}\n\nconst PREFIX = '[hobots-monitor]';\n\nexport function makeLogger(enabled: boolean, prefix: string = PREFIX): Logger {\n  return {\n    debug: (...args) => enabled && console.debug(prefix, ...args),\n    warn: (...args) => enabled && console.warn(prefix, ...args),\n    error: (...args) => console.error(prefix, ...args),\n  };\n}\n"],"mappings":";AAcO,SAAS,YAAY,KAAa,QAA8B;AACrE,MAAI;AACJ,MAAI;AACF,UAAM,IAAI,IAAI,GAAG;AAAA,EACnB,QAAQ;AACN,UAAM,IAAI,MAAM,GAAG,MAAM,sBAAmB,GAAG,GAAG;AAAA,EACpD;AAEA,QAAM,MAAM,IAAI;AAChB,QAAM,OAAO,IAAI,SAAS,QAAQ,QAAQ,EAAE;AAC5C,MAAI,CAAC,OAAO,CAAC,MAAM;AACjB,UAAM,IAAI,MAAM,GAAG,MAAM,sBAAmB,GAAG,gDAA2C;AAAA,EAC5F;AAEA,SAAO,EAAE,KAAK,MAAM,QAAQ,GAAG,IAAI,QAAQ,KAAK,IAAI,IAAI,GAAG;AAC7D;AAGO,SAAS,SAAS,KAAwB;AAC/C,QAAM,EAAE,KAAK,MAAM,OAAO,IAAI,YAAY,KAAK,kBAAkB;AACjE,SAAO;AAAA,IACL,WAAW;AAAA,IACX,WAAW;AAAA,IACX,UAAU,GAAG,MAAM,eAAe,GAAG;AAAA,EACvC;AACF;;;ACvCO,IAAM,WAAW;AACjB,IAAM,cAAc;AAEpB,SAAS,SAAkB;AAChC,SAAO,OAAO,YAAY,eAAe,OAAO,QAAQ,UAAU,SAAS;AAC7E;AAGO,SAAS,QAAgB;AAC9B,QAAM,YAAa,WAAmC;AACtD,MAAI,aAAa,OAAO,UAAU,eAAe,YAAY;AAC3D,WAAO,UAAU,WAAW,EAAE,QAAQ,MAAM,EAAE;AAAA,EAChD;AACA,MAAI,MAAM;AACV,WAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AAC3B,WAAO,KAAK,MAAM,KAAK,OAAO,IAAI,EAAE,EAAE,SAAS,EAAE;AAAA,EACnD;AACA,SAAO;AACT;AAEO,SAAS,SAAiB;AAC/B,UAAO,oBAAI,KAAK,GAAE,YAAY;AAChC;AAGO,SAAS,WAAW,OAAsB;AAC/C,EAAC,OAA8C,QAAQ;AACzD;AAEO,SAAS,MAAM,IAA2B;AAC/C,SAAO,IAAI,QAAQ,aAAW;AAC5B,UAAM,QAAQ,WAAW,SAAS,EAAE;AACpC,eAAW,KAAK;AAAA,EAClB,CAAC;AACH;AAQA,IAAM,SAAS;AAER,SAAS,WAAW,SAAkB,SAAiB,QAAgB;AAC5E,SAAO;AAAA,IACL,OAAO,IAAI,SAAS,WAAW,QAAQ,MAAM,QAAQ,GAAG,IAAI;AAAA,IAC5D,MAAM,IAAI,SAAS,WAAW,QAAQ,KAAK,QAAQ,GAAG,IAAI;AAAA,IAC1D,OAAO,IAAI,SAAS,QAAQ,MAAM,QAAQ,GAAG,IAAI;AAAA,EACnD;AACF;","names":[]}