@jjlmoya/utils-tools 1.1.0

package/src/tool/password-generator/i18n/en.ts

@@ -0,0 +1,166 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { PasswordGeneratorUI } from '../ui';
+
+const faqData = [
+  {
+    question: 'Is it safe to use an online password generator?',
+    answer: "Yes, as long as the generator is client-side. Our tool generates passwords locally in your browser using cryptographically secure algorithms. Your password is never sent over the internet or stored on any server.",
+  },
+  {
+    question: "What makes a password 'hacker-proof'?",
+    answer: 'The key is entropy (randomness). A mix of uppercase, lowercase, numbers and special symbols combined with a minimum length of 12-16 characters makes a brute-force attack practically impossible with current technology.',
+  },
+  {
+    question: 'Why avoid common words or dates?',
+    answer: 'Hackers use dictionary attacks that test millions of words, names and date combinations per second. Purely random passwords follow no linguistic patterns, making them far more secure.',
+  },
+  {
+    question: 'Should I memorise all my passwords?',
+    answer: 'Not recommended. The ideal approach is to use a password manager (like Bitwarden, 1Password or your browser built-in) to store these long, random passwords, so you only need to remember one strong master password.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Set the length',
+    text: 'Adjust the slider to choose how many characters your password will have. Current security standards recommend at least 12.',
+  },
+  {
+    name: 'Choose complexity',
+    text: 'Check the uppercase, numbers and symbols options according to the requirements of the site where you will use the password.',
+  },
+  {
+    name: 'Generate the password',
+    text: 'Click the generate button. Each click creates a unique, high-entropy combination based on cryptographic algorithms.',
+  },
+  {
+    name: 'Copy with one click',
+    text: 'Use the copy button to send the password directly to your clipboard in a secure way.',
+  },
+];
+
+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<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'How to use the secure password generator',
+  step: howToData.map((s) => ({ '@type': 'HowToStep', name: s.name, text: s.text })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: 'Secure Random Password Generator',
+  applicationCategory: 'SecurityApplication',
+  operatingSystem: 'Web',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  description: 'Create strong, hack-proof passwords instantly. Free cybersecurity tool to generate random, secure keys.',
+};
+
+const ui: PasswordGeneratorUI = {
+  generating: 'Generating...',
+  labelSecurity: 'Strength',
+  labelLength: 'Length',
+  strengthWeak: 'Weak',
+  strengthFair: 'Fair',
+  strengthGood: 'Good',
+  strengthStrong: 'Strong',
+  strengthUnbreakable: 'Unbreakable',
+  optionUppercase: 'Uppercase',
+  optionLowercase: 'Lowercase',
+  optionNumbers: 'Numbers',
+  optionSymbols: 'Symbols',
+  copyTitle: 'Copy',
+  regenerateTitle: 'Generate New',
+};
+
+export const content: ToolLocaleContent<PasswordGeneratorUI> = {
+  slug: 'password-generator',
+  title: 'Secure Random Password Generator',
+  description: 'Create strong, hack-proof passwords instantly. Free cybersecurity tool to generate random, secure keys.',
+  ui,
+  faqTitle: 'Frequently Asked Questions',
+  faq: faqData,
+  howTo: howToData,
+  bibliographyTitle: 'References',
+  bibliography: [
+    { name: 'Web Cryptography API — MDN Web Docs', url: 'https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API' },
+    { name: 'NIST SP 800-63B: Digital Identity Guidelines', url: 'https://pages.nist.gov/800-63-3/sp800-63b.html' },
+    { name: 'Password — Wikipedia', url: 'https://en.wikipedia.org/wiki/Password' },
+    { name: 'Have I Been Pwned — Check if your password was exposed', url: 'https://haveibeenpwned.com/Passwords' },
+  ],
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'The Anatomy of an Uncrackable Password',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Your password is the only barrier between your personal data (banking, medical, photos) and a cybercriminal. Yet the average user still relies on predictable patterns like "123456" or pet names, which can be cracked in <strong>less than a second</strong>.',
+    },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          icon: 'mdi:alert-circle',
+          title: 'The Danger of Rainbow Tables',
+          description: 'Hackers do not guess your password one attempt at a time. They use massive databases (Rainbow Tables) containing millions of pre-computed hashes of common passwords. If your password is in the dictionary or is a famous phrase, it was already compromised before you started using it.',
+          points: [],
+        },
+        {
+          icon: 'mdi:flask',
+          title: 'The Solution: Pure Entropy',
+          description: 'Entropy measures disorder or unpredictability. The higher the entropy (bits), the more time a computer needs to crack it. This tool uses crypto.getRandomValues(), a browser API that generates cryptographically secure random numbers, unlike Math.random() which is predictable.',
+          points: [],
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Basic Cybersecurity Principles',
+      level: 2,
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          icon: 'mdi:ruler',
+          title: 'Length over Complexity',
+          description: 'A 20-character lowercase-only password is more secure than an 8-character one with rare symbols. Mathematically, each extra character multiplies the difficulty exponentially.',
+          points: [],
+        },
+        {
+          icon: 'mdi:eye-off',
+          title: 'The Substitution Myth',
+          description: 'Replacing "a" with "@" or "e" with "3" (Leetspeak) fools no one. Modern attack dictionaries already include these variations automatically. Avoid using recognisable words.',
+          points: [],
+        },
+        {
+          icon: 'mdi:key-chain',
+          title: 'Different Site, Different Key',
+          description: 'If you use the same password for your email and a forum, and the forum gets hacked, they now have access to your email. Use a Password Manager (like Bitwarden or 1Password) to remember complex passwords for you.',
+          points: [],
+        },
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Privacy guaranteed',
+      html: 'All generation happens <strong>in your browser</strong>. No password is transmitted over the internet or logged on any server. The source code is auditable.',
+    },
+  ],
+};

