@jjlmoya/utils-games-development 1.50.0 → 1.52.0

package/src/tool/saveFileEditor/i18n/de.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: 'spiel-speicherstand-editor',
+  title: 'Spiel Speicherstand Editor und Obfuskator',
+  description: 'Entschlüsseln, überprüfen, bearbeiten Sie JSON Payloads und verschlüsseln Sie Spiel Speicherstände lokal mit Base64, XOR Maskierung oder Klartext.',
+  ui: {
+    title: 'Spiel Speicherstand Editor & Obfuskator',
+    subtitle: 'Lokale Speicherstände sicher prüfen, bearbeiten und verschlüsseln ohne Serverübertragung',
+    dropSaveFile: 'Ziehen Sie die Speicherdatei hierher oder klicken Sie',
+    orSelectFile: 'oder klicken Sie, um eine lokale Datei auszuwählen',
+    encryptionMethod: 'Verschlüsselungsformat',
+    methodBase64: 'Base64 Kodierung',
+    methodXor: 'XOR Maske + Base64',
+    methodRaw: 'Unverschlüsseltes JSON',
+    xorKeyLabel: 'Geheimer XOR Schlüssel',
+    xorKeyPlaceholder: 'z.B. MeinGeheimerSchluessel2026',
+    jsonRawTitle: 'Entschlüsseltes JSON Payload (Live Editor)',
+    encodeAndDownload: 'Verschlüsseln & Datei Herunterladen',
+    copyEncoded: 'Verschlüsselten Text Kopieren',
+    copiedNotice: 'In die Zwischenablage kopiert!',
+    decodedKeysCount: 'Gesamte Parameter',
+    dataSize: 'Payload Größe',
+    detectedFormat: 'Erkanntes Format',
+    exportPreviewLabel: 'Vorschau der Verschlüsselten Ausgabe',
+    decodePanelTitle: 'Entschlüsselung und Live JSON Editor',
+    exportPanelTitle: 'Neu Verschlüsselte Ausgabe',
+    decodeError: 'Fehler beim Entschlüsseln der Speicherdatei',
+    bytesUnit: 'B',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Sicherheit und Obfuskationsprotokolle für Spielspeicherstände',
+    },
+    {
+      type: 'paragraph',
+      html: 'Videospiele serialisieren den Fortschritt des Spielers in persistenten Speicherformaten, um Inventarbestände, freigeschaltete Level und Spielerattribute über Spielsitzungen hinweg zu bewahren. Um einfaches Ändern im Texteditor durch Endnutzer zu verhindern, obfuszieren Entwickler Speicherstände mit Kodierungsschemata wie Base64 oder XOR Bitmaskierung mit einem geheimen Schlüssel. Während der Qualitätssicherung und des Live Operations Debuggings benötigen Entwicklungsteams sofortigen Zugriff auf rohe JSON Strukturen, um Grenzwerttests durchzuführen und modifizierte Daten ohne erneutes Kompilieren von Spielbinärdateien bereitzustellen.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { label: 'Client Verarbeitung', value: '100% Lokal' },
+        { label: 'Unterstützte Dekoder', value: 'Base64 / XOR / JSON' },
+        { label: 'Dekodierungslatenz', value: '0 ms' },
+        { label: 'Datenverlust Risiko', value: 'Null' },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Vergleich der Obfuskationsverfahren',
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Base64 Kodierung',
+          description: 'Schnelle Zeichenkonvertierung gegen einfaches Bearbeiten im Texteditor ohne kryptografische Sicherheit.',
+        },
+        {
+          title: 'XOR Maskierung + Base64',
+          description: 'Standard in der Indie Spieleentwicklung. Mischt String Bytes mit einem Schlüssel gegen Cheat Engines.',
+        },
+        {
+          title: 'Unverschlüsseltes JSON',
+          description: 'Lesbarer Speicherstand für Prototypen und interne Team Iterationen.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'QS Testpraxis für Speicherstandsüberprüfung',
+    },
+    {
+      type: 'tip',
+      title: 'Best Practices für Speicherstandssicherheit in der QS',
+      html: 'Verwenden Sie getrennte Debug Schlüssel für interne Builds. Nutzen Sie lokale Inspektoren zur Überprüfung von Grenzwerten ohne Neukompilierung des Spielcodes.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Richtlinien für Spielzustandsparameter',
+    },
+    {
+      type: 'table',
+      headers: ['Datentyp', 'Empfohlenes Format', 'Typischer Anwendungsfall', 'Obfuskationsschicht'],
+      rows: [
+        ['Numerische Zahlen', '32-Bit-Integer', 'Münzen, Level, XP, Munition', 'XOR-maskiert'],
+        ['Booleche Flags', 'Standard-Boolean', 'Tutorial Abgeschlossen', 'Base64 / XOR'],
+        ['Verschachtelte Objekte', 'JSON-Hierarchie', 'Inventar, Fähigkeiten', 'Base64-kodiert'],
+        ['Zeitstempel', 'ISO 8601 UTC', 'Tägliches Login', 'XOR-maskiert'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Reverse Engineering und Anti Tamper Überlegungen',
+    },
+    {
+      type: 'paragraph',
+      html: 'Obfuskation auf Client Seite verhindert einfaches Ändern durch Gelegenheitsspieler, jedoch sind XOR und Base64 keine echten kryptografischen Algorithmen. Werkzeuge zur Speicheranalyse wie RenderDoc oder x64dbg können Schlüsselgenerierungsroutinen direkt in kompilierten C++ oder C# Baugruppen untersuchen. Für kompetitive Titel sind serverseitige Validierungen oder kryptografische HMAC Signaturen unerlässlich.',
+    },
+  ],
+  faqTitle: 'Häufig Gestellte Fragen',
+  faq: [
+    {
+      question: 'Werden meine Speicherdaten auf einen Server hochgeladen?',
+      answer: 'Nein. Alle Vorgänge finden zu 100% lokal in Ihrem Browser statt.',
+    },
+    {
+      question: 'Wie funktioniert die XOR Obfuskation in Unity oder Godot?',
+      answer: 'Die XOR Obfuskation wendet bitweise XOR Operationen auf UTF-8 Bytes gegen einen geheimen Schlüssel an.',
+    },
+  ],
+  howTo: [
+    {
+      name: 'Datei Laden oder Einfügen',
+      text: 'Laden Sie Ihre verschlüsselte Speicherdatei hoch.',
+    },
+    {
+      name: 'Methode und Schlüssel Wählen',
+      text: 'Wählen Sie Base64 oder XOR und geben Sie den Schlüssel ein.',
+    },
+    {
+      name: 'JSON Bearbeiten',
+      text: 'Ändern Sie die Werte direkt im Live Editor.',
+    },
+    {
+      name: 'Verschlüsseln und Exportieren',
+      text: 'Laden Sie die neue Datei für Tests herunter.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Spiel Speicherstand Editor',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: {
+        '@type': 'Offer',
+        price: '0',
+        priceCurrency: 'EUR',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [
+        {
+          '@type': 'Question',
+          name: 'Werden meine Speicherdaten hochgeladen?',
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: 'Nein. Alle Vorgänge finden zu 100% lokal statt.',
+          },
+        },
+      ],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'So bearbeiten Sie Speicherstände',
+      step: [
+        {
+          '@type': 'HowToStep',
+          name: 'Datei Laden',
+          text: 'Laden Sie Ihre Speicherdatei hoch.',
+        },
+      ],
+    },
+  ],
+  bibliographyTitle: 'Referenzen und Weiterführende Literatur',
+  bibliography: bibliographyEntries,
+};

