@getparallel/parx 0.5.0 → 0.6.0

package/dist/estimacion.js

@@ -0,0 +1,118 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { carpetaDeConfiguracion } from "./config.js";
+import { MODELOS, ORDEN_DE_MODELOS, nombreDeModelo } from "./modelos.js";
+import { t } from "./textos.js";
+export const PERFILES = {
+    pregunta: { vueltas: 2, crecimiento: 700, salidaPorVuelta: 80, salidaFinal: 350 },
+    pequena: { vueltas: 4, crecimiento: 900, salidaPorVuelta: 350, salidaFinal: 200 },
+    media: { vueltas: 8, crecimiento: 1200, salidaPorVuelta: 550, salidaFinal: 250 },
+    grande: { vueltas: 16, crecimiento: 1500, salidaPorVuelta: 650, salidaFinal: 350 },
+};
+const GRANDE = /\b(refactor|refactoriz|migrat|migra[r]?\b|rewrite|reescrib|rework|whole (project|app|codebase|repo)|entire|todo el (proyecto|código|repo)|toda la (app|aplicación)|all (the )?files|todos los ficheros|architecture|arquitectura|from scratch|desde cero|full[- ]stack|authentication|autenticaci|database|base de datos|deploy|despliega|integrat|integra[r]?\b|test suite|end[- ]to[- ]end|e2e|multi[- ]?page|varias páginas|dashboard|backend|api rest|microservic)/i;
+const CREA = /\b(create|build|make|write|generate|implement|crea[r]?|construye|monta|escribe|genera|implementa|haz(me)?|new|nuev[oa])\b/i;
+const SUSTANCIAL = /\b(page|página|pagina|website|web ?site|site|web|app|form|formulario|component|componente|feature|funcionalidad|endpoint|screen|pantalla|module|módulo|modulo|api|script|server|servidor|service|servicio|table|tabla|model|modelo|view|vista)\b/i;
+const PEQUENA = /\b(typo|errata|rename|renombra|one[- ]line|una línea|small|pequeñ|minor|mínim|quick|rápid|simple|sencill|tiny|just|solo|sólo|only|fix the|arregla el|arregla la|change the|cambia el|cambia la|add a |añade un|añade una|remove the|quita el|quita la|update the|actualiza el)\b/i;
+const PREGUNTA = /^(what|why|how|where|which|who|when|is|are|does|do|can|could|should|explain|describe|tell me|show me|list|qué|que|por qué|cómo|como|dónde|donde|cuál|cual|quién|quien|cuándo|explica|describe|dime|enséñame|lista|hay)\b/i;
+function palabras(s) {
+    return s.trim().split(/\s+/).filter(Boolean).length;
+}
+export function clasificarTarea(pedido) {
+    const s = pedido.replace(/\s+/g, ' ').trim();
+    const n = palabras(s);
+    if (!s)
+        return 'pequena';
+    if (GRANDE.test(s) || n > 90)
+        return 'grande';
+    const pregunta = PREGUNTA.test(s) || (s.endsWith('?') && !CREA.test(s));
+    if (pregunta && !CREA.test(s))
+        return 'pregunta';
+    const creaAlgo = CREA.test(s) || SUSTANCIAL.test(s);
+    if (n <= 10 && !creaAlgo)
+        return 'pequena';
+    if (PEQUENA.test(s) && !creaAlgo)
+        return 'pequena';
+    return 'media';
+}
+export function tokensDe(texto) {
+    const chars = typeof texto === 'number' ? texto : texto.length;
+    return Math.ceil(chars / 3.8);
+}
+export function accionesEnBruto(clase, baseTokens, tarifa) {
+    const p = PERFILES[clase];
+    let entrada = 0;
+    let salida = 0;
+    for (let i = 0; i < p.vueltas; i++) {
+        entrada += baseTokens + i * p.crecimiento;
+        salida += i === p.vueltas - 1 ? p.salidaFinal : p.salidaPorVuelta;
+    }
+    return (entrada * tarifa.entrada + salida * tarifa.salida) / 1000;
+}
+export function redondear(n) {
+    if (n < 1)
+        return 1;
+    if (n < 10)
+        return Math.round(n);
+    const magnitud = 10 ** (Math.floor(Math.log10(n)) - 1);
+    return Math.round(n / magnitud) * magnitud;
+}
+export function estimarTarea(e) {
+    const clase = clasificarTarea(e.pedido);
+    const base = tokensDe(e.contextoChars) + tokensDe(e.pedido);
+    const acciones = {};
+    for (const m of ORDEN_DE_MODELOS) {
+        const bruto = accionesEnBruto(clase, base, e.tarifas[MODELOS[m].servidor]);
+        acciones[m] = redondear(bruto * factorDeCalibracion(e.calibracion, clase, m));
+    }
+    return { clase, acciones };
+}
+export function lineaDeEstimacion(est, modelo) {
+    const actual = est.acciones[modelo];
+    let sugerido = null;
+    if (modelo === 'summit' && est.clase !== 'grande')
+        sugerido = 'stride';
+    if ((modelo === 'summit' || modelo === 'stride') && (est.clase === 'pregunta' || est.clase === 'pequena'))
+        sugerido = 'swift';
+    if (sugerido && est.acciones[sugerido] <= actual * 0.6 && actual >= 5) {
+        return t('estimacion.con', { n: actual.toLocaleString('en-US'), modelo: nombreDeModelo(sugerido).replace(/ \d+(\.\d+)?$/, ''), otro: est.acciones[sugerido].toLocaleString('en-US') });
+    }
+    return t('estimacion.linea', { n: actual.toLocaleString('en-US') });
+}
+const FICHERO = 'estimaciones.json';
+const PESO = 0.3;
+export function leerCalibracion(dir = carpetaDeConfiguracion()) {
+    try {
+        const c = JSON.parse(readFileSync(join(dir, FICHERO), 'utf8'));
+        return c && typeof c === 'object' ? c : {};
+    }
+    catch {
+        return {};
+    }
+}
+function guardarCalibracion(c, dir) {
+    try {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        writeFileSync(join(dir, FICHERO), JSON.stringify(c, null, 2), { mode: 0o600 });
+    }
+    catch {
+    }
+}
+export function factorDeCalibracion(c, clase, modelo) {
+    const f = c?.[clase]?.[modelo]?.factor;
+    if (typeof f !== 'number' || !Number.isFinite(f) || f <= 0)
+        return 1;
+    return Math.min(2, Math.max(0.5, f));
+}
+export function aprenderDeLaTarea(o) {
+    const dir = o.dir ?? carpetaDeConfiguracion();
+    const c = o.calibracion ?? leerCalibracion(dir);
+    if (!(o.estimada > 0) || !(o.real > 0))
+        return c;
+    const ratio = Math.min(4, Math.max(0.25, o.real / o.estimada));
+    const antes = c[o.clase]?.[o.modelo];
+    const factor = antes ? antes.factor * (1 - PESO) + ratio * PESO : ratio;
+    c[o.clase] = { ...(c[o.clase] ?? {}), [o.modelo]: { factor: Number(factor.toFixed(3)), n: (antes?.n ?? 0) + 1 } };
+    guardarCalibracion(c, dir);
+    return c;
+}

