@jjlmoya/utils-developer 1.3.0 → 1.5.0

package/src/tool/inspectorCertificadosSsl/index.ts

@@ -9,6 +9,18 @@ export type InspectorCertificadosSslLocaleContent = ToolLocaleContent<InspectorC
 import { content as es } from './i18n/es';
 import { content as en } from './i18n/en';
 import { content as fr } from './i18n/fr';
+import { content as de } from './i18n/de';
+import { content as it } from './i18n/it';
+import { content as ja } from './i18n/ja';
+import { content as ko } from './i18n/ko';
+import { content as nl } from './i18n/nl';
+import { content as pl } from './i18n/pl';
+import { content as pt } from './i18n/pt';
+import { content as ru } from './i18n/ru';
+import { content as sv } from './i18n/sv';
+import { content as tr } from './i18n/tr';
+import { content as zh } from './i18n/zh';
+import { content as id } from './i18n/id';
 
 export const inspectorCertificadosSsl: DeveloperToolEntry<InspectorCertificadosSslUI> = {
   id: 'inspector-certificados-ssl',
@@ -20,6 +32,18 @@ export const inspectorCertificadosSsl: DeveloperToolEntry<InspectorCertificadosS
     es: async () => es,
     en: async () => en,
     fr: async () => fr,
+    de: async () => de,
+    it: async () => it,
+    ja: async () => ja,
+    ko: async () => ko,
+    nl: async () => nl,
+    pl: async () => pl,
+    pt: async () => pt,
+    ru: async () => ru,
+    sv: async () => sv,
+    tr: async () => tr,
+    zh: async () => zh,
+    id: async () => id,
   },
 };
 

package/src/tool/jsonFormatter/i18n/de.ts

