@fontdata/ai-harness 3.3.1 → 4.0.0

package/dist/versao/diff.js

@@ -0,0 +1,58 @@
+import { decodificar } from './extratores/comum.js';
+function linhas(conteudo) {
+    return decodificar(conteudo).texto.split('\n').map((l) => l.replace(/\r$/, ''));
+}
+/**
+ * Diff por linha: cada bloco alterado vira pares antes/depois; linha sem par fica com o outro lado `null`.
+ * `linha` é a do arquivo original, ou a do arquivo novo quando a linha só foi acrescentada.
+ */
+export function diffLinhas(original, novo) {
+    const a = linhas(original);
+    const b = linhas(novo);
+    let ini = 0;
+    while (ini < a.length && ini < b.length && a[ini] === b[ini])
+        ini++;
+    let fa = a.length;
+    let fb = b.length;
+    while (fa > ini && fb > ini && a[fa - 1] === b[fb - 1]) {
+        fa--;
+        fb--;
+    }
+    const n = fa - ini;
+    const m = fb - ini;
+    const lcs = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            lcs[i][j] = a[ini + i] === b[ini + j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const saida = [];
+    let removidas = [];
+    let acrescentadas = [];
+    const fechar = () => {
+        for (let k = 0; k < Math.max(removidas.length, acrescentadas.length); k++) {
+            const r = removidas[k];
+            const s = acrescentadas[k];
+            saida.push({ linha: (r ?? s) + 1, antes: r === undefined ? null : a[r], depois: s === undefined ? null : b[s] });
+        }
+        removidas = [];
+        acrescentadas = [];
+    };
+    let i = 0;
+    let j = 0;
+    while (i < n || j < m) {
+        if (i < n && j < m && a[ini + i] === b[ini + j]) {
+            fechar();
+            i++;
+            j++;
+        }
+        else if (j >= m || (i < n && lcs[i + 1][j] >= lcs[i][j + 1])) {
+            removidas.push(ini + i++);
+        }
+        else {
+            acrescentadas.push(ini + j++);
+        }
+    }
+    fechar();
+    return saida;
+}

package/dist/versao/extratores/comum.js

@@ -0,0 +1,41 @@
+import { substituirTrecho } from '../texto.js';
+/**
+ * Decodifica como UTF-8 quando o arquivo é UTF-8 válido e como latin1 (1 char = 1 byte) quando não é,
+ * para arquivos ANSI de Delphi não corromperem os offsets em bytes.
+ */
+export function decodificar(conteudo) {
+    const utf8 = conteudo.toString('utf8');
+    if (Buffer.from(utf8, 'utf8').equals(conteudo)) {
+        return { texto: utf8, conteudo, bytes: (indice) => Buffer.byteLength(utf8.slice(0, indice), 'utf8') };
+    }
+    return { texto: conteudo.toString('latin1'), conteudo, bytes: (indice) => indice };
+}
+export function linhaDoByte(conteudo, offset) {
+    let linha = 1;
+    for (let i = conteudo.indexOf(0x0a); i !== -1 && i < offset; i = conteudo.indexOf(0x0a, i + 1))
+        linha++;
+    return linha;
+}
+/** Monta a ocorrência a partir de índices de caractere no texto decodificado. */
+export function ocorrencia(arquivo, dec, inicio, fim, grupo) {
+    const bInicio = dec.bytes(inicio);
+    const bFim = dec.bytes(fim);
+    const o = {
+        arquivo,
+        linha: linhaDoByte(dec.conteudo, bInicio),
+        inicio: bInicio,
+        fim: bFim,
+        valor: dec.conteudo.subarray(bInicio, bFim).toString('utf8'),
+    };
+    if (grupo !== undefined)
+        o.grupo = grupo;
+    return o;
+}
+/** Troca o valor de cada ocorrência por `versao`, de trás para frente; lança erro se não houver nenhuma. */
+export function gravarOcorrencias(conteudo, ocorrencias, versao, descricao) {
+    if (ocorrencias.length === 0)
+        throw new Error(`versão não encontrada: ${descricao}`);
+    return [...ocorrencias]
+        .sort((a, b) => b.inicio - a.inicio)
+        .reduce((buffer, o) => substituirTrecho(buffer, o.inicio, o.fim, versao), conteudo);
+}

package/dist/versao/extratores/csproj.js

@@ -0,0 +1,28 @@
+import { decodificar, gravarOcorrencias, ocorrencia } from './comum.js';
+const GRUPO = /<PropertyGroup\b[^>]*>([\s\S]*?)<\/PropertyGroup>/dg;
+const TAG = /<(Version|AssemblyVersion|FileVersion)>[ \t]*([^<\s]+)[ \t]*<\/\1>/dg;
+/**
+ * `<Version>`, `<AssemblyVersion>` e `<FileVersion>` dos `<PropertyGroup>`; `grupo` é o nome da tag.
+ * Valor com `$(...)` referencia outra propriedade e não é tocado.
+ */
+export const extratorCsproj = {
+    nome: 'csproj',
+    ler(caminho, conteudo) {
+        const dec = decodificar(conteudo);
+        const texto = dec.texto.replace(/<!--[\s\S]*?-->/g, (c) => ' '.repeat(c.length));
+        const ocorrencias = [];
+        for (const g of texto.matchAll(GRUPO)) {
+            const [inicioGrupo] = g.indices[1];
+            for (const t of g[1].matchAll(TAG)) {
+                if (t[2].includes('$('))
+                    continue;
+                const [inicio, fim] = t.indices[2];
+                ocorrencias.push(ocorrencia(caminho, dec, inicioGrupo + inicio, inicioGrupo + fim, t[1]));
+            }
+        }
+        return ocorrencias;
+    },
+    gravar(caminho, conteudo, versao) {
+        return gravarOcorrencias(conteudo, this.ler(caminho, conteudo), versao, `<Version> em ${caminho}`);
+    },
+};

package/dist/versao/extratores/dproj.js

@@ -0,0 +1,149 @@
+import { formatarVersao, parseVersao } from '../formato.js';
+import { substituirTrecho } from '../texto.js';
+const NUMERICAS = ['MajorVer', 'MinorVer', 'Release', 'Build'];
+const PADRAO_OMITIDA = { MajorVer: '1', MinorVer: '0', Release: '0', Build: '0' };
+function nomeDoGrupo(atributos) {
+    const condicao = /\bCondition="([^"]*)"/.exec(atributos)?.[1];
+    if (condicao === undefined)
+        return 'PropertyGroup';
+    return /^\s*'\$\((\w+)\)'\s*!=\s*''\s*$/.exec(condicao)?.[1] ?? condicao;
+}
+function lerGrupos(texto) {
+    const grupos = [];
+    const padrao = /<PropertyGroup\b([^>]*?)(?:\/>|>([\s\S]*?)<\/PropertyGroup>)/g;
+    for (const m of texto.matchAll(padrao)) {
+        const corpo = m[2];
+        if (corpo === undefined)
+            continue;
+        const base = m.index + m[0].length - '</PropertyGroup>'.length - corpo.length;
+        const grupo = { nome: nomeDoGrupo(m[1]), chaves: [], fimDasKeys: [], numericas: new Map() };
+        for (const k of corpo.matchAll(/<VerInfo_Keys>([^<]*)<\/VerInfo_Keys>/g)) {
+            const inicioValor = base + k.index + '<VerInfo_Keys>'.length;
+            grupo.fimDasKeys.push(base + k.index + k[0].length);
+            for (const c of k[1].matchAll(/(^|;)(FileVersion|ProductVersion)=([^;]*)/g)) {
+                const inicio = inicioValor + c.index + c[1].length + c[2].length + 1;
+                grupo.chaves.push({ chave: c[2], inicio, fim: inicio + c[3].length, valor: c[3] });
+            }
+        }
+        for (const n of corpo.matchAll(/<VerInfo_(MajorVer|MinorVer|Release|Build)>([^<]*)<\/VerInfo_\1>/g)) {
+            const nome = n[1];
+            if (grupo.numericas.has(nome))
+                continue;
+            const inicio = base + n.index + `<VerInfo_${nome}>`.length;
+            grupo.numericas.set(nome, {
+                inicio,
+                fim: inicio + n[2].length,
+                valor: n[2],
+                fimTag: base + n.index + n[0].length,
+            });
+        }
+        grupos.push(grupo);
+    }
+    return grupos;
+}
+function lerLegado(texto) {
+    const legado = { numericas: new Map(), chaves: [] };
+    for (const m of texto.matchAll(/<VersionInfo Name="(MajorVer|MinorVer|Release|Build)">([^<]*)<\/VersionInfo>/g)) {
+        const nome = m[1];
+        if (legado.numericas.has(nome))
+            continue;
+        const inicio = m.index + m[0].length - '</VersionInfo>'.length - m[2].length;
+        legado.numericas.set(nome, { inicio, fim: inicio + m[2].length, valor: m[2] });
+    }
+    for (const m of texto.matchAll(/<VersionInfoKeys Name="(FileVersion|ProductVersion)">([^<]*)<\/VersionInfoKeys>/g)) {
+        const inicio = m.index + m[0].length - '</VersionInfoKeys>'.length - m[2].length;
+        legado.chaves.push({ chave: m[1], inicio, fim: inicio + m[2].length, valor: m[2] });
+    }
+    return legado;
+}
+function composta(numericas) {
+    return NUMERICAS.map((n) => numericas.get(n)?.valor.trim() ?? PADRAO_OMITIDA[n]).join('.');
+}
+function contarLinha(texto, posicao) {
+    let linha = 1;
+    for (let i = texto.indexOf('\n'); i !== -1 && i < posicao; i = texto.indexOf('\n', i + 1))
+        linha++;
+    return linha;
+}
+function indentacaoDaLinha(texto, posicao) {
+    const inicioLinha = texto.lastIndexOf('\n', posicao - 1) + 1;
+    return /^[ \t]*/.exec(texto.slice(inicioLinha, posicao))[0];
+}
+function ler(caminho, conteudo) {
+    const texto = conteudo.toString('latin1');
+    const brutas = [];
+    for (const g of lerGrupos(texto)) {
+        for (const c of g.chaves)
+            brutas.push({ ...c, grupo: `${g.nome}/VerInfo_Keys:${c.chave}` });
+        const valor = composta(g.numericas);
+        for (const [nome, t] of g.numericas)
+            brutas.push({ ...t, valor, grupo: `${g.nome}/VerInfo_${nome}` });
+    }
+    const legado = lerLegado(texto);
+    const valorLegado = composta(legado.numericas);
+    for (const [nome, t] of legado.numericas)
+        brutas.push({ ...t, valor: valorLegado, grupo: `VersionInfo:${nome}` });
+    for (const c of legado.chaves)
+        brutas.push({ ...c, grupo: `VersionInfoKeys:${c.chave}` });
+    return brutas
+        .sort((a, b) => a.inicio - b.inicio)
+        .map((o) => ({
+        arquivo: caminho,
+        linha: contarLinha(texto, o.inicio),
+        inicio: o.inicio,
+        fim: o.fim,
+        valor: Buffer.from(o.valor, 'latin1').toString('utf8'),
+        grupo: o.grupo,
+    }));
+}
+function gravar(_caminho, conteudo, versao) {
+    const segmentos = parseVersao(versao);
+    if (segmentos.length !== 4)
+        throw new Error(`o .dproj exige versão com 4 segmentos; recebeu "${versao}"`);
+    const completa = formatarVersao(segmentos);
+    const porNumerica = Object.fromEntries(NUMERICAS.map((n, i) => [n, String(segmentos[i])]));
+    const texto = conteudo.toString('latin1');
+    const lf = texto.indexOf('\n');
+    const eol = lf > 0 && texto[lf - 1] === '\r' ? '\r\n' : '\n';
+    const trocas = [];
+    const insercoes = new Map();
+    const trocar = (t, novo) => {
+        if (t.valor !== novo)
+            trocas.push({ inicio: t.inicio, fim: t.fim, valor: novo });
+    };
+    for (const g of lerGrupos(texto)) {
+        for (const c of g.chaves)
+            trocar(c, completa);
+        for (const [nome, t] of g.numericas)
+            trocar(t, porNumerica[nome]);
+        if (g.fimDasKeys.length === 0)
+            continue;
+        let ancora = g.fimDasKeys[0];
+        for (const nome of NUMERICAS) {
+            const existente = g.numericas.get(nome);
+            if (existente) {
+                ancora = existente.fimTag;
+                continue;
+            }
+            const tag = `${eol}${indentacaoDaLinha(texto, ancora)}<VerInfo_${nome}>${porNumerica[nome]}</VerInfo_${nome}>`;
+            insercoes.set(ancora, (insercoes.get(ancora) ?? '') + tag);
+        }
+    }
+    const legado = lerLegado(texto);
+    for (const [nome, t] of legado.numericas)
+        trocar(t, porNumerica[nome]);
+    for (const c of legado.chaves)
+        trocar(c, completa);
+    for (const [posicao, novo] of insercoes)
+        trocas.push({ inicio: posicao, fim: posicao, valor: novo });
+    return trocas
+        .sort((a, b) => b.inicio - a.inicio)
+        .reduce((buffer, t) => substituirTrecho(buffer, t.inicio, t.fim, t.valor), Buffer.from(conteudo));
+}
+/**
+ * Versão do .dproj nas 3 famílias: `FileVersion`/`ProductVersion` de cada `VerInfo_Keys`, as tags
+ * `VerInfo_MajorVer/MinorVer/Release/Build` por PropertyGroup e o bloco legado `<VersionInfo>`/`<VersionInfoKeys>`.
+ * Nas tags numéricas, `valor` é a versão composta do grupo (tag omitida vale 0; `MajorVer` omitida vale 1)
+ * e `inicio`/`fim` apontam o número da própria tag. `gravar` cria as numéricas omitidas nos grupos com `VerInfo_Keys`.
+ */
+export const extratorDproj = { nome: 'dproj', ler, gravar };