package/src/tool/saveFileEditor/i18n/en.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-file-editor',
+  title: 'Game Save File Obfuscator and Editor',
+  description: 'Decrypt, inspect, edit JSON payloads, and re-encrypt game save files using Base64, XOR masking, or plain text 100% locally in your browser.',
+  ui: {
+    title: 'Game Save File Obfuscator & Editor',
+    subtitle: 'Inspect, modify, and encrypt local save state files securely without server leaks',
+    dropSaveFile: 'Drag & Drop game save file here',
+    orSelectFile: 'or click to browse local file',
+    encryptionMethod: 'Encryption Format',
+    methodBase64: 'Base64 Encoding',
+    methodXor: 'XOR Mask + Base64',
+    methodRaw: 'Plain JSON / Unencrypted',
+    xorKeyLabel: 'XOR Secret Key',
+    xorKeyPlaceholder: 'e.g. MySecretGameKey2026',
+    jsonRawTitle: 'Decoded JSON Payload (Live Editor)',
+    encodeAndDownload: 'Encrypt & Download Save File',
+    copyEncoded: 'Copy Encrypted Text',
+    copiedNotice: 'Copied to Clipboard!',
+    decodedKeysCount: 'Total Parameters',
+    dataSize: 'Payload Size',
+    detectedFormat: 'Detected Format',
+    exportPreviewLabel: 'Encrypted Output Preview',
+    decodePanelTitle: 'Decode and Live JSON Editor',
+    exportPanelTitle: 'Re Encrypted Output Payload',
+    decodeError: 'Failed to decode save file',
+    bytesUnit: 'B',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Game Save File Security and Obfuscation Protocols',
+    },
+    {
+      type: 'paragraph',
+      html: 'Video games routinely serialize player progression state into persistent storage formats to maintain inventory counts, unlocked stages, player attributes, and narrative flags across play sessions. To prevent trivial end-user tampering via plain text editors, game studios obfuscate save states using binary encoding schemes like Base64 or bitwise XOR masking against a secret string key. During internal QA testing and live operations debugging, development teams require immediate capability to inspect raw JSON structures, force boundary test states, and re-encrypt modified payloads for deployment without recompiling game binaries.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { label: 'Client Processing Privacy', value: '100%' },
+        { label: 'Supported Decoders', value: 'Base64 / XOR / JSON' },
+        { label: 'Latency', value: '0 ms' },
+        { label: 'Data Leak Risk', value: 'Zero' },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Obfuscation Schemes Comparison',
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Base64 Encoding',
+          description: 'Fast, lightweight string conversion that prevents casual end-user text edits in plain notepad but offers no cryptographic security.',
+        },
+        {
+          title: 'XOR Masking + Base64',
+          description: 'Standard practice in indie game development. Blends string bytes with a custom secret key to prevent casual memory editing or cheat engines.',
+        },
+        {
+          title: 'Plain JSON Payload',
+          description: 'Unencrypted readable save state. Ideal for initial prototyping, debug builds, and rapid internal team iterations.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'QA Testing Practices for Save State Verification',
+    },
+    {
+      type: 'tip',
+      title: 'Best Practices for Game Save Security during QA',
+      html: 'Always maintain separate debug keys for internal builds and production builds. When verifying edge-case bugs, use local tree inspectors to force inventory caps, boundary levels, and edge stats without recompiling game code.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Game State Parameter Guidelines Table',
+    },
+    {
+      type: 'table',
+      headers: ['Data Type', 'Recommended Format', 'Common Use Case', 'Obfuscation Layer'],
+      rows: [
+        ['Numeric Integers', '32-bit Integer', 'Coins, Level, XP, Ammo', 'XOR Masked'],
+        ['Boolean Flags', 'Standard Boolean', 'Tutorial Complete, Boss Defeated', 'Base64 / XOR'],
+        ['Nested Objects', 'JSON Hierarchy', 'Player Inventory, Skill Tree', 'Base64 Encoded'],
+        ['Timestamp Strings', 'ISO 8601 UTC', 'Daily Login, Save Timestamp', 'XOR Masked'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Reverse Engineering and Anti Tamper Considerations',
+    },
+    {
+      type: 'paragraph',
+      html: 'While client-side obfuscation prevents casual players from modifying save files in standard text editors, XOR masking and Base64 encoding are not cryptographic algorithms. Memory scanners, cheat software, and reverse-engineering tools like RenderDoc or x64dbg can inspect key generation routines directly within compiled C++ or C# game assemblies. For competitive multiplayer titles, authoritative server validation or cryptographic HMAC signatures (such as SHA-256 integrity hashes appended to the save file payload) are essential to detect payload tampering upon game startup.',
+    },
+  ],
+  faqTitle: 'Frequently Asked Questions',
+  faq: [
+    {
+      question: 'Are my game save files uploaded to a remote server?',
+      answer: 'No. All decoding, JSON tree rendering, editing, and re-encoding happen 100% inside your web browser web workers and JavaScript engine.',
+    },
+    {
+      question: 'How does XOR key obfuscation work in game engines like Unity or Godot?',
+      answer: 'XOR obfuscation iterates over UTF-8 bytes of the serialized JSON string, applying a bitwise XOR operation against characters of a secret key, then encoding the resulting bytes in Base64.',
+    },
+  ],
+  howTo: [
+    {
+      name: 'Load or Paste Save File',
+      text: 'Upload your encrypted save file or select one of the built-in game presets (RPG, Platformer, Tycoon).',
+    },
+    {
+      name: 'Select Decoding Method and Key',
+      text: 'Choose Base64 or XOR Masking and enter the corresponding game secret key, then click Decode.',
+    },
+    {
+      name: 'Edit JSON State',
+      text: 'Use the interactive tree view or raw code tab to adjust levels, gold, inventory items, or game flags.',
+    },
+    {
+      name: 'Encrypt and Export',
+      text: 'Select your target output format and download your modified save file ready for game testing.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Game Save File Obfuscator and Editor',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: {
+        '@type': 'Offer',
+        price: '0',
+        priceCurrency: 'USD',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [
+        {
+          '@type': 'Question',
+          name: 'Are my game save files uploaded to a remote server?',
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: 'No. All decoding and editing happen 100% inside your browser.',
+          },
+        },
+      ],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'How to Edit Encrypted Game Save Files',
+      step: [
+        {
+          '@type': 'HowToStep',
+          name: 'Load or Paste Save File',
+          text: 'Upload your encrypted save file.',
+        },
+      ],
+    },
+  ],
+  bibliographyTitle: 'References and Further Reading',
+  bibliography: bibliographyEntries,
+};

