Conversor de XML para JSON

Parseia XML em um objeto JSON usando as convenções do fast-xml-parser: elementos filhos viram propriedades de objeto, filhos repetidos viram arrays, atributos são preservados com prefixo `@_` no objeto pai, e o conteúdo de texto de nós mistos cai em uma chave `#text`. Valores numéricos e booleanos de atributo são auto-tipados via `parseAttributeValue: true` — um XML `count="42"` faz round-trip como `"@_count": 42`, não como string `"42"`.

Exemplo

Entrada XML:

<root version="1">
  <name>Ada</name>
  <tags>math</tags>
  <tags>logic</tags>
</root>

Saída JSON:

{
  "root": {
    "@_version": 1,
    "name": "Ada",
    "tags": ["math", "logic"]
  }
}

Armadilhas comuns de XML e como tratá-las

XML tem casos extremos que JSON não tem. Esses são os padrões que produzem saídas surpreendentes.

• Filho único vs. múltiplos filhos. `<a><b/></a>` produz `{"a":{"b":""}}` (filho único como propriedade de objeto), mas `<a><b/><b/></a>` produz `{"a":{"b":["",""]}}` (múltiplos como array). Se seu código a jusante sempre espera um array, normalize após conversão.
• Atributos vs. elementos filhos. Atributos aparecem com prefixo `@_` no mesmo nível dos filhos. `<user id="1"><name>Ada</name></user>` vira `{"user":{"@_id":1,"name":"Ada"}}`. Algumas ferramentas mesclam atributos em propriedades — essa é uma convenção diferente da usada aqui.
• Conteúdo misto (texto + elementos filhos). `<p>Hello <b>world</b></p>` produz `{"p":{"#text":"Hello ","b":"world"}}`. O texto é capturado mas sua posição relativa aos filhos se perde — JSON não tem como representar conteúdo misto ordenado. A maioria do XML estilo config não cai nesse caso.
• Namespaces. Namespaces (`<x:foo xmlns:x="...">`) são preservados como parte do nome do elemento (`x:foo`). Muitos consumidores XML removem o prefixo; se você precisar disso, faça como passo de pós-processamento.
• Seções CDATA. `<![CDATA[some text]]>` é parseado como texto puro e se junta ao `#text` do pai. O enquadramento CDATA se perde — ok para a maioria dos casos mas vale notar se o enquadramento tinha significado semântico.
• Auto-fechado vs. vazio. `<x/>` e `<x></x>` são equivalentes em XML e produzem a mesma saída JSON (`""` para o valor). O enquadramento original não é recuperável a partir do JSON.

Por que minha saída tem prefixo `@_` nos atributos?

Distingue atributos XML de elementos filhos. Sem prefixo, `<user id="1"><id>foo</id></user>` teria duas chaves `id` — um objeto JSON só pode ter uma. O prefixo mantém ambos round-trippáveis. Se você não precisa do prefixo, troque `"@_"` por `""` em pós-processamento (e aceite o risco de colisão).

Posso obter o JSON sem a chave raiz envolvente?

XML sempre tem um único elemento raiz. O JSON mantém esse envoltório para round-trippability. Remova após conversão se quiser o objeto interno — `result.root` em vez de `result`.

Comentários XML são preservados?

Não. JSON não tem sintaxe de comentários, e o parser está configurado para ignorar comentários XML. Se você precisa preservar comentários, teria que usar uma representação intermediária diferente que os suporte.

Os valores de atributo são tipados?

Sim — `parseAttributeValue: true` está ligado, então `count="42"` vira `"@_count": 42` (número) e `enabled="true"` vira `"@_enabled": true` (booleano). Se você precisa de atributos como strings, pós-processe ou bifurque a configuração.

Meu XML é enviado para algum lugar?

Não. Tudo roda no seu navegador — seu XML é parseado por JavaScript nesta página e nunca enviado a servidor. Verifique nas ferramentas de desenvolvedor do navegador.

Pode lidar com arquivos XML muito grandes?

Até cerca de 30 MB antes do textarea ficar lento. O parser escala linearmente. Para entradas maiores, rode fast-xml-parser na linha de comando — mesma biblioteca.