@getparallel/parx 0.0.0-stage → 0.4.1

package/dist/marca.js

@@ -0,0 +1,200 @@
+import { usarPuntosAscii } from "./texto.js";
+export function detectarCapacidades(env = process.env, salida = process.stdout, plataforma = process.platform) {
+    const ancho = salida.columns && salida.columns > 20 ? salida.columns : 80;
+    let color = 0;
+    if (env.FORCE_COLOR !== undefined && env.FORCE_COLOR !== '0') {
+        color = env.FORCE_COLOR === '1' ? 2 : 3;
+    }
+    else if (env.NO_COLOR === undefined && salida.isTTY && env.TERM !== 'dumb') {
+        const term = env.TERM ?? '';
+        if (env.COLORTERM === 'truecolor' || env.COLORTERM === '24bit' || env.WT_SESSION || env.TERM_PROGRAM === 'iTerm.app' || env.TERM_PROGRAM === 'vscode' || env.TERM_PROGRAM === 'Apple_Terminal' || plataforma === 'win32') {
+            color = 3;
+        }
+        else if (/256/.test(term)) {
+            color = 2;
+        }
+        else {
+            color = 1;
+        }
+    }
+    const unicode = env.PARALLEL_ASCII ? false : plataforma !== 'win32' || Boolean(env.WT_SESSION) || env.TERM_PROGRAM === 'vscode' || Boolean(env.TERM);
+    return { color, unicode, ancho };
+}
+let caps = detectarCapacidades();
+usarPuntosAscii(!caps.unicode);
+export function capacidades() {
+    return caps;
+}
+export function fijarCapacidades(c) {
+    caps = { ...caps, ...c };
+    usarPuntosAscii(!caps.unicode);
+}
+const PALETA = {
+    violeta: [109, 74, 255],
+    violetaClaro: [139, 112, 255],
+    violetaTexto: [174, 155, 255],
+    gris: [165, 159, 186],
+    ok: [139, 112, 255],
+    aviso: [245, 166, 35],
+    error: [240, 82, 82],
+    verdeDiff: [80, 200, 120],
+    rojoDiff: [240, 100, 100],
+    peligro: [255, 69, 58],
+};
+const ANSI256 = {
+    violeta: 99,
+    violetaClaro: 141,
+    violetaTexto: 147,
+    gris: 146,
+    ok: 141,
+    aviso: 214,
+    error: 203,
+    verdeDiff: 78,
+    rojoDiff: 203,
+    peligro: 196,
+};
+const ANSI16 = {
+    violeta: 35,
+    violetaClaro: 95,
+    violetaTexto: 95,
+    gris: 90,
+    ok: 95,
+    aviso: 33,
+    error: 31,
+    verdeDiff: 32,
+    rojoDiff: 31,
+    peligro: 91,
+};
+function pintar(nombre, texto) {
+    const { color } = caps;
+    if (color === 0)
+        return texto;
+    if (color === 3) {
+        const [r, g, b] = PALETA[nombre];
+        return `\x1b[38;2;${r};${g};${b}m${texto}\x1b[39m`;
+    }
+    if (color === 2)
+        return `\x1b[38;5;${ANSI256[nombre]}m${texto}\x1b[39m`;
+    return `\x1b[${ANSI16[nombre]}m${texto}\x1b[39m`;
+}
+export const c = {
+    violeta: (t) => pintar('violeta', t),
+    claro: (t) => pintar('violetaClaro', t),
+    marca: (t) => pintar('violetaTexto', t),
+    gris: (t) => pintar('gris', t),
+    ok: (t) => pintar('ok', t),
+    aviso: (t) => pintar('aviso', t),
+    error: (t) => pintar('error', t),
+    mas: (t) => pintar('verdeDiff', t),
+    menos: (t) => pintar('rojoDiff', t),
+    peligro: (t) => pintar('peligro', t),
+    negrita: (t) => (caps.color ? `\x1b[1m${t}\x1b[22m` : t),
+    tenue: (t) => (caps.color ? `\x1b[2m${t}\x1b[22m` : t),
+};
+export { sinColor } from "./texto.js";
+export function logo() {
+    const filas = caps.unicode
+        ? ['    ▄█▀  ▄█▀', '   ▄█▀  ▄█▀ ', '  ▄█▀  ▄█▀  ', ' ▄█▀  ▄█▀   ']
+        : ['    //  // ', '   //  //  ', '  //  //   ', ' //  //    '];
+    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 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`;
+    }
+    return u ? `▐${ojos}▌` : `[${ojos}]`;
+}
+export const ANCHO_DE_ANIMACION = 8;
+export function animacion(tipo, paso) {
+    const u = caps.unicode;
+    const L = ANCHO_DE_ANIMACION;
+    const p = Math.max(0, Math.floor(paso));
+    const tenue = (x) => c.tenue(c.gris(x));
+    switch (tipo) {
+        case 'ruta': {
+            const pos = Math.min(L - 1, p % 12);
+            return `${c.violeta((u ? '━' : '=').repeat(pos))}${c.claro(u ? '●' : 'o')}${tenue((u ? '┄' : '-').repeat(L - 1 - pos))}`;
+        }
+        case 'tren': {
+            const cabeza = p % (L + 3);
+            let out = '';
+            for (let i = 0; i < L; i++) {
+                if (i === cabeza)
+                    out += c.claro(u ? '▸' : '>');
+                else if (i === cabeza - 1 || i === cabeza - 2)
+                    out += c.violeta(u ? '▰' : '=');
+                else
+                    out += tenue(u ? '─' : '-');
+            }
+            return out;
+        }
+        case 'lectura': {
+            const ciclo = (L - 1) * 2;
+            const q = p % ciclo;
+            const pos = q < L ? q : ciclo - q;
+            let out = '';
+            for (let i = 0; i < L; i++) {
+                if (i === pos)
+                    out += c.claro(u ? '╪' : '#');
+                else if (Math.abs(i - pos) === 1)
+                    out += c.violeta(u ? '═' : '=');
+                else
+                    out += tenue(u ? '═' : '=');
+            }
+            return out;
+        }
+        case 'tendido': {
+            const n = Math.min(L, p % 12);
+            let out = '';
+            for (let i = 0; i < L; i++)
+                out += i < n ? c.violeta(i % 2 === 0 ? (u ? '╪' : '+') : u ? '═' : '=') : tenue(u ? '·' : '.');
+            return out;
+        }
+    }
+}
+export function signo() {
+    return caps.unicode ? '╱╱' : '//';
+}
+export function carril(ancho) {
+    return (caps.unicode ? '═' : '=').repeat(Math.max(0, ancho));
+}
+export function sep() {
+    return caps.unicode ? ' · ' : ' - ';
+}
+export const SIMBOLOS = {
+    get punto() {
+        return caps.unicode ? '●' : '*';
+    },
+    get hecho() {
+        return caps.unicode ? '✓' : 'v';
+    },
+    get falla() {
+        return caps.unicode ? '✗' : 'x';
+    },
+    get flecha() {
+        return caps.unicode ? '›' : '>';
+    },
+    get raya() {
+        return caps.unicode ? '─' : '-';
+    },
+    get candado() {
+        return caps.unicode ? '⏺' : '!';
+    },
+};

package/dist/mision.js

@@ -0,0 +1,16 @@
+export const MAX_OBJETIVO = 600;
+export function objetivoDeMision(meta, diario) {
+    const ultima = [...diario].reverse().find((d) => d.pedido.trim());
+    const que = (meta.trim() || ultima?.pedido.trim() || '').replace(/\s+/g, ' ');
+    if (que.length < 4)
+        return null;
+    const ficheros = [...new Set(diario.flatMap((d) => d.ficheros))].slice(0, 6);
+    const contexto = ultima
+        ? ` Context from the terminal (parx): ${ficheros.length ? `changed ${ficheros.join(', ')}. ` : ''}${ultima.respuesta ? `Last result: ${ultima.respuesta.replace(/\s+/g, ' ')}` : ''}`
+        : '';
+    const base = que.length > MAX_OBJETIVO ? `${que.slice(0, MAX_OBJETIVO - 1)}…` : que;
+    const sitio = MAX_OBJETIVO - base.length;
+    if (!contexto.trim() || sitio < 40)
+        return base;
+    return `${base}${contexto.length > sitio ? `${contexto.slice(0, sitio - 1)}…` : contexto}`;
+}

package/dist/modelos.js

@@ -0,0 +1,28 @@
+export const MODELOS = {
+    swift: { id: 'swift', nombre: 'Swift', version: '1.0', servidor: 'rapido', descripcion: 'Fast, for simple things. Spends less.' },
+    stride: { id: 'stride', nombre: 'Stride', version: '1.0', servidor: 'potente', descripcion: 'The balance. The default.' },
+    summit: { id: 'summit', nombre: 'Summit', version: '1.0', servidor: 'maximo', descripcion: 'Most capable, for the hardest work. Spends more.' },
+};
+export const ORDEN_DE_MODELOS = ['swift', 'stride', 'summit'];
+export const MODELO_POR_DEFECTO = 'stride';
+export function nombreDeModelo(m) {
+    const f = MODELOS[m];
+    return `${f.nombre} ${f.version}`;
+}
+export function modeloDe(texto) {
+    const v = (texto ?? '').trim().toLowerCase().replace(/\s*\d+(\.\d+)?$/, '');
+    const tabla = {
+        swift: 'swift',
+        fast: 'swift',
+        rapido: 'swift',
+        'rápido': 'swift',
+        stride: 'stride',
+        powerful: 'stride',
+        potente: 'stride',
+        summit: 'summit',
+        max: 'summit',
+        maximo: 'summit',
+        'máximo': 'summit',
+    };
+    return tabla[v] ?? null;
+}

package/dist/notificar.js

@@ -0,0 +1,112 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { carpetaDeConfiguracion } from "./config.js";
+export const TAREA_LARGA_MS = 45_000;
+export function debeAvisar(enfocada, ms) {
+    if (enfocada === false)
+        return true;
+    if (enfocada === null)
+        return ms >= TAREA_LARGA_MS;
+    return false;
+}
+export function sonidoDeParallel() {
+    const hz = 44_100;
+    const dur = 0.62;
+    const n = Math.floor(hz * dur);
+    const datos = Buffer.alloc(n * 2);
+    const notas = [
+        [659.25, 0],
+        [987.77, 0.09],
+    ];
+    for (let i = 0; i < n; i++) {
+        const t = i / hz;
+        let v = 0;
+        for (const [f, desde] of notas) {
+            if (t < desde)
+                continue;
+            const x = t - desde;
+            const entrada = Math.min(1, x / 0.012);
+            const caida = Math.exp(-x * 6.5);
+            v += Math.sin(2 * Math.PI * f * x) * entrada * caida * 0.28 + Math.sin(4 * Math.PI * f * x) * entrada * caida * 0.04;
+        }
+        datos.writeInt16LE(Math.max(-32767, Math.min(32767, Math.round(v * 32767))), i * 2);
+    }
+    const cab = Buffer.alloc(44);
+    cab.write('RIFF', 0);
+    cab.writeUInt32LE(36 + datos.length, 4);
+    cab.write('WAVE', 8);
+    cab.write('fmt ', 12);
+    cab.writeUInt32LE(16, 16);
+    cab.writeUInt16LE(1, 20);
+    cab.writeUInt16LE(1, 22);
+    cab.writeUInt32LE(hz, 24);
+    cab.writeUInt32LE(hz * 2, 28);
+    cab.writeUInt16LE(2, 32);
+    cab.writeUInt16LE(16, 34);
+    cab.write('data', 36);
+    cab.writeUInt32LE(datos.length, 40);
+    return Buffer.concat([cab, datos]);
+}
+export function rutaDelSonido(dir = carpetaDeConfiguracion()) {
+    const ruta = join(dir, 'par.wav');
+    try {
+        if (!existsSync(ruta)) {
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            writeFileSync(ruta, sonidoDeParallel(), { mode: 0o600 });
+        }
+        return ruta;
+    }
+    catch {
+        return null;
+    }
+}
+function existe(programa) {
+    return spawnSync(process.platform === 'win32' ? 'where' : 'which', [programa], { stdio: 'ignore' }).status === 0;
+}
+function lanzar(programa, args, env) {
+    try {
+        const h = spawn(programa, args, { stdio: 'ignore', detached: true, windowsHide: true, env: env ? { ...process.env, ...env } : process.env });
+        h.on('error', () => { });
+        h.unref();
+    }
+    catch {
+    }
+}
+export function ordenesDeAviso(a, plataforma, sonido, hay = existe) {
+    const texto = a.texto.replace(/\s+/g, ' ').slice(0, 180);
+    if (plataforma === 'darwin') {
+        const out = [{ programa: 'osascript', args: ['-e', 'on run argv', '-e', 'display notification (item 2 of argv) with title (item 1 of argv)', '-e', 'end run', a.titulo, texto] }];
+        if (sonido)
+            out.push({ programa: 'afplay', args: [sonido] });
+        return out;
+    }
+    if (plataforma === 'win32') {
+        const ps = [
+            '[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null',
+            '$x = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)',
+            '$x.GetElementsByTagName("text")[0].AppendChild($x.CreateTextNode($env:PARX_AVISO_TITULO)) > $null',
+            '$x.GetElementsByTagName("text")[1].AppendChild($x.CreateTextNode($env:PARX_AVISO_TEXTO)) > $null',
+            '$a = "{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe"',
+            '[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier($a).Show([Windows.UI.Notifications.ToastNotification]::new($x))',
+            'if ($env:PARX_AVISO_SONIDO) { (New-Object Media.SoundPlayer $env:PARX_AVISO_SONIDO).PlaySync() }',
+        ].join('; ');
+        return [{ programa: 'powershell.exe', args: ['-NoProfile', '-NonInteractive', '-WindowStyle', 'Hidden', '-Command', ps], env: { PARX_AVISO_TITULO: a.titulo, PARX_AVISO_TEXTO: texto, PARX_AVISO_SONIDO: sonido ?? '' } }];
+    }
+    const out = [];
+    if (hay('notify-send'))
+        out.push({ programa: 'notify-send', args: ['--app-name=parx', a.titulo, texto] });
+    if (sonido) {
+        if (hay('paplay'))
+            out.push({ programa: 'paplay', args: [sonido] });
+        else if (hay('aplay'))
+            out.push({ programa: 'aplay', args: ['-q', sonido] });
+    }
+    return out;
+}
+export function avisarEnElEscritorio(a) {
+    if (process.env.PARX_NO_NOTIFY || process.env.CI)
+        return;
+    for (const o of ordenesDeAviso(a, process.platform, rutaDelSonido()))
+        lanzar(o.programa, o.args, o.env);
+}

package/dist/qr.js

@@ -0,0 +1,272 @@
+const ECC_POR_BLOQUE_M = [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26];
+const BLOQUES_M = [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5];
+const BITS_DE_FORMATO_M = 0;
+function modulosDeDatos(ver) {
+    let r = (16 * ver + 128) * ver + 64;
+    if (ver >= 2) {
+        const n = Math.floor(ver / 7) + 2;
+        r -= (25 * n - 10) * n - 55;
+        if (ver >= 7)
+            r -= 36;
+    }
+    return r;
+}
+function palabrasDeDatos(ver) {
+    return Math.floor(modulosDeDatos(ver) / 8) - ECC_POR_BLOQUE_M[ver] * BLOQUES_M[ver];
+}
+function mul(x, y) {
+    let z = 0;
+    for (let i = 7; i >= 0; i--) {
+        z = (z << 1) ^ ((z >>> 7) * 0x11d);
+        z ^= ((y >>> i) & 1) * x;
+    }
+    return z & 0xff;
+}
+function divisor(grado) {
+    const r = new Array(grado).fill(0);
+    r[grado - 1] = 1;
+    let raiz = 1;
+    for (let i = 0; i < grado; i++) {
+        for (let j = 0; j < r.length; j++) {
+            r[j] = mul(r[j], raiz);
+            if (j + 1 < r.length)
+                r[j] ^= r[j + 1];
+        }
+        raiz = mul(raiz, 0x02);
+    }
+    return r;
+}
+function resto(datos, div) {
+    const r = div.map(() => 0);
+    for (const b of datos) {
+        const f = b ^ r.shift();
+        r.push(0);
+        div.forEach((c, i) => (r[i] ^= mul(c, f)));
+    }
+    return r;
+}
+function posicionesDeAlineacion(ver) {
+    if (ver === 1)
+        return [];
+    const n = Math.floor(ver / 7) + 2;
+    const paso = Math.ceil((ver * 4 + 4) / (n * 2 - 2)) * 2;
+    const r = [6];
+    for (let pos = ver * 4 + 17 - 7; r.length < n; pos -= paso)
+        r.splice(1, 0, pos);
+    return r;
+}
+export function matrizQR(texto) {
+    const bytes = [...Buffer.from(texto, 'utf8')];
+    let ver = 1;
+    for (; ver <= 10; ver++) {
+        const bitsCuenta = ver < 10 ? 8 : 16;
+        if (4 + bitsCuenta + bytes.length * 8 <= palabrasDeDatos(ver) * 8)
+            break;
+    }
+    if (ver > 10)
+        throw new Error('QR: text too long');
+    const capacidad = palabrasDeDatos(ver) * 8;
+    const bits = [];
+    const poner = (v, n) => {
+        for (let i = n - 1; i >= 0; i--)
+            bits.push((v >>> i) & 1);
+    };
+    poner(0b0100, 4);
+    poner(bytes.length, ver < 10 ? 8 : 16);
+    for (const b of bytes)
+        poner(b, 8);
+    poner(0, Math.min(4, capacidad - bits.length));
+    poner(0, (8 - (bits.length % 8)) % 8);
+    for (let p = 0xec; bits.length < capacidad; p ^= 0xec ^ 0x11)
+        poner(p, 8);
+    const datos = [];
+    for (let i = 0; i < bits.length; i += 8)
+        datos.push(bits.slice(i, i + 8).reduce((a, b) => (a << 1) | b, 0));
+    const nBloques = BLOQUES_M[ver];
+    const eccLen = ECC_POR_BLOQUE_M[ver];
+    const brutas = Math.floor(modulosDeDatos(ver) / 8);
+    const cortos = nBloques - (brutas % nBloques);
+    const largoCorto = Math.floor(brutas / nBloques);
+    const div = divisor(eccLen);
+    const bloques = [];
+    for (let i = 0, k = 0; i < nBloques; i++) {
+        const dat = datos.slice(k, k + largoCorto - eccLen + (i < cortos ? 0 : 1));
+        k += dat.length;
+        const ecc = resto(dat, div);
+        if (i < cortos)
+            dat.push(0);
+        bloques.push(dat.concat(ecc));
+    }
+    const final = [];
+    for (let i = 0; i < bloques[0].length; i++) {
+        bloques.forEach((b, j) => {
+            if (i !== largoCorto - eccLen || j >= cortos)
+                final.push(b[i]);
+        });
+    }
+    const n = ver * 4 + 17;
+    const m = Array.from({ length: n }, () => new Array(n).fill(false));
+    const fn = Array.from({ length: n }, () => new Array(n).fill(false));
+    const fijar = (x, y, v) => {
+        m[y][x] = v;
+        fn[y][x] = true;
+    };
+    for (let i = 0; i < n; i++) {
+        fijar(6, i, i % 2 === 0);
+        fijar(i, 6, i % 2 === 0);
+    }
+    for (const [cx, cy] of [
+        [3, 3],
+        [n - 4, 3],
+        [3, n - 4],
+    ]) {
+        for (let dy = -4; dy <= 4; dy++) {
+            for (let dx = -4; dx <= 4; dx++) {
+                const d = Math.max(Math.abs(dx), Math.abs(dy));
+                const x = cx + dx;
+                const y = cy + dy;
+                if (x >= 0 && x < n && y >= 0 && y < n)
+                    fijar(x, y, d !== 2 && d !== 4);
+            }
+        }
+    }
+    const al = posicionesDeAlineacion(ver);
+    al.forEach((a, i) => al.forEach((b, j) => {
+        if ((i === 0 && j === 0) || (i === 0 && j === al.length - 1) || (i === al.length - 1 && j === 0))
+            return;
+        for (let dy = -2; dy <= 2; dy++)
+            for (let dx = -2; dx <= 2; dx++)
+                fijar(a + dx, b + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+    }));
+    const formato = (mascara) => {
+        const d = (BITS_DE_FORMATO_M << 3) | mascara;
+        let r = d;
+        for (let i = 0; i < 10; i++)
+            r = (r << 1) ^ ((r >>> 9) * 0x537);
+        const b = ((d << 10) | r) ^ 0x5412;
+        const bit = (i) => ((b >>> i) & 1) !== 0;
+        for (let i = 0; i <= 5; i++)
+            fijar(8, i, bit(i));
+        fijar(8, 7, bit(6));
+        fijar(8, 8, bit(7));
+        fijar(7, 8, bit(8));
+        for (let i = 9; i < 15; i++)
+            fijar(14 - i, 8, bit(i));
+        for (let i = 0; i < 8; i++)
+            fijar(n - 1 - i, 8, bit(i));
+        for (let i = 8; i < 15; i++)
+            fijar(8, n - 15 + i, bit(i));
+        fijar(8, n - 8, true);
+    };
+    formato(0);
+    if (ver >= 7) {
+        let r = ver;
+        for (let i = 0; i < 12; i++)
+            r = (r << 1) ^ ((r >>> 11) * 0x1f25);
+        const b = (ver << 12) | r;
+        for (let i = 0; i < 18; i++) {
+            const v = ((b >>> i) & 1) !== 0;
+            const a = n - 11 + (i % 3);
+            const c = Math.floor(i / 3);
+            fijar(a, c, v);
+            fijar(c, a, v);
+        }
+    }
+    let i = 0;
+    for (let derecha = n - 1; derecha >= 1; derecha -= 2) {
+        if (derecha === 6)
+            derecha = 5;
+        for (let v = 0; v < n; v++) {
+            for (let j = 0; j < 2; j++) {
+                const x = derecha - j;
+                const y = ((derecha + 1) & 2) === 0 ? n - 1 - v : v;
+                if (!fn[y][x] && i < final.length * 8) {
+                    m[y][x] = ((final[i >>> 3] >>> (7 - (i & 7))) & 1) !== 0;
+                    i++;
+                }
+            }
+        }
+    }
+    const MASCARAS = [
+        (x, y) => (x + y) % 2 === 0,
+        (_x, y) => y % 2 === 0,
+        (x) => x % 3 === 0,
+        (x, y) => (x + y) % 3 === 0,
+        (x, y) => (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0,
+        (x, y) => ((x * y) % 2) + ((x * y) % 3) === 0,
+        (x, y) => (((x * y) % 2) + ((x * y) % 3)) % 2 === 0,
+        (x, y) => (((x + y) % 2) + ((x * y) % 3)) % 2 === 0,
+    ];
+    const aplicar = (k) => {
+        for (let y = 0; y < n; y++)
+            for (let x = 0; x < n; x++)
+                if (!fn[y][x] && MASCARAS[k](x, y))
+                    m[y][x] = !m[y][x];
+    };
+    const penalizacion = () => {
+        let p = 0;
+        for (let a = 0; a < n; a++) {
+            for (const fila of [true, false]) {
+                let racha = 1;
+                for (let b = 1; b <= n; b++) {
+                    const igual = b < n && (fila ? m[a][b] === m[a][b - 1] : m[b]?.[a] === m[b - 1][a]);
+                    if (igual)
+                        racha++;
+                    else {
+                        if (racha >= 5)
+                            p += racha - 2;
+                        racha = 1;
+                    }
+                }
+            }
+        }
+        for (let y = 0; y < n - 1; y++)
+            for (let x = 0; x < n - 1; x++)
+                if (m[y][x] === m[y][x + 1] && m[y][x] === m[y + 1][x] && m[y][x] === m[y + 1][x + 1])
+                    p += 3;
+        const oscuros = m.flat().filter(Boolean).length;
+        p += Math.floor(Math.abs(oscuros * 20 - n * n * 10) / (n * n)) * 10;
+        return p;
+    };
+    let mejor = 0;
+    let minimo = Infinity;
+    for (let k = 0; k < 8; k++) {
+        aplicar(k);
+        formato(k);
+        const p = penalizacion();
+        if (p < minimo) {
+            minimo = p;
+            mejor = k;
+        }
+        aplicar(k);
+    }
+    aplicar(mejor);
+    formato(mejor);
+    return m;
+}
+export function qrEnTexto(texto, opciones) {
+    if (!opciones.unicode)
+        return null;
+    const m = matrizQR(texto);
+    const margen = 2;
+    const n = m.length + margen * 2;
+    const oscuro = (x, y) => {
+        const xx = x - margen;
+        const yy = y - margen;
+        return yy >= 0 && yy < m.length && xx >= 0 && xx < m.length ? m[yy][xx] : false;
+    };
+    const lineas = [];
+    for (let y = 0; y < n; y += 2) {
+        let l = '';
+        for (let x = 0; x < n; x++) {
+            const arriba = oscuro(x, y);
+            const abajo = y + 1 < n ? oscuro(x, y + 1) : false;
+            if (opciones.color)
+                l += arriba && abajo ? '█' : arriba ? '▀' : abajo ? '▄' : ' ';
+            else
+                l += !arriba && !abajo ? '█' : !arriba ? '▀' : !abajo ? '▄' : ' ';
+        }
+        lineas.push(opciones.color ? `\x1b[30;107m${l}\x1b[39;49m` : l);
+    }
+    return lineas;
+}

package/dist/registro.js

@@ -0,0 +1,24 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { carpetaDeConfiguracion } from "./config.js";
+export class Registro {
+    ruta;
+    sesion;
+    constructor(sesion, dir = join(carpetaDeConfiguracion(), 'registro')) {
+        this.sesion = sesion;
+        const dia = new Date().toISOString().slice(0, 10);
+        this.ruta = join(dir, `${dia}.jsonl`);
+        try {
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        }
+        catch {
+        }
+    }
+    apuntar(tipo, datos = {}) {
+        try {
+            appendFileSync(this.ruta, `${JSON.stringify({ t: new Date().toISOString(), sesion: this.sesion, tipo, ...datos })}\n`, { mode: 0o600 });
+        }
+        catch {
+        }
+    }
+}