@getparallel/parx 0.0.0-stage → 0.4.1

package/dist/tui.js

@@ -0,0 +1,1198 @@
+import { animacion, c, capacidades, sep, cabezaDePar, caraDePar, carril, fijarCapacidades, signo, ANCHO_DE_PAR, SIMBOLOS } from "./marca.js";
+import { anchoDe, envolver, puntos, recortar, rellenar } from "./texto.js";
+import { ALIAS_COMANDO, COMANDOS, t as tt } from "./textos.js";
+import { MODELOS, ORDEN_DE_MODELOS } from "./modelos.js";
+import { consejo, ordenDeConsejos } from "./consejos.js";
+export { anchoDe } from "./texto.js";
+export const MARGEN = 2;
+export function anchoUtil(ancho) {
+    return Math.max(10, ancho - MARGEN * 2);
+}
+const m = ' '.repeat(MARGEN);
+function barraDoble() {
+    return capacidades().unicode ? '║' : '|';
+}
+export function bloqueDeTexto(texto, sangria = '') {
+    return (ancho) => {
+        const util = anchoUtil(ancho);
+        const out = [];
+        for (const linea of texto.split('\n')) {
+            const propia = /^\s*/.exec(linea)?.[0] ?? '';
+            for (const l of envolver(linea, util, sangria || propia))
+                out.push(`${m}${l}`);
+        }
+        return out;
+    };
+}
+export function bloqueDeLinea(linea) {
+    return (ancho) => [`${m}${recortar(linea, anchoUtil(ancho))}`];
+}
+export function bloqueDeLaPersona(texto) {
+    return (ancho) => {
+        const util = anchoUtil(ancho);
+        const barra = `${c.violeta(barraDoble())} `;
+        const lineas = texto.split('\n').flatMap((l) => envolver(l, util - 2));
+        return ['', ...lineas.map((l) => `${m}${barra}${l}`)];
+    };
+}
+export function bloqueDeBienvenida(d) {
+    return (ancho) => {
+        const util = anchoUtil(ancho) - 2;
+        const barra = `${c.violeta(barraDoble())} `;
+        const filas = [
+            `${c.negrita('parx')} ${c.gris(d.version)}${c.gris(sep())}${d.quien ? tt('tui.hola', { nombre: d.quien }) : tt('tui.hola_sin_nombre')}`,
+            c.gris(`${d.carpeta}${d.plan ? `${sep()}${d.plan}` : ''}`),
+            ...(d.novedad ? [c.gris(d.novedad)] : []),
+        ];
+        const out = filas.map((f) => `${m}${barra}${recortar(f, util)}`);
+        if (d.peligro?.())
+            out.push(...avisoDeBypass(ancho));
+        return [...out, ''];
+    };
+}
+export function avisoDeBypass(ancho) {
+    const util = anchoUtil(ancho);
+    const senal = c.peligro(capacidades().unicode ? '▲' : '!');
+    const lineas = envolver(`${tt('bypass.arriba')}. ${tt('bypass.arriba_desc')}`, util - 2);
+    const titulo = `${tt('bypass.arriba')}.`;
+    return [
+        '',
+        ...lineas.map((l, i) => {
+            if (i === 0 && l.startsWith(titulo))
+                return `${m}${senal} ${c.negrita(c.peligro(titulo))}${c.gris(l.slice(titulo.length))}`;
+            return `${m}  ${c.gris(l)}`;
+        }),
+    ];
+}
+export function bloqueDeConsejos(ids) {
+    return (ancho) => {
+        const lista = ids();
+        if (!lista.length)
+            return [];
+        const u = capacidades().unicode;
+        const util = anchoUtil(ancho);
+        const barra = c.violeta(u ? '│' : '|');
+        const interior = util - 2;
+        const consejos = lista.map((id) => consejo(id));
+        const out = [];
+        const titulo = c.negrita(recortar(tt('consejos.titulo'), interior));
+        const quitar = c.tenue(c.gris(tt('consejos.quitar', { orden: ordenDeConsejos(false) })));
+        out.push(`${m}${barra} ${izquierdaYDerecha(titulo, quitar, interior).trimEnd()}`);
+        const anchoTecla = Math.max(...consejos.map((k) => anchoDe(k.tecla))) + 3;
+        const dosColumnas = interior - anchoTecla >= 24;
+        for (const k of consejos) {
+            if (dosColumnas) {
+                const lineas = envolver(k.texto, interior - anchoTecla);
+                lineas.forEach((l, i) => {
+                    const tecla = i === 0 ? c.marca(rellenar(k.tecla, anchoTecla)) : ' '.repeat(anchoTecla);
+                    out.push(`${m}${barra} ${tecla}${c.gris(l)}`);
+                });
+            }
+            else {
+                out.push(`${m}${barra} ${c.marca(recortar(k.tecla, interior))}`);
+                for (const l of envolver(k.texto, interior - 2))
+                    out.push(`${m}${barra}   ${c.gris(l)}`);
+            }
+        }
+        const esquina = u ? '╰' : '`';
+        const raya = u ? '─' : '-';
+        out.push(`${m}${c.violeta(`${esquina}${raya.repeat(Math.max(0, util - 1))}`)}`);
+        return out;
+    };
+}
+export function bloqueDeCierre(texto, marca) {
+    return (ancho) => {
+        const util = anchoUtil(ancho);
+        const izq = recortar(`${marca} ${texto}`, util);
+        const resto = util - anchoDe(izq) - 1;
+        return [`${m}${izq}${resto > 0 ? ` ${c.tenue(c.gris((capacidades().unicode ? '─' : '-').repeat(resto)))}` : ''}`];
+    };
+}
+export function trocearTeclas(datos, estado) {
+    const out = [];
+    let i = 0;
+    while (i < datos.length) {
+        if (estado.pegando) {
+            const fin = datos.indexOf('\x1b[201~', i);
+            const trozo = fin === -1 ? datos.slice(i) : datos.slice(i, fin);
+            if (trozo)
+                out.push({ t: 'pegado', v: trozo });
+            if (fin === -1)
+                return out;
+            estado.pegando = false;
+            i = fin + 6;
+            continue;
+        }
+        const ch = datos[i];
+        if (ch === '\x1b') {
+            const r = /^\x1b(?:\[([0-9;?]*)([ -/]*[@-~])|O([@-~])|([\s\S]))?/.exec(datos.slice(i));
+            const seq = r[0];
+            i += Math.max(1, seq.length);
+            const params = r[1] ?? '';
+            const fin = r[2] ?? r[3] ?? '';
+            if (seq === '\x1b[200~') {
+                estado.pegando = true;
+                continue;
+            }
+            const conModificador = /;[35]$/.test(params);
+            if (seq === '\x1b')
+                out.push({ t: 'esc' });
+            else if (fin === 'D')
+                out.push({ t: conModificador ? 'palabra_izq' : 'izq' });
+            else if (fin === 'C')
+                out.push({ t: conModificador ? 'palabra_der' : 'der' });
+            else if (fin === 'A')
+                out.push({ t: 'arriba' });
+            else if (fin === 'B')
+                out.push({ t: 'abajo' });
+            else if (fin === 'H' || (fin === '~' && (params === '1' || params === '7')))
+                out.push({ t: 'inicio' });
+            else if (fin === 'F' || (fin === '~' && (params === '4' || params === '8')))
+                out.push({ t: 'fin' });
+            else if (fin === '~' && params === '3')
+                out.push({ t: 'suprimir' });
+            else if (fin === 'Z')
+                out.push({ t: 'cambiar' });
+            else if (fin === 'I' && params === '')
+                out.push({ t: 'foco_si' });
+            else if (fin === 'O' && params === '' && r[2])
+                out.push({ t: 'foco_no' });
+            else if (r[4] === '\x7f')
+                out.push({ t: 'borrar_palabra' });
+            else if (r[4] === 'b')
+                out.push({ t: 'palabra_izq' });
+            else if (r[4] === 'f')
+                out.push({ t: 'palabra_der' });
+            else if (r[4] === '\r')
+                out.push({ t: 'intro' });
+            else
+                out.push({ t: 'nada' });
+            continue;
+        }
+        i++;
+        if (ch === '\r' || ch === '\n')
+            out.push({ t: 'intro' });
+        else if (ch === '\x7f' || ch === '\b')
+            out.push({ t: 'borrar' });
+        else if (ch === '\x03')
+            out.push({ t: 'ctrlc' });
+        else if (ch === '\x04')
+            out.push({ t: 'ctrld' });
+        else if (ch === '\x01')
+            out.push({ t: 'inicio' });
+        else if (ch === '\x05')
+            out.push({ t: 'fin' });
+        else if (ch === '\x02')
+            out.push({ t: 'izq' });
+        else if (ch === '\x06')
+            out.push({ t: 'der' });
+        else if (ch === '\x0b')
+            out.push({ t: 'borrar_hasta_fin' });
+        else if (ch === '\x15')
+            out.push({ t: 'borrar_linea' });
+        else if (ch === '\x17')
+            out.push({ t: 'borrar_palabra' });
+        else if (ch === '\x0c')
+            out.push({ t: 'limpiar' });
+        else if (ch === '\x10')
+            out.push({ t: 'arriba' });
+        else if (ch === '\x0e')
+            out.push({ t: 'abajo' });
+        else if (ch === '\t')
+            out.push({ t: 'tab' });
+        else if (ch >= ' ') {
+            const ultimo = out[out.length - 1];
+            if (ultimo && ultimo.t === 'texto')
+                ultimo.v += ch;
+            else
+                out.push({ t: 'texto', v: ch });
+        }
+    }
+    return out;
+}
+const CON_VALOR = new Set(['mode', 'model', 'tips', 'notify', 'teach']);
+const CON_TEXTO = new Set(['folder']);
+const MODOS_DEL_MENU = ['ask', 'auto', 'read', 'bypass'];
+export function opcionesDelMenu(valor) {
+    if (!valor.startsWith('/') || valor.includes('\n'))
+        return null;
+    const sinBarra = valor.slice(1);
+    const espacio = sinBarra.indexOf(' ');
+    if (espacio === -1) {
+        const q = sinBarra.toLocaleLowerCase();
+        const out = [];
+        for (const [cmd, descripcion] of COMANDOS) {
+            const casa = cmd.startsWith(q) || (q.length > 0 && Object.entries(ALIAS_COMANDO).some(([alias, destino]) => destino === cmd && alias.startsWith(q)));
+            if (!casa)
+                continue;
+            const conAlgo = CON_VALOR.has(cmd) || CON_TEXTO.has(cmd);
+            out.push({ nombre: `/${cmd}`, descripcion, completar: `/${cmd}${conAlgo ? ' ' : ''}`, enviar: !conAlgo });
+        }
+        return out;
+    }
+    const cmd = ALIAS_COMANDO[sinBarra.slice(0, espacio).toLocaleLowerCase()];
+    if (!cmd || !CON_VALOR.has(cmd))
+        return null;
+    const q = sinBarra.slice(espacio + 1).toLocaleLowerCase();
+    if (q.includes(' '))
+        return null;
+    const base = valor.slice(0, valor.length - q.length);
+    const valores = cmd === 'mode'
+        ? MODOS_DEL_MENU.map((k) => [k, tt(`modo.${k}.desc`)])
+        : cmd === 'model'
+            ? ORDEN_DE_MODELOS.map((k) => [k, `${MODELOS[k].nombre} ${MODELOS[k].version}: ${MODELOS[k].descripcion}`])
+            : [
+                ['on', cmd === 'teach' ? 'Explain each step as it codes' : cmd === 'notify' ? 'Notify me when it finishes or needs me' : 'Show them when parx opens'],
+                ['off', cmd === 'teach' ? 'Back to normal' : cmd === 'notify' ? 'No desktop notifications' : 'Don’t show them again'],
+            ];
+    return valores
+        .filter(([v]) => v.startsWith(q))
+        .map(([v, d]) => ({ nombre: v, descripcion: d, completar: `${base}${v}`, enviar: true, ...(cmd === 'mode' && v === 'bypass' ? { peligro: true } : {}) }));
+}
+export function componerBarra(e, util) {
+    const punto = c.gris(sep());
+    const modo = e.peligro ? c.aviso(c.negrita(`${capacidades().unicode ? '▲' : '!'} ${e.modo}`)) : c.gris(e.modo);
+    const extra = e.extra ? `${punto}${c.marca(e.extra)}` : '';
+    const opciones = [
+        [`${modo}${punto}${c.gris(e.modelo)}${extra}`, e.saldo],
+        [`${modo}${punto}${c.gris(e.modelo)}${extra}`, e.saldoCorto ?? e.saldo],
+        [`${modo}${punto}${c.gris(e.modelo)}`, e.saldoCorto ?? e.saldo],
+        [modo, e.saldoCorto ?? e.saldo],
+    ];
+    for (const [izq, der] of opciones) {
+        const hueco = util - anchoDe(izq) - anchoDe(der);
+        if (hueco >= 2)
+            return `${izq}${' '.repeat(hueco)}${c.gris(der)}`;
+    }
+    const der = e.saldoCorto ?? '';
+    const izq = recortar(modo, Math.max(1, util - anchoDe(der) - 2));
+    return rellenar(`${izq}${' '.repeat(Math.max(0, util - anchoDe(izq) - anchoDe(der)))}${c.gris(der)}`, util);
+}
+export function duracion(ms) {
+    const s = Math.max(0, Math.floor(ms / 1000));
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ${String(s % 60).padStart(2, '0')}s`;
+    return `${Math.floor(m / 60)}h ${String(m % 60).padStart(2, '0')}m`;
+}
+export function acciones(n) {
+    return n === 1 ? tt('estado.accion') : tt('estado.acciones', { n: n.toLocaleString('en-US') });
+}
+const FRASES = ['trabajo.ruta', 'trabajo.puntos', 'trabajo.carriles', 'trabajo.numeros', 'trabajo.mapa', 'trabajo.afinar', 'trabajo.agujas', 'trabajo.estacion'];
+export const MS_POR_FRASE = 2800;
+export function fraseDeEspera(ms, semilla = 0) {
+    const vuelta = Math.floor(Math.max(0, ms) / MS_POR_FRASE);
+    if (vuelta === 0)
+        return `${tt(FRASES[0])}…`;
+    return `${tt(FRASES[1 + ((semilla + vuelta - 1) % (FRASES.length - 1))])}…`;
+}
+export function ponerTextoDeTrabajo(w, texto, anim = 'ruta', vivo = false, ahora = Date.now()) {
+    if (texto) {
+        w.texto = texto;
+        w.anim = anim;
+        w.vivo = vivo;
+        w.literalHasta = ahora + 1800;
+    }
+    else {
+        w.vivo = false;
+        w.esperaDesde = Math.max(ahora, w.literalHasta);
+    }
+}
+export function nuevoTrabajo(ahora = Date.now()) {
+    return { texto: null, literalHasta: 0, vivo: false, anim: 'ruta', desde: ahora, esperaDesde: ahora, paso: 0, acciones: null, semilla: Math.floor(Math.random() * 7) };
+}
+export function textoDeTrabajo(w, ahora) {
+    if (w.texto && (w.vivo || ahora < w.literalHasta))
+        return { texto: w.texto, anim: w.anim };
+    return { texto: fraseDeEspera(ahora - w.esperaDesde, w.semilla), anim: 'ruta' };
+}
+export function filaDeTrabajo(w, ahora) {
+    const { texto, anim } = textoDeTrabajo(w, ahora);
+    const tiempo = duracion(ahora - w.desde);
+    const gasto = w.acciones ? `${sep()}${acciones(w.acciones)}` : '';
+    return `${animacion(anim, w.paso)} ${texto}${c.gris(`${sep()}${tiempo}${gasto}`)}`;
+}
+export function filaDeCarril(k, util, ahora) {
+    const fin = k.hasta ?? ahora;
+    const numero = c.claro(String(k.numero));
+    const tiempo = duracion(fin - k.trabajo.desde);
+    const derecha = c.gris(`${tiempo}${k.trabajo.acciones ? `${sep()}${acciones(k.trabajo.acciones)}` : ''}`);
+    let señal;
+    let texto;
+    if (k.estado === 'trabaja') {
+        const x = textoDeTrabajo(k.trabajo, ahora);
+        señal = animacion(x.anim, k.trabajo.paso + k.numero * 3);
+        texto = x.texto;
+    }
+    else {
+        const marca = k.estado === 'hecho' ? c.ok(SIMBOLOS.hecho) : k.estado === 'error' ? c.error(SIMBOLOS.falla) : c.gris('■');
+        señal = rellenar(marca, 8);
+        texto = k.estado === 'hecho' ? tt('estado.hecho') : k.estado === 'error' ? 'Stopped by an error' : tt('estado.interrumpido');
+    }
+    const anchoTarea = Math.max(8, Math.floor(util * 0.32));
+    const tarea = recortar(k.tarea.replace(/\s+/g, ' '), anchoTarea);
+    const izq = `${numero} ${señal} ${c.negrita(tarea)}${c.gris(sep())}${c.gris(texto)}`;
+    return izquierdaYDerecha(recortar(izq, util - (anchoDe(derecha) + 2 <= util / 2 ? anchoDe(derecha) + 2 : 0)), derecha, util);
+}
+function izquierdaYDerecha(izq, der, util) {
+    if (anchoDe(izq) + anchoDe(der) + 2 <= util)
+        return `${izq}${' '.repeat(util - anchoDe(izq) - anchoDe(der))}${der}`;
+    return rellenar(izq, util);
+}
+export function ventanaDeEntrada(unidades, cursor, ancho) {
+    const w = unidades.map(anchoDe);
+    const suma = (d, h) => w.slice(d, h).reduce((x, y) => x + y, 0);
+    if (suma(0, w.length) < ancho)
+        return { texto: unidades.join(''), col: suma(0, cursor) };
+    let desde = 0;
+    while (desde < cursor && (desde > 0 ? 1 : 0) + suma(desde, cursor) > ancho - 2)
+        desde++;
+    let texto = desde > 0 ? puntos() : '';
+    let usado = desde > 0 ? 1 : 0;
+    let i = desde;
+    for (; i < unidades.length; i++) {
+        const limite = i < unidades.length - 1 ? ancho - 1 : ancho;
+        if (usado + w[i] > limite)
+            break;
+        texto += unidades[i];
+        usado += w[i];
+    }
+    if (i < unidades.length)
+        texto += puntos();
+    const col = (desde > 0 ? 1 : 0) + suma(desde, cursor);
+    return { texto: recortar(texto, ancho), col: Math.max(0, Math.min(col, ancho - 1)) };
+}
+export function cabePar(ancho) {
+    return ancho >= 56;
+}
+export function componerCarril(d, ancho, alto) {
+    const util = anchoUtil(ancho);
+    const conPar = cabePar(ancho);
+    const huecoPar = conPar ? ANCHO_DE_PAR + 2 : 0;
+    const signoW = 3;
+    let filaEscribir;
+    let cursor = null;
+    const anchoEscribir = util - (conPar ? huecoPar + 1 : 0);
+    if (d.pregunta) {
+        const p = d.pregunta;
+        const pinta = (etiquetas) => etiquetas
+            .map((e, i) => {
+            const txt = `${i + 1} ${e}`;
+            return i === p.elegida ? `${c.claro(capacidades().unicode ? '▸' : '>')} ${c.negrita(txt)}` : `  ${c.gris(txt)}`;
+        })
+            .join('  ');
+        let opciones = pinta(p.opciones);
+        if (anchoDe(opciones) > anchoEscribir - signoW)
+            opciones = pinta(p.cortas);
+        filaEscribir = rellenar(`${(p.peligro ? c.peligro : c.aviso)(signo())} ${opciones}`, anchoEscribir);
+    }
+    else {
+        const libre = Math.max(4, anchoEscribir - signoW);
+        const color = d.trabajo ? c.gris : c.claro;
+        if (!d.unidades.length) {
+            filaEscribir = rellenar(`${color(signo())} ${c.gris(recortar(d.ejemplo, libre))}`, anchoEscribir);
+            cursor = { fila: 0, col: MARGEN + signoW };
+        }
+        else {
+            const v = ventanaDeEntrada(d.unidades, d.cursor, libre);
+            filaEscribir = rellenar(`${color(signo())} ${v.texto}`, anchoEscribir);
+            cursor = { fila: 0, col: MARGEN + signoW + v.col };
+        }
+    }
+    if (conPar)
+        filaEscribir += ` ${cabezaDePar()}  `;
+    const tinta = (t) => c.violeta(t);
+    const linea = conPar ? `${tinta(carril(util - ANCHO_DE_PAR - 2))}${caraDePar(d.gesto)}${tinta(carril(2))}` : tinta(carril(util));
+    let barra;
+    const enCarriles = (d.carriles ?? []).filter((k) => k.estado === 'trabaja').length;
+    if (d.trabajo && !d.pregunta && d.carriles?.length) {
+        const gasto = d.carriles.reduce((n, k) => n + (k.trabajo.acciones ?? 0), 0);
+        const izq = `${animacion('tren', d.trabajo.paso)} ${tt('carriles.en_marcha', { n: enCarriles, total: d.carriles.length })}${c.gris(`${sep()}${duracion(d.ahora - d.trabajo.desde)}${gasto ? `${sep()}${acciones(gasto)}` : ''}`)}`;
+        barra = izquierdaYDerecha(recortar(izq, util), c.tenue(c.gris(d.aviso ?? tt('tui.parar'))), util);
+    }
+    else if (d.trabajo && !d.pregunta) {
+        barra = izquierdaYDerecha(recortar(filaDeTrabajo(d.trabajo, d.ahora), util), c.tenue(c.gris(d.aviso ?? tt('tui.parar'))), util);
+    }
+    else if (d.aviso) {
+        barra = izquierdaYDerecha(c.aviso(recortar(d.aviso, util)), '', util);
+    }
+    else {
+        barra = componerBarra(d.estado, util);
+    }
+    const base = [filaEscribir, linea, barra].map((f) => `${m}${f}`);
+    let filas = alto >= 3 ? base : alto === 2 ? [base[0], base[2]] : [base[0]];
+    const carriles = (d.carriles ?? []).slice(0, Math.max(0, alto - filas.length - 2));
+    const filasDeCarriles = carriles.map((k) => `${m}${rellenar(filaDeCarril(k, util, d.ahora), util)}`);
+    filas = [...filasDeCarriles, ...filas];
+    if (cursor)
+        cursor = { fila: cursor.fila + filasDeCarriles.length, col: cursor.col };
+    const hueco = Math.max(0, alto - filas.length);
+    let encima = [];
+    if (d.pregunta) {
+        const p = d.pregunta;
+        const marca = p.peligro ? c.peligro(capacidades().unicode ? '▲' : '!') : c.aviso('?');
+        encima = envolver(p.texto, util - 2).map((l, i) => `${m}${rellenar(`${i === 0 ? marca : ' '} ${c.negrita(p.peligro ? c.peligro(l) : l)}`, util)}`);
+        if (encima.length > hueco)
+            encima = [`${m}${rellenar(`${marca} ${c.negrita(p.texto)}`, util)}`];
+    }
+    else if (d.menu && d.menu.opciones.length) {
+        const ops = d.menu.opciones;
+        const visibles = Math.min(6, ops.length, hueco);
+        if (visibles > 0) {
+            const ini = Math.max(0, Math.min(d.menu.elegida - visibles + 1, ops.length - visibles));
+            const anchoNombre = Math.min(Math.max(...ops.map((o) => anchoDe(o.nombre) + (o.peligro ? 2 : 0))) + 2, Math.floor(util / 2));
+            encima = ops.slice(ini, ini + visibles).map((o, k) => {
+                const i = ini + k;
+                const sel = i === d.menu.elegida;
+                const marca = sel ? (o.peligro ? c.peligro : c.claro)(capacidades().unicode ? '▌' : '>') : ' ';
+                const resto = Math.max(0, util - 2 - anchoNombre);
+                const desc = recortar(o.descripcion, resto);
+                if (o.peligro) {
+                    const nombre = rellenar(recortar(`${capacidades().unicode ? '▲' : '!'} ${o.nombre}`, anchoNombre - 1), anchoNombre);
+                    return `${m}${rellenar(`${marca} ${sel ? c.negrita(c.peligro(nombre)) : c.peligro(nombre)}${sel ? c.peligro(desc) : c.tenue(c.peligro(desc))}`, util)}`;
+                }
+                const nombre = rellenar(recortar(o.nombre, anchoNombre - 1), anchoNombre);
+                return `${m}${rellenar(`${marca} ${sel ? c.negrita(c.marca(nombre)) : c.gris(nombre)}${sel ? desc : c.tenue(c.gris(desc))}`, util)}`;
+            });
+        }
+    }
+    encima = encima.slice(Math.max(0, encima.length - hueco));
+    return { encima, carril: filas, cursor: cursor && filas.length ? cursor : null };
+}
+export function opcionesDePregunta(tipo) {
+    switch (tipo) {
+        case 'carpeta':
+            return { opciones: [tt('tui.si'), tt('tui.si_carpeta'), tt('tui.no')], cortas: [tt('tui.si'), tt('tui.si_carpeta_corto'), tt('tui.no')], valores: ['si', 'siempre', 'no'], elegida: 0 };
+        case 'ediciones':
+            return { opciones: [tt('tui.si'), tt('tui.si_ediciones'), tt('tui.no')], cortas: [tt('tui.si'), tt('tui.si_ediciones_corto'), tt('tui.no')], valores: ['si', 'siempre', 'no'], elegida: 0 };
+        case 'dos':
+            return { opciones: [tt('tui.si'), tt('tui.no')], cortas: [tt('tui.si'), tt('tui.no')], valores: ['si', 'no'], elegida: 0 };
+        case 'credencial':
+            return { opciones: [tt('tui.una_vez'), tt('tui.no')], cortas: [tt('tui.si'), tt('tui.no')], valores: ['si', 'no'], elegida: 1 };
+        case 'bypass':
+            return { opciones: [tt('bypass.aceptar'), tt('bypass.rechazar')], cortas: [tt('bypass.aceptar'), tt('bypass.rechazar')], valores: ['si', 'no'], elegida: 1 };
+        default:
+            return { opciones: [tt('tui.si'), tt('tui.siempre'), tt('tui.no')], cortas: [tt('tui.si'), tt('tui.siempre_corto'), tt('tui.no')], valores: ['si', 'siempre', 'no'], elegida: 0 };
+    }
+}
+const MAX_LINEAS = 4000;
+const MAX_BLOQUES = 1500;
+const PEGADO_LARGO = 280;
+const FICHA = /^(\d+)$/;
+const FICHA_IMAGEN = /^(\d+)$/;
+const IMAGEN = /\.(png|jpe?g|gif|webp)$/i;
+export function rutaDeImagenPegada(texto) {
+    let v = texto.trim();
+    if (!v || v.includes('\n'))
+        return null;
+    if ((v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"')))
+        v = v.slice(1, -1);
+    else
+        v = v.replace(/\\(.)/g, '$1');
+    if (v.startsWith('file://'))
+        v = decodeURIComponent(v.slice(7));
+    return IMAGEN.test(v) && /^(\/|~|[A-Za-z]:\\|\.)/.test(v) ? v : null;
+}
+export class Superficie {
+    o;
+    bloques = [];
+    lineas = [];
+    anchoCompuesto = 0;
+    encimaPintadas = 0;
+    carrilPintadas = 0;
+    activa = false;
+    oyente = null;
+    alRedimensionar = null;
+    relojResize = null;
+    relojAnim = null;
+    relojAviso = null;
+    pegando = { pegando: false };
+    unidades = [];
+    cursor = 0;
+    pegados = [];
+    imagenes = [];
+    historial = [];
+    posHistorial = 0;
+    borrador = [];
+    menuCerradoPara = null;
+    menuElegida = 0;
+    cola = null;
+    ctrlC = 0;
+    ejemplo = null;
+    resolverLectura = null;
+    trabajo = null;
+    carriles = [];
+    pregunta = null;
+    esperando = [];
+    aviso = null;
+    gesto = 'quieto';
+    ultimoParpadeo = Date.now();
+    consejos = [];
+    consejosVisibles = false;
+    foco = null;
+    peligroPintado = false;
+    constructor(o) {
+        this.o = o;
+    }
+    get ancho() {
+        return Math.max(20, this.o.salida.columns || 80);
+    }
+    get alto() {
+        return Math.max(1, this.o.salida.rows || 24);
+    }
+    get enfocada() {
+        return this.foco;
+    }
+    escribir(s) {
+        this.o.salida.write(s);
+    }
+    datos() {
+        const valor = this.valorCrudo();
+        const ops = this.menuCerradoPara === valor ? null : opcionesDelMenu(valor);
+        if (ops && this.menuElegida >= ops.length)
+            this.menuElegida = Math.max(0, ops.length - 1);
+        return {
+            unidades: this.unidades.map((u) => this.vistaDeUnidad(u)),
+            cursor: this.cursor,
+            ejemplo: this.ejemplo ?? tt('tui.escribe'),
+            estado: this.o.estado(),
+            trabajo: this.trabajo,
+            aviso: this.aviso,
+            pregunta: this.pregunta,
+            menu: ops && ops.length ? { opciones: ops, elegida: this.menuElegida } : null,
+            carriles: this.carriles,
+            gesto: this.pregunta ? 'pregunta' : this.trabajo || this.carriles.some((k) => k.estado === 'trabaja') ? (((this.trabajo?.paso ?? this.carriles[0]?.trabajo.paso ?? 0) >> 1) % 4) : this.gesto,
+            ahora: Date.now(),
+        };
+    }
+    vistaDeUnidad(u) {
+        const img = FICHA_IMAGEN.exec(u);
+        if (img) {
+            const ruta = this.imagenes[Number(img[1])] ?? '';
+            return c.marca(`[${tt('tui.imagen', { nombre: ruta.split(/[\\/]/).pop() ?? ruta })}]`);
+        }
+        const f = FICHA.exec(u);
+        if (!f)
+            return u === '\n' ? c.gris(capacidades().unicode ? '⏎' : '|') : u;
+        const p = this.pegados[Number(f[1])] ?? '';
+        const n = p.split('\n').length;
+        return c.marca(`[${n > 1 ? tt('tui.pegado', { n }) : tt('tui.pegado_corto', { n: p.length.toLocaleString('en-US') })}]`);
+    }
+    filaDelCarril(n) {
+        return this.alto - n + 1;
+    }
+    desplazadas(altoCarril) {
+        return Math.max(0, this.lineas.length - (this.alto - altoCarril));
+    }
+    filaTrasLaConversacion(altoCarril) {
+        return Math.min(this.lineas.length, Math.max(0, this.alto - altoCarril)) + 1;
+    }
+    lineaDeFila(fila, altoCarril) {
+        const indice = this.desplazadas(altoCarril) + (fila - 1);
+        return indice >= 0 ? (this.lineas[indice] ?? '') : '';
+    }
+    pintar() {
+        if (!this.activa)
+            return;
+        const peligro = Boolean(this.o.estado().peligro);
+        if (peligro !== this.peligroPintado) {
+            this.peligroPintado = peligro;
+            this.recomponer();
+            if (peligro && this.desplazadas(this.carrilPintadas) > 0)
+                this.anadir((ancho) => avisoDeBypass(ancho));
+            return;
+        }
+        const k = componerCarril(this.datos(), this.ancho, this.alto);
+        const n = k.carril.length;
+        let s = '\x1b[?2026h\x1b[?25l';
+        if (this.carrilPintadas && n > this.carrilPintadas) {
+            s += this.destapar();
+            const ocupadas = Math.min(this.lineas.length, Math.max(0, this.alto - this.carrilPintadas));
+            const subir = Math.max(0, ocupadas - Math.max(0, this.alto - n));
+            if (subir)
+                s += `\x1b[${this.alto};1H${'\r\n'.repeat(subir)}`;
+        }
+        if (this.carrilPintadas && n < this.carrilPintadas) {
+            s += this.destapar();
+            const topNuevo = this.filaDelCarril(n);
+            for (let fila = 1; fila < topNuevo; fila++)
+                s += `\x1b[${fila};1H\x1b[2K${this.lineaDeFila(fila, n)}`;
+        }
+        this.carrilPintadas = n;
+        const top = this.filaDelCarril(n);
+        for (let i = k.encima.length; i < this.encimaPintadas; i++) {
+            const fila = top - 1 - i;
+            if (fila >= 1)
+                s += `\x1b[${fila};1H\x1b[2K${this.lineaDeFila(fila, n)}`;
+        }
+        k.encima.forEach((l, i) => {
+            const fila = top - k.encima.length + i;
+            if (fila >= 1)
+                s += `\x1b[${fila};1H\x1b[2K${l}`;
+        });
+        this.encimaPintadas = k.encima.length;
+        k.carril.forEach((l, i) => {
+            s += `\x1b[${top + i};1H\x1b[2K${l}`;
+        });
+        if (k.cursor)
+            s += `\x1b[${top + k.cursor.fila};${k.cursor.col + 1}H\x1b[?25h`;
+        s += '\x1b[?2026l';
+        this.escribir(s);
+    }
+    destapar() {
+        const n = this.carrilPintadas || componerCarril(this.datos(), this.ancho, this.alto).carril.length;
+        const top = this.filaDelCarril(n);
+        let s = '';
+        for (let i = 0; i < this.encimaPintadas; i++) {
+            const fila = top - 1 - i;
+            if (fila >= 1)
+                s += `\x1b[${fila};1H\x1b[2K${this.lineaDeFila(fila, n)}`;
+        }
+        this.encimaPintadas = 0;
+        return s;
+    }
+    ocultarConsejos() {
+        if (!this.consejosVisibles)
+            return;
+        this.consejosVisibles = false;
+        if (!this.activa)
+            return;
+        this.lineas = this.bloques.flatMap((b) => b(this.ancho));
+        if (this.lineas.length > MAX_LINEAS)
+            this.lineas.splice(0, this.lineas.length - MAX_LINEAS);
+        const n = componerCarril(this.datos(), this.ancho, this.alto).carril.length;
+        const top = this.filaDelCarril(n);
+        let s = '\x1b[?2026h\x1b[?25l';
+        for (let fila = 1; fila < top; fila++)
+            s += `\x1b[${fila};1H\x1b[2K${this.lineaDeFila(fila, n)}`;
+        s += '\x1b[?2026l';
+        this.encimaPintadas = 0;
+        this.escribir(s);
+        this.pintar();
+    }
+    anadir(b) {
+        this.ocultarConsejos();
+        const destapado = this.activa ? this.destapar() : '';
+        const n = this.activa ? this.carrilPintadas || componerCarril(this.datos(), this.ancho, this.alto).carril.length : 0;
+        const desde = this.activa ? this.filaTrasLaConversacion(n) : 0;
+        this.bloques.push(b);
+        if (this.bloques.length > MAX_BLOQUES)
+            this.bloques.splice(0, this.bloques.length - MAX_BLOQUES);
+        const nuevas = b(this.ancho);
+        this.lineas.push(...nuevas);
+        if (this.lineas.length > MAX_LINEAS)
+            this.lineas.splice(0, this.lineas.length - MAX_LINEAS);
+        if (!this.activa)
+            return;
+        let s = `\x1b[?2026h\x1b[?25l${destapado}`;
+        s += `\x1b[${desde};1H\x1b[J`;
+        s += nuevas.map((l) => `${l}\x1b[K\r\n`).join('');
+        s += '\r\n'.repeat(Math.max(0, n - 1));
+        s += '\x1b[?2026l';
+        this.escribir(s);
+        this.pintar();
+    }
+    ultimoBloque() {
+        return this.bloques[this.bloques.length - 1];
+    }
+    reemplazarUltimo(b) {
+        const viejo = this.ultimoBloque();
+        const k = viejo ? viejo(this.ancho).length : -1;
+        const nuevas = b(this.ancho);
+        if (!viejo || !this.activa || nuevas.length !== k || this.encimaPintadas > 0 || this.lineas.length < k) {
+            this.anadir(b);
+            return;
+        }
+        this.bloques[this.bloques.length - 1] = b;
+        this.lineas.splice(this.lineas.length - k, k, ...nuevas);
+        const n = this.carrilPintadas || componerCarril(this.datos(), this.ancho, this.alto).carril.length;
+        const primera = this.lineas.length - k - this.desplazadas(n) + 1;
+        let s = '\x1b[?2026h\x1b[?25l';
+        nuevas.forEach((l, i) => {
+            const fila = primera + i;
+            if (fila >= 1)
+                s += `\x1b[${fila};1H\x1b[2K${l}`;
+        });
+        s += '\x1b[?2026l';
+        this.escribir(s);
+        this.pintar();
+    }
+    recomponer(alEmpezar = false) {
+        if (!this.activa)
+            return;
+        fijarCapacidades({ ancho: this.ancho });
+        this.anchoCompuesto = this.ancho;
+        this.lineas = this.bloques.flatMap((b) => b(this.ancho));
+        if (this.lineas.length > MAX_LINEAS)
+            this.lineas.splice(0, this.lineas.length - MAX_LINEAS);
+        const n = componerCarril(this.datos(), this.ancho, this.alto).carril.length;
+        let s = alEmpezar ? `\x1b[?2026h\x1b[?25l${'\r\n'.repeat(this.alto)}\x1b[H` : '\x1b[?2026h\x1b[?25l\x1b[H\x1b[2J\x1b[3J\x1b[H';
+        s += this.lineas.map((l) => `${l}\x1b[K\r\n`).join('');
+        s += '\r\n'.repeat(Math.max(0, n - 1));
+        s += '\x1b[?2026l';
+        this.encimaPintadas = 0;
+        this.carrilPintadas = n;
+        this.escribir(s);
+        this.pintar();
+    }
+    iniciar(bienvenida, consejos = []) {
+        if (this.activa)
+            return;
+        this.activa = true;
+        if (bienvenida)
+            this.bloques.push(bienvenida);
+        if (consejos.length) {
+            const ocupado = (bienvenida ? bienvenida(this.ancho).length : 0) + 3;
+            let n = consejos.length;
+            while (n > 0 && ocupado + bloqueDeConsejos(() => consejos.slice(0, n))(this.ancho).length > this.alto)
+                n--;
+            this.consejos = consejos.slice(0, n);
+            this.consejosVisibles = n > 0;
+            if (n > 0)
+                this.bloques.push(bloqueDeConsejos(() => (this.consejosVisibles ? this.consejos : [])));
+        }
+        this.escribir('\x1b[?2004h\x1b[?1004h');
+        try {
+            this.o.entrada.setRawMode?.(true);
+        }
+        catch {
+        }
+        this.o.entrada.resume();
+        this.oyente = (d) => this.alTeclear(String(d));
+        this.o.entrada.on('data', this.oyente);
+        this.peligroPintado = Boolean(this.o.estado().peligro);
+        this.alRedimensionar = () => {
+            if (this.relojResize)
+                clearTimeout(this.relojResize);
+            this.relojResize = setTimeout(() => this.recomponer(), 40);
+        };
+        this.o.salida.on('resize', this.alRedimensionar);
+        this.recomponer(true);
+        if (!this.o.quieta) {
+            this.relojAnim = setInterval(() => this.latido(), 110);
+            this.relojAnim.unref?.();
+        }
+    }
+    latido() {
+        const enCarriles = this.carriles.filter((k) => k.estado === 'trabaja');
+        if (this.trabajo || enCarriles.length) {
+            if (this.trabajo)
+                this.trabajo.paso++;
+            for (const k of enCarriles)
+                k.trabajo.paso++;
+            this.pintar();
+            return;
+        }
+        const ahora = Date.now();
+        if (this.gesto === 'parpadeo' && ahora - this.ultimoParpadeo > 160) {
+            this.gesto = 'quieto';
+            this.pintar();
+        }
+        else if (this.gesto === 'quieto' && !this.pregunta && ahora - this.ultimoParpadeo > 5200) {
+            this.ultimoParpadeo = ahora;
+            this.gesto = 'parpadeo';
+            this.pintar();
+        }
+    }
+    terminar(despedida) {
+        if (!this.activa)
+            return;
+        const n = this.carrilPintadas || componerCarril(this.datos(), this.ancho, this.alto).carril.length;
+        let s = this.destapar();
+        s += `\x1b[${this.filaTrasLaConversacion(n)};1H\x1b[J`;
+        if (despedida)
+            s += `${m}${despedida}\r\n`;
+        s += '\x1b[?2004l\x1b[?1004l\x1b[?25h';
+        this.escribir(s);
+        this.activa = false;
+        if (this.relojAnim)
+            clearInterval(this.relojAnim);
+        if (this.relojResize)
+            clearTimeout(this.relojResize);
+        if (this.relojAviso)
+            clearTimeout(this.relojAviso);
+        if (this.oyente)
+            this.o.entrada.removeListener('data', this.oyente);
+        if (this.alRedimensionar)
+            this.o.salida.removeListener('resize', this.alRedimensionar);
+        try {
+            this.o.entrada.setRawMode?.(false);
+        }
+        catch {
+        }
+        this.o.entrada.pause();
+    }
+    restaurarDeUrgencia() {
+        if (!this.activa)
+            return;
+        this.o.salida.write('\x1b[?2004l\x1b[?1004l\x1b[?25h\x1b[?2026l');
+        try {
+            this.o.entrada.setRawMode?.(false);
+        }
+        catch {
+        }
+    }
+    leer(ejemplo = null) {
+        this.ejemplo = ejemplo;
+        if (this.cola !== null) {
+            const r = this.cola;
+            this.cola = null;
+            this.ejemplo = null;
+            this.mostrarAviso(null);
+            this.anadir(bloqueDeLaPersona(this.vistaDeEnvio(r)));
+            return Promise.resolve(this.expandir(r));
+        }
+        return new Promise((resolver) => {
+            this.resolverLectura = (r) => {
+                this.ejemplo = null;
+                resolver(r);
+            };
+            this.pintar();
+        });
+    }
+    trabajar(alParar) {
+        if (this.trabajo)
+            this.trabajo.alParar = alParar;
+        else
+            this.trabajo = { ...nuevoTrabajo(), alParar };
+        this.pintar();
+    }
+    textoDeTrabajo(texto, anim = 'ruta', vivo = false) {
+        if (!this.trabajo)
+            return;
+        ponerTextoDeTrabajo(this.trabajo, texto, anim, vivo);
+        this.pintar();
+    }
+    progreso(accionesDeLaTarea) {
+        if (!this.trabajo)
+            return;
+        this.trabajo.acciones = accionesDeLaTarea;
+        this.pintar();
+    }
+    descansar() {
+        this.trabajo = null;
+        if (this.aviso === tt('tui.parar'))
+            this.aviso = null;
+        this.pintar();
+    }
+    fijarCarriles(carriles) {
+        this.carriles = carriles;
+        this.pintar();
+    }
+    actualizarCarriles() {
+        this.pintar();
+    }
+    preguntar(texto, tipo = 'normal') {
+        return new Promise((resolver) => {
+            const mostrar = () => {
+                const o = opcionesDePregunta(tipo);
+                this.pregunta = { texto, ...o, ...(tipo === 'bypass' ? { peligro: true } : {}), resolver };
+                this.o.alPreguntar?.(texto);
+                this.pintar();
+            };
+            if (this.pregunta)
+                this.esperando.push(mostrar);
+            else
+                mostrar();
+        });
+    }
+    responder(i) {
+        const p = this.pregunta;
+        if (!p)
+            return;
+        const r = p.valores[i] ?? 'no';
+        this.pregunta = null;
+        const etiqueta = p.opciones[i] ?? tt('tui.no');
+        if (r !== 'si' && !p.peligro)
+            this.anadir(bloqueDeLinea(`${c.gris('?')} ${p.texto} ${c.gris('→')} ${r === 'no' ? c.gris(etiqueta) : c.marca(etiqueta)}`));
+        else
+            this.pintar();
+        p.resolver(r);
+        this.esperando.shift()?.();
+    }
+    mostrarAviso(texto, ms = 0) {
+        this.aviso = texto;
+        if (this.relojAviso)
+            clearTimeout(this.relojAviso);
+        if (texto && ms) {
+            this.relojAviso = setTimeout(() => {
+                if (this.aviso === texto) {
+                    this.aviso = null;
+                    this.ctrlC = 0;
+                    this.pintar();
+                }
+            }, ms);
+            this.relojAviso.unref?.();
+        }
+        this.pintar();
+    }
+    valorCrudo() {
+        return this.unidades.join('');
+    }
+    expandir(v) {
+        return v
+            .replace(/\uE000(\d+)/g, (_x, i) => this.pegados[Number(i)] ?? '')
+            .replace(/\uE003(\d+)/g, (_x, i) => `\uE001${this.imagenes[Number(i)] ?? ''}\uE002`);
+    }
+    vistaDeEnvio(v) {
+        return v.replace(/[\uE000\uE003]\d+/g, (x) => sinColorSimple(this.vistaDeUnidad(x)));
+    }
+    ponerValor(v) {
+        this.unidades = v.match(/[\uE000\uE003]\d+|[\s\S]/gu) ?? [];
+        this.cursor = this.unidades.length;
+    }
+    insertar(texto) {
+        const nuevas = Array.from(texto);
+        this.unidades.splice(this.cursor, 0, ...nuevas);
+        this.cursor += nuevas.length;
+    }
+    enviar() {
+        const crudo = this.valorCrudo();
+        const v = crudo.trim();
+        this.unidades = [];
+        this.cursor = 0;
+        this.menuCerradoPara = null;
+        this.menuElegida = 0;
+        this.borrador = [];
+        if (v && this.historial[this.historial.length - 1] !== crudo)
+            this.historial.push(crudo);
+        this.posHistorial = this.historial.length;
+        if (this.trabajo || !this.resolverLectura) {
+            if (v) {
+                this.cola = crudo;
+                this.mostrarAviso(tt('tui.en_cola'));
+            }
+            return;
+        }
+        const r = this.resolverLectura;
+        this.resolverLectura = null;
+        if (v)
+            this.anadir(bloqueDeLaPersona(this.vistaDeEnvio(crudo.trim())));
+        else
+            this.pintar();
+        r(this.expandir(crudo));
+    }
+    alTeclear(datos) {
+        for (const k of trocearTeclas(datos, this.pegando))
+            this.tecla(k);
+        if (this.consejosVisibles && this.unidades.length)
+            this.ocultarConsejos();
+        this.pintar();
+    }
+    tecla(k) {
+        if (k.t === 'foco_si' || k.t === 'foco_no') {
+            this.foco = k.t === 'foco_si';
+            return;
+        }
+        if (this.pregunta)
+            return this.teclaDePregunta(k);
+        if (k.t !== 'ctrlc' && this.ctrlC && !this.trabajo) {
+            this.ctrlC = 0;
+            if (this.aviso === tt('tui.salir_otra'))
+                this.aviso = null;
+        }
+        const valor = this.valorCrudo();
+        const ops = this.menuCerradoPara === valor ? null : opcionesDelMenu(valor);
+        const menu = ops && ops.length ? ops : null;
+        switch (k.t) {
+            case 'texto':
+                this.insertar(k.v);
+                this.menuElegida = 0;
+                this.menuCerradoPara = null;
+                break;
+            case 'pegado': {
+                const v = k.v.replace(/\r\n?/g, '\n');
+                const imagen = rutaDeImagenPegada(v);
+                if (imagen) {
+                    this.imagenes.push(imagen);
+                    this.unidades.splice(this.cursor, 0, `\uE003${this.imagenes.length - 1}`, ' ');
+                    this.cursor += 2;
+                    break;
+                }
+                if (v.includes('\n') || v.length > PEGADO_LARGO) {
+                    this.pegados.push(v);
+                    this.unidades.splice(this.cursor, 0, `\uE000${this.pegados.length - 1}`);
+                    this.cursor++;
+                }
+                else
+                    this.insertar(v);
+                break;
+            }
+            case 'intro':
+                if (menu) {
+                    const o = menu[this.menuElegida];
+                    this.ponerValor(o.completar);
+                    if (!o.enviar) {
+                        this.menuElegida = 0;
+                        break;
+                    }
+                }
+                this.enviar();
+                break;
+            case 'tab':
+                if (menu) {
+                    this.ponerValor(menu[this.menuElegida].completar);
+                    this.menuElegida = 0;
+                }
+                break;
+            case 'esc':
+                if (menu)
+                    this.menuCerradoPara = valor;
+                else if (this.trabajo)
+                    this.trabajo.alParar();
+                break;
+            case 'borrar':
+                if (this.cursor > 0) {
+                    this.unidades.splice(this.cursor - 1, 1);
+                    this.cursor--;
+                    this.menuElegida = 0;
+                    this.menuCerradoPara = null;
+                }
+                break;
+            case 'suprimir':
+                if (this.cursor < this.unidades.length)
+                    this.unidades.splice(this.cursor, 1);
+                break;
+            case 'izq':
+                this.cursor = Math.max(0, this.cursor - 1);
+                break;
+            case 'der':
+                this.cursor = Math.min(this.unidades.length, this.cursor + 1);
+                break;
+            case 'palabra_izq': {
+                let i = this.cursor;
+                while (i > 0 && this.unidades[i - 1] === ' ')
+                    i--;
+                while (i > 0 && this.unidades[i - 1] !== ' ')
+                    i--;
+                this.cursor = i;
+                break;
+            }
+            case 'palabra_der': {
+                let i = this.cursor;
+                while (i < this.unidades.length && this.unidades[i] === ' ')
+                    i++;
+                while (i < this.unidades.length && this.unidades[i] !== ' ')
+                    i++;
+                this.cursor = i;
+                break;
+            }
+            case 'inicio':
+                this.cursor = 0;
+                break;
+            case 'fin':
+                this.cursor = this.unidades.length;
+                break;
+            case 'borrar_linea':
+                this.unidades.splice(0, this.cursor);
+                this.cursor = 0;
+                break;
+            case 'borrar_hasta_fin':
+                this.unidades.splice(this.cursor);
+                break;
+            case 'borrar_palabra': {
+                let i = this.cursor;
+                while (i > 0 && this.unidades[i - 1] === ' ')
+                    i--;
+                while (i > 0 && this.unidades[i - 1] !== ' ')
+                    i--;
+                this.unidades.splice(i, this.cursor - i);
+                this.cursor = i;
+                break;
+            }
+            case 'arriba':
+            case 'abajo': {
+                if (menu) {
+                    const n = menu.length;
+                    this.menuElegida = (this.menuElegida + (k.t === 'arriba' ? -1 : 1) + n) % n;
+                    break;
+                }
+                if (!this.historial.length)
+                    break;
+                if (this.posHistorial === this.historial.length)
+                    this.borrador = [...this.unidades];
+                this.posHistorial = Math.max(0, Math.min(this.historial.length, this.posHistorial + (k.t === 'arriba' ? -1 : 1)));
+                if (this.posHistorial === this.historial.length) {
+                    this.unidades = [...this.borrador];
+                    this.cursor = this.unidades.length;
+                }
+                else
+                    this.ponerValor(this.historial[this.posHistorial]);
+                this.menuCerradoPara = this.valorCrudo();
+                break;
+            }
+            case 'cambiar':
+                this.o.alCambiarModo?.();
+                break;
+            case 'ctrlc':
+                if (this.trabajo) {
+                    this.trabajo.alParar();
+                    break;
+                }
+                if (this.unidades.length) {
+                    this.unidades = [];
+                    this.cursor = 0;
+                    break;
+                }
+                this.ctrlC++;
+                if (this.ctrlC >= 2) {
+                    this.o.alSalir?.();
+                    break;
+                }
+                this.mostrarAviso(tt('tui.salir_otra'), 2000);
+                break;
+            case 'ctrld':
+                if (!this.unidades.length && this.resolverLectura && !this.trabajo) {
+                    const r = this.resolverLectura;
+                    this.resolverLectura = null;
+                    r(null);
+                }
+                break;
+            case 'limpiar':
+                this.recomponer();
+                break;
+            default:
+                break;
+        }
+    }
+    teclaDePregunta(k) {
+        const p = this.pregunta;
+        const n = p.opciones.length;
+        if (k.t === 'texto') {
+            const r = k.v.trim().toLowerCase();
+            const num = Number(r);
+            if (Number.isInteger(num) && num >= 1 && num <= n)
+                return this.responder(num - 1);
+            if (r === 'n')
+                return this.responder(p.valores.indexOf('no'));
+            if (r === 'y' && (p.valores[p.elegida] !== 'no' || p.peligro))
+                return this.responder(0);
+            return;
+        }
+        if (k.t === 'izq' || k.t === 'arriba')
+            p.elegida = (p.elegida + n - 1) % n;
+        else if (k.t === 'der' || k.t === 'abajo' || k.t === 'tab')
+            p.elegida = (p.elegida + 1) % n;
+        else if (k.t === 'intro')
+            this.responder(p.elegida);
+        else if (k.t === 'esc' || k.t === 'ctrlc')
+            this.responder(p.valores.indexOf('no'));
+    }
+    get _lineas() {
+        return this.lineas;
+    }
+    get _consejosVisibles() {
+        return this.consejosVisibles;
+    }
+    get _anchoCompuesto() {
+        return this.anchoCompuesto;
+    }
+    get _trabajo() {
+        return this.trabajo;
+    }
+}
+function sinColorSimple(t) {
+    return t.replace(/\x1b\[[0-9;]*m/g, '');
+}