package/src/tool/password-generator/i18n/es.ts

@@ -0,0 +1,166 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { PasswordGeneratorUI } from '../ui';
+
+const faqData = [
+  {
+    question: '¿Es seguro usar un generador de contraseñas online?',
+    answer: "Sí, siempre que el generador sea 'Client-Side'. Nuestra herramienta genera las claves localmente en tu navegador mediante criptografía segura. Tu contraseña nunca se envía a través de internet ni se guarda en ningún servidor.",
+  },
+  {
+    question: "¿Qué hace que una contraseña sea 'hacker-proof'?",
+    answer: 'La clave es la entropía (aleatoriedad). Una mezcla de mayúsculas, minúsculas, números y símbolos especiales, combinada con una longitud mínima de 12-16 caracteres, hace que un ataque de fuerza bruta sea prácticamente imposible con la tecnología actual.',
+  },
+  {
+    question: '¿Por qué evitar palabras comunes o fechas?',
+    answer: 'Los hackers utilizan ataques de diccionario que prueban millones de palabras, nombres y combinaciones de fechas en segundos. Las claves puramente aleatorias no siguen patrones lingüísticos, lo que las hace mucho más seguras.',
+  },
+  {
+    question: '¿Debo memorizar todas mis contraseñas?',
+    answer: 'No es recomendable. Lo ideal es usar un gestor de contraseñas (como Bitwarden, 1Password o el propio del navegador) para guardar estas claves largas y aleatorias, y así solo tener que recordar una clave maestra robusta.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Definir la longitud',
+    text: 'Ajusta el selector para elegir cuántos caracteres tendrá tu clave. El estándar de seguridad actual recomienda al menos 12.',
+  },
+  {
+    name: 'Elegir la complejidad',
+    text: 'Marca las opciones de mayúsculas, números y símbolos según los requisitos del sitio donde vayas a usar la contraseña.',
+  },
+  {
+    name: 'Generar la clave',
+    text: 'Pulsa el botón de generar. Cada clic crea una combinación única de alta entropía basada en algoritmos criptográficos.',
+  },
+  {
+    name: 'Copiar con un clic',
+    text: 'Utiliza el botón de copiar para llevar la contraseña directamente a tu portapapeles de forma segura.',
+  },
+];
+
+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<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'Cómo usar el generador de contraseñas seguras',
+  step: howToData.map((s) => ({ '@type': 'HowToStep', name: s.name, text: s.text })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: 'Generador de Contraseñas Seguras y Aleatorias',
+  applicationCategory: 'SecurityApplication',
+  operatingSystem: 'Web',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  description: 'Crea contraseñas robustas e imposibles de hackear al instante. Herramienta gratuita de ciberseguridad para generar claves aleatorias y seguras.',
+};
+
+const ui: PasswordGeneratorUI = {
+  generating: 'Generando...',
+  labelSecurity: 'Seguridad',
+  labelLength: 'Longitud',
+  strengthWeak: 'Débil',
+  strengthFair: 'Media',
+  strengthGood: 'Buena',
+  strengthStrong: 'Excelente',
+  strengthUnbreakable: 'Impenetrable',
+  optionUppercase: 'Mayúsculas',
+  optionLowercase: 'Minúsculas',
+  optionNumbers: 'Números',
+  optionSymbols: 'Símbolos',
+  copyTitle: 'Copiar',
+  regenerateTitle: 'Generar Nueva',
+};
+
+export const content: ToolLocaleContent<PasswordGeneratorUI> = {
+  slug: 'generador-contrasenas',
+  title: 'Generador de Contraseñas Seguras y Aleatorias',
+  description: 'Crea contraseñas robustas e imposibles de hackear al instante. Herramienta gratuita de ciberseguridad para generar claves aleatorias y seguras.',
+  ui,
+  faqTitle: 'Preguntas Frecuentes',
+  faq: faqData,
+  howTo: howToData,
+  bibliographyTitle: 'Referencias',
+  bibliography: [
+    { name: 'Web Cryptography API — MDN Web Docs', url: 'https://developer.mozilla.org/es/docs/Web/API/Web_Crypto_API' },
+    { name: 'NIST SP 800-63B: Digital Identity Guidelines', url: 'https://pages.nist.gov/800-63-3/sp800-63b.html' },
+    { name: 'Contraseña — Wikipedia', url: 'https://es.wikipedia.org/wiki/Contrase%C3%B1a' },
+    { name: 'Have I Been Pwned — Comprueba si tu contraseña fue expuesta', url: 'https://haveibeenpwned.com/Passwords' },
+  ],
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'La Anatomía de una Contraseña Indescifrable',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Tu contraseña es la única barrera entre tus datos personales (bancarios, médicos, fotos) y un ciberdelincuente. Sin embargo, el usuario promedio sigue utilizando patrones predecibles como "123456" o nombres de mascotas, que pueden ser crackeados en <strong>menos de un segundo</strong>.',
+    },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          icon: 'mdi:alert-circle',
+          title: 'El Peligro de las Tablas Rainbow',
+          description: 'Los hackers no "adivinan" tu contraseña probando una por una manualmente. Usan bases de datos gigantescas (Rainbow Tables) con millones de hashes precalculados de contraseñas comunes. Si tu contraseña está en el diccionario o es una frase famosa, ya ha sido hackeada antes de que empieces a usarla.',
+          points: [],
+        },
+        {
+          icon: 'mdi:flask',
+          title: 'La Solución: Entropía Pura',
+          description: 'La entropía mide el desorden o la imprevisibilidad. Cuanto mayor es la entropía (bits), más tiempo necesita un ordenador para crackearla. Esta herramienta utiliza crypto.getRandomValues(), una API del navegador que genera números aleatorios criptográficamente seguros, a diferencia de Math.random() que es predecible.',
+          points: [],
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Decálogo de Ciberseguridad Básica',
+      level: 2,
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          icon: 'mdi:ruler',
+          title: 'Longitud antes que Complejidad',
+          description: 'Una contraseña de 20 caracteres solo minúsculas es más segura que una de 8 con símbolos raros. Matemáticamente, cada carácter extra multiplica exponencialmente la dificultad.',
+          points: [],
+        },
+        {
+          icon: 'mdi:eye-off',
+          title: 'El mito de las sustituciones',
+          description: 'Cambiar "a" por "@" o "e" por "3" (Leetspeak) no engaña a nadie. Los diccionarios de ataque modernos ya incluyen estas variaciones automáticamente. Evita usar palabras reconocibles.',
+          points: [],
+        },
+        {
+          icon: 'mdi:key-chain',
+          title: 'Diferente sitio, diferente llave',
+          description: 'Si usas la misma contraseña para tu email y para un foro, y hackean el foro, ya tienen acceso a tu email. Usa un Gestor de Contraseñas (como Bitwarden o 1Password) para recordar estas claves complejas.',
+          points: [],
+        },
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Privacidad garantizada',
+      html: 'Toda la generación ocurre <strong>en tu navegador</strong>. Ninguna contraseña se transmite por internet ni se registra en ningún servidor. El código fuente es auditable.',
+    },
+  ],
+};