@@ -0,0 +1,157 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { JsonFormatterUI } from '../ui';
+
+const slug = 'json-formatter-de';
+const title = 'Kostenloser Online JSON Formatter und Validator';
+const description =
+  'Kostenloses Online-Tool zum Formatieren, Validieren und Reparieren von JSON-Code. JSON verschönern und formatieren. Erkennt Syntaxfehler und verbessert die Lesbarkeit des Codes.';
+
+const faqData = [
+  {
+    question: 'Sind meine Daten bei der Verwendung dieses Formatierers sicher?',
+    answer:
+      'Absolut. Die gesamte Verarbeitung findet zu 100 % in Ihrem Browser statt (Client-Side). Ihre JSON-Daten werden niemals an einen Server gesendet, was die vollständige Privatsphäre Ihrer Datenstrukturen gewährleistet.',
+  },
+  {
+    question: 'Was verursacht einen "Invalid JSON"-Fehler?',
+    answer:
+      'Dies wird meist durch abschließende Kommas am Ende eines Objekts, fehlende doppelte Anführungszeichen um Schlüssel oder unsichtbare Zeichen verursacht. Unser Tool markiert die exakte Zeile des Fehlers, damit Sie ihn beheben können.',
+  },
+  {
+    question: 'Kann es fehlerhaftes JSON reparieren?',
+    answer:
+      'Unser Tool versucht automatisch, häufige Fehler wie unnötige abschließende Kommas oder falsch formatierte Zeichen-Escapes zu korrigieren, damit das JSON dem RFC 8259-Standard entspricht.',
+  },
+  {
+    question: 'Werden sehr große JSON-Dateien unterstützt?',
+    answer:
+      'Ja, die Verarbeitungs-Engine ist darauf optimiert, komplexe Datenstrukturen und große Dateien zu verarbeiten, ohne die Benutzeroberfläche des Browsers zu blockieren.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Code einfügen',
+    text: 'Fügen Sie Ihr unformatiertes oder minimiertes JSON in das Haupttextfeld ein.',
+  },
+  {
+    name: 'Validieren und Formatieren',
+    text: 'Das System analysiert den Code automatisch, hebt Syntaxfehler hervor und wendet Einrückungen an, um die Lesbarkeit zu verbessern.',
+  },
+  {
+    name: 'Stil wählen',
+    text: 'Wählen Sie zwischen einem erweiterten (Beautify) oder komprimierten (Minify) Format, je nachdem, ob Sie Lesbarkeit oder Platzersparnis benötigen.',
+  },
+  {
+    name: 'Ergebnis kopieren',
+    text: 'Klicken Sie auf den Kopieren-Button, um das perfekt validierte JSON in Ihre Zwischenablage zu übernehmen.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'de',
+};
+
+const ui: JsonFormatterUI = {
+  labelInput: 'Eingabe (JSON)',
+  labelOutput: 'Ausgabe',
+  btnMinify: 'Minimieren',
+  btnBeautify: 'Formatieren',
+  btnFix: 'Reparatur versuchen',
+  btnCopy: 'Kopieren',
+  statusWaiting: 'Warten auf Eingabe...',
+  statusValid: 'Gültiges JSON',
+  statusInvalid: 'Ungültiges JSON',
+  toastCopied: 'Kopiert!',
+  toastFixed: 'JSON repariert (Vorschau)',
+  toastFixFailed: 'Automatische Reparatur fehlgeschlagen',
+  placeholder: 'Fügen Sie hier Ihr JSON ein...',
+};
+
+export const content: ToolLocaleContent<JsonFormatterUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Häufig gestellte Fragen',
+  faq: faqData,
+  bibliographyTitle: 'Referenzen und Standards',
+  bibliography: [
+    {
+      name: 'RFC 8259 – The JavaScript Object Notation (JSON) Data Interchange Format (IETF)',
+      url: 'https://datatracker.ietf.org/doc/html/rfc8259',
+    },
+    {
+      name: 'ECMA-404 – The JSON Data Interchange Syntax (Ecma International)',
+      url: 'https://www.ecma-international.org/publications-and-standards/standards/ecma-404/',
+    },
+    {
+      name: 'JSON.org – Introducing JSON',
+      url: 'https://www.json.org/json-en.html',
+    },
+    {
+      name: 'MDN Web Docs – JSON',
+      url: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'JSON Validierung und Formatierung',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'JSON (JavaScript Object Notation) ist der De-facto-Standard für den Datenaustausch im Web. Seine strikte Syntax macht es jedoch anfällig für menschliche Fehler bei der manuellen Bearbeitung.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Dieses Tool ermöglicht es Ihnen, die Struktur zu validieren, den Code zur Verbesserung der Lesbarkeit zu formatieren und häufige Syntaxfehler automatisch zu reparieren.',
+    },
+    { type: 'grid', columns: 2 },
+    {
+      type: 'card',
+      title: 'Häufig reparierte Fehler',
+      html: '<ul><li><strong>Einfache Anführungszeichen:</strong> Der JSON-Standard erfordert doppelte Anführungszeichen. Das Tool konvertiert <code>\'Key\': \'Value\'</code> in <code>"Key": "Value"</code>.</li><li><strong>Unquotierte Schlüssel:</strong> Erkennt Objektschlüssel im JavaScript-Stil und fügt die erforderlichen Anführungszeichen hinzu.</li><li><strong>Abschließende Kommas:</strong> Entfernt Kommas am Ende von Objekten oder Arrays, die den strikten Parser stören.</li></ul>',
+    },
+    {
+      type: 'card',
+      title: 'Funktionen',
+      html: '<ul><li><strong>Syntax-Highlighting:</strong> Färbt Schlüssel, Strings, Zahlen und Booleans ein, um das schnelle Lesen zu erleichtern.</li><li><strong>Echtzeit-Validierung:</strong> Zeigt sofort an, ob das JSON gültig ist, oder markiert den spezifischen Parsing-Fehler.</li><li><strong>Totale Privatsphäre:</strong> Die Verarbeitung erfolgt zu 100 % in Ihrem Browser. Es werden keine Daten an externe Server gesendet.</li></ul>',
+    },
+  ],
+};
+

package/src/tool/jsonFormatter/i18n/es.ts

@@ -2,7 +2,7 @@ import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'sche
 import type { ToolLocaleContent } from '../../../types';
 import type { JsonFormatterUI } from '../ui';
 
-const slug = 'json-formatter';
+const slug = 'json-formatter-es';
 const title = 'Formateador y Validador JSON Online Gratuito';
 const description =
   'Herramienta online gratuita para formatear, validar y reparar código JSON. Formatea y embellece JSON. Detecta errores de sintaxis y mejora la lectura del código';