package/dist/firmas.js

@@ -0,0 +1,55 @@
+import { createHash, createVerify } from 'node:crypto';
+export const CLAVES_DE_NPM = [
+    {
+        keyid: 'SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U',
+        key: 'MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEY6Ya7W++7aUPzvMTrezH6Ycx3c+HOKYCcNGybJZSCJq/fd7Qa8uuAKtdIkUQtQiEKERhAmE5lMMJhP8OkDOa2g==',
+    },
+];
+const REGISTRO_DE_NPM = 'https://registry.npmjs.org';
+export function keyidDe(spkiBase64) {
+    return `SHA256:${createHash('sha256').update(Buffer.from(spkiBase64, 'base64')).digest('base64').replace(/=+$/, '')}`;
+}
+export function clavesDeConfianza(env = process.env) {
+    const claves = [...CLAVES_DE_NPM];
+    const registro = (env.PARX_REGISTRY ?? '').replace(/\/+$/, '');
+    if (registro && registro !== REGISTRO_DE_NPM && env.PARX_CLAVES_DE_FIRMA) {
+        for (const k of env.PARX_CLAVES_DE_FIRMA.split(',').map((x) => x.trim()).filter(Boolean))
+            claves.push({ keyid: keyidDe(k), key: k });
+    }
+    return claves;
+}
+export function mensajeFirmado(nombre, version, integrity) {
+    return `${nombre}@${version}:${integrity}`;
+}
+export function firmaValida(d, claves = CLAVES_DE_NPM) {
+    if (!Array.isArray(d.firmas) || !d.firmas.length)
+        return false;
+    if (!/^sha512-[A-Za-z0-9+/]+={0,2}$/.test(d.integrity))
+        return false;
+    const mensaje = mensajeFirmado(d.nombre, d.version, d.integrity);
+    for (const f of d.firmas) {
+        if (!f || typeof f !== 'object')
+            continue;
+        const { keyid, sig } = f;
+        if (typeof keyid !== 'string' || typeof sig !== 'string')
+            continue;
+        const clave = claves.find((k) => k.keyid === keyid);
+        if (!clave)
+            continue;
+        try {
+            const v = createVerify('SHA256');
+            v.update(mensaje);
+            if (v.verify(`-----BEGIN PUBLIC KEY-----\n${clave.key}\n-----END PUBLIC KEY-----`, sig, 'base64'))
+                return true;
+        }
+        catch {
+        }
+    }
+    return false;
+}
+export function integridadDe(contenido) {
+    return `sha512-${createHash('sha512').update(contenido).digest('base64')}`;
+}
+export function integridadCoincide(contenido, integrity) {
+    return integridadDe(contenido) === integrity;
+}