package/src/tool/password-generator/i18n/fr.ts

@@ -0,0 +1,166 @@
+import type { ToolLocaleContent } from '../../../types';
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { PasswordGeneratorUI } from '../ui';
+
+const faqData = [
+  {
+    question: 'Est-il sûr d\'utiliser un générateur de mots de passe en ligne ?',
+    answer: "Oui, à condition que le générateur soit côté client. Notre outil génère les mots de passe localement dans votre navigateur grâce à la cryptographie sécurisée. Votre mot de passe n'est jamais envoyé sur Internet ni stocké sur un serveur.",
+  },
+  {
+    question: 'Qu\'est-ce qui rend un mot de passe "inviolable" ?',
+    answer: 'La clé est l\'entropie (le hasard). Un mélange de majuscules, minuscules, chiffres et symboles spéciaux, combiné à une longueur minimale de 12 à 16 caractères, rend une attaque par force brute pratiquement impossible avec la technologie actuelle.',
+  },
+  {
+    question: 'Pourquoi éviter les mots courants ou les dates ?',
+    answer: 'Les pirates utilisent des attaques par dictionnaire qui testent des millions de mots, de noms et de combinaisons de dates en quelques secondes. Les mots de passe purement aléatoires ne suivent aucun schéma linguistique, ce qui les rend bien plus sûrs.',
+  },
+  {
+    question: 'Dois-je mémoriser tous mes mots de passe ?',
+    answer: 'Ce n\'est pas recommandé. L\'idéal est d\'utiliser un gestionnaire de mots de passe (comme Bitwarden, 1Password ou celui intégré au navigateur) pour stocker ces clés longues et aléatoires, afin de ne devoir mémoriser qu\'un seul mot de passe maître solide.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Définir la longueur',
+    text: 'Ajustez le curseur pour choisir le nombre de caractères de votre mot de passe. Les normes de sécurité actuelles recommandent au moins 12 caractères.',
+  },
+  {
+    name: 'Choisir la complexité',
+    text: 'Cochez les options majuscules, chiffres et symboles selon les exigences du site où vous utiliserez le mot de passe.',
+  },
+  {
+    name: 'Générer le mot de passe',
+    text: 'Cliquez sur le bouton générer. Chaque clic crée une combinaison unique à haute entropie basée sur des algorithmes cryptographiques.',
+  },
+  {
+    name: 'Copier en un clic',
+    text: 'Utilisez le bouton copier pour envoyer le mot de passe directement dans votre presse-papiers de manière sécurisée.',
+  },
+];
+
+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<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: 'Comment utiliser le générateur de mots de passe sécurisés',
+  step: howToData.map((s) => ({ '@type': 'HowToStep', name: s.name, text: s.text })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: 'Générateur de mots de passe sécurisés et aléatoires',
+  applicationCategory: 'SecurityApplication',
+  operatingSystem: 'Web',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  description: 'Créez des mots de passe robustes et impossibles à pirater instantanément. Outil de cybersécurité gratuit pour générer des clés aléatoires et sécurisées.',
+};
+
+const ui: PasswordGeneratorUI = {
+  generating: 'Génération...',
+  labelSecurity: 'Sécurité',
+  labelLength: 'Longueur',
+  strengthWeak: 'Faible',
+  strengthFair: 'Moyen',
+  strengthGood: 'Bon',
+  strengthStrong: 'Excellent',
+  strengthUnbreakable: 'Inviolable',
+  optionUppercase: 'Majuscules',
+  optionLowercase: 'Minuscules',
+  optionNumbers: 'Chiffres',
+  optionSymbols: 'Symboles',
+  copyTitle: 'Copier',
+  regenerateTitle: 'Générer un nouveau',
+};
+
+export const content: ToolLocaleContent<PasswordGeneratorUI> = {
+  slug: 'generateur-mot-de-passe',
+  title: 'Générateur de mots de passe sécurisés et aléatoires',
+  description: 'Créez des mots de passe robustes et impossibles à pirater instantanément. Outil de cybersécurité gratuit pour générer des clés aléatoires et sécurisées.',
+  ui,
+  faqTitle: 'Questions fréquentes',
+  faq: faqData,
+  howTo: howToData,
+  bibliographyTitle: 'Références',
+  bibliography: [
+    { name: 'API Web Cryptography — MDN Web Docs', url: 'https://developer.mozilla.org/fr/docs/Web/API/Web_Crypto_API' },
+    { name: 'NIST SP 800-63B : Lignes directrices sur l\'identité numérique', url: 'https://pages.nist.gov/800-63-3/sp800-63b.html' },
+    { name: 'Mot de passe — Wikipédia', url: 'https://fr.wikipedia.org/wiki/Mot_de_passe' },
+    { name: 'Have I Been Pwned — Vérifiez si votre mot de passe a été exposé', url: 'https://haveibeenpwned.com/Passwords' },
+  ],
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'L\'anatomie d\'un mot de passe indéchiffrable',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Votre mot de passe est la seule barrière entre vos données personnelles (bancaires, médicales, photos) et un cybercriminel. Pourtant, l\'utilisateur moyen continue d\'utiliser des schémas prévisibles comme "123456" ou des noms d\'animaux, qui peuvent être déchiffrés en <strong>moins d\'une seconde</strong>.',
+    },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          icon: 'mdi:alert-circle',
+          title: 'Le danger des Rainbow Tables',
+          description: 'Les pirates ne devinent pas votre mot de passe en essayant une par une. Ils utilisent d\'immenses bases de données (Rainbow Tables) contenant des millions de hachages pré-calculés de mots de passe courants. Si votre mot de passe figure dans le dictionnaire, il a déjà été compromis avant que vous commenciez à l\'utiliser.',
+          points: [],
+        },
+        {
+          icon: 'mdi:flask',
+          title: 'La solution : entropie pure',
+          description: 'L\'entropie mesure le désordre ou l\'imprévisibilité. Plus l\'entropie (en bits) est élevée, plus un ordinateur a besoin de temps pour la craquer. Cet outil utilise crypto.getRandomValues(), une API du navigateur qui génère des nombres aléatoires cryptographiquement sécurisés, contrairement à Math.random() qui est prévisible.',
+          points: [],
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Principes fondamentaux de cybersécurité',
+      level: 2,
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          icon: 'mdi:ruler',
+          title: 'La longueur prime sur la complexité',
+          description: 'Un mot de passe de 20 caractères en minuscules est plus sûr qu\'un mot de 8 caractères avec des symboles rares. Mathématiquement, chaque caractère supplémentaire multiplie la difficulté de manière exponentielle.',
+          points: [],
+        },
+        {
+          icon: 'mdi:eye-off',
+          title: 'Le mythe des substitutions',
+          description: 'Remplacer "a" par "@" ou "e" par "3" (Leetspeak) ne trompe personne. Les dictionnaires d\'attaque modernes incluent déjà ces variations automatiquement. Évitez d\'utiliser des mots reconnaissables.',
+          points: [],
+        },
+        {
+          icon: 'mdi:key-chain',
+          title: 'Site différent, clé différente',
+          description: 'Si vous utilisez le même mot de passe pour votre e-mail et un forum, et que le forum est piraté, ils ont accès à votre e-mail. Utilisez un gestionnaire de mots de passe (comme Bitwarden ou 1Password) pour mémoriser ces clés complexes à votre place.',
+          points: [],
+        },
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Confidentialité garantie',
+      html: 'Toute la génération se déroule <strong>dans votre navigateur</strong>. Aucun mot de passe n\'est transmis sur Internet ni enregistré sur un serveur. Le code source est auditable.',
+    },
+  ],
+};