package/dist/versao/extratores/index.js

@@ -0,0 +1,26 @@
+import { extratorCsproj } from './csproj.js';
+import { extratorDproj } from './dproj.js';
+import { criarExtratorJson } from './json.js';
+import { extratorPubspec } from './pubspec.js';
+import { extratorPyproject } from './pyproject.js';
+import { criarExtratorRegex } from './regex.js';
+import { extratorVersoesTxt } from './versoes-txt.js';
+/** Devolve o extrator da config; lança erro para regex sem grupo de captura. */
+export function criarExtrator(cfg) {
+    switch (cfg.tipo) {
+        case 'json':
+            return criarExtratorJson(cfg.caminho);
+        case 'regex':
+            return criarExtratorRegex(cfg.padrao);
+        case 'pubspec':
+            return extratorPubspec;
+        case 'pyproject':
+            return extratorPyproject;
+        case 'csproj':
+            return extratorCsproj;
+        case 'versoes-txt':
+            return extratorVersoesTxt;
+        case 'dproj':
+            return extratorDproj;
+    }
+}

package/dist/versao/extratores/json.js

@@ -0,0 +1,118 @@
+import { decodificar, gravarOcorrencias, ocorrencia } from './comum.js';
+class Varredor {
+    texto;
+    i = 0;
+    constructor(texto) {
+        this.texto = texto;
+        if (texto.charCodeAt(0) === 0xfeff)
+            this.i = 1;
+    }
+    erro(mensagem) {
+        return new Error(`JSON inválido na posição ${this.i}: ${mensagem}`);
+    }
+    espacos() {
+        while (/[ \t\r\n]/.test(this.texto[this.i] ?? ''))
+            this.i++;
+    }
+    esperar(char) {
+        this.espacos();
+        if (this.texto[this.i] !== char)
+            throw this.erro(`esperado "${char}"`);
+        this.i++;
+    }
+    string() {
+        this.esperar('"');
+        const inicio = this.i;
+        while (this.i < this.texto.length && this.texto[this.i] !== '"')
+            this.i += this.texto[this.i] === '\\' ? 2 : 1;
+        if (this.i >= this.texto.length)
+            throw this.erro('string sem fechamento');
+        this.i++;
+        return { inicio, fim: this.i - 1 };
+    }
+    /** Percorre o valor atual; quando `chaves` acaba num valor string, devolve o trecho dele (sem aspas). */
+    valor(chaves) {
+        this.espacos();
+        const c = this.texto[this.i];
+        if (c === '{')
+            return this.objeto(chaves);
+        if (c === '[')
+            return this.lista(chaves);
+        if (c === '"') {
+            const trecho = this.string();
+            return chaves?.length === 0 ? trecho : null;
+        }
+        const m = /^(?:true|false|null|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)/.exec(this.texto.slice(this.i, this.i + 64));
+        if (!m)
+            throw this.erro('valor inesperado');
+        this.i += m[0].length;
+        return null;
+    }
+    objeto(chaves) {
+        this.i++;
+        let achado = null;
+        this.espacos();
+        if (this.texto[this.i] === '}') {
+            this.i++;
+            return null;
+        }
+        for (;;) {
+            const chave = this.string();
+            this.esperar(':');
+            const nome = JSON.parse(this.texto.slice(chave.inicio - 1, chave.fim + 1));
+            const casa = chaves !== null && chaves.length > 0 && nome === chaves[0];
+            const resultado = this.valor(casa ? chaves.slice(1) : null);
+            if (casa)
+                achado = resultado;
+            this.espacos();
+            if (this.texto[this.i] === '}') {
+                this.i++;
+                return achado;
+            }
+            this.esperar(',');
+        }
+    }
+    lista(chaves) {
+        this.i++;
+        let achado = null;
+        this.espacos();
+        if (this.texto[this.i] === ']') {
+            this.i++;
+            return null;
+        }
+        for (let indice = 0;; indice++) {
+            const casa = chaves !== null && chaves.length > 0 && chaves[0] === String(indice);
+            const resultado = this.valor(casa ? chaves.slice(1) : null);
+            if (casa)
+                achado = resultado;
+            this.espacos();
+            if (this.texto[this.i] === ']') {
+                this.i++;
+                return achado;
+            }
+            this.esperar(',');
+        }
+    }
+}
+function localizar(dec, chaves) {
+    const varredor = new Varredor(dec.texto);
+    const trecho = varredor.valor(chaves);
+    varredor.espacos();
+    if (varredor.i < dec.texto.length)
+        throw varredor.erro('conteúdo depois do valor raiz');
+    return trecho;
+}
+/** Extrator `json:<caminho>`: varre o texto até o valor string do caminho, sem reserializar o arquivo. */
+export function criarExtratorJson(chaves) {
+    const descricao = chaves.map((c) => (/^[^.[\]"]+$/.test(c) ? c : `[${JSON.stringify(c)}]`)).join('.').replace(/\.\[/g, '[');
+    const ler = (caminho, conteudo) => {
+        const dec = decodificar(conteudo);
+        const trecho = localizar(dec, chaves);
+        return trecho ? [ocorrencia(caminho, dec, trecho.inicio, trecho.fim)] : [];
+    };
+    return {
+        nome: `json:${descricao}`,
+        ler,
+        gravar: (caminho, conteudo, versao) => gravarOcorrencias(conteudo, ler(caminho, conteudo), JSON.stringify(versao).slice(1, -1), `json:${descricao} em ${caminho}`),
+    };
+}

package/dist/versao/extratores/pubspec.js

@@ -0,0 +1,15 @@
+import { decodificar, gravarOcorrencias, ocorrencia } from './comum.js';
+const VERSAO = /^version[ \t]*:[ \t]*(?:"([^"\r\n]*)"|'([^'\r\n]*)'|([^\s#"']+))/dgm;
+/** `version:` da raiz do pubspec.yaml; o valor inclui o `+build` (ex.: `1.2.3+45`). */
+export const extratorPubspec = {
+    nome: 'pubspec',
+    ler(caminho, conteudo) {
+        const dec = decodificar(conteudo);
+        const m = [...dec.texto.matchAll(VERSAO)][0];
+        const indices = m?.indices?.slice(1).find((i) => i !== undefined);
+        return indices ? [ocorrencia(caminho, dec, indices[0], indices[1])] : [];
+    },
+    gravar(caminho, conteudo, versao) {
+        return gravarOcorrencias(conteudo, this.ler(caminho, conteudo), versao, `version do pubspec em ${caminho}`);
+    },
+};

package/dist/versao/extratores/pyproject.js

@@ -0,0 +1,26 @@
+import { decodificar, gravarOcorrencias, ocorrencia } from './comum.js';
+const SECOES = new Set(['project', 'tool.poetry']);
+const LINHA = /^[ \t]*(?:\[[ \t]*([^[\]\r\n]+?)[ \t]*\][ \t]*(?:#.*)?$|\[\[.*$|version[ \t]*=[ \t]*(?:"([^"\r\n]*)"|'([^'\r\n]*)'))/dgm;
+/** `version = "..."` das tabelas `[project]` e `[tool.poetry]`; `grupo` é o nome da tabela. */
+export const extratorPyproject = {
+    nome: 'pyproject',
+    ler(caminho, conteudo) {
+        const dec = decodificar(conteudo);
+        const ocorrencias = [];
+        let secao = null;
+        for (const m of dec.texto.matchAll(LINHA)) {
+            if (m[1] !== undefined)
+                secao = m[1].replace(/[ \t]/g, '');
+            else if (m[2] === undefined && m[3] === undefined)
+                secao = null;
+            else if (secao !== null && SECOES.has(secao)) {
+                const indices = (m.indices?.[2] ?? m.indices?.[3]);
+                ocorrencias.push(ocorrencia(caminho, dec, indices[0], indices[1], secao));
+            }
+        }
+        return ocorrencias;
+    },
+    gravar(caminho, conteudo, versao) {
+        return gravarOcorrencias(conteudo, this.ler(caminho, conteudo), versao, `version de [project] ou [tool.poetry] em ${caminho}`);
+    },
+};

package/dist/versao/extratores/regex.js

@@ -0,0 +1,20 @@
+import { decodificar, gravarOcorrencias, ocorrencia } from './comum.js';
+/** Extrator `regex`: a versão é o primeiro grupo de captura de cada casamento (flags `g` e `m`). */
+export function criarExtratorRegex(padrao) {
+    const regex = new RegExp(padrao, 'dgm');
+    if ((new RegExp(`${padrao}|`).exec('')?.length ?? 1) < 2) {
+        throw new Error(`o padrão do extrator regex precisa de um grupo de captura com a versão: ${padrao}`);
+    }
+    const ler = (caminho, conteudo) => {
+        const dec = decodificar(conteudo);
+        return [...dec.texto.matchAll(regex)].flatMap((m) => {
+            const indices = m.indices?.[1];
+            return indices ? [ocorrencia(caminho, dec, indices[0], indices[1])] : [];
+        });
+    };
+    return {
+        nome: 'regex',
+        ler,
+        gravar: (caminho, conteudo, versao) => gravarOcorrencias(conteudo, ler(caminho, conteudo), versao, `regex ${padrao} em ${caminho}`),
+    };
+}

package/dist/versao/extratores/versoes-txt.js

@@ -0,0 +1,29 @@
+import { decodificar, ocorrencia } from './comum.js';
+const ENTRADA = /^\uFEFF?[ \t]*(?:V(?:ers[aã]o)?[ \t]*)?(\d+(?:\.\d+)+)/dgim;
+function comparar(a, b) {
+    const x = a.split('.').map(Number);
+    const y = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(x.length, y.length); i++) {
+        const d = (x[i] ?? 0) - (y[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+/** Versoes.txt: `ler` devolve a maior versão que abre uma linha; o bloco novo é escrito pelo changelog do /versao. */
+export const extratorVersoesTxt = {
+    nome: 'versoes-txt',
+    ler(caminho, conteudo) {
+        const dec = decodificar(conteudo);
+        let maior;
+        for (const m of dec.texto.matchAll(ENTRADA)) {
+            if (!maior || comparar(m[1], maior[1]) > 0)
+                maior = m;
+        }
+        const indices = maior?.indices?.[1];
+        return indices ? [ocorrencia(caminho, dec, indices[0], indices[1])] : [];
+    },
+    gravar(caminho) {
+        throw new Error(`${caminho}: o extrator versoes-txt só lê; o bloco da versão nova no Versoes.txt é escrito pelo changelog do /versao`);
+    },
+};

package/dist/versao/formato.js

@@ -0,0 +1,67 @@
+const INDICE = { major: 0, minor: 1, patch: 2, build: 3 };
+function partesDoFormato(formato) {
+    const literais = [];
+    const larguras = [];
+    const marcador = /\{(\d+)\}/g;
+    let ultimo = 0;
+    for (const m of formato.matchAll(marcador)) {
+        literais.push(formato.slice(ultimo, m.index));
+        larguras.push(Number(m[1]));
+        ultimo = m.index + m[0].length;
+    }
+    literais.push(formato.slice(ultimo));
+    if (larguras.length === 0)
+        throw new Error(`formato de versão sem segmento {n}: "${formato}"`);
+    return { literais, larguras };
+}
+function escaparRegex(texto) {
+    return texto.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Lê a versão como lista de inteiros. Com `formato` (ex.: `{1}.{3}.{2}.{2}`), o texto precisa
+ * seguir os literais e ter um segmento por marcador; sem formato, aceita inteiros separados por ponto.
+ */
+export function parseVersao(texto, formato) {
+    if (formato === undefined) {
+        if (!/^\d+(\.\d+)*$/.test(texto))
+            throw new Error(`versão inválida: "${texto}"`);
+        return texto.split('.').map(Number);
+    }
+    const { literais, larguras } = partesDoFormato(formato);
+    const padrao = literais.map(escaparRegex).join('(\\d+)');
+    const m = new RegExp(`^${padrao}$`).exec(texto);
+    if (!m)
+        throw new Error(`versão "${texto}" não segue o formato "${formato}"`);
+    return larguras.map((_, i) => Number(m[i + 1]));
+}
+/**
+ * Monta o texto da versão. Cada `{n}` do formato é a largura mínima do segmento, completada com
+ * zeros à esquerda; sem formato, junta os segmentos por ponto sem padding.
+ */
+export function formatarVersao(segmentos, formato) {
+    for (const s of segmentos) {
+        if (!Number.isSafeInteger(s) || s < 0)
+            throw new Error(`segmento de versão inválido: ${s}`);
+    }
+    if (formato === undefined)
+        return segmentos.join('.');
+    const { literais, larguras } = partesDoFormato(formato);
+    if (larguras.length !== segmentos.length) {
+        throw new Error(`o formato "${formato}" tem ${larguras.length} segmentos e a versão tem ${segmentos.length}`);
+    }
+    return literais.reduce((acc, literal, i) => i < larguras.length ? acc + literal + String(segmentos[i]).padStart(larguras[i], '0') : acc + literal, '');
+}
+/** Soma 1 no segmento do tipo (major=0 … build=3) e zera os da direita; devolve um array novo. */
+export function incrementar(segmentos, tipo) {
+    const indice = INDICE[tipo];
+    if (tipo === 'build' && segmentos.length < 4) {
+        throw new Error(`o incremento build exige versão com 4 segmentos; a versão tem ${segmentos.length}`);
+    }
+    const novo = [...segmentos];
+    while (novo.length <= indice)
+        novo.push(0);
+    novo[indice] = novo[indice] + 1;
+    for (let i = indice + 1; i < novo.length; i++)
+        novo[i] = 0;
+    return novo;
+}