@@ -154,3 +154,4 @@ export const content: ToolLocaleContent<JsonFormatterUI> = {
     },
   ],
 };
+

package/src/tool/jsonFormatter/i18n/fr.ts

@@ -2,7 +2,7 @@ import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'sche
 import type { ToolLocaleContent } from '../../../types';
 import type { JsonFormatterUI } from '../ui';
 
-const slug = 'json-formatter';
+const slug = 'json-formatter-fr';
 const title = 'Formateur et Validateur JSON Gratuit en Ligne';
 const description =
   'Outil en ligne gratuit pour formater, valider et réparer du code JSON. Embellissez et formatez du JSON. Détecte les erreurs de syntaxe et améliore la lisibilité du code.';
@@ -154,3 +154,4 @@ export const content: ToolLocaleContent<JsonFormatterUI> = {
     },
   ],
 };
+

package/src/tool/jsonFormatter/i18n/id.ts

@@ -0,0 +1,157 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { JsonFormatterUI } from '../ui';
+
+const slug = 'json-formatter-id';
+const title = 'Format dan Validasi JSON Online Gratis';
+const description =
+  'Alat online gratis untuk memformat, memvalidasi, dan memperbaiki kode JSON. Mempercantik dan memformat JSON. Mendeteksi kesalahan sintaksis dan meningkatkan keterbacaan kode.';
+
+const faqData = [
+  {
+    question: 'Apakah data saya aman saat menggunakan pemformat ini?',
+    answer:
+      'Tentu saja. Semua pemrosesan terjadi 100% di browser Anda (Sisi Klien). Data JSON Anda tidak pernah dikirim ke server mana pun, memastikan privasi lengkap untuk struktur data Anda.',
+  },
+  {
+    question: "Apa yang menyebabkan kesalahan 'Invalid JSON'?",
+    answer:
+      'Biasanya disebabkan oleh koma berlebih di akhir objek, kurangnya tanda kutip ganda di sekitar kunci, atau karakter yang tidak terlihat. Alat kami menyoroti baris kesalahan yang tepat sehingga Anda dapat memperbaikinya.',
+  },
+  {
+    question: 'Dapatkah alat ini memperbaiki JSON yang rusak?',
+    answer:
+      'Alat kami secara otomatis mencoba memperbaiki kesalahan umum seperti koma berlebih yang tidak perlu atau karakter escape yang salah, sehingga JSON menjadi valid sesuai dengan standar RFC 8259.',
+  },
+  {
+    question: 'Apakah alat ini mendukung file JSON yang sangat besar?',
+    answer:
+      'Ya, mesin pemrosesan dioptimalkan untuk menangani struktur data yang kompleks dan file berukuran besar tanpa memblokir antarmuka browser.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Tempel kode Anda',
+    text: 'Tempelkan JSON Anda yang belum diformat atau telah diminifikasi ke dalam area teks utama.',
+  },
+  {
+    name: 'Validasi dan Format',
+    text: 'Sistem akan secara otomatis menganalisis kode, menyoroti kesalahan sintaksis, dan menerapkan indentasi untuk meningkatkan keterbacaan.',
+  },
+  {
+    name: 'Pilih gaya',
+    text: 'Pilih antara format diperluas (beautify) atau dikompresi (minify) tergantung pada apakah Anda membutuhkan keterbacaan atau penghematan ruang.',
+  },
+  {
+    name: 'Salin hasilnya',
+    text: 'Klik tombol salin untuk mengambil JSON yang telah divalidasi dengan sempurna ke papan klip Anda.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'id',
+};
+
+const ui: JsonFormatterUI = {
+  labelInput: 'Input (JSON)',
+  labelOutput: 'Output',
+  btnMinify: 'Minifikasi',
+  btnBeautify: 'Perkanti',
+  btnFix: 'Coba Perbaiki',
+  btnCopy: 'Salin',
+  statusWaiting: 'Menunggu input...',
+  statusValid: 'JSON Valid',
+  statusInvalid: 'JSON Tidak Valid',
+  toastCopied: 'Tersalin!',
+  toastFixed: 'JSON diperbaiki (Pratinjau)',
+  toastFixFailed: 'Tidak dapat memperbaiki secara otomatis',
+  placeholder: 'Tempel JSON Anda di sini...',
+};
+
+export const content: ToolLocaleContent<JsonFormatterUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Pertanyaan yang Sering Diajukan',
+  faq: faqData,
+  bibliographyTitle: 'Referensi dan Standar',
+  bibliography: [
+    {
+      name: 'RFC 8259 – The JavaScript Object Notation (JSON) Data Interchange Format (IETF)',
+      url: 'https://datatracker.ietf.org/doc/html/rfc8259',
+    },
+    {
+      name: 'ECMA-404 – The JSON Data Interchange Syntax (Ecma International)',
+      url: 'https://www.ecma-international.org/publications-and-standards/standards/ecma-404/',
+    },
+    {
+      name: 'JSON.org – Mengenal JSON',
+      url: 'https://www.json.org/json-en.html',
+    },
+    {
+      name: 'MDN Web Docs – JSON',
+      url: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Validasi dan Pemformatan JSON',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'JSON (JavaScript Object Notation) adalah standar de facto untuk pertukaran data di web. Namun, sintaksnya yang ketat membuatnya rentan terhadap kesalahan manusia saat diedit secara manual.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Alat ini memungkinkan Anda untuk memvalidasi struktur, memformat kode untuk meningkatkan keterbacaannya, dan secara otomatis memperbaiki kesalahan sintaksis yang umum.',
+    },
+    { type: 'grid', columns: 2 },
+    {
+      type: 'card',
+      title: 'Kesalahan Umum yang Diperbaiki',
+      html: '<ul><li><strong>Tanda Kutip Tunggal:</strong> Standar JSON memerlukan tanda kutip ganda. Alat ini mengubah <code>\'key\': \'value\'</code> menjadi <code>"key\": \"value\"</code>.</li><li><strong>Kunci Tanpa Tanda Kutip:</strong> Mendeteksi kunci objek gaya JavaScript dan menambahkan tanda kutip yang diperlukan.</li><li><strong>Koma di Akhir:</strong> Menghapus koma di akhir objek atau array (trailing commas) yang merusak parser ketat.</li></ul>',
+    },
+    {
+      type: 'card',
+      title: 'Fitur',
+      html: '<ul><li><strong>Penyorotan Sintaksis:</strong> Mewarnai kunci, string, angka, dan boolean untuk memfasilitasi pembacaan cepat.</li><li><strong>Validasi Real-Time:</strong> Secara instan menunjukkan apakah JSON valid atau menunjukkan kesalahan penguraian spesifik.</li><li><strong>Privasi Total:</strong> Pemrosesan terjadi 100% di browser Anda. Tidak ada data yang dikirim ke server eksternal.</li></ul>',
+    },
+  ],
+};
+

