@jjlmoya/utils-games-development 1.51.0 → 1.52.0

package/src/tool/saveFileEditor/i18n/nl.ts

@@ -0,0 +1,182 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { SaveFileEditorUI } from '../ui';
+import { bibliographyEntries } from '../bibliography';
+
+export const content: ToolLocaleContent<SaveFileEditorUI> = {
+  slug: 'game-save-bestand-editor',
+  title: 'Game Save Bestand Obfuscator en Editor',
+  description: 'Ontsleutel, inspecteer, bewerk JSON payloads en versleutel game save bestanden opnieuw met Base64, XOR masking of platte tekst 100% lokaal in je browser.',
+  ui: {
+    title: 'Game Save Bestand Obfuscator & Editor',
+    subtitle: 'Inspecteer, wijzig en versleutel lokale save bestanden veilig zonder serverlekken',
+    dropSaveFile: 'Sleep het game save bestand hier naartoe',
+    orSelectFile: 'of klik om een lokaal bestand te kiezen',
+    encryptionMethod: 'Versleutelingsformaat',
+    methodBase64: 'Base64 Codering',
+    methodXor: 'XOR Masker + Base64',
+    methodRaw: 'Platte JSON / Onversleuteld',
+    xorKeyLabel: 'XOR Geheime Sleutel',
+    xorKeyPlaceholder: 'bijv. MijnGeheimeSleutel2026',
+    jsonRawTitle: 'Gedecodeerde JSON Payload (Live Editor)',
+    encodeAndDownload: 'Versleutelen & Bestand Downloaden',
+    copyEncoded: 'Kopieer Versleutelde Tekst',
+    copiedNotice: 'Gekopieerd naar Klembord!',
+    decodedKeysCount: 'Totaal Aantal Parameters',
+    dataSize: 'Payload Grootte',
+    detectedFormat: 'Gedetecteerd Formaat',
+    exportPreviewLabel: 'Voorbeeld van Versleutelde Uitvoer',
+    decodePanelTitle: 'Decoderen en Live JSON Editor',
+    exportPanelTitle: 'Opnieuw Versleutelde Uitvoer',
+    decodeError: 'Het ontcijferen van het save bestand is mislukt',
+    bytesUnit: 'B',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Veiligheid en Obfuscantie Protocollen voor Game Saves',
+    },
+    {
+      type: 'paragraph',
+      html: 'Videogames serialiseren de voortgang van spelers naar permanente opslagformaten om inventarissen, vrijgespeelde niveaus en spelerattributen te bewaren tussen speelsessies. Om onbevoegde aanpassingen in gewone tekstverwerkers door eindgebruikers te voorkomen, obfusceren gamestudio s savebestanden met binaire coderingen zoals Base64 of bitwise XOR-maskering met een geheime sleutel. Tijdens interne QA-tests en live operaties debugging hebben ontwikkelingsteams directe toegang nodig om ruwe JSON-structuren te inspecteren, grenswaarden te testen en gewijzigde gegevens opnieuw te versleutelen zonder de game opnieuw te compileren.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { label: 'Client Verwerkingsprivacy', value: '100% Lokaal' },
+        { label: 'Ondersteunde Decoders', value: 'Base64 / XOR / JSON' },
+        { label: 'Decodeer Latentie', value: '0 ms' },
+        { label: 'Datalek Risico', value: 'Nul' },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Vergelijking van Obfuscantie Schema s',
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Base64 Codering',
+          description: 'Snelle tekstconversie die eenvoudige bewerkingen in Kladblok voorkomt, maar geen echte cryptografische beveiliging biedt.',
+        },
+        {
+          title: 'XOR Maskering + Base64',
+          description: 'Standaardpraktijk bij indie gameontwikkeling. Mengt tekstbytes met een geheime sleutel tegen geheugen-editors.',
+        },
+        {
+          title: 'Platte JSON Payload',
+          description: 'Leesbare save-status zonder versleuteling. Ideaal voor prototypes en interne team-iteraties.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'QA Testpraktijken voor Verificatie van Save Status',
+    },
+    {
+      type: 'tip',
+      title: 'Beste Praktijken voor Game Save Beveiliging tijdens QA',
+      html: 'Gebruik altijd afzonderlijke debugsleutels voor interne builds. Gebruik lokale inspecteurs om grenswaarden en statistieken te testen zonder de gamecode opnieuw te compileren.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Tabel met Richtlijnen voor Spelstatus Parameters',
+    },
+    {
+      type: 'table',
+      headers: ['Datatype', 'Aanbevolen Formaat', 'Veelvoorkomende Toepassing', 'Obfuscantielaag'],
+      rows: [
+        ['Numerieke Gehele Getallen', '32-bit Integer', 'Munten, Level, XP, Munitie', 'XOR Gemaskerd'],
+        ['Booleaanse Vlaggen', 'Standaard Boolean', 'Tutorial Voltooid, Baas Verslagen', 'Base64 / XOR'],
+        ['Geneste Objecten', 'JSON Hiërarchie', 'Spelersinventaris, Vaardigheden', 'Base64 Gecodeerd'],
+        ['Tijdstempel Strings', 'ISO 8601 UTC', 'Dagelijkse Login, Opslagtijdstempel', 'XOR Gemaskerd'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Reverse Engineering en Anti Tamper Overwegingen',
+    },
+    {
+      type: 'paragraph',
+      html: 'Hoewel obfuscantie aan de clientzijde voorkomt dat incidentele spelers opslagbestanden wijzigen in standaard tekstverwerkers, zijn XOR en Base64 geen cryptografische algoritmen. Geheugenscanners en tools zoals RenderDoc of x64dbg kunnen sleutelgeneratieroutines in gecompileerde bestanden inspecteren. Voor competitieve games zijn serververificatie of cryptografische HMAC-handtekeningen essentieel.',
+    },
+  ],
+  faqTitle: 'Veelgestelde Vragen',
+  faq: [
+    {
+      question: 'Worden mijn game save bestanden geüpload naar een externe server?',
+      answer: 'Nee. Alle decodering, JSON-structuurbewerking en her-versleuteling vinden 100% plaats binnen je eigen webbrowser.',
+    },
+    {
+      question: 'Hoe werkt XOR-sleutelobfuscantie in game-engines zoals Unity of Godot?',
+      answer: 'XOR-obfuscantie voert bitwise XOR-operaties uit op UTF-8 bytes van de JSON-string met de tekens van een geheime sleutel.',
+    },
+  ],
+  howTo: [
+    {
+      name: 'Bestand Laden of Plakken',
+      text: 'Upload je versleutelde savebestand of sleep het naar de uploadzone.',
+    },
+    {
+      name: 'Selecteer Decodeermethode en Sleutel',
+      text: 'Kies Base64 of XOR Maskering en voer de geheime sleutel in.',
+    },
+    {
+      name: 'JSON Status Bewerken',
+      text: 'Pas waarden voor niveau, goud, inventaris en spelvlaggen direct aan in de live editor.',
+    },
+    {
+      name: 'Versleutelen en Exporteren',
+      text: 'Download het gewijzigde savebestand gereed voor testen in de game.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Game Save Bestand Editor',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: {
+        '@type': 'Offer',
+        price: '0',
+        priceCurrency: 'EUR',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [
+        {
+          '@type': 'Question',
+          name: 'Worden mijn game save bestanden geüpload naar een externe server?',
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: 'Nee. Alle verwerkingen vinden 100% lokaal in je browser plaats.',
+          },
+        },
+      ],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'Hoe Versleutelde Game Save Bestanden te Bewerken',
+      step: [
+        {
+          '@type': 'HowToStep',
+          name: 'Bestand Laden',
+          text: 'Upload je versleutelde savebestand.',
+        },
+      ],
+    },
+  ],
+  bibliographyTitle: 'Referenties en Verder Lezen',
+  bibliography: bibliographyEntries,
+};

package/src/tool/saveFileEditor/i18n/pl.ts

@@ -0,0 +1,182 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { SaveFileEditorUI } from '../ui';
+import { bibliographyEntries } from '../bibliography';
+
+export const content: ToolLocaleContent<SaveFileEditorUI> = {
+  slug: 'edytor-plikow-zapisu-gier',
+  title: 'Edytor i Ofuskator Plików Zapisu Gier',
+  description: 'Odszyfruj, sprawdzaj, edytuj dane JSON i ponownie szyfruj pliki zapisu stanu gry przy użyciu Base64, maskowania XOR lub czystego tekstu 100% lokalnie w przeglądarce.',
+  ui: {
+    title: 'Edytor i Ofuskator Zapisu Stanu Gry',
+    subtitle: 'Bezpiecznie sprawdzaj, modyfikuj i szyfruj lokalne pliki zapisu bez przesyłania danych na serwer',
+    dropSaveFile: 'Przeciągnij i upuść plik zapisu gry tutaj',
+    orSelectFile: 'lub kliknij, aby wybrać plik z dysku',
+    encryptionMethod: 'Format Szyfrowania',
+    methodBase64: 'Kodowanie Base64',
+    methodXor: 'Maska XOR + Base64',
+    methodRaw: 'Czysty JSON / Nieszyfrowany',
+    xorKeyLabel: 'Tajny Klucz XOR',
+    xorKeyPlaceholder: 'np. MojTajnyKluczGry2026',
+    jsonRawTitle: 'Odszyfrowane Dane JSON (Edytor Na Żywo)',
+    encodeAndDownload: 'Zaszyfruj i Pobierz Plik Zapisu',
+    copyEncoded: 'Kopiuj Zaszyfrowany Tekst',
+    copiedNotice: 'Skopiowano do Schowka!',
+    decodedKeysCount: 'Liczba Parametrów',
+    dataSize: 'Rozmiar Danych',
+    detectedFormat: 'Wykryty Format',
+    exportPreviewLabel: 'Podgląd Zaszyfrowanego Wyjścia',
+    decodePanelTitle: 'Odszyfrowywanie i Edytor JSON Na Żywo',
+    exportPanelTitle: 'Zaszyfrowane Dane Wyjściowe',
+    decodeError: 'Nie udało się odszyfrować pliku zapisu gry',
+    bytesUnit: 'B',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Bezpieczeństwo i Protokoły Ofuskacji Plików Zapisu Gier',
+    },
+    {
+      type: 'paragraph',
+      html: 'Gry komputerowe i mobilne regularnie szeregują stan postępu gracza w trwałych formatach pamięci masowej, aby zachować stan ekwipunku, odblokowane poziomy, atrybuty postaci oraz flagi fabularne między sesjami rozgrywki. Aby zapobiec bezpośrednim modyfikacjom dokonywanym przez użytkowników w prostych edytorach tekstu, studia deweloperskie stosują ofuskację plików zapisu za pomocą schematów kodowania binarnego, takich jak Base64, lub bitowego maskowania XOR przy użyciu tajnego klucza. Podczas wewnętrznych testów kontroli jakości QA i debugowania, zespoły programistów potrzebują natychmiastowej możliwości inspekcji struktur JSON, testowania wartości brzegowych i ponownego szyfrowania danych bez konieczności ponownej kompilacji całej gry.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { label: 'Prywatność Przetwarzania', value: '100% Lokalnie' },
+        { label: 'Obsługiwane Dekodery', value: 'Base64 / XOR / JSON' },
+        { label: 'Opóźnienie Dekodowania', value: '0 ms' },
+        { label: 'Ryzyko Wycieku Danych', value: 'Zero' },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Porównanie Schematów Ofuskacji',
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Kodowanie Base64',
+          description: 'Szybka konwersja tekstu zapobiegająca przypadkowej edycji w notatniku, lecz niezapewniająca bezpieczeństwa kryptograficznego.',
+        },
+        {
+          title: 'Maskowanie XOR + Base64',
+          description: 'Standardowa praktyka w grach niezależnych. Łączy bajty tekstu z tajnym kluczem w celu ochrony przed edytorami pamięci.',
+        },
+        {
+          title: 'Czysty JSON',
+          description: 'Czytelny plik zapisu bez szyfrowania. Idealny do wczesnego prototypowania oraz wewnętrznych testów zespołu.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Praktyki Testowania QA do Weryfikacji Stanu Gry',
+    },
+    {
+      type: 'tip',
+      title: 'Najlepsze Praktyki Bezpieczeństwa Zapisów w QA',
+      html: 'Zawsze utrzymuj osobne klucze debugowania dla wersji wewnętrznych i produkcyjnych. Podczas weryfikacji błędów używaj lokalnych edytorów, aby wymusić wartości graniczne ekwipunku bez kompilowania kodu gry.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Tabela Wytycznych dla Parametrów Stanu Gry',
+    },
+    {
+      type: 'table',
+      headers: ['Typ Danych', 'Zalecany Format', 'Częste Zastosowanie', 'Warstwa Ofuskacji'],
+      rows: [
+        ['Liczby Całkowite', '32-bitowy Integer', 'Monety, Poziom, XP, Amunicja', 'Maska XOR'],
+        ['Flagi Logiczne', 'Standardowy Boolean', 'Samouczek Ukończony, Boss Pokonany', 'Base64 / XOR'],
+        ['Obiekty Zagnieżdżone', 'Hierarchia JSON', 'Ekwipunek Gracza, Drzewo Umiejętności', 'Kodowanie Base64'],
+        ['Znaczniki Czasu', 'ISO 8601 UTC', 'Codzienny Logowanie, Czas Zapisu', 'Maska XOR'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Inżynieria Wsteczna i Ochrona Przed Modyfikacją',
+    },
+    {
+      type: 'paragraph',
+      html: 'Choć ofuskacja po stronie klienta zapobiega edycji plików przez niedoświadczonych graczy, maskowanie XOR i Base64 nie są pełnymi algorytmami kryptograficznymi. Narzędzia do analizy pamięci, takie jak RenderDoc czy x64dbg, mogą odczytać procedury generowania kluczy bezpośrednio z zebranych plików wykonywalnych. W grach wieloosobowych niezbędna jest weryfikacja po stronie serwera lub stosowanie podpisów kryptograficznych HMAC.',
+    },
+  ],
+  faqTitle: 'Często Zadawane Pytania',
+  faq: [
+    {
+      question: 'Czy moje pliki zapisu gry są przesyłane na zewnętrzny serwer?',
+      answer: 'Nie. Cały proces dekodowania, edycji drzewa JSON i ponownego szyfrowania odbywa się w 100% wewnątrz Twojej przeglądarki internetowej.',
+    },
+    {
+      question: 'Jak działa ofuskacja kluczem XOR w silnikach takich jak Unity lub Godot?',
+      answer: 'Ofuskacja XOR wykonuje operację bitową XOR na bajtach UTF-8 ciągu JSON przy użyciu znaków tajnego klucza, a następnie przekształca wynik do formatu Base64.',
+    },
+  ],
+  howTo: [
+    {
+      name: 'Wczytaj lub Wklej Plik Zapisu',
+      text: 'Prześlij swój zaszyfrowany plik zapisu stanu gry lub przeciągnij go do strefy zrzutu.',
+    },
+    {
+      name: 'Wybierz Metodę Dekodowania i Klucz',
+      text: 'Wybierz Base64 lub Maskowanie XOR i wprowadź tajny klucz gry.',
+    },
+    {
+      name: 'Edytuj Stan JSON',
+      text: 'Zmieniaj poziomy, złoto, przedmioty w ekwipunku oraz flagi gry bezpośrednio w edytorze na żywo.',
+    },
+    {
+      name: 'Zaszyfruj i Eksportuj',
+      text: 'Pobierz zmodyfikowany plik zapisu przygotowany do testów w grze.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Edytor Plików Zapisu Gier',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: {
+        '@type': 'Offer',
+        price: '0',
+        priceCurrency: 'PLN',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [
+        {
+          '@type': 'Question',
+          name: 'Czy moje pliki zapisu gry są przesyłane na zewnętrzny serwer?',
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: 'Nie. Całe przetwarzanie odbywa się w 100% lokalnie w przeglądarce.',
+          },
+        },
+      ],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'Jak Edytować Zaszyfrowane Pliki Zapisu Gier',
+      step: [
+        {
+          '@type': 'HowToStep',
+          name: 'Wczytaj Plik Zapisu',
+          text: 'Prześlij zaszyfrowany plik zapisu.',
+        },
+      ],
+    },
+  ],
+  bibliographyTitle: 'Referencje i Dalsza Lektura',
+  bibliography: bibliographyEntries,
+};

package/src/tool/saveFileEditor/i18n/pt.ts

@@ -0,0 +1,182 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { SaveFileEditorUI } from '../ui';
+import { bibliographyEntries } from '../bibliography';
+
+export const content: ToolLocaleContent<SaveFileEditorUI> = {
+  slug: 'editor-salvamento-jogo',
+  title: 'Editor e Ofuscador de Save de Jogo',
+  description: 'Descriptografe, inspecione, edite payloads JSON e criptografe arquivos de save de jogos usando Base64, máscara XOR ou texto simples 100% localmente no navegador.',
+  ui: {
+    title: 'Editor e Ofuscador de Save de Jogo',
+    subtitle: 'Inspecione, modifique e criptografe arquivos de save locais com segurança e sem envio a servidores',
+    dropSaveFile: 'Arraste e solte o arquivo de save aqui',
+    orSelectFile: 'ou clique para selecionar um arquivo local',
+    encryptionMethod: 'Formato de Criptografia',
+    methodBase64: 'Codificação Base64',
+    methodXor: 'Máscara XOR + Base64',
+    methodRaw: 'JSON Simples / Não Criptografado',
+    xorKeyLabel: 'Chave Secreta XOR',
+    xorKeyPlaceholder: 'ex. MinhaChaveSecreta2026',
+    jsonRawTitle: 'Payload JSON Decodificado (Editor em Tempo Real)',
+    encodeAndDownload: 'Criptografar e Baixar Arquivo',
+    copyEncoded: 'Copiar Texto Criptografado',
+    copiedNotice: 'Copiado para a Área de Transferência!',
+    decodedKeysCount: 'Total de Parâmetros',
+    dataSize: 'Tamanho do Payload',
+    detectedFormat: 'Formato Detectado',
+    exportPreviewLabel: 'Pré-visualização da Saída Criptografada',
+    decodePanelTitle: 'Decodificação e Editor JSON em Tempo Real',
+    exportPanelTitle: 'Payload de Saída Re Criptografado',
+    decodeError: 'Falha ao decodificar o arquivo de save',
+    bytesUnit: 'B',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Segurança e Protocolos de Ofuscação em Saves de Jogos',
+    },
+    {
+      type: 'paragraph',
+      html: 'Os videogames serializam o progresso do jogador em formatos de armazenamento persistentes para manter inventários, níveis desbloqueados e atributos ao longo das sessões. Para evitar modificações diretas em editores de texto por parte dos usuários, os estúdios ofuscam arquivos de save com esquemas de codificação binária como Base64 ou máscaras XOR bit a bit combinadas com uma chave secreta. Durante os testes de controle de qualidade QA e depuração de operações ao vivo, as equipes de desenvolvimento precisam da capacidade imediata de inspecionar estruturas JSON brutas, forçar estados limite de teste e re-criptografar os dados modificados para implantação sem a necessidade de recompilar executáveis.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { label: 'Privacidade de Processamento', value: '100% Local' },
+        { label: 'Decodificadores Suportados', value: 'Base64 / XOR / JSON' },
+        { label: 'Latência', value: '0 ms' },
+        { label: 'Risco de Vazamento', value: 'Zero' },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Comparação de Esquemas de Ofuscação',
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Codificação Base64',
+          description: 'Conversão rápida para evitar edições simples sem oferecer segurança criptográfica real.',
+        },
+        {
+          title: 'Máscara XOR + Base64',
+          description: 'Prática comum no desenvolvimento indie. Mistura bytes com uma chave secreta contra editores de memória.',
+        },
+        {
+          title: 'Payload JSON Simples',
+          description: 'Save legível sem criptografia. Ideal para prototipagem e builds de depuração.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Práticas de Teste de QA para Saves',
+    },
+    {
+      type: 'tip',
+      title: 'Melhores Práticas em Testes de QA',
+      html: 'Mantenha chaves de depuração separadas para builds internas. Use inspetores locais para testar limites sem recompilar o código do jogo.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Diretrizes de Parâmetros do Jogo',
+    },
+    {
+      type: 'table',
+      headers: ['Tipo de Dado', 'Formato Recomendado', 'Caso de Uso', 'Camada de Ofuscação'],
+      rows: [
+        ['Inteiros Numéricos', 'Inteiro 32-bit', 'Moedas, Nível, XP, Munição', 'Máscara XOR'],
+        ['Flags Booleanas', 'Booleano Padrão', 'Tutorial Concluído, Chefe Derrotado', 'Base64 / XOR'],
+        ['Objetos Aninhados', 'Hierarquia JSON', 'Inventário, Habilidades', 'Base64'],
+        ['Timestamps', 'ISO 8601 UTC', 'Login Diário, Timestamp de Save', 'Máscara XOR'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Engenharia Reversa e Anti Adulteração',
+    },
+    {
+      type: 'paragraph',
+      html: 'Embora a ofuscação no cliente evite edições casuais, XOR e Base64 não são criptografia forte. Ferramentas de análise de memória como RenderDoc ou x64dbg podem inspecionar rotinas de geração de chaves em código compilado. Para jogos competitivos, assinaturas HMAC ou validações no servidor são necessárias para detectar alterações.',
+    },
+  ],
+  faqTitle: 'Perguntas Frequentes',
+  faq: [
+    {
+      question: 'Meus arquivos são enviados para algum servidor?',
+      answer: 'Não. Todo o processo acontece 100% no seu navegador.',
+    },
+    {
+      question: 'Como funciona a ofuscação XOR no Unity ou Godot?',
+      answer: 'A ofuscação XOR aplica operações bit a bit nos bytes da string JSON usando uma chave secreta.',
+    },
+  ],
+  howTo: [
+    {
+      name: 'Carregar Arquivo',
+      text: 'Envie seu arquivo de save criptografado.',
+    },
+    {
+      name: 'Selecionar Método',
+      text: 'Escolha o formato e digite a chave secreta.',
+    },
+    {
+      name: 'Editar JSON',
+      text: 'Modifique os valores no editor em tempo real.',
+    },
+    {
+      name: 'Exportar e Baixar',
+      text: 'Baixe o novo arquivo modificado para testar.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Editor de Save de Jogo',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: {
+        '@type': 'Offer',
+        price: '0',
+        priceCurrency: 'BRL',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [
+        {
+          '@type': 'Question',
+          name: 'Meus arquivos são enviados para algum servidor?',
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: 'Não. Todo o processo acontece 100% no seu navegador.',
+          },
+        },
+      ],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'Como Editar Saves de Jogos',
+      step: [
+        {
+          '@type': 'HowToStep',
+          name: 'Carregar Arquivo',
+          text: 'Envie seu arquivo de save criptografado.',
+        },
+      ],
+    },
+  ],
+  bibliographyTitle: 'Referências e Leituras Adicionais',
+  bibliography: bibliographyEntries,
+};