@signalcore/ui 0.1.0 → 1.0.0-beta.1

package/src/es.ts

@@ -0,0 +1,423 @@
+/**
+ * The package's words in Spanish, for the people an agent serves: the chat, the browser it drives,
+ * the kit's controls (with an automation's and its runs'), a call and the agent's space. English
+ * is every component's default; a host in Spanish passes these as `messages`, the calendar's
+ * language as `locale` (`import { es } from "@signalcore/ui/locale"`).
+ */
+import type { ChatMessages } from "./AgentChat";
+import type { SpaceMessages } from "./AgentSpace";
+import type { TaskMessages } from "./AgentTasks";
+import type { AutomationMessages, DayRef } from "./automation/messages";
+import type { BrowserMessages } from "./BrowserView";
+import type { KitMessages } from "./kit/messages";
+import type { VoiceCallMessages } from "./VoiceCall";
+
+/** The article before a time: "la 1:00", "las 8:00". */
+const at = (time: string): string => `a ${time.startsWith("1:") ? "la" : "las"} ${time}`;
+
+const list = (items: readonly string[]): string => new Intl.ListFormat("es").format(items);
+
+/** A weekday as the plural says it: "los lunes", "los sábados". */
+const days = (name: string): string => (name.endsWith("s") ? name : `${name}s`);
+
+const capital = (text: string): string => text.charAt(0).toUpperCase() + text.slice(1);
+
+/** A day said after "próxima": "hoy", "mañana", "el lunes", "el 3 nov". */
+function nextDay(day: DayRef): string {
+  switch (day.kind) {
+    case "today":
+      return "hoy";
+    case "tomorrow":
+      return "mañana";
+    case "yesterday":
+      return "";
+    default:
+      return `el ${day.name}`;
+  }
+}
+
+/** A message sent on a channel, by the channel's kind: "un WhatsApp", "un SMS". */
+const SENT: Readonly<Record<string, string>> = {
+  whatsapp: "un WhatsApp",
+  instagram: "un mensaje de Instagram",
+  sms: "un SMS",
+};
+
+/** What an automation's tool call did, by what the tool's name says, done or (a test) not. */
+const TOOL = {
+  search: [(app: string) => `Buscó en ${app}`, (app: string) => `Buscó en ${app}`],
+  send: [(app: string) => `Envió por ${app}`, (app: string) => `Habría enviado por ${app}`],
+  create: [(app: string) => `Creó en ${app}`, (app: string) => `Habría creado en ${app}`],
+  update: [(app: string) => `Cambió en ${app}`, (app: string) => `Habría cambiado en ${app}`],
+  remove: [(app: string) => `Borró en ${app}`, (app: string) => `Habría borrado en ${app}`],
+  use: [(app: string) => `Usó ${app}`, (app: string) => `Habría usado ${app}`],
+} as const;
+
+export const AUTOMATION_MESSAGES_ES: AutomationMessages = {
+  daily: "Cada día",
+  weekdays: "Cada día laborable",
+  weekends: "Los fines de semana",
+  weekly: (names) =>
+    names.length === 1 ? `Cada ${names[0] ?? ""}` : `Los ${list(names.map(days))}`,
+  monthly: (numbers) =>
+    numbers.length === 1
+      ? `El día ${numbers[0] ?? ""} de cada mes`
+      : `Los días ${list(numbers.map(String))} de cada mes`,
+  at: (times) => list(times.map(at)),
+  every: (count, unit) =>
+    unit === "minute"
+      ? count === 1
+        ? "Cada minuto"
+        : `Cada ${count} minutos`
+      : count === 1
+        ? "Cada hora"
+        : `Cada ${count} horas`,
+  between: (from, to) => `de ${from} a ${to}`,
+  on: (often, when) => `${often}, ${when.charAt(0).toLowerCase()}${when.slice(1)}`,
+  custom: "Con un horario propio",
+  webhook: "Cuando otro sistema la llama",
+  event: (app, event) =>
+    event
+      ? `Cuando pasa «${event}» en ${app ?? "una app"}`
+      : `Cuando pasa algo en ${app ?? "una app"}`,
+  next: (day, time) =>
+    ["próxima", nextDay(day), time === null ? "" : at(time)].filter(Boolean).join(" "),
+  states: { active: "Activa", paused: "En pausa", failing: "Falló la última" },
+  switchLabel: "Activa",
+  steps: "Pasos",
+  runs: "Ejecuciones",
+  noRuns: "Aún no se ha ejecutado.",
+  uses: {
+    ai: "IA",
+    agent: "Agente",
+    notify: "Aviso",
+    send: "Mensaje",
+    data: "Tabla",
+    http: "Web",
+  },
+  more: (count) => `+${count}`,
+  gone: "Esta automatización ya no existe.",
+  moment: (day, time) => {
+    switch (day.kind) {
+      case "today":
+        return `Hoy ${time}`;
+      case "yesterday":
+        return `Ayer ${time}`;
+      case "tomorrow":
+        return `Mañana ${time}`;
+      default:
+        return `${capital(day.name)} ${time}`;
+    }
+  },
+  by: (by, app) =>
+    ({
+      schedule: "horario",
+      webhook: "webhook",
+      event: app ? `evento de ${app}` : "evento",
+      agent: "se lo pidieron en el chat",
+      test: "prueba",
+    })[by],
+  statuses: {
+    running: "En curso",
+    waiting: "Esperando",
+    done: "Hecha",
+    failed: "Falló",
+    skipped: "Omitida",
+  },
+  dry: (summary) => `Prueba: ${summary}`,
+  took: (ms) => {
+    if (ms < 1000) return "menos de 1 s";
+    const seconds = Math.round(ms / 1000);
+    return seconds < 60 ? `${seconds} s` : `${Math.floor(seconds / 60)} min ${seconds % 60} s`;
+  },
+  opened: "Conversaciones que abrió",
+  conversation: (index) => `Conversación ${index}`,
+  askedIn: "La conversación donde se lo pidieron",
+  noCalls: "No llegó a hacer nada.",
+  outside: "Fuera de los pasos",
+  times: (count) => `×${count}`,
+  calls: {
+    tool: (verb, app, would) => TOOL[verb][would ? 1 : 0](app),
+    ai: "Usó la IA",
+    notify: (would) => (would ? "Habría avisado en la bandeja" : "Avisó en la bandeja"),
+    send: (channel, to, would) => {
+      const sent = `${SENT[channel ?? ""] ?? "un mensaje"} a ${to || "un contacto"}`;
+      return would ? `Habría enviado ${sent}` : `Envió ${sent}`;
+    },
+    start: (would) => (would ? "Habría abierto una conversación" : "Abrió una conversación"),
+    find: (table) => `Consultó ${table}`,
+    add: (table, would) =>
+      would ? `Habría añadido una fila a ${table}` : `Añadió una fila a ${table}`,
+    change: (table, would) =>
+      would ? `Habría cambiado una fila de ${table}` : `Cambió una fila de ${table}`,
+    http: (host, would) => (would ? `Habría llamado a ${host}` : `Llamó a ${host}`),
+    files: "Buscó en los archivos",
+    read: (file) => `Leyó ${file}`,
+    wrote: (file, would) => (would ? `Habría guardado ${file}` : `Guardó ${file}`),
+    listed: "Miró sus archivos",
+    remember: (would) => (would ? "Habría guardado un recuerdo" : "Guardó un recuerdo"),
+    recall: "Buscó en lo aprendido",
+  },
+};
+
+const FAMILIES: Readonly<Record<string, string>> = {
+  image: "imágenes",
+  video: "vídeos",
+  audio: "audios",
+  text: "textos",
+};
+
+export const KIT_MESSAGES_ES: KitMessages = {
+  required: "Este campo es obligatorio",
+  chooseDate: "Elige un día",
+  chooseTime: "Elige una hora",
+  chooseMoment: "Elige día y hora",
+  chooseOption: "Elige una opción",
+  other: "Otra respuesta",
+  otherPlaceholder: "Escribe tu respuesta",
+  chooseRating: "Elige una puntuación",
+  check: "Marca la casilla para seguir",
+  invalidEmail: "Correo no válido",
+  invalidPhone: "Teléfono no válido",
+  invalidUrl: "Dirección no válida",
+  invalidNumber: "Escribe un número",
+  invalidTime: "Escribe la hora así: 9:30",
+  atLeast: (min) => `Como mínimo ${min}`,
+  atMost: (max) => `Como máximo ${max}`,
+  unavailableDate: "Ese día no está disponible",
+  unavailableTime: "Esa hora no está disponible",
+  optional: "Opcional",
+  pick: "Elige…",
+  search: "Buscar…",
+  noResults: "Sin resultados",
+  show: "Mostrar",
+  hide: "Ocultar",
+  increase: "Sumar",
+  decrease: "Restar",
+  remove: (label) => `Quitar ${label}`,
+  yes: "Sí",
+  no: "No",
+  rated: (value, max) => `${value} de ${max}`,
+  stars: (count) => (count === 1 ? "1 estrella" : `${count} estrellas`),
+  send: "Enviar",
+  sent: "Enviado",
+  chooseFile: "Falta el archivo",
+  upload: (multiple) => (multiple ? "Sube archivos" : "Sube un archivo"),
+  drop: "Suelta aquí o elige",
+  limits: (kinds, size) => (kinds ? `${kinds}, hasta ${size}` : `Hasta ${size}`),
+  anyOf: (family) => FAMILIES[family] ?? family,
+  uploading: "Subiendo",
+  tooBig: (size) => `Pasa de ${size}`,
+  wrongType: "Aquí no vale este tipo de archivo",
+  tooMany: (max) => `Como máximo ${max} archivos`,
+  uploadFailed: "No se ha podido subir",
+  retry: "Reintentar",
+  stillUploading: "Espera a que termine de subir",
+  fixFiles: "Quita o reintenta los archivos con error",
+  open: (name) => `Abrir ${name}`,
+  file: "Archivo",
+  play: "Reproducir",
+  pause: "Pausar",
+  position: "Posición",
+  automation: AUTOMATION_MESSAGES_ES,
+};
+
+export const BROWSER_MESSAGES_ES: BrowserMessages = {
+  agent: (name) => `Lo controla ${name}`,
+  agentMine: (name) => `${name}, en tu Chrome`,
+  person: "Lo controlas tú",
+  take: "Tomar el control",
+  giveBack: "Devolver",
+  handedOver: (name) => `${name} te pasa el navegador`,
+  done: "Listo, sigue",
+  closed: "El navegador se cerró mientras te esperaba.",
+  close: "Cerrar el navegador",
+  expand: "Ampliar",
+  shrink: "Reducir",
+  blank: "Página en blanco",
+  screen: (where) => `Navegador: ${where}`,
+};
+
+export const CHAT_MESSAGES_ES: ChatMessages = {
+  placeholder: (name) => `Escribe a ${name}…`,
+  connecting: "Conectando…",
+  awaiting: "Responde arriba para seguir…",
+  thinking: (name) => `${name} está pensando`,
+  typing: "Escribiendo",
+  working: "Trabajando",
+  writing: "Escribiendo",
+  elapsed: (seconds) => `${seconds} s`,
+  escape: "esc para detener",
+  done: (seconds) =>
+    `Listo en ${seconds < 60 ? `${seconds} s` : `${Math.floor(seconds / 60)} min ${seconds % 60} s`}`,
+  empty: (name) => `Habla con ${name}`,
+  intro: () => "",
+  send: "Enviar",
+  attach: "Adjuntar archivos",
+  drop: "Suelta para adjuntar",
+  dictate: "Dictar",
+  dictateStop: "Parar y escribirlo",
+  dictation: {
+    listening: "Escuchando…",
+    writing: "Escribiéndolo…",
+    failed: "No te he oído: permite el micrófono e inténtalo otra vez",
+  },
+  stop: "Detener",
+  log: "Conversación",
+  steps: {
+    show: "Muestra",
+    ask_person: "Pregunta",
+    search_files: "Busca en archivos",
+    read_file: "Lee un archivo",
+    keep_file: "Guarda un archivo",
+    remember: "Recuerda",
+    recall: "Busca en lo aprendido",
+    escalate: "Pasa a una persona",
+    notify: "Avisa",
+    data_find: "Consulta una tabla",
+    data_add: "Añade una fila",
+    data_update: "Cambia una fila",
+    browser_open: "Abre una página",
+    browser_read: "Lee la página",
+    browser_click: "Hace clic",
+    browser_fill: "Rellena un campo",
+    browser_scroll: "Desplaza la página",
+    browser_back: "Vuelve atrás",
+    browser_submit: "Envía en la web",
+    browser_hand_over: "Te pasa el navegador",
+    browser_attach: "Sube un archivo a la web",
+    browser_download: "Guarda un archivo de la web",
+    browser_screenshot: "Hace una captura de la web",
+    browser_record: "Graba la web en vídeo",
+    browser_fill_key: "Escribe una clave en la web",
+    ask_builder: "Se lo pide al builder",
+    send_message: "Envía un mensaje",
+    voice_note: "Manda una nota de voz",
+    ai: "Usa la IA",
+    call: "Llama",
+  },
+  failed: "falló",
+  approval: "Necesita tu aprobación",
+  request: (name, action) => `${name} quiere hacer «${action}»`,
+  inputs: {},
+  allow: "Aprobar",
+  decline: "Rechazar",
+  confirming: "Esperando la confirmación del negocio",
+  handedOff: "Pasada a una persona",
+  handover: (holder, by, name) => {
+    const automation = by.kind === "automation" ? ` por «${by.title}»` : "";
+    switch (holder) {
+      case "agent":
+        if (by.kind === "owner") return `Devolviste la conversación a ${name}`;
+        return `Se devolvió a ${name}${automation}`;
+      case "person":
+        if (by.kind === "owner") return `Pausaste a ${name}`;
+        if (by.kind === "agent") return `${name} la pasó a una persona`;
+        return `Pasó a una persona${automation}`;
+      case "nobody":
+        return `Ignorada${automation}`;
+    }
+  },
+  skipped: "No respondió",
+  cut: (heard) =>
+    heard === "" ? "Interrumpida antes de que se oyera nada" : `Interrumpida tras «${heard}»`,
+  write: "Responde como el negocio…",
+  business: "Tú",
+  voiceNote: "Nota de voz",
+  delivery: {
+    queued: "Esperando para salir",
+    sent: "Enviado",
+    delivered: "Entregado",
+    read: "Leído",
+    failed: "No entregado",
+  },
+  undelivered: (error) => (error ? `No entregado: ${error}` : "No entregado"),
+  noTool: "Esta página no puede hacer eso",
+  kit: KIT_MESSAGES_ES,
+  browser: BROWSER_MESSAGES_ES,
+};
+
+export const VOICE_CALL_MESSAGES_ES: VoiceCallMessages = {
+  call: (name) => `Llamada con ${name}`,
+  states: {
+    connecting: "Conectando…",
+    listening: "Escuchando",
+    thinking: "Pensando",
+    speaking: "Hablando",
+    reconnecting: "Reconectando…",
+    ended: "Llamada terminada",
+  },
+  calling: (name) => `Llamando a ${name}`,
+  ended: {
+    person: () => "Has colgado",
+    agent: (name) => `${name} ha colgado`,
+    limit: () => "Se alcanzó la duración máxima",
+    dropped: () => "Se cortó la llamada",
+  },
+  problems: {
+    denied: {
+      title: () => "Sin permiso para el micrófono",
+      help: "Permite el micrófono a esta página (en el icono junto a la dirección) y vuelve a llamar.",
+    },
+    nomic: {
+      title: () => "No hay ningún micrófono",
+      help: "Conecta uno, o elige otro en los ajustes de sonido del sistema, y vuelve a llamar.",
+    },
+    inuse: {
+      title: () => "El micrófono está ocupado",
+      help: "Otra aplicación lo está usando. Ciérrala y vuelve a llamar.",
+    },
+    unsupported: {
+      title: () => "Este navegador no puede llamar",
+      help: "Abre la página por https en un Chrome, Edge, Safari o Firefox actual.",
+    },
+    off: {
+      title: () => "Las llamadas no están activadas",
+      help: "Este servicio aún no atiende llamadas. Escríbele mientras tanto.",
+    },
+    builder: {
+      title: (name) => `${name} no atiende llamadas`,
+      help: "Escríbele en el chat.",
+    },
+    refused: {
+      title: (name) => `${name} no puede atender la llamada`,
+      help: "Inténtalo de nuevo en un momento.",
+    },
+    failed: {
+      title: (name) => `No se ha podido llamar a ${name}`,
+      help: "Comprueba tu conexión y vuelve a intentarlo.",
+    },
+    unanswered: {
+      title: (name) => `${name} no contesta`,
+      help: "Ahora mismo no atiende llamadas. Inténtalo de nuevo en un momento.",
+    },
+  },
+  mute: "Silenciar",
+  hangUp: "Colgar",
+  keys: "Espacio silencia y activa el micrófono",
+  muted: "Tu micrófono está silenciado",
+  hear: (name) => `Oír a ${name}`,
+};
+
+export const TASK_MESSAGES_ES: TaskMessages = {
+  open: (count) =>
+    count === 1 ? "Tienes 1 tarea programada" : `Tienes ${count} tareas programadas`,
+  title: "Tus tareas",
+  back: "Volver a la conversación",
+  remove: "Quitar",
+  empty: "No hay nada programado. Pídele que te recuerde algo, o que te escriba más adelante.",
+  failed: "No se ha podido cambiar. Inténtalo de nuevo.",
+};
+
+export const SPACE_MESSAGES_ES: SpaceMessages = {
+  modes: { label: "Modo", text: "Texto", voice: "Voz" },
+  again: "Volver a llamar",
+  close: "Cerrar",
+  agent: "Agente",
+  opening: "Abriendo la conversación…",
+  failed: "No se ha podido abrir la conversación.",
+  retry: "Reintentar",
+  chat: CHAT_MESSAGES_ES,
+  voice: VOICE_CALL_MESSAGES_ES,
+  tasks: TASK_MESSAGES_ES,
+};