package/src/tool/jsonFormatter/i18n/it.ts

@@ -0,0 +1,156 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { JsonFormatterUI } from '../ui';
+
+const slug = 'formattatore-json';
+const title = 'Formattatore e Validatore JSON Online Gratuito';
+const description =
+  'Strumento online gratuito per formattare, validare e riparare il codice JSON. Abbellisci e formatta JSON. Rileva errori di sintassi e migliora la leggibilità del codice.';
+
+const faqData = [
+  {
+    question: 'I miei dati sono sicuri usando questo formattatore?',
+    answer:
+      'Assolutamente sì. Tutta l\'elaborazione avviene al 100% nel tuo browser (Client-Side). I tuoi dati JSON non vengono mai inviati a nessun server, garantendo la completa privacy per le tue strutture dati.',
+  },
+  {
+    question: "Cosa causa un errore 'Invalid JSON'?",
+    answer:
+      'Di solito è causato da virgole finali alla fine di un oggetto, mancanza di doppie virgolette intorno alle chiavi o caratteri invisibili. Il nostro strumento evidenzia l\'esatta riga dell\'errore in modo da poterlo correggere.',
+  },
+  {
+    question: 'Può riparare JSON danneggiati?',
+    answer:
+      'Il nostro strumento tenta automaticamente di correggere errori comuni come virgole finali non necessarie o escape di caratteri malformati, in modo che il JSON diventi valido secondo lo standard RFC 8259.',
+  },
+  {
+    question: 'Supporta file JSON molto grandi?',
+    answer:
+      'Sì, il motore di elaborazione è ottimizzato per gestire strutture dati complesse e file di grandi dimensioni senza bloccare l\'interfaccia del browser.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Incolla il tuo codice',
+    text: 'Incolla il tuo JSON non formattato o minificato nell\'area di testo principale.',
+  },
+  {
+    name: 'Valida e Formatta',
+    text: 'Il sistema analizzerà automaticamente il codice, evidenziando gli errori di sintassi e applicando l\'indentazione per migliorare la leggibilità.',
+  },
+  {
+    name: 'Scegli uno stile',
+    text: 'Scegli tra un formato espanso (beautify) o compresso (minify) a seconda che tu abbia bisogno di leggibilità o di risparmiare spazio.',
+  },
+  {
+    name: 'Copia il risultato',
+    text: 'Fai clic sul pulsante copia per portare il JSON perfettamente validato nei tuoi appunti.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowToThing> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'it',
+};
+
+const ui: JsonFormatterUI = {
+  labelInput: 'Input (JSON)',
+  labelOutput: 'Output',
+  btnMinify: 'Minifica',
+  btnBeautify: 'Abbellisci',
+  btnFix: 'Prova a riparare',
+  btnCopy: 'Copia',
+  statusWaiting: 'In attesa di input...',
+  statusValid: 'JSON Valido',
+  statusInvalid: 'JSON Non Valido',
+  toastCopied: 'Copiato!',
+  toastFixed: 'JSON riparato (Anteprima)',
+  toastFixFailed: 'Impossibile riparare automaticamente',
+  placeholder: 'Incolla qui il tuo JSON...',
+};
+
+export const content: ToolLocaleContent<JsonFormatterUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Domande Frequenti',
+  faq: faqData,
+  bibliographyTitle: 'Riferimenti e Standard',
+  bibliography: [
+    {
+      name: 'RFC 8259 – The JavaScript Object Notation (JSON) Data Interchange Format (IETF)',
+      url: 'https://datatracker.ietf.org/doc/html/rfc8259',
+    },
+    {
+      name: 'ECMA-404 – The JSON Data Interchange Syntax (Ecma International)',
+      url: 'https://www.ecma-international.org/publications-and-standards/standards/ecma-404/',
+    },
+    {
+      name: 'JSON.org – Introduzione a JSON',
+      url: 'https://www.json.org/json-it.html',
+    },
+    {
+      name: 'MDN Web Docs – JSON',
+      url: 'https://developer.mozilla.org/it/docs/Web/JavaScript/Reference/Global_Objects/JSON',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Validazione e Formattazione JSON',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'JSON (JavaScript Object Notation) è lo standard de facto per lo scambio di dati sul web. Tuttavia, la sua sintassi rigorosa lo rende propenso a errori umani quando viene modificato manualmente.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Questo strumento ti consente di validare la struttura, formattare il codice per migliorarne la leggibilità e riparare automaticamente i comuni errori di sintassi.',
+    },
+    { type: 'grid', columns: 2 },
+    {
+      type: 'card',
+      title: 'Errori Comuni che Ripara',
+      html: '<ul><li><strong>Virgolette Singole:</strong> Lo standard JSON richiede le doppie virgolette. Lo strumento converte <code>\'chiave\': \'valore\'</code> in <code>"chiave": "valore"</code>.</li><li><strong>Chiavi senza virgolette:</strong> Rileva le chiavi degli oggetti in stile JavaScript e aggiunge le virgolette necessarie.</li><li><strong>Virgole Finali:</strong> Rimuove le virgole alla fine di oggetti o array (trailing commas) che interrompono il parser rigoroso.</li></ul>',
+    },
+    {
+      type: 'card',
+      title: 'Caratteristiche',
+      html: '<ul><li><strong>Evidenziazione della Sintassi:</strong> Colora chiavi, stringhe, numeri e booleani per facilitare una lettura rapida.</li><li><strong>Validazione in Tempo Reale:</strong> Indica istantaneamente se il JSON è valido o mostra l\'errore di parsing specifico.</li><li><strong>Privacy Totale:</strong> L\'elaborazione avviene al 100% nel tuo browser. Nessun dato viene inviato a server esterni.</li></ul>',
+    },
+  ],
+};