package/src/tool/password-generator/index.ts

@@ -0,0 +1,22 @@
+import type { ToolDefinition, ToolsToolEntry } from '../../types';
+import type { PasswordGeneratorUI } from './ui';
+import PasswordGeneratorComponent from './component.astro';
+import PasswordGeneratorSEO from './seo.astro';
+import PasswordGeneratorBibliography from './bibliography.astro';
+
+export const passwordGenerator: ToolsToolEntry<PasswordGeneratorUI> = {
+  id: 'password-generator',
+  icons: { bg: 'mdi:shield-key', fg: 'mdi:lock-reset' },
+  i18n: {
+    es: () => import('./i18n/es').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+  },
+};
+
+export const PASSWORD_GENERATOR_TOOL: ToolDefinition = {
+  entry: passwordGenerator,
+  Component: PasswordGeneratorComponent,
+  SEOComponent: PasswordGeneratorSEO,
+  BibliographyComponent: PasswordGeneratorBibliography,
+};

package/src/tool/password-generator/seo.astro

@@ -0,0 +1,14 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { passwordGenerator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await passwordGenerator.i18n[locale]?.();
+---
+
+{content && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/password-generator/ui.ts

@@ -0,0 +1,16 @@
+export interface PasswordGeneratorUI extends Record<string, string> {
+  generating: string;
+  labelSecurity: string;
+  labelLength: string;
+  strengthWeak: string;
+  strengthFair: string;
+  strengthGood: string;
+  strengthStrong: string;
+  strengthUnbreakable: string;
+  optionUppercase: string;
+  optionLowercase: string;
+  optionNumbers: string;
+  optionSymbols: string;
+  copyTitle: string;
+  regenerateTitle: string;
+}

package/src/tool/routes/bibliography.astro

@@ -0,0 +1,14 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { routes } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'es' } = Astro.props;
+const content = await routes.i18n[locale]?.();
+---
+
+{content && <SharedBibliography links={content.bibliography} />}