package/src/files.ts

@@ -0,0 +1,238 @@
+/**
+ * How a file is shown before it is saved, read from its name first (the owner named it, and a
+ * browser often gives no type) and from its type when the name says nothing.
+ */
+
+/**
+ * Words with headings (Markdown), plain words, a source read in the mono face (JSON, YAML, a
+ * page's HTML: shown as written, never run), rows of cells (CSV), a PDF, a picture, or nothing.
+ */
+export type Preview = "markdown" | "text" | "code" | "table" | "pdf" | "image" | "none";
+
+const BY_EXTENSION: Readonly<Record<string, Preview>> = {
+  md: "markdown",
+  markdown: "markdown",
+  txt: "text",
+  log: "text",
+  json: "code",
+  yaml: "code",
+  yml: "code",
+  xml: "code",
+  html: "code",
+  htm: "code",
+  css: "code",
+  js: "code",
+  ts: "code",
+  py: "code",
+  sql: "code",
+  toml: "code",
+  ini: "code",
+  csv: "table",
+  tsv: "table",
+  pdf: "pdf",
+  png: "image",
+  jpg: "image",
+  jpeg: "image",
+  gif: "image",
+  webp: "image",
+  avif: "image",
+  bmp: "image",
+  svg: "image",
+};
+
+/** The type a browser needs to draw a PDF or a picture, by extension. */
+const MEDIA: Readonly<Record<string, string>> = {
+  pdf: "application/pdf",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  bmp: "image/bmp",
+  svg: "image/svg+xml",
+};
+
+/** A name's extension, lowercase; "" for one without (`README`, `.env`). */
+export function extensionOf(name: string): string {
+  const base = baseName(name);
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? "" : base.slice(dot + 1).toLowerCase();
+}
+
+/** The last name of a path: what a file is saved as. */
+export const baseName = (path: string): string => path.slice(path.lastIndexOf("/") + 1);
+
+function byType(type: string): Preview {
+  const media = type.split(";")[0]?.trim().toLowerCase() ?? "";
+  if (media === "text/markdown") return "markdown";
+  if (media === "text/csv" || media === "text/tab-separated-values") return "table";
+  if (media === "text/html" || /^application\/(json|xml|x-yaml|yaml)$/.test(media)) return "code";
+  if (media.startsWith("text/")) return "text";
+  if (media === "application/pdf") return "pdf";
+  if (Object.values(MEDIA).includes(media)) return "image";
+  return "none";
+}
+
+/** How a file of this name and type is shown. */
+export function previewOf(name: string, type: string): Preview {
+  return BY_EXTENSION[extensionOf(name)] ?? byType(type);
+}
+
+/**
+ * The bytes typed as a browser must have them to draw them (a PDF, a picture), whatever type
+ * they came with: one uploaded without a type is kept as plain bytes.
+ */
+export function typedFor(blob: Blob, name: string): Blob {
+  const type = MEDIA[extensionOf(name)];
+  return type === undefined || blob.type === type ? blob : new Blob([blob], { type });
+}
+
+/** JSON laid out two spaces deep; anything that is not JSON as it was. */
+export function pretty(text: string): string {
+  try {
+    return JSON.stringify(JSON.parse(text), null, 2);
+  } catch {
+    return text;
+  }
+}
+
+const SEPARATORS = [",", ";", "\t"] as const;
+
+/**
+ * A CSV (or TSV) as rows of cells, when it is simple enough to draw as a table: one separator,
+ * the commonest of comma, semicolon and tab on the first line; quoted cells kept whole (quotes
+ * doubled inside, line breaks too); every row as wide as the first, and that at least two. Null
+ * otherwise, and it is shown as written.
+ */
+export function tableOf(text: string): string[][] | null {
+  const body = text.replace(/^/, "").replace(/\r\n?/g, "\n").replace(/\n+$/, "");
+  const first = body.split("\n", 1)[0] ?? "";
+  const separator = SEPARATORS.reduce((best, each) =>
+    first.split(each).length > first.split(best).length ? each : best,
+  );
+  if (!first.includes(separator)) return null;
+  const rows = cellsOf(body, separator);
+  const width = rows[0]?.length ?? 0;
+  return width >= 2 && rows.every((row) => row.length === width) ? rows : null;
+}
+
+function cellsOf(text: string, separator: string): string[][] {
+  const rows: string[][] = [];
+  let row: string[] = [];
+  let cell = "";
+  let quoted = false;
+  for (let at = 0; at < text.length; at += 1) {
+    const char = text.charAt(at);
+    if (quoted) {
+      if (char !== '"') cell += char;
+      else if (text.charAt(at + 1) === '"') {
+        cell += '"';
+        at += 1;
+      } else quoted = false;
+    } else if (char === '"' && cell === "") {
+      quoted = true;
+    } else if (char === separator || char === "\n") {
+      row.push(cell);
+      cell = "";
+      if (char === "\n") {
+        rows.push(row);
+        row = [];
+      }
+    } else {
+      cell += char;
+    }
+  }
+  row.push(cell);
+  rows.push(row);
+  return rows;
+}
+
+/** The tags a Word file's HTML keeps, as the API keeps them (`preview.TAGS`). */
+const DOCUMENT_TAGS: ReadonlySet<string> = new Set([
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "p",
+  "br",
+  "hr",
+  "blockquote",
+  "pre",
+  "code",
+  "ul",
+  "ol",
+  "li",
+  "table",
+  "thead",
+  "tbody",
+  "tr",
+  "th",
+  "td",
+  "strong",
+  "b",
+  "em",
+  "i",
+  "u",
+  "s",
+  "sub",
+  "sup",
+  "img",
+]);
+
+/** What goes with everything it holds; any other tag not kept goes and leaves its words. */
+const DROPPED: ReadonlySet<string> = new Set([
+  "script",
+  "style",
+  "template",
+  "iframe",
+  "object",
+  "embed",
+  "noscript",
+  "svg",
+  "math",
+  "link",
+  "meta",
+  "title",
+]);
+
+/** A picture inline, as the only address a document may hold. */
+const PICTURE = /^data:image\/(?:png|jpe?g|gif|webp|bmp);base64,/i;
+
+/** Whether an element keeps an attribute: a picture its data address and words, a cell its span. */
+function keeps(tag: string, name: string, value: string): boolean {
+  if (tag === "img") return name === "alt" || (name === "src" && PICTURE.test(value));
+  return (tag === "td" || tag === "th") && (name === "colspan" || name === "rowspan");
+}
+
+/**
+ * A Word file's HTML (a `document` preview) kept again, here, to what a viewer draws: the API
+ * cleans it, and what the page puts in itself it checks itself. Its tags and attributes the
+ * API's allow-list, scripts and styles gone with what they hold, any other tag gone and its words
+ * kept, a picture only by a data address.
+ */
+export function cleanDocument(html: string): string {
+  const body = new DOMParser().parseFromString(html, "text/html").body;
+  const clean = (parent: Element) => {
+    for (const child of [...parent.children]) {
+      const tag = child.tagName.toLowerCase();
+      if (DROPPED.has(tag)) {
+        child.remove();
+        continue;
+      }
+      clean(child);
+      if (!DOCUMENT_TAGS.has(tag)) {
+        child.replaceWith(...child.childNodes);
+        continue;
+      }
+      for (const { name, value } of [...child.attributes]) {
+        if (!keeps(tag, name.toLowerCase(), value)) child.removeAttribute(name);
+      }
+      if (tag === "img" && !child.hasAttribute("src")) child.remove();
+    }
+  };
+  clean(body);
+  return body.innerHTML;
+}