@jjlmoya/utils-developer 1.2.0

package/src/tool/hashGenerator/component.astro

@@ -0,0 +1,367 @@
+---
+import { Icon } from 'astro-icon/components';
+import type { KnownLocale } from '../../types';
+import type { HashGeneratorUI } from './ui';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as HashGeneratorUI;
+---
+
+<div id="hg-root" data-i18n={JSON.stringify(t)} class="hg-root">
+  <div class="hg-card">
+    <div class="hg-input-block">
+      <div class="hg-field">
+        <label for="hg-input" class="hg-label">
+          <Icon name="mdi:text-box-outline" class="hg-label-icon" />
+          {t.labelInput}
+        </label>
+        <textarea id="hg-input" class="hg-textarea" spellcheck="false" placeholder={t.placeholderInput}></textarea>
+      </div>
+      <div class="hg-options-row">
+        <div class="hg-option">
+          <label for="hg-salt" class="hg-option-label">{t.labelSalt}</label>
+          <input type="text" id="hg-salt" class="hg-option-input" placeholder={t.placeholderSalt} />
+        </div>
+        <div class="hg-option">
+          <label for="hg-rounds" class="hg-option-label">{t.labelRounds}</label>
+          <input type="number" id="hg-rounds" class="hg-option-input" value="1" min="1" max="1000" />
+        </div>
+      </div>
+    </div>
+
+    <div class="hg-divider"></div>
+
+    <div class="hg-results-block">
+      <div class="hg-row">
+        <span class="hg-badge">MD5</span>
+        <span id="hg-out-md5" class="hg-hash">...</span>
+        <button class="hg-copy-btn" data-target="hg-out-md5" title={t.copyMd5}>
+          <Icon name="mdi:content-copy" class="hg-copy-icon" />
+        </button>
+      </div>
+      <div class="hg-row">
+        <span class="hg-badge">SHA-1</span>
+        <span id="hg-out-sha1" class="hg-hash">...</span>
+        <button class="hg-copy-btn" data-target="hg-out-sha1" title={t.copySha1}>
+          <Icon name="mdi:content-copy" class="hg-copy-icon" />
+        </button>
+      </div>
+      <div class="hg-row">
+        <span class="hg-badge">SHA-256</span>
+        <span id="hg-out-sha256" class="hg-hash">...</span>
+        <button class="hg-copy-btn" data-target="hg-out-sha256" title={t.copySha256}>
+          <Icon name="mdi:content-copy" class="hg-copy-icon" />
+        </button>
+      </div>
+      <div class="hg-row">
+        <span class="hg-badge">SHA-512</span>
+        <span id="hg-out-sha512" class="hg-hash">...</span>
+        <button class="hg-copy-btn" data-target="hg-out-sha512" title={t.copySha512}>
+          <Icon name="mdi:content-copy" class="hg-copy-icon" />
+        </button>
+      </div>
+    </div>
+  </div>
+</div>
+
+<script>
+  import { md5 } from './md5';
+
+  const input = document.getElementById('hg-input') as HTMLTextAreaElement;
+  const saltInput = document.getElementById('hg-salt') as HTMLInputElement;
+  const roundsInput = document.getElementById('hg-rounds') as HTMLInputElement;
+
+  const outputs: Record<string, HTMLElement | null> = {
+    md5: document.getElementById('hg-out-md5'),
+    sha1: document.getElementById('hg-out-sha1'),
+    sha256: document.getElementById('hg-out-sha256'),
+    sha512: document.getElementById('hg-out-sha512'),
+  };
+
+  async function hashSHA(text: string, algo: 'SHA-1' | 'SHA-256' | 'SHA-512'): Promise<string> {
+    const buf = await crypto.subtle.digest(algo, new TextEncoder().encode(text));
+    return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, '0')).join('');
+  }
+
+  function clearOutputs() {
+    Object.values(outputs).forEach((el) => { if (el) el.textContent = '...'; });
+  }
+
+  async function computeMd5(text: string, rounds: number) {
+    let val = text;
+    for (let i = 0; i < rounds; i++) val = md5(val);
+    return val;
+  }
+
+  async function computeSha(text: string, algo: 'SHA-1' | 'SHA-256' | 'SHA-512', rounds: number) {
+    let val = text;
+    for (let i = 0; i < rounds; i++) val = await hashSHA(val, algo);
+    return val;
+  }
+
+  async function updateHashes() {
+    const raw = input.value;
+    const salt = saltInput.value;
+    const rounds = parseInt(roundsInput.value) || 1;
+    if (!raw) { clearOutputs(); return; }
+    const text = raw + salt;
+    const el = outputs;
+    if (el.md5) el.md5.textContent = await computeMd5(text, rounds);
+    if (el.sha1) el.sha1.textContent = await computeSha(text, 'SHA-1', rounds);
+    if (el.sha256) el.sha256.textContent = await computeSha(text, 'SHA-256', rounds);
+    if (el.sha512) el.sha512.textContent = await computeSha(text, 'SHA-512', rounds);
+  }
+
+  input.addEventListener('input', updateHashes);
+  saltInput.addEventListener('input', updateHashes);
+  roundsInput.addEventListener('input', updateHashes);
+
+  const svgCheck = '<svg width="16" height="16" fill="none" stroke="rgb(34,197,94)" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2.5" d="M5 13l4 4L19 7"/></svg>';
+
+  document.querySelectorAll('.hg-copy-btn').forEach((btn) => {
+    btn.addEventListener('click', () => {
+      const targetId = (btn as HTMLElement).dataset.target;
+      const target = document.getElementById(targetId ?? '');
+      if (!target || !target.textContent || target.textContent === '...') return;
+      navigator.clipboard.writeText(target.textContent);
+      const orig = btn.innerHTML;
+      btn.innerHTML = svgCheck;
+      setTimeout(() => { btn.innerHTML = orig; }, 2000);
+    });
+  });
+</script>
+
+<style>
+  .hg-root {
+    width: 100%;
+  }
+
+  .hg-card {
+    background: #fff;
+    border: 1px solid rgb(226, 232, 240);
+    border-radius: 1.5rem;
+    overflow: hidden;
+  }
+
+  :global(.theme-dark) .hg-card {
+    background: rgb(15, 23, 42);
+    border-color: rgb(30, 41, 59);
+  }
+
+  .hg-input-block {
+    padding: 1.5rem;
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+  }
+
+  .hg-field {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+
+  .hg-label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-size: 0.875rem;
+    font-weight: 600;
+    color: rgb(15, 23, 42);
+  }
+
+  :global(.theme-dark) .hg-label {
+    color: rgb(226, 232, 240);
+  }
+
+  .hg-label-icon {
+    width: 1rem;
+    height: 1rem;
+    color: rgb(99, 102, 241);
+  }
+
+  .hg-textarea {
+    width: 100%;
+    min-height: 100px;
+    padding: 0.75rem 1rem;
+    font-size: 0.875rem;
+    color: rgb(15, 23, 42);
+    background: rgb(248, 250, 252);
+    border: 1px solid rgb(226, 232, 240);
+    border-radius: 0.75rem;
+    resize: vertical;
+    transition: border-color 0.2s;
+    box-sizing: border-box;
+  }
+
+  .hg-textarea:focus {
+    outline: none;
+    border-color: rgb(99, 102, 241);
+    box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.1);
+  }
+
+  :global(.theme-dark) .hg-textarea {
+    background: rgb(30, 41, 59);
+    border-color: rgb(51, 65, 85);
+    color: rgb(226, 232, 240);
+  }
+
+  .hg-options-row {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 0.75rem;
+  }
+
+  .hg-option {
+    display: flex;
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+
+  .hg-option-label {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: rgb(100, 116, 139);
+  }
+
+  .hg-option-input {
+    width: 100%;
+    padding: 0.5rem 0.75rem;
+    font-size: 0.8125rem;
+    color: rgb(15, 23, 42);
+    background: rgb(248, 250, 252);
+    border: 1px solid rgb(226, 232, 240);
+    border-radius: 0.5rem;
+    transition: border-color 0.2s;
+    box-sizing: border-box;
+  }
+
+  .hg-option-input:focus {
+    outline: none;
+    border-color: rgb(99, 102, 241);
+  }
+
+  :global(.theme-dark) .hg-option-input {
+    background: rgb(30, 41, 59);
+    border-color: rgb(51, 65, 85);
+    color: rgb(226, 232, 240);
+  }
+
+  .hg-divider {
+    height: 1px;
+    background: rgb(226, 232, 240);
+  }
+
+  :global(.theme-dark) .hg-divider {
+    background: rgb(30, 41, 59);
+  }
+
+  .hg-results-block {
+    display: flex;
+    flex-direction: column;
+  }
+
+  .hg-row {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    padding: 0.75rem 1.5rem;
+    border-bottom: 1px solid rgb(241, 245, 249);
+    transition: background 0.15s;
+  }
+
+  .hg-row:last-child {
+    border-bottom: none;
+  }
+
+  .hg-row:hover {
+    background: rgb(248, 250, 252);
+  }
+
+  :global(.theme-dark) .hg-row {
+    border-bottom-color: rgb(30, 41, 59);
+  }
+
+  :global(.theme-dark) .hg-row:hover {
+    background: rgb(30, 41, 59);
+  }
+
+  .hg-badge {
+    flex-shrink: 0;
+    width: 4.5rem;
+    text-align: center;
+    padding: 0.125rem 0;
+    font-size: 0.6875rem;
+    font-weight: 700;
+    color: rgb(99, 102, 241);
+    background: rgba(99, 102, 241, 0.1);
+    border-radius: 9999px;
+  }
+
+  .hg-hash {
+    flex: 1;
+    font-size: 0.75rem;
+    color: rgb(71, 85, 105);
+    word-break: break-all;
+    line-height: 1.4;
+  }
+
+  :global(.theme-dark) .hg-hash {
+    color: rgb(148, 163, 184);
+  }
+
+  .hg-copy-btn {
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.75rem;
+    height: 1.75rem;
+    background: transparent;
+    border: 1px solid rgb(226, 232, 240);
+    border-radius: 0.375rem;
+    cursor: pointer;
+    color: rgb(148, 163, 184);
+    transition: all 0.15s;
+  }
+
+  .hg-copy-btn:hover {
+    background: rgb(241, 245, 249);
+    color: rgb(99, 102, 241);
+    border-color: rgb(99, 102, 241);
+  }
+
+  .hg-copy-btn:active {
+    transform: scale(0.92);
+  }
+
+  :global(.theme-dark) .hg-copy-btn {
+    border-color: rgb(51, 65, 85);
+    color: rgb(100, 116, 139);
+  }
+
+  :global(.theme-dark) .hg-copy-btn:hover {
+    background: rgb(51, 65, 85);
+    color: rgb(99, 102, 241);
+  }
+
+  .hg-copy-icon {
+    width: 0.875rem;
+    height: 0.875rem;
+  }
+
+  @media (max-width: 480px) {
+    .hg-options-row {
+      grid-template-columns: 1fr;
+    }
+
+    .hg-row {
+      padding: 0.625rem 1rem;
+    }
+  }
+</style>

package/src/tool/hashGenerator/i18n/en.ts

@@ -0,0 +1,118 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { HashGeneratorUI } from '../ui';
+
+const slug = 'hash-generator';
+const title = 'Online Security Hash Generator';
+const description = 'Calculate MD5, SHA-1, SHA-256 and SHA-512 hashes instantly. Free, private and ultra-fast security tool for developers. 100% Client-Side.';
+
+const faqData = [
+  {
+    question: 'What is a hash and what is it used for?',
+    answer: 'A hash is a unique digital fingerprint of a text or file. It is used to verify that data has not been tampered with and to store passwords securely.',
+  },
+  {
+    question: 'Is it safe to use this online generator?',
+    answer: 'Yes, it is completely safe. Unlike other sites, we process the hash directly in your browser. Your data is never sent to any server.',
+  },
+  {
+    question: 'Which hash algorithm should I choose?',
+    answer: 'For modern security and key storage, we recommend SHA-256 or SHA-512. MD5 and SHA-1 should only be used for compatibility with legacy systems.',
+  },
+  {
+    question: "What does adding a 'Salt' mean?",
+    answer: 'A Salt is an extra string mixed with your text to make the hash unique and much harder to crack through dictionary attacks.',
+  },
+];
+
+const howToData = [
+  { name: 'Enter Text', text: 'Type or paste the text you want to hash into the input box.' },
+  { name: 'Configure Security', text: 'Add an optional Salt or increase processing rounds for greater robustness.' },
+  { name: 'Get Results', text: 'The different hashes (MD5, SHA etc.) are calculated in real time as you type.' },
+  { name: 'Copy the Hash', text: 'Click the copy icon next to each algorithm to save it to your clipboard.' },
+];
+
+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((s, i) => ({ '@type': 'HowToStep', position: i + 1, name: s.name, text: s.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: 'en',
+};
+
+const ui: HashGeneratorUI = {
+  labelInput: 'Input text',
+  placeholderInput: 'Type or paste text here to calculate its hashes...',
+  labelSalt: 'Salt (Optional)',
+  placeholderSalt: 'Security seed...',
+  labelRounds: 'Rounds (Stretch)',
+  copyMd5: 'Copy MD5',
+  copySha1: 'Copy SHA-1',
+  copySha256: 'Copy SHA-256',
+  copySha512: 'Copy SHA-512',
+};
+
+export const content: ToolLocaleContent<HashGeneratorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Frequently Asked Questions',
+  faq: faqData,
+  bibliographyTitle: 'Technical Resources on Hashing',
+  bibliography: [
+    { name: 'MDN Web Docs: SubtleCrypto.digest() API', url: 'https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest' },
+    { name: 'NIST: FIPS 180-4 Secure Hash Standard (SHA)', url: 'https://csrc.nist.gov/publications/detail/fips/180/4/final' },
+    { name: 'IETF: The MD5 Message-Digest Algorithm (RFC 1321)', url: 'https://datatracker.ietf.org/doc/html/rfc1321' },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: 'What is a Cryptographic Hash?', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'A <strong>cryptographic hash</strong> is a mathematical function that transforms any amount of data into a fixed-length string. The same input always produces the same output, but any minimal change in the input generates a completely different hash.',
+    },
+    { type: 'title', text: 'Available algorithms', level: 3 },
+    {
+      type: 'list',
+      items: [
+        '<strong>MD5 (128 bits):</strong> Fast and widely supported. Considered insecure for passwords but useful for file integrity checks in non-critical environments.',
+        '<strong>SHA-1 (160 bits):</strong> Deprecated for critical security uses since 2017. Still present in legacy systems.',
+        '<strong>SHA-256 (256 bits):</strong> The current standard for most applications. Used in Bitcoin, TLS and code signing.',
+        '<strong>SHA-512 (512 bits):</strong> Longer variant of SHA-2, ideal when maximum collision resistance is required.',
+      ],
+    },
+    { type: 'title', text: 'Salt and Key Stretching', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'The <strong>Salt</strong> is a random string added to the text before hashing, ensuring that two identical inputs produce different hashes. <strong>Key Stretching</strong> (rounds) applies the hash function multiple times to harden against brute-force attacks.',
+    },
+    { type: 'title', text: 'Total privacy: 100% Client-Side', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'This tool uses the browser\'s <strong>Web Crypto API</strong> for SHA and a pure TypeScript implementation for MD5. All processing happens locally: your data never leaves your device.',
+    },
+  ],
+};

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

@@ -0,0 +1,118 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { HashGeneratorUI } from '../ui';
+
+const slug = 'generador-hashes-seguridad';
+const title = 'Generador de Hashes de Seguridad Online';
+const description = 'Calcula hashes MD5, SHA-1, SHA-256 y SHA-512 al instante. Herramienta de seguridad gratuita, privada y ultra rápida para desarrolladores. 100% Client-Side.';
+
+const faqData = [
+  {
+    question: '\u00bfQu\u00e9 es un hash y para qu\u00e9 sirve?',
+    answer: 'Un hash es una huella digital \u00fanica de un texto o archivo. Sirve para verificar que los datos no han sido alterados y para almacenar contrase\u00f1as de forma segura.',
+  },
+  {
+    question: '\u00bfEs seguro usar este generador online?',
+    answer: 'S\u00ed, es totalmente seguro. A diferencia de otras webs, procesamos el hash directamente en tu navegador. Tus datos nunca se env\u00edan a ning\u00fan servidor.',
+  },
+  {
+    question: '\u00bfQu\u00e9 algoritmo de hash deber\u00eda elegir?',
+    answer: 'Para seguridad moderna y almacenamiento de claves, te recomendamos SHA-256 o SHA-512. MD5 y SHA-1 solo deben usarse por compatibilidad con sistemas antiguos.',
+  },
+  {
+    question: '\u00bfQu\u00e9 significa a\u00f1adir un Salt?',
+    answer: 'Un Salt es una cadena extra que se mezcla con tu texto para hacer que el hash sea \u00fanico y mucho m\u00e1s dif\u00edcil de descifrar mediante ataques de diccionario.',
+  },
+];
+
+const howToData = [
+  { name: 'Introducir Texto', text: 'Escribe o pega el texto que quieres cifrar en el cuadro de entrada.' },
+  { name: 'Configurar Seguridad', text: 'A\u00f1ade un Salt opcional o aumenta las rondas de procesamiento para mayor robustez.' },
+  { name: 'Obtener Resultados', text: 'Los diferentes hashes (MD5, SHA etc.) se calculan en tiempo real mientras escribes.' },
+  { name: 'Copiar el Hash', text: 'Haz clic en el icono de copiar situado junto a cada algoritmo para guardarlo en tu portapapeles.' },
+];
+
+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((s, i) => ({ '@type': 'HowToStep', position: i + 1, name: s.name, text: s.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: 'es',
+};
+
+const ui: HashGeneratorUI = {
+  labelInput: 'Texto de entrada',
+  placeholderInput: 'Escribe o pega aqu\u00ed el texto para calcular sus hashes...',
+  labelSalt: 'Salt (Opcional)',
+  placeholderSalt: 'Semilla de seguridad...',
+  labelRounds: 'Rondas (Stretch)',
+  copyMd5: 'Copiar MD5',
+  copySha1: 'Copiar SHA-1',
+  copySha256: 'Copiar SHA-256',
+  copySha512: 'Copiar SHA-512',
+};
+
+export const content: ToolLocaleContent<HashGeneratorUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Preguntas Frecuentes',
+  faq: faqData,
+  bibliographyTitle: 'Recursos T\u00e9cnicos sobre Hashing',
+  bibliography: [
+    { name: 'MDN Web Docs: SubtleCrypto.digest() API', url: 'https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest' },
+    { name: 'NIST: FIPS 180-4 Secure Hash Standard (SHA)', url: 'https://csrc.nist.gov/publications/detail/fips/180/4/final' },
+    { name: 'IETF: The MD5 Message-Digest Algorithm (RFC 1321)', url: 'https://datatracker.ietf.org/doc/html/rfc1321' },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    { type: 'title', text: '\u00bfQu\u00e9 es un Hash Criptogr\u00e1fico?', level: 2 },
+    {
+      type: 'paragraph',
+      html: 'Un <strong>hash criptogr\u00e1fico</strong> es una funci\u00f3n matem\u00e1tica que transforma cualquier cantidad de datos en una cadena de longitud fija. La misma entrada siempre produce el mismo resultado, pero cualquier m\u00ednimo cambio en la entrada genera un hash completamente diferente.',
+    },
+    { type: 'title', text: 'Algoritmos disponibles', level: 3 },
+    {
+      type: 'list',
+      items: [
+        '<strong>MD5 (128 bits):</strong> R\u00e1pido y ampliamente soportado. Considerado inseguro para contrase\u00f1as pero \u00fatil para verificar integridad de archivos en entornos no cr\u00edticos.',
+        '<strong>SHA-1 (160 bits):</strong> Deprecado para usos cr\u00edticos de seguridad desde 2017. A\u00fan presente en sistemas heredados.',
+        '<strong>SHA-256 (256 bits):</strong> El est\u00e1ndar actual para la mayor\u00eda de aplicaciones. Usado en Bitcoin, TLS y firmado de c\u00f3digo.',
+        '<strong>SHA-512 (512 bits):</strong> Variante de mayor longitud de SHA-2, ideal cuando se requiere m\u00e1xima resistencia a colisiones.',
+      ],
+    },
+    { type: 'title', text: 'Salt y Key Stretching', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'El <strong>Salt</strong> es una cadena aleatoria que se a\u00f1ade al texto antes de calcular el hash, garantizando que dos entradas id\u00e9nticas produzcan hashes distintos. El <strong>Key Stretching</strong> (rondas) aplica la funci\u00f3n hash m\u00faltiples veces para dificultar los ataques de fuerza bruta.',
+    },
+    { type: 'title', text: 'Privacidad total: 100% Client-Side', level: 3 },
+    {
+      type: 'paragraph',
+      html: 'Esta herramienta utiliza la <strong>Web Crypto API</strong> del navegador para SHA y una implementaci\u00f3n pura de TypeScript para MD5. Todo el procesamiento ocurre localmente: tus datos nunca abandonan tu dispositivo.',
+    },
+  ],
+};