package/dist/marca.js

@@ -125,27 +125,64 @@ export function logo() {
     const tonos = [c.marca, c.claro, c.claro, c.violeta];
     return filas.map((f, i) => tonos[i](f));
 }
-export const ANCHO_DE_PAR = 6;
-export function cabezaDePar() {
-    return caps.unicode ? c.claro('▗▄▄▄▄▖') : c.claro(' .--. ');
+export const ANCHO_DE_PAR = 8;
+function miniPar(gesto) {
+    const ojo = gesto === 'error' ? 'R' : 'E';
+    const fila1 = ['.', '.', 'B', 'B', '.', 'B', 'B', '.'];
+    if (gesto === 'pregunta') {
+        fila1.splice(0, 8, '.', '.', ojo, ojo, '.', ojo, ojo, '.');
+    }
+    else if (gesto !== 'parpadeo') {
+        const izquierda = gesto === 1 || gesto === 2;
+        const a = izquierda ? 2 : 3;
+        fila1[a] = ojo;
+        fila1[a + 3] = ojo;
+    }
+    return [
+        ['.', '.', '.', 'B', 'B', '.', 'B', 'B'],
+        fila1,
+        ['.', 'B', 'B', '.', 'B', 'B', '.', '.'],
+        ['B', 'B', '.', 'B', 'B', '.', '.', '.'],
+    ];
 }
-export function caraDePar(gesto = 'quieto') {
-    const u = caps.unicode;
-    const ojos = gesto === 'parpadeo'
-        ? u ? ' ── ' : ' -- '
-        : gesto === 'pregunta'
-            ? u ? ' •• ' : ' oo '
-            : gesto === 'error'
-                ? u ? ' ×× ' : ' xx '
-                : typeof gesto === 'number'
-                    ?
-                        (u ? ['╱╱  ', ' ╱╱ ', '  ╱╱', ' ╱╱ '] : ['//  ', ' // ', '  //', ' // '])[gesto]
-                    : u ? ' ╱╱ ' : ' // ';
-    if (caps.color) {
-        const fondo = caps.color === 3 ? '\x1b[48;2;139;112;255m' : caps.color === 2 ? '\x1b[48;5;141m' : '\x1b[45m';
-        return `${fondo}\x1b[1;97m ${ojos} \x1b[22;39;49m`;
+const RGB_DE_PAR = { B: [139, 112, 255], E: [246, 243, 255], R: [255, 107, 107] };
+const C256_DE_PAR = { B: 141, E: 255, R: 203 };
+function filaDePar(arriba, abajo) {
+    let out = '';
+    for (let x = 0; x < ANCHO_DE_PAR; x++) {
+        const a = arriba[x];
+        const b = abajo[x];
+        if (!caps.unicode || !caps.color) {
+            const hay = a !== '.' || b !== '.';
+            const ojo = a === 'E' || a === 'R' || b === 'E' || b === 'R';
+            out += ojo ? 'o' : hay ? (caps.unicode ? '█' : '/') : ' ';
+            continue;
+        }
+        if (a === '.' && b === '.') {
+            out += ' ';
+            continue;
+        }
+        const fg = a === '.' ? null : a;
+        const bg = b === '.' ? null : b;
+        const color = (p, fondo) => caps.color === 3 ? `\x1b[${fondo ? 48 : 38};2;${RGB_DE_PAR[p].join(';')}m` : caps.color === 2 ? `\x1b[${fondo ? 48 : 38};5;${C256_DE_PAR[p]}m` : p === 'B' ? `\x1b[${fondo ? 45 : 35}m` : p === 'R' ? `\x1b[${fondo ? 41 : 31}m` : `\x1b[${fondo ? 47 : 97}m`;
+        if (fg && bg && fg === bg)
+            out += `${color(fg, false)}█\x1b[39m`;
+        else if (fg && bg)
+            out += `${color(fg, false)}${color(bg, true)}▀\x1b[39;49m`;
+        else if (fg)
+            out += `${color(fg, false)}▀\x1b[39m`;
+        else
+            out += `${color(bg, false)}▄\x1b[39m`;
     }
-    return u ? `▐${ojos}▌` : `[${ojos}]`;
+    return out;
+}
+export function cabezaDePar(gesto = 'quieto') {
+    const p = miniPar(gesto);
+    return filaDePar(p[0], p[1]);
+}
+export function caraDePar(gesto = 'quieto') {
+    const p = miniPar(gesto);
+    return filaDePar(p[2], p[3]);
 }
 export const ANCHO_DE_ANIMACION = 8;
 export function animacion(tipo, paso) {

package/dist/par.js

@@ -0,0 +1,355 @@
+export const LADO = 16;
+export const TONOS = {
+    300: { cuerpo: '#ae9bff', sombra: '#8b70ff', detalle: '#ddd3ff' },
+    400: { cuerpo: '#8b70ff', sombra: '#6d4aff', detalle: '#ae9bff' },
+    500: { cuerpo: '#7b5cff', sombra: '#5a36e6', detalle: '#ae9bff' },
+    600: { cuerpo: '#6d4aff', sombra: '#5a36e6', detalle: '#ae9bff' },
+    700: { cuerpo: '#5a36e6', sombra: '#4626ba', detalle: '#8b70ff' },
+};
+export const ORDEN_DE_TONOS = [600, 400, 700, 500, 300];
+export const TINTA = '#15131f';
+export const CLARO = '#d3cde8';
+export const ORO = '#f2b632';
+function huella(s) {
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+export function tonoDe(semilla) {
+    if (!semilla)
+        return 600;
+    return ORDEN_DE_TONOS[huella(semilla) % ORDEN_DE_TONOS.length];
+}
+export function tonosDelEquipo(semillas) {
+    const usados = new Set();
+    return semillas.map((s) => {
+        let t = tonoDe(s);
+        if (usados.size < ORDEN_DE_TONOS.length) {
+            let i = ORDEN_DE_TONOS.indexOf(t);
+            while (usados.has(t)) {
+                i = (i + 1) % ORDEN_DE_TONOS.length;
+                t = ORDEN_DE_TONOS[i];
+            }
+        }
+        usados.add(t);
+        return t;
+    });
+}
+export function colorDe(c, tono) {
+    const t = TONOS[tono];
+    switch (c) {
+        case 'B':
+            return t.cuerpo;
+        case 'D':
+            return t.sombra;
+        case 'A':
+            return t.detalle;
+        case 'E':
+            return TINTA;
+        case 'W':
+            return CLARO;
+        case 'Y':
+            return ORO;
+        default:
+            return null;
+    }
+}
+const INICIO = [7, 11];
+const ARRIBA = 2;
+const FILAS = 12;
+const FILA_OJO = ARRIBA + 3;
+function pon(m, x, y, c) {
+    if (x >= 0 && x < LADO && y >= 0 && y < LADO)
+        m[y][x] = c;
+}
+export function matrizDe(c, accesorio) {
+    const m = Array.from({ length: LADO }, () => Array(LADO).fill('.'));
+    const ojos = Array.isArray(c.ojos) ? c.ojos : [c.ojos ?? 'abierto', c.ojos ?? 'abierto'];
+    [c.izq, c.der].forEach((b, k) => {
+        const dx = b?.dx ?? 0;
+        const dy = b?.dy ?? 0;
+        const estira = b?.estira ?? 0;
+        const inicio = INICIO[k];
+        const xDe = (y) => inicio - Math.floor((y - ARRIBA) / 2) + dx;
+        for (let y = ARRIBA - estira; y <= ARRIBA + FILAS; y++) {
+            const color = y === ARRIBA + FILAS ? 'D' : 'B';
+            for (let i = 0; i < 3; i++)
+                pon(m, xDe(y) + i, y + dy, color);
+        }
+        const filaOjo = FILA_OJO - estira;
+        const fy = filaOjo + dy;
+        const cx = xDe(filaOjo) + 1;
+        const ojo = ojos[k];
+        switch (ojo) {
+            case 'abierto':
+                pon(m, cx, fy, 'E');
+                break;
+            case 'cerrado':
+                pon(m, cx - 1, fy, 'D');
+                pon(m, cx, fy, 'D');
+                pon(m, cx + 1, fy, 'D');
+                break;
+            case 'feliz':
+                pon(m, cx, fy - 1, 'E');
+                pon(m, cx - 1, fy, 'E');
+                pon(m, cx + 1, fy, 'E');
+                break;
+            case 'grande':
+                pon(m, cx, fy - 1, 'E');
+                pon(m, cx, fy, 'E');
+                break;
+            case 'x':
+                pon(m, cx - 1, fy - 1, 'E');
+                pon(m, cx + 1, fy - 1, 'E');
+                pon(m, cx, fy, 'E');
+                pon(m, cx - 1, fy + 1, 'E');
+                pon(m, cx + 1, fy + 1, 'E');
+                break;
+            case 'abajo':
+                pon(m, cx, fy + 1, 'E');
+                break;
+            case 'arriba':
+                pon(m, cx, fy - 1, 'E');
+                break;
+            case 'izquierda':
+                pon(m, cx - 1, fy, 'E');
+                break;
+            case 'derecha':
+                pon(m, cx + 1, fy, 'E');
+                break;
+        }
+    });
+    if (accesorio) {
+        for (const [x, y, ch] of PIEZAS[accesorio]) {
+            const b = x <= 9 ? c.izq : c.der;
+            pon(m, x + (b?.dx ?? 0), y + (b?.dy ?? 0) - (b?.estira ?? 0), ch);
+        }
+    }
+    for (const p of c.extra ?? [])
+        pon(m, p[0], p[1], p[2] ?? 'A');
+    return m.map((f) => f.join(''));
+}
+const FILAS_DE_ACCESORIOS = {
+    gorra: { 0: '...........DDD..', 1: '...........DDDDD' },
+    copa: { 0: '.......EAE......', 1: '......EEEEE.....' },
+    astronauta: { 0: '........WWWWW...', 1: '......WW.....WW.', 2: '......W.......W.', 3: '......W.......W.' },
+    corona: { 0: '...........Y.Y..', 1: '...........YYY..' },
+    gafas_sol: { 4: '......WEE.WEE...', 5: '......EEEEEEE...' },
+    gafas: { 4: '......YYY.YYY...', 5: '......Y.YYY.Y...', 6: '......YYY.YYY...' },
+    bigote: { 7: '.......EEE......' },
+    pajarita: { 9: '.....EEAEE......' },
+    idea: { 0: '.......YYY......', 1: '......A.Y.A.....' },
+    gato: { 0: '...........B.B..', 1: '...........BBB..' },
+    fiesta: { 0: '........Y.......', 1: '.......YEY......' },
+    auriculares: { 0: '............E...', 1: '...........E.E..', 3: '..........E....E', 4: '..........E....E' },
+    cocinero: { 0: '......WWWWW.....', 1: '.......WWW......' },
+    pirata: { 4: '......EEE.......', 5: '......EEE.......' },
+    bufanda: { 10: '...YYY.YYY......', 11: '........YY......' },
+    antena: { 0: '............Y...', 1: '............D...' },
+    sombrilla: { 0: '.......DDD......', 1: '......DDDDD.....' },
+    nube: { 0: '.......WW.......', 1: '......WWWW......', 2: '.....A..........', 3: '....A...........', 4: '.....A..........' },
+    halo: { 0: '.......YYY......' },
+    pelo: { 0: '......B.B.B.....', 1: '......BBBBB.....' },
+};
+export const LISTA_DE_ACCESORIOS = Object.keys(FILAS_DE_ACCESORIOS);
+const PIEZAS = Object.fromEntries(LISTA_DE_ACCESORIOS.map((id) => [
+    id,
+    Object.entries(FILAS_DE_ACCESORIOS[id]).flatMap(([y, fila]) => [...fila].flatMap((ch, x) => (ch === '.' ? [] : [[x, Number(y), ch]]))),
+]));
+export function accesorioDe(semilla) {
+    if (!semilla)
+        return null;
+    return LISTA_DE_ACCESORIOS[huella(`${semilla}·accesorio`) % LISTA_DE_ACCESORIOS.length];
+}
+export function accesoriosDelEquipo(semillas) {
+    const usados = new Set();
+    return semillas.map((s) => {
+        let a = accesorioDe(s || 'parallel');
+        if (usados.size < LISTA_DE_ACCESORIOS.length) {
+            let i = LISTA_DE_ACCESORIOS.indexOf(a);
+            while (usados.has(a)) {
+                i = (i + 1) % LISTA_DE_ACCESORIOS.length;
+                a = LISTA_DE_ACCESORIOS[i];
+            }
+        }
+        usados.add(a);
+        return a;
+    });
+}
+const P = (puntos, dx = 0, dy = 0, c = 'A') => puntos.map(([x, y]) => [x + dx, y + dy, c]);
+const INTERROGACION = [[1, 0], [2, 0], [3, 1], [2, 2], [2, 4]];
+const EXCLAMACION = [[2, 0], [2, 1], [2, 2], [2, 4]];
+const TIC = [[0, 2], [1, 3], [2, 2], [3, 1], [4, 0]];
+const CORAZON = [[1, 0], [3, 0], [0, 1], [1, 1], [2, 1], [3, 1], [4, 1], [1, 2], [2, 2], [3, 2], [2, 3]];
+const ZETA = [[0, 0], [1, 0], [2, 0], [1, 1], [0, 2], [1, 2], [2, 2]];
+const NOTA = [[1, 0], [2, 0], [1, 1], [1, 2], [0, 3], [1, 3]];
+export const ANIMACIONES = {
+    reposo: [{ ms: 1500 }, { ojos: 'cerrado', ms: 120 }, { ms: 1800 }, { ojos: 'derecha', ms: 700 }, { ms: 500 }, { izq: { dy: 1 }, der: { dy: 1 }, ms: 400 }, { ms: 900 }],
+    saludo: [
+        { ojos: 'feliz', ms: 200 },
+        { ojos: 'feliz', der: { dx: 1, dy: -1 }, ms: 180 },
+        { ojos: 'feliz', ms: 180 },
+        { ojos: 'feliz', der: { dx: 1, dy: -1 }, ms: 180 },
+        { ojos: 'feliz', ms: 600 },
+    ],
+    pensando: [
+        { ojos: 'arriba', ms: 350 },
+        { ojos: 'arriba', extra: P([[2, 1]]), ms: 350 },
+        { ojos: 'arriba', extra: P([[2, 1], [4, 1]]), ms: 350 },
+        { ojos: 'arriba', extra: P([[2, 1], [4, 1], [6, 0]]), ms: 600 },
+        { ojos: 'cerrado', extra: P([[2, 1], [4, 1], [6, 0]]), ms: 120 },
+    ],
+    trabajando: [
+        { izq: { dy: -1 }, extra: P([[1, 9], [15, 3]]), ms: 170 },
+        { der: { dy: -1 }, extra: P([[0, 7], [15, 6]]), ms: 170 },
+    ],
+    escribiendo: [
+        { ojos: 'abajo', extra: P([[3, 15]]), ms: 220 },
+        { ojos: 'abajo', extra: P([[3, 15], [5, 15]]), ms: 220 },
+        { ojos: 'abajo', extra: P([[3, 15], [5, 15], [7, 15]]), ms: 220 },
+        { ojos: 'abajo', ms: 220 },
+    ],
+    buscando: [{ ojos: 'izquierda', ms: 380 }, { ms: 200 }, { ojos: 'derecha', ms: 380 }, { ms: 200 }],
+    esperando: [{ ms: 450 }, { extra: P(INTERROGACION, 1, 1), ms: 650 }, { extra: P(INTERROGACION, 1, 1), ojos: 'cerrado', ms: 120 }, { extra: P(INTERROGACION, 1, 1), ms: 650 }],
+    hecho: [
+        { ms: 200 },
+        { izq: { dy: -1 }, der: { dy: -1 }, ojos: 'feliz', ms: 140 },
+        { izq: { dy: -2 }, der: { dy: -2 }, ojos: 'feliz', extra: P(TIC, 1, 1), ms: 240 },
+        { izq: { dy: -1 }, der: { dy: -1 }, ojos: 'feliz', extra: P(TIC, 1, 1), ms: 140 },
+        { ojos: 'feliz', extra: P(TIC, 1, 1), ms: 900 },
+    ],
+    error: [
+        { ojos: 'x', izq: { dx: -1 }, der: { dx: -1 }, ms: 90 },
+        { ojos: 'x', izq: { dx: 1 }, der: { dx: 1 }, ms: 90 },
+        { ojos: 'x', izq: { dx: -1 }, der: { dx: -1 }, ms: 90 },
+        { ojos: 'x', izq: { dx: 1 }, der: { dx: 1 }, ms: 90 },
+        { ojos: 'x', ms: 900 },
+    ],
+    dormido: [
+        { ojos: 'cerrado', extra: P(ZETA, 1, 6), ms: 600 },
+        { ojos: 'cerrado', izq: { dy: 1 }, der: { dy: 1 }, extra: P(ZETA, 1, 3), ms: 600 },
+        { ojos: 'cerrado', extra: P(ZETA, 2, 0), ms: 600 },
+        { ojos: 'cerrado', izq: { dy: 1 }, der: { dy: 1 }, ms: 600 },
+    ],
+    estirarse: [
+        { ms: 300 },
+        { izq: { estira: 1 }, der: { estira: 1 }, ojos: 'cerrado', ms: 220 },
+        { izq: { estira: 2 }, der: { estira: 2 }, ojos: 'cerrado', ms: 500 },
+        { izq: { estira: 1 }, der: { estira: 1 }, ojos: 'cerrado', ms: 200 },
+        { ojos: 'feliz', ms: 600 },
+    ],
+    salto: [
+        { izq: { dy: 1 }, der: { dy: 1 }, ms: 160 },
+        { izq: { dy: -1 }, der: { dy: -1 }, ojos: 'feliz', ms: 120 },
+        { izq: { dy: -2 }, der: { dy: -2 }, ojos: 'feliz', ms: 220 },
+        { izq: { dy: -1 }, der: { dy: -1 }, ojos: 'feliz', ms: 120 },
+        { izq: { dy: 1 }, der: { dy: 1 }, ms: 140 },
+        { ms: 500 },
+    ],
+    baile: [
+        { izq: { dy: -1, dx: -1 }, der: { dx: -1 }, ojos: 'feliz', extra: P(NOTA, 0, 1), ms: 220 },
+        { izq: { dx: 1 }, der: { dy: -1, dx: 1 }, ojos: 'feliz', ms: 220 },
+        { izq: { dy: -1, dx: -1 }, der: { dx: -1 }, ojos: 'feliz', ms: 220 },
+        { izq: { dx: 1 }, der: { dy: -1, dx: 1 }, ojos: 'feliz', extra: P(NOTA, 0, 0), ms: 220 },
+    ],
+    guino: [{ ms: 600 }, { ojos: ['abierto', 'cerrado'], ms: 260 }, { ojos: 'feliz', ms: 700 }],
+    corazon: [
+        { ojos: 'feliz', extra: P(CORAZON, 0, 3), ms: 260 },
+        { ojos: 'feliz', extra: P(CORAZON, 0, 2), ms: 260 },
+        { ojos: 'feliz', extra: P(CORAZON, 0, 1), ms: 260 },
+        { ojos: 'feliz', extra: P(CORAZON, 0, 0), ms: 700 },
+    ],
+    fiesta: [
+        { ojos: 'feliz', izq: { dy: -1 }, der: { dy: -1 }, extra: P([[1, 2], [4, 0], [15, 1], [14, 9], [0, 11]]), ms: 200 },
+        { ojos: 'feliz', extra: P([[2, 4], [5, 1], [14, 3], [15, 11], [1, 13]]), ms: 200 },
+        { ojos: 'feliz', izq: { dy: -1 }, der: { dy: -1 }, extra: P([[0, 6], [3, 0], [15, 5], [13, 13], [2, 15]]), ms: 200 },
+        { ojos: 'feliz', extra: P([[1, 8], [6, 0], [14, 7], [15, 14], [0, 1]]), ms: 200 },
+    ],
+    musica: [
+        { ojos: 'cerrado', izq: { dx: -1 }, der: { dx: -1 }, extra: P(NOTA, 1, 5), ms: 380 },
+        { ojos: 'cerrado', extra: P(NOTA, 1, 3), ms: 380 },
+        { ojos: 'cerrado', izq: { dx: 1 }, der: { dx: 1 }, extra: P(NOTA, 2, 1), ms: 380 },
+        { ojos: 'cerrado', extra: P(NOTA, 2, 0), ms: 380 },
+    ],
+    mirar: [{ ojos: 'izquierda', ms: 600 }, { ms: 250 }, { ojos: 'derecha', ms: 600 }, { ojos: 'arriba', ms: 500 }, { ms: 500 }],
+    sorpresa: [{ ms: 300 }, { ojos: 'grande', izq: { dy: -1 }, der: { dy: -1 }, extra: P(EXCLAMACION, 1, 1), ms: 200 }, { ojos: 'grande', extra: P(EXCLAMACION, 1, 1), ms: 900 }],
+    asomarse: [
+        { izq: { dy: 12 }, der: { dy: 12 }, ms: 500 },
+        { izq: { dy: 8 }, der: { dy: 8 }, ms: 140 },
+        { izq: { dy: 5 }, der: { dy: 5 }, ms: 140 },
+        { izq: { dy: 3 }, der: { dy: 3 }, ms: 900 },
+        { izq: { dy: 3 }, der: { dy: 3 }, ojos: 'cerrado', ms: 120 },
+        { izq: { dy: 3 }, der: { dy: 3 }, ojos: 'derecha', ms: 700 },
+        { izq: { dy: 6 }, der: { dy: 6 }, ms: 140 },
+        { izq: { dy: 12 }, der: { dy: 12 }, ms: 700 },
+    ],
+};
+export const LISTA_DE_ANIMACIONES = Object.keys(ANIMACIONES);
+export const DEL_TRABAJO = ['saludo', 'pensando', 'trabajando', 'escribiendo', 'buscando', 'esperando', 'hecho', 'error'];
+export function animacionDelEstado(estado) {
+    switch (estado) {
+        case 'trabajando':
+            return 'trabajando';
+        case 'espera':
+            return 'esperando';
+        case 'parado':
+            return 'error';
+        case 'hecho':
+            return 'hecho';
+        default:
+            return 'reposo';
+    }
+}
+const cache = new Map();
+export function fotogramasDe(a, accesorio) {
+    const clave = `${a}|${accesorio ?? ''}`;
+    let f = cache.get(clave);
+    if (!f) {
+        f = ANIMACIONES[a].map((c) => ({ matriz: matrizDe(c, accesorio), ms: c.ms }));
+        cache.set(clave, f);
+    }
+    return f;
+}
+export function duracionDe(a) {
+    return fotogramasDe(a).reduce((s, f) => s + f.ms, 0);
+}
+export function fotogramaEn(a, t, accesorio) {
+    const fs = fotogramasDe(a, accesorio);
+    const total = duracionDe(a);
+    let r = ((t % total) + total) % total;
+    for (const f of fs) {
+        if (r < f.ms)
+            return f;
+        r -= f.ms;
+    }
+    return fs[fs.length - 1];
+}
+export function rectangulosDe(matriz, tono) {
+    const out = [];
+    matriz.forEach((fila, y) => {
+        let x = 0;
+        while (x < LADO) {
+            const c = fila[x];
+            const color = colorDe(c, tono);
+            if (!color) {
+                x++;
+                continue;
+            }
+            let fin = x + 1;
+            while (fin < LADO && fila[fin] === c)
+                fin++;
+            out.push({ x, y, ancho: fin - x, color });
+            x = fin;
+        }
+    });
+    return out;
+}
+export function svgDe(matriz, tono, px = 64) {
+    const r = rectangulosDe(matriz, tono)
+        .map((q) => `<rect x="${q.x}" y="${q.y}" width="${q.ancho}" height="1" fill="${q.color}"/>`)
+        .join('');
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${px}" height="${px}" viewBox="0 0 16 16" shape-rendering="crispEdges">${r}</svg>`;
+}