package/src/tool/saveFileEditor/i18n/es.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-archivos-guardado-juegos',
+  title: 'Editor y Ofuscador de Archivos de Guardado de Juegos',
+  description: 'Desencripta, inspecciona, edita payloads JSON y vuelve a encriptar archivos de guardado usando Base64, máscaras XOR o texto plano 100% local en tu navegador.',
+  ui: {
+    title: 'Editor y Ofuscador de Guardado de Juegos',
+    subtitle: 'Inspecciona, modifica y encripta archivos de estado de guardado local sin filtraciones a servidores',
+    dropSaveFile: 'Arrastra y suelta el archivo de guardado aquí',
+    orSelectFile: 'o haz clic para explorar un archivo local',
+    encryptionMethod: 'Formato de Encriptación',
+    methodBase64: 'Codificación Base64',
+    methodXor: 'Máscara XOR + Base64',
+    methodRaw: 'JSON Plano / Sin Encriptar',
+    xorKeyLabel: 'Clave Secreta XOR',
+    xorKeyPlaceholder: 'ej. MiClaveSecretaJuego2026',
+    jsonRawTitle: 'Payload JSON Decodificado (Editor en Vivo)',
+    encodeAndDownload: 'Encriptar y Descargar Archivo',
+    copyEncoded: 'Copiar Texto Encriptado',
+    copiedNotice: '¡Copiado al Portapapeles!',
+    decodedKeysCount: 'Parámetros Totales',
+    dataSize: 'Tamaño del Payload',
+    detectedFormat: 'Formato Detectado',
+    exportPreviewLabel: 'Previsualización de Salida Encriptada',
+    decodePanelTitle: 'Decodificación y Editor JSON en Vivo',
+    exportPanelTitle: 'Payload de Salida Re Encriptado',
+    decodeError: 'Error al decodificar el archivo de guardado',
+    bytesUnit: 'B',
+  },
+  seo: [
+    {
+      type: 'title',
+      level: 2,
+      text: 'Seguridad y Protocolos de Ofuscación en Guardado de Juegos',
+    },
+    {
+      type: 'paragraph',
+      html: 'Los videojuegos serializan el estado de progreso del jugador en formatos de almacenamiento persistentes para mantener inventarios, niveles desbloqueados y atributos a lo largo de las sesiones de juego. Para evitar manipulaciones directas en editores de texto plano por parte de los usuarios finales, los estudios de desarrollo ofuscan estos archivos con esquemas de codificación binaria como Base64 o máscaras bit a bit XOR contra una clave secreta personalizada. Durante las pruebas internas de control de calidad y depuración de operaciones en vivo, los equipos técnicos necesitan la capacidad inmediata de inspeccionar estructuras JSON crudas, forzar estados límite de prueba y volver a encriptar los datos modificados para su despliegue sin necesidad de reevaluar ni recompilar binarios.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { label: 'Privacidad de Procesamiento', value: '100% Local' },
+        { label: 'Decodificadores Soportados', value: 'Base64 / XOR / JSON' },
+        { label: 'Latencia de Decodificación', value: '0 ms' },
+        { label: 'Riesgo de Filtración', value: 'Cero' },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Comparativa de Esquemas de Ofuscación',
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Codificación Base64',
+          description: 'Conversión de texto rápida que evita ediciones accidentales en blocs de notas convencionales pero no ofrece seguridad criptográfica real.',
+        },
+        {
+          title: 'Máscara XOR + Base64',
+          description: 'Práctica habitual en desarrollo indie. Mezcla bytes de texto con una clave secreta personalizada para evitar editores de memoria o Cheat Engine.',
+        },
+        {
+          title: 'Payload JSON Plano',
+          description: 'Estado de guardado legible sin encriptar. Ideal para prototipado inicial, builds de depuración e iteraciones internas del equipo.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Prácticas de Pruebas de QA para Verificación de Estados',
+    },
+    {
+      type: 'tip',
+      title: 'Mejores Prácticas de Seguridad en Guardados durante QA',
+      html: 'Mantén siempre claves de depuración separadas para builds internas y de producción. Al verificar errores en casos límite, utiliza editores locales para forzar límites de inventario y estadísticas de borde sin recompilar el código del juego.',
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Guía de Parámetros de Estado de Juego',
+    },
+    {
+      type: 'table',
+      headers: ['Tipo de Dato', 'Formato Recomendado', 'Caso de Uso Habitual', 'Capa de Ofuscación'],
+      rows: [
+        ['Enteros Numéricos', 'Entero de 32 bits', 'Monedas, Nivel, Experiencia, Munición', 'Máscara XOR'],
+        ['Banderas Booleanas', 'Booleano Estándar', 'Tutorial Completo, Jefe Derrotado', 'Base64 / XOR'],
+        ['Objetos Anidados', 'Jerarquía JSON', 'Inventario del Jugador, Árbol de Habilidades', 'Codificado en Base64'],
+        ['Fechas y Tiempos', 'ISO 8601 UTC', 'Recompensa Diaria, Marca de Tiempo de Guardado', 'Máscara XOR'],
+      ],
+    },
+    {
+      type: 'title',
+      level: 2,
+      text: 'Ingeniería Inversa y Consideraciones Anti Tamper',
+    },
+    {
+      type: 'paragraph',
+      html: 'Aunque la ofuscación en el cliente evita que los usuarios casuales modifiquen archivos de guardado en editores estándar, las operaciones XOR y Base64 no constituyen algoritmos criptográficos verdaderos. Las herramientas de análisis de memoria y desensamblado como RenderDoc o x64dbg permiten inspeccionar las rutinas de generación de claves en ensamblados de C++ o C# compilados. Para títulos multijugador competitivos, la validación de estado autoritativo en servidor o firmas criptográficas HMAC son esenciales para detectar alteraciones al iniciar el juego.',
+    },
+  ],
+  faqTitle: 'Preguntas Frecuentes',
+  faq: [
+    {
+      question: '¿Se suben mis archivos de guardado a un servidor remoto?',
+      answer: 'No. Toda la decodificación, edición de árbol JSON y re-encriptación ocurre 100% dentro de tu navegador web sin enviar datos al exterior.',
+    },
+    {
+      question: '¿Cómo funciona la ofuscación XOR en motores como Unity o Godot?',
+      answer: 'La ofuscación XOR recorre los bytes UTF-8 de la cadena JSON serializada aplicando una operación XOR bit a bit contra los caracteres de una clave secreta.',
+    },
+  ],
+  howTo: [
+    {
+      name: 'Cargar o Pegar Archivo de Guardado',
+      text: 'Sube tu archivo de guardado encriptado o arrástralo directamente a la zona de carga.',
+    },
+    {
+      name: 'Seleccionar Método de Decodificación y Clave',
+      text: 'Selecciona Base64 o Máscara XOR e introduce la clave secreta correspondiente.',
+    },
+    {
+      name: 'Editar el Estado JSON',
+      text: 'Modifica los valores numéricos, banderas o inventarios directamente en el editor JSON en vivo.',
+    },
+    {
+      name: 'Encriptar y Exportar',
+      text: 'Descarga o copia el payload resultante listo para ser probado en el motor de juego.',
+    },
+  ],
+  schemas: [
+    {
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareApplication',
+      name: 'Editor de Archivos de Guardado de Juegos',
+      applicationCategory: 'DeveloperApplication',
+      operatingSystem: 'Any',
+      offers: {
+        '@type': 'Offer',
+        price: '0',
+        priceCurrency: 'EUR',
+      },
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'FAQPage',
+      mainEntity: [
+        {
+          '@type': 'Question',
+          name: '¿Se suben mis archivos de guardado a un servidor remoto?',
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: 'No. Toda la decodificación y edición ocurre 100% dentro de tu navegador.',
+          },
+        },
+      ],
+    },
+    {
+      '@context': 'https://schema.org',
+      '@type': 'HowTo',
+      name: 'Cómo Editar Archivos de Guardado Encriptados',
+      step: [
+        {
+          '@type': 'HowToStep',
+          name: 'Cargar o Pegar Archivo',
+          text: 'Sube tu archivo de guardado encriptado.',
+        },
+      ],
+    },
+  ],
+  bibliographyTitle: 'Referencias y Lecturas Adicionales',
+  bibliography: bibliographyEntries,
+};