primocode 11.1.0 → 11.2.0

package/lib/plugin/video/ops-fx.js

@@ -215,7 +215,7 @@ const OPS = {
                 ate = Math.min(asset.seconds, ate);
                 if (!(ate > de + 0.5)) throw T.erro('o momento 3D precisa de pelo menos meio segundo');
             }
-            return require('./ops.js').mutar(ctx, 'separate_layers', (tl) => {
+            return require('./mutar.js').mutar(ctx, 'separate_layers', (tl) => {
                 const pessoa = camadaDaPessoa(tl, asset, rs);
                 const out = { layers: { pessoa: pessoa.length, fundo: 'a gravação embaixo' } };
                 if (a.show3d !== undefined) { C.limparPapel(tl, 'camadas3d', asset.id); C.limparGerados(tl); }
@@ -261,7 +261,7 @@ const OPS = {
             const seg = a.at === undefined ? await momento(ctx, asset, 'snap').catch(() => 0) : await momento(ctx, asset, a.at);
             const medido = await r().medirAsset(ctx.tl, arquivo);
             const ganho = ganhoDeCor(await corMedia(rs.arquivos.fundo), await corMedia(arquivo));
-            return require('./ops.js').mutar(ctx, 'replace_background', (tl) => {
+            return require('./mutar.js').mutar(ctx, 'replace_background', (tl) => {
                 if (!temPessoa(tl, asset.id)) camadaDaPessoa(tl, asset, rs);
                 const F = quadro({ tl }, asset, seg) ?? 0;
                 const fim = a.until !== undefined ? Math.round(Number(a.until)) : T.duracao(tl);
@@ -334,7 +334,7 @@ const OPS = {
             if (de === null) de = t[0];
             const ate = a.to !== undefined ? await momento(ctx, asset, a.to) : Math.min(asset.seconds, Math.max(t[1] + 0.3, de + 1.5));
             if (!(ate > de)) throw T.erro('"to" antes de "from"');
-            return require('./ops.js').mutar(ctx, 'attach_3d', (tl) => {
+            return require('./mutar.js').mutar(ctx, 'attach_3d', (tl) => {
                 const f = fxDe(tl, asset.id);
                 const o = { id: `o${f.objetos.length + 1}`, modelo, mao, de: r2(de * 1000) / 1000, ate: r2(ate * 1000) / 1000 };
                 if (a.color) o.cor = C.cor(a.color);
@@ -365,7 +365,7 @@ const OPS = {
             }
             const ateFusao = a.until !== undefined ? await momento(ctx, asset, a.until) : null;
             const depois = a.then === 'none' || a.then === false ? null : C.modeloDe(a.then || 'brain') || 'cerebro';
-            return require('./ops.js').mutar(ctx, 'merge_on_join', (tl) => {
+            return require('./mutar.js').mutar(ctx, 'merge_on_join', (tl) => {
                 const f = fxDe(tl, asset.id);
                 // Os objetos vivos na junção ficam até ela (e se fundem).
                 for (const o of f.objetos) if (o.de < junta && o.ate < junta + 0.5) o.ate = r2((junta + 0.6) * 1000) / 1000;
@@ -400,7 +400,7 @@ const OPS = {
                 if (i1 > i0) ranges.push([T.origemParaQuadro(ctx.tl, c, i0), T.origemParaQuadro(ctx.tl, c, i1)]);
             }
             if (!ranges.length) return { ok: false, error: 'esse silêncio já foi cortado' };
-            return require('./ops.js').mutar(ctx, 'cut_silence_at', (tl) => ({ silence: { de: r2(de), ate: r2(ate) }, ...E.apagarTrechos(tl, ranges) }));
+            return require('./mutar.js').mutar(ctx, 'cut_silence_at', (tl) => ({ silence: { de: r2(de), ate: r2(ate) }, ...E.apagarTrechos(tl, ranges) }));
         },
     },
     style_captions: {
@@ -423,7 +423,7 @@ const OPS = {
             const CY = { bottom: 0.78, baixo: 0.78, top: 0.14, topo: 0.14, center: 0.5, centro: 0.5, middle: 0.5 };
             if (pos && !seguir && CY[pos] === undefined) throw T.erro(`position "${a.position}" (use above_head, bottom, top ou center)`);
             const corPedida = a.color !== undefined ? C.cor(a.color) : undefined;
-            return require('./ops.js').mutar(ctx, 'style_captions', (t) => {
+            return require('./mutar.js').mutar(ctx, 'style_captions', (t) => {
                 for (const ref of alvo) {
                     const c = T.achar(t, ref.id).clip;
                     const st = { ...(c.text.style || {}) };

package/lib/plugin/video/ops.js

@@ -17,6 +17,7 @@ const T = require('./timeline.js');
 const E = require('./edits.js');
 const F = require('./filters.js');
 const { diff } = require('./delta.js');
+const { mutar } = require('./mutar.js');
 const P = require('./projeto.js');
 const TR = require('./transcript.js');
 const A = require('./analise.js');
@@ -35,19 +36,6 @@ function alvos(tl, args, { tipos = ['video', 'image'] } = {}) {
     return refs.map((ref) => T.achar(tl, ref).clip.id);
 }
 
-async function mutar(ctx, op, fn) {
-    const antes = T.clone(ctx.tl);
-    const extra = (await fn(ctx.tl)) || {};
-    T.ordenar(ctx.tl);
-    const probs = T.problemas(ctx.tl);
-    if (probs.length) throw T.erro(`edição recusada (nada mudou): ${probs.slice(0, 4).join('; ')}`);
-    P.fotografar(ctx.p, antes, op);
-    P.salvar(ctx.p, ctx.tl);
-    const d = diff(antes, ctx.tl, extra);
-    P.anotar(ctx.p, op, { dur: d.dur, added: (d.added || []).length, removed: (d.removed || []).length });
-    return d;
-}
-
 function precisaProjeto(ctx) {
     if (!ctx.tl) throw T.erro('nenhum projeto aberto: comece com import {"path":"..."} (cria o projeto) ou new');
 }
@@ -311,6 +299,7 @@ const PED = require('./pedido.js');
 const AUTO = require('./auto.js');
 const ZOOM = require('./zoom.js');   // o zoom que segue o cursor (gravação de tela): fica na ajuda principal
 Object.assign(OPS, FXO.OPS, PED.OPS, AUTO.OPS, ZOOM.OPS);
+require('./catalogo.js').registrar(OPS);   // auto e pedido encadeiam operações por aqui
 
 const ALIAS = { timeline: 'get_timeline', transcript: 'get_transcript', captions: 'add_captions', texts: 'add_texts', render: 'export', pedido: 'do', analyze: 'track' };
 

package/lib/plugin/video/pedido.js

@@ -152,7 +152,7 @@ const OPS = {
             const resumo = plano.passos.map((p) => ({ op: p.op, args: p.args }));
             if (a.dryRun) return { ok: true, plano: resumo, ...(plano.avisos.length ? { avisos: plano.avisos } : {}) };
             if (!tl) throw T.erro('nenhum projeto aberto: import {"path":"..."} primeiro');
-            const { OPS: TODAS } = require('./ops.js');
+            const TODAS = require('./catalogo.js').catalogo();
             // O que é lento e não depende de nada roda JUNTO antes do primeiro passo.
             const C2 = require('./camadas.js');
             const asset = C2.base(tl);

package/lib/plugin/video/zoom.js

@@ -231,7 +231,7 @@ const OPS = {
         async run(ctx, a) {
             const T = require('./timeline.js');
             const E = require('./edits.js');
-            const { mutar } = require('./ops.js');
+            const { mutar } = require('./mutar.js');
             if (!ctx.tl) throw T.erro('nenhum projeto aberto: comece com import {"path":"..."}');
             const primeiro = T.todosOsClipes(ctx.tl).find((x) => x.clip.type === 'video');
             if (!a.id && !primeiro) throw T.erro('não há clipe de vídeo');

package/lib/projetos-meta.js

@@ -0,0 +1,90 @@
+// Projetos do app: pasta em ~/primocode/<projeto>/ + .primocode/projeto.json
+// (nome, descrição, ícone, cor). docs/estrutura.md, seção 7. Node puro.
+// "Apagar" só arquiva (marca no projeto.json): os arquivos da pessoa nunca são removidos.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ICONES = ['folder', 'film', 'palette', 'workflow', 'pen', 'home', 'shield', 'bell', 'sliders'];
+const COR_PADRAO = '#22d3ee';
+const hexOk = (h) => /^#[0-9a-f]{6}$/i.test(String(h || ''));
+const cfg = () => require('./config/config');
+const raiz = () => cfg().ROOT_DIR;
+const metaDe = (dir) => path.join(dir, '.primocode', 'projeto.json');
+
+function lerMeta(dir) { try { return JSON.parse(fs.readFileSync(metaDe(dir), 'utf8')); } catch { return {}; } }
+function gravarMeta(dir, meta) {
+    fs.mkdirSync(path.join(dir, '.primocode'), { recursive: true });
+    fs.writeFileSync(metaDe(dir), JSON.stringify(meta, null, 2) + '\n');
+}
+
+/* id = nome da pasta. Só vale se a pasta existe dentro da raiz. */
+function pastaDe(id) {
+    const s = String(id || '');
+    if (!/^[\w][\w.-]{0,80}$/.test(s)) return null;
+    const dir = path.join(raiz(), s);
+    try { return fs.statSync(dir).isDirectory() ? dir : null; } catch { return null; }
+}
+
+/* Se a pasta é um repositório git, devolve { git: true, ramo }: lido do .git/HEAD, sem rodar o git. */
+function ramoGit(dir) {
+    try {
+        const cabeca = fs.readFileSync(path.join(dir, '.git', 'HEAD'), 'utf8').trim();
+        const m = /^ref: refs\/heads\/(.+)$/.exec(cabeca);
+        return { git: true, ramo: m ? m[1] : cabeca.slice(0, 7) };
+    } catch { return { git: false, ramo: '' }; }
+}
+
+function resumo(id) {
+    const dir = path.join(raiz(), id);
+    const m = lerMeta(dir);
+    return {
+        id, nome: m.nome || id, descricao: m.descricao || '',
+        icone: ICONES.includes(m.icone) ? m.icone : 'folder', cor: hexOk(m.cor) ? m.cor : COR_PADRAO,
+        caminho: dir, arquivado: !!m.arquivado, criado: m.criado || null,
+        ...ramoGit(dir),
+    };
+}
+
+function listar({ arquivados = false } = {}) {
+    return cfg().listProjects().map(resumo).filter((p) => arquivados || !p.arquivado);
+}
+
+function limpar(c, { criando = false } = {}) {
+    const out = {};
+    if ('nome' in c) { out.nome = String(c.nome || '').trim().slice(0, 80); if (!out.nome) throw new Error('falta o nome'); }
+    else if (criando) throw new Error('falta o nome');
+    if ('descricao' in c) out.descricao = String(c.descricao || '').trim().slice(0, 240);
+    if ('icone' in c && c.icone) { if (!ICONES.includes(c.icone)) throw new Error(`ícone inválido (use: ${ICONES.join(', ')})`); out.icone = c.icone; }
+    if ('cor' in c && c.cor) { if (!hexOk(c.cor)) throw new Error('cor inválida (use #rrggbb)'); out.cor = String(c.cor).toLowerCase(); }
+    return out;
+}
+
+function criar(c = {}) {
+    const campos = limpar(c, { criando: true });
+    const dir = cfg().createProjectDir(campos.nome);
+    const id = path.basename(dir);
+    const atual = lerMeta(dir);
+    if (atual.nome && !atual.arquivado) throw new Error(`já existe o projeto "${atual.nome}"`);
+    gravarMeta(dir, { ...atual, ...campos, arquivado: false, criado: atual.criado || new Date().toISOString() });
+    return resumo(id);
+}
+
+function atualizar(id, c = {}) {
+    const dir = pastaDe(id);
+    if (!dir) throw new Error(`não achei o projeto ${id}`);
+    const campos = limpar(c);
+    if (!Object.keys(campos).length) throw new Error('nada para mudar (nome, descricao, icone, cor)');
+    gravarMeta(dir, { ...lerMeta(dir), ...campos });
+    return resumo(path.basename(dir));
+}
+
+function arquivar(id) {
+    const dir = pastaDe(id);
+    if (!dir) throw new Error(`não achei o projeto ${id}`);
+    gravarMeta(dir, { ...lerMeta(dir), arquivado: true });
+    return { id: path.basename(dir), arquivado: true, arquivos: 'mantidos' };
+}
+
+module.exports = { ICONES, listar, criar, atualizar, arquivar, pastaDe, resumo };

package/lib/qr.js

@@ -0,0 +1,209 @@
+// Gerador de QR code mínimo, sem dependência: modo byte (UTF-8), correção L ou M, versões 1 a 10
+// (até 213 bytes no M, 271 no L). Serve para o pareamento do celular (docs/estrutura.md, seção 15).
+// Algoritmo da ISO/IEC 18004: Reed-Solomon em GF(256), 8 máscaras, escolhe a de menor penalidade.
+'use strict';
+
+const ECC_POR_BLOCO = { L: [7, 10, 15, 20, 26, 18, 20, 24, 30, 18], M: [10, 16, 26, 18, 24, 16, 18, 22, 22, 26] };
+const NUM_BLOCOS = { L: [1, 1, 1, 1, 1, 2, 2, 2, 2, 4], M: [1, 1, 1, 2, 2, 4, 4, 4, 5, 5] };
+const FORMATO_ECC = { L: 1, M: 0 };
+const VERSAO_MAX = 10;
+
+/* Módulos que sobram para dados + correção, descontados padrões de função. */
+function modulosBrutos(v) {
+    let r = (16 * v + 128) * v + 64;
+    if (v >= 2) {
+        const n = Math.floor(v / 7) + 2;
+        r -= (25 * n - 10) * n - 55;
+        if (v >= 7) r -= 36;
+    }
+    return r;
+}
+const dadosCodewords = (v, ecc) => Math.floor(modulosBrutos(v) / 8) - ECC_POR_BLOCO[ecc][v - 1] * NUM_BLOCOS[ecc][v - 1];
+
+/* GF(256) com o polinômio 0x11D. */
+function multiplicar(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;
+}
+function divisor(grau) {
+    const r = new Array(grau).fill(0);
+    r[grau - 1] = 1;
+    let raiz = 1;
+    for (let i = 0; i < grau; i++) {
+        for (let j = 0; j < r.length; j++) { r[j] = multiplicar(r[j], raiz); if (j + 1 < r.length) r[j] ^= r[j + 1]; }
+        raiz = multiplicar(raiz, 2);
+    }
+    return r;
+}
+function resto(dados, div) {
+    const r = new Array(div.length).fill(0);
+    for (const b of dados) {
+        const f = b ^ r.shift();
+        r.push(0);
+        div.forEach((c, i) => { r[i] ^= multiplicar(c, f); });
+    }
+    return r;
+}
+
+function bitsDoTexto(bytes, v, ecc) {
+    const bits = [];
+    const poe = (valor, n) => { for (let i = n - 1; i >= 0; i--) bits.push((valor >>> i) & 1); };
+    poe(0b0100, 4);
+    poe(bytes.length, v <= 9 ? 8 : 16);
+    for (const b of bytes) poe(b, 8);
+    const cap = dadosCodewords(v, ecc) * 8;
+    poe(0, Math.min(4, cap - bits.length));
+    poe(0, (8 - (bits.length % 8)) % 8);
+    for (let pad = 0xEC; bits.length < cap; pad ^= 0xEC ^ 0x11) poe(pad, 8);
+    const cw = [];
+    for (let i = 0; i < bits.length; i += 8) cw.push(parseInt(bits.slice(i, i + 8).join(''), 2));
+    return cw;
+}
+
+/* Divide em blocos, calcula a correção e intercala. */
+function intercalar(dados, v, ecc) {
+    const nb = NUM_BLOCOS[ecc][v - 1];
+    const eb = ECC_POR_BLOCO[ecc][v - 1];
+    const total = Math.floor(modulosBrutos(v) / 8);
+    const curtos = nb - (total % nb);
+    const lenCurto = Math.floor(total / nb) - eb;
+    const div = divisor(eb);
+    const blocos = [];
+    for (let i = 0, k = 0; i < nb; i++) {
+        const dat = dados.slice(k, k + lenCurto + (i < curtos ? 0 : 1));
+        k += dat.length;
+        blocos.push({ dat, ecc: resto(dat, div) });
+    }
+    const out = [];
+    for (let i = 0; i <= lenCurto; i++) for (const b of blocos) if (i < b.dat.length) out.push(b.dat[i]);
+    for (let i = 0; i < eb; i++) for (const b of blocos) out.push(b.ecc[i]);
+    return out;
+}
+
+function criarMatriz(v) {
+    const n = v * 4 + 17;
+    return { n, m: Array.from({ length: n }, () => new Array(n).fill(false)), f: Array.from({ length: n }, () => new Array(n).fill(false)) };
+}
+function posAlinhamento(v) {
+    if (v === 1) return [];
+    const n = Math.floor(v / 7) + 2;
+    const passo = v === 32 ? 26 : Math.ceil((v * 4 + 4) / (n * 2 - 2)) * 2;
+    const r = [6];
+    for (let p = v * 4 + 10; r.length < n; p -= passo) r.splice(1, 0, p);
+    return r;
+}
+function desenharFuncoes(Q, v, ecc) {
+    const { n, m, f } = Q;
+    const set = (x, y, cor) => { if (x >= 0 && x < n && y >= 0 && y < n) { m[y][x] = cor; f[y][x] = true; } };
+    for (let i = 0; i < n; i++) { set(6, i, i % 2 === 0); set(i, 6, i % 2 === 0); }
+    const busca = (cx, cy) => { for (let dy = -4; dy <= 4; dy++) for (let dx = -4; dx <= 4; dx++) { const d = Math.max(Math.abs(dx), Math.abs(dy)); set(cx + dx, cy + dy, d !== 2 && d !== 4); } };
+    busca(3, 3); busca(n - 4, 3); busca(3, n - 4);
+    const al = posAlinhamento(v);
+    for (let i = 0; i < al.length; i++) for (let j = 0; j < al.length; j++) {
+        if ((i === 0 && j === 0) || (i === 0 && j === al.length - 1) || (i === al.length - 1 && j === 0)) continue;
+        for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) set(al[i] + dx, al[j] + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+    }
+    desenharFormato(Q, ecc, 0);
+    if (v >= 7) {
+        let r = v;
+        for (let i = 0; i < 12; i++) r = (r << 1) ^ ((r >>> 11) * 0x1F25);
+        const bits = (v << 12) | r;
+        for (let i = 0; i < 18; i++) {
+            const cor = ((bits >>> i) & 1) !== 0;
+            const a = n - 11 + (i % 3);
+            const b = Math.floor(i / 3);
+            set(a, b, cor); set(b, a, cor);
+        }
+    }
+}
+function desenharFormato(Q, ecc, mascara) {
+    const { n, m, f } = Q;
+    const dados = (FORMATO_ECC[ecc] << 3) | mascara;
+    let r = dados;
+    for (let i = 0; i < 10; i++) r = (r << 1) ^ ((r >>> 9) * 0x537);
+    const bits = ((dados << 10) | r) ^ 0x5412;
+    const bit = (i) => ((bits >>> i) & 1) !== 0;
+    const set = (x, y, cor) => { m[y][x] = cor; f[y][x] = true; };
+    for (let i = 0; i <= 5; i++) set(8, i, bit(i));
+    set(8, 7, bit(6)); set(8, 8, bit(7)); set(7, 8, bit(8));
+    for (let i = 9; i < 15; i++) set(14 - i, 8, bit(i));
+    for (let i = 0; i < 8; i++) set(n - 1 - i, 8, bit(i));
+    for (let i = 8; i < 15; i++) set(8, n - 15 + i, bit(i));
+    set(8, n - 8, true);
+}
+function colocarDados(Q, cw) {
+    const { n, m, f } = Q;
+    let i = 0;
+    for (let direita = n - 1; direita >= 1; direita -= 2) {
+        if (direita === 6) direita = 5;
+        for (let vert = 0; vert < n; vert++) for (let j = 0; j < 2; j++) {
+            const x = direita - j;
+            const y = ((direita + 1) & 2) === 0 ? n - 1 - vert : vert;
+            if (!f[y][x] && i < cw.length * 8) { m[y][x] = ((cw[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,
+];
+function aplicarMascara(Q, k) {
+    for (let y = 0; y < Q.n; y++) for (let x = 0; x < Q.n; x++) if (!Q.f[y][x] && MASCARAS[k](x, y)) Q.m[y][x] = !Q.m[y][x];
+}
+function penalidade(Q) {
+    const { n, m } = Q;
+    let p = 0;
+    const corrida = (linha) => {
+        let s = 0; let run = 1;
+        for (let i = 1; i <= linha.length; i++) {
+            if (i < linha.length && linha[i] === linha[i - 1]) run++;
+            else { if (run >= 5) s += run - 2; run = 1; }
+        }
+        const str = linha.map((b) => (b ? 1 : 0)).join('');
+        for (const pad of ['10111010000', '00001011101']) { let at = str.indexOf(pad); while (at >= 0) { s += 40; at = str.indexOf(pad, at + 1); } }
+        return s;
+    };
+    for (let y = 0; y < n; y++) p += corrida(m[y]);
+    for (let x = 0; x < n; x++) p += corrida(m.map((l) => l[x]));
+    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 escuros = m.reduce((a, l) => a + l.filter(Boolean).length, 0);
+    p += (Math.ceil(Math.abs(escuros * 20 - n * n * 10) / (n * n)) - 1) * 10;
+    return p;
+}
+
+/* Devolve { tamanho, modulos: boolean[][], versao }. Lança se o texto não cabe. */
+function gerarQR(texto, { ecc = 'M' } = {}) {
+    if (!ECC_POR_BLOCO[ecc]) throw new Error('ecc deve ser L ou M');
+    const bytes = Buffer.from(String(texto), 'utf8');
+    let v = 1;
+    for (; v <= VERSAO_MAX; v++) {
+        const bitsLen = 4 + (v <= 9 ? 8 : 16) + bytes.length * 8;
+        if (bitsLen <= dadosCodewords(v, ecc) * 8) break;
+    }
+    if (v > VERSAO_MAX) throw new Error(`texto grande demais para o QR (${bytes.length} bytes; máximo ${dadosCodewords(VERSAO_MAX, ecc) - 3})`);
+    const cw = intercalar(bitsDoTexto(bytes, v, ecc), v, ecc);
+    let melhor = null;
+    for (let k = 0; k < 8; k++) {
+        const Q = criarMatriz(v);
+        desenharFuncoes(Q, v, ecc);
+        colocarDados(Q, cw);
+        aplicarMascara(Q, k);
+        desenharFormato(Q, ecc, k);
+        const pen = penalidade(Q);
+        if (!melhor || pen < melhor.pen) melhor = { pen, Q };
+    }
+    return { tamanho: melhor.Q.n, modulos: melhor.Q.m, versao: v };
+}
+
+/* SVG pronto (módulos escuros em `cor`, fundo em `fundo`, com a zona de silêncio de 4 módulos). */
+function qrSvg(texto, { ecc = 'M', cor = '#000', fundo = '#fff' } = {}) {
+    const { tamanho, modulos } = gerarQR(texto, { ecc });
+    const t = tamanho + 8;
+    let d = '';
+    for (let y = 0; y < tamanho; y++) for (let x = 0; x < tamanho; x++) if (modulos[y][x]) d += `M${x + 4} ${y + 4}h1v1h-1z`;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${t} ${t}" shape-rendering="crispEdges" role="img" aria-label="QR code de pareamento"><rect width="${t}" height="${t}" fill="${fundo}"/><path d="${d}" fill="${cor}"/></svg>`;
+}
+
+module.exports = { gerarQR, qrSvg };