@jjlmoya/utils-converters 1.1.0 → 1.2.0

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

@@ -65,37 +65,102 @@ const bibliography: GifAWebpLocaleContent['bibliography'] = [
 const seo: GifAWebpLocaleContent['seo'] = [
   {
     type: 'title',
-    text: 'Convertidor GIF a WebP Online Gratuito',
+    text: 'Convertidor de GIF a WebP: El Reemplazo Moderno para las Animaciones Pesadas',
+    level: 2,
   },
   {
     type: 'paragraph',
-    html:
-      'Convertir GIF a WebP combina las mejores características de ambos formatos. El GIF puede tener transparencias y múltiples fotogramas, mientras que WebP puede ser estático, más ligero y con mejor calidad. Al extraer el primer fotograma del GIF y exportarlo como WebP, obtienes una imagen moderna, ultraligera y con soporte completo para transparencias.',
+    html: 'Los GIFs animados son los dinosaurios del contenido web moderno: consumen un ancho de banda desproporcionado, degradan el PageSpeed de cualquier página y son responsables de un porcentaje significativo del peso total en miles de sitios web. Un GIF animado típico de 5 MB puede convertirse a WebP animado con menos de 1 MB manteniendo la misma calidad visual. WebP es el sucesor moderno que Google diseñó específicamente para reemplazar al GIF en la web.',
+  },
+  {
+    type: 'title',
+    text: 'GIF vs WebP: la diferencia entre el pasado y el presente de la web',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'El formato WebP ofrece compresión superior tanto con pérdida como sin pérdida. Para imágenes extraídas de GIFs con pocos colores o grandes áreas uniformes, la compresión WebP sin pérdida puede producir archivos extraordinariamente pequeños manteniendo una calidad perfecta.',
+    html: 'El GIF es un formato de 1987 que no fue diseñado para animaciones: esa característica llegó como un hack posterior. Su paleta de 256 colores, su falta de compresión eficiente y su incapacidad para audio lo convierten en un formato obsoleto. WebP, desarrollado por Google en 2010, ofrece compresión superior tanto con pérdida como sin pérdida, soporte de animación nativo y canal alfa completo.',
   },
   {
     type: 'paragraph',
-    html:
-      'Todo el proceso de conversión ocurre localmente en tu navegador. El archivo GIF se decodifica en memoria, se renderiza el primer fotograma en un canvas HTML5 y se exporta como WebP. No hay servidores involucrados, garantizando la máxima privacidad.',
+    html: 'Para un desarrollador web, reemplazar GIFs por WebP en las páginas puede suponer una mejora de 10-30 puntos en el score de PageSpeed de Google. Menos peso de página significa mejor Core Web Vitals, mejor posicionamiento SEO y menor coste de ancho de banda en servidores. No es solo una mejora estética: es una decisión de arquitectura técnica.',
   },
   {
-    type: 'tip',
-    html:
-      'Usa la conversión GIF a WebP para modernizar tu colección de avatares o stickers animados: obtendrás imágenes estáticas ultra-comprimidas con transparencias perfectas, ideales para web.',
+    type: 'title',
+    text: 'Comparativa de Arquitectura: Local vs Nube',
+    level: 3,
+  },
+  {
+    type: 'comparative',
+    items: [
+      {
+        title: 'Convertidores Cloud',
+        description: 'Plataformas que procesan tus GIFs en servidores remotos.',
+        icon: 'mdi:cloud-upload',
+        pointIcon: 'mdi:close-circle-outline',
+        points: [
+          'Tus animaciones viajan por internet a servidores de terceros',
+          'Espera por latencia de red en subida y bajada',
+          'Límites de tamaño (los GIFs grandes suelen rechazarse)',
+          'Riesgo de retención y análisis de tus archivos',
+        ],
+      },
+      {
+        title: 'Nuestra Arquitectura Local',
+        description: 'Procesamiento directo en tu hardware mediante tecnología Vanilla JS.',
+        icon: 'mdi:laptop-mac',
+        highlight: true,
+        points: [
+          'El GIF nunca sale de tu dispositivo',
+          'Conversión instantánea sin espera de red',
+          'Sin límites de tamaño: procesa GIFs de cualquier peso',
+          'Privacidad total: 0 bytes enviados al exterior',
+        ],
+      },
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Cómo funciona la conversión local GIF a WebP',
+    level: 3,
+  },
+  {
+    type: 'paragraph',
+    html: 'La conversión local utiliza el Canvas API de HTML5. El GIF se carga como un elemento Image nativo del navegador. Al dibujarlo sobre un canvas, el motor gráfico captura el primer fotograma de la animación con toda su información de transparencia. El método <code>toDataURL(\'image/webp\')</code> exporta el fotograma como WebP directamente en la RAM.',
   },
   {
     type: 'paragraph',
-    html:
-      'Un GIF de 300 KB puede producir un WebP estático del primer fotograma de apenas 15-50 KB si tiene áreas uniformes y transparencias. La reducción de tamaño puede superar el 80%.',
+    html: 'El formato WebP soporta canal alfa completo, por lo que las transparencias del GIF se preservan en el WebP resultante sin necesidad de añadir fondo. Los algoritmos de compresión WebP son significativamente más eficientes que los del GIF o PNG, lo que explica la drástica reducción de tamaño del archivo final.',
+  },
+  {
+    type: 'tip',
+    title: 'Ganancia de PageSpeed garantizada',
+    html: 'Un GIF animado de 5 MB puede convertirse en un WebP de menos de 1 MB. Si tienes GIFs en las páginas de tu sitio web, reemplazarlos por WebP puede mejorar tu Largest Contentful Paint (LCP) y tu Total Blocking Time (TBT) de forma inmediata, impactando directamente en el posicionamiento SEO.',
+  },
+  {
+    type: 'title',
+    text: 'Casos de uso y compatibilidad del WebP resultante',
+    level: 3,
+  },
+  {
+    type: 'list',
+    icon: 'mdi:check-circle',
+    items: [
+      'Sustitución de GIFs en páginas web para mejorar PageSpeed.',
+      'Avatares y stickers optimizados para Discord, Slack y plataformas modernas.',
+      'Banners y elementos visuales para campañas de marketing digital.',
+      'Animaciones en aplicaciones web progresivas (PWA).',
+      'Compatible con Chrome, Edge, Firefox, Safari 14+ y todos los navegadores modernos.',
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Conclusión: migra tus GIFs al siglo XXI',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Convierte GIF a WebP estático gratis y offline. Mejor compresión que PNG y JPG, con soporte de transparencias. Procesado localmente sin contacto con servidores.',
+    html: 'Cada GIF en tu sitio web es una oportunidad de optimización perdida. Nuestra herramienta convierte GIFs a WebP de forma instantánea, privada y sin límites, directamente en tu navegador. El resultado: archivos hasta 5 veces más pequeños, transparencias perfectas y compatibilidad con todos los navegadores modernos.',
   },
 ];
 

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

@@ -65,32 +65,102 @@ const bibliography: GifAWebpLocaleContent['bibliography'] = [
 const seo: GifAWebpLocaleContent['seo'] = [
   {
     type: 'title',
-    text: 'Convertisseur GIF vers WebP en Ligne Gratuit',
+    text: 'Convertisseur GIF vers WebP : Le Remplacement Moderne des Animations Lourdes',
+    level: 2,
   },
   {
     type: 'paragraph',
-    html:
-      'Convertir GIF en WebP combine les meilleures caractéristiques des deux formats. Le GIF peut avoir de la transparence et plusieurs images, tandis que WebP peut être statique, plus léger et de meilleure qualité. En extrayant la première image du GIF et en l\'exportant en WebP, vous obtenez une image moderne, ultra-légère avec support complet de la transparence.',
+    html: 'Les GIF animés sont les dinosaures du contenu web moderne : ils consomment une bande passante disproportionnée, dégradent le PageSpeed de toute page et sont responsables d\'un pourcentage significatif du poids total sur des milliers de sites web. Un GIF animé typique de 5 Mo peut devenir une animation WebP de moins de 1 Mo avec la même qualité visuelle. WebP est le successeur moderne que Google a spécifiquement conçu pour remplacer le GIF sur le web.',
+  },
+  {
+    type: 'title',
+    text: 'GIF vs WebP : l\'écart entre le passé et le présent du web',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Le format WebP offre une compression supérieure avec et sans perte. Pour les images extraites de GIF avec peu de couleurs ou de grandes zones uniformes, la compression WebP sans perte peut produire des fichiers extraordinairement petits tout en maintenant une qualité parfaite.',
+    html: 'Le GIF est un format de 1987 qui n\'a pas été conçu à l\'origine pour les animations — cette fonctionnalité est arrivée comme un hack ultérieur. Sa palette de 256 couleurs, sa compression inefficace et son incapacité à gérer l\'audio en font un format obsolète. WebP, développé par Google en 2010, offre une compression supérieure avec et sans perte, un support d\'animation natif et un canal alpha complet.',
   },
   {
-    type: 'tip',
-    html:
-      'Utilisez la conversion GIF vers WebP pour moderniser votre collection d\'avatars animés ou de stickers : vous obtiendrez des images statiques ultra-compressées avec une transparence parfaite, idéales pour le web.',
+    type: 'paragraph',
+    html: 'Pour un développeur web, remplacer les GIF par des WebP sur les pages peut représenter une amélioration de 10 à 30 points dans le score PageSpeed de Google. Moins de poids de page signifie de meilleurs Core Web Vitals, un meilleur référencement SEO et des coûts de bande passante réduits sur les serveurs. Ce n\'est pas seulement une amélioration esthétique — c\'est une décision d\'architecture technique.',
+  },
+  {
+    type: 'title',
+    text: 'Comparaison d\'Architecture : Local vs Cloud',
+    level: 3,
+  },
+  {
+    type: 'comparative',
+    items: [
+      {
+        title: 'Convertisseurs Cloud',
+        description: 'Plateformes qui traitent vos GIF sur des serveurs distants.',
+        icon: 'mdi:cloud-upload',
+        pointIcon: 'mdi:close-circle-outline',
+        points: [
+          'Vos animations transitent sur internet vers des serveurs tiers',
+          'Temps d\'attente dû à la latence réseau',
+          'Limites de taille (les grands GIF sont souvent rejetés)',
+          'Risque de rétention et d\'analyse de vos fichiers',
+        ],
+      },
+      {
+        title: 'Notre Architecture Locale',
+        description: 'Traitement direct sur votre matériel via la technologie Vanilla JS.',
+        icon: 'mdi:laptop-mac',
+        highlight: true,
+        points: [
+          'Le GIF ne quitte jamais votre appareil',
+          'Conversion instantanée sans attente réseau',
+          'Aucune limite de taille : traitez des GIF de tout poids',
+          'Confidentialité totale : 0 octet envoyé à l\'extérieur',
+        ],
+      },
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Comment fonctionne la conversion locale GIF vers WebP',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Un GIF de 300 Ko peut produire un WebP statique de la première image de seulement 15-50 Ko s\'il a des zones uniformes et de la transparence. La réduction de taille peut dépasser 80%.',
+    html: 'La conversion locale utilise l\'API Canvas HTML5. Le GIF est chargé comme un élément Image natif du navigateur. En le dessinant sur un canvas, le moteur graphique capture la première image de l\'animation avec toutes ses informations de transparence. La méthode <code>toDataURL(\'image/webp\')</code> exporte l\'image en WebP directement dans la RAM.',
+  },
+  {
+    type: 'paragraph',
+    html: 'Le WebP supporte le canal alpha complet, donc les transparences du GIF sont préservées dans le WebP résultant sans avoir besoin d\'ajouter un fond. Les algorithmes de compression WebP sont significativement plus efficaces que ceux du GIF ou du PNG, ce qui explique la réduction drastique de la taille du fichier final.',
+  },
+  {
+    type: 'tip',
+    title: 'Amélioration PageSpeed garantie',
+    html: 'Un GIF animé de 5 Mo peut devenir un WebP de moins de 1 Mo. Si vous avez des GIF sur les pages de votre site, les remplacer par des WebP peut immédiatement améliorer votre Largest Contentful Paint (LCP) et votre Total Blocking Time (TBT), impactant directement le référencement SEO.',
+  },
+  {
+    type: 'title',
+    text: 'Cas d\'usage et compatibilité du WebP résultant',
+    level: 3,
+  },
+  {
+    type: 'list',
+    icon: 'mdi:check-circle',
+    items: [
+      'Remplacement des GIF sur les pages web pour améliorer le PageSpeed.',
+      'Avatars et stickers optimisés pour Discord, Slack et les plateformes modernes.',
+      'Bannières et visuels pour les campagnes de marketing digital.',
+      'Animations dans les applications web progressives (PWA).',
+      'Compatible avec Chrome, Edge, Firefox, Safari 14+ et tous les navigateurs modernes.',
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Conclusion : migrez vos GIF vers le XXIe siècle',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Convertissez GIF en WebP statique gratuitement et hors ligne. Meilleure compression que PNG et JPG, avec support de transparence. Traitement local sans contact avec les serveurs.',
+    html: 'Chaque GIF sur votre site web est une opportunité d\'optimisation manquée. Notre outil convertit les GIF en WebP instantanément, en toute confidentialité et sans limites, directement dans votre navigateur. Le résultat : des fichiers jusqu\'à 5 fois plus petits, une transparence parfaite et une compatibilité avec tous les navigateurs modernes.',
   },
 ];
 

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

@@ -74,42 +74,83 @@ const bibliography: ImagenBase64LocaleContent['bibliography'] = [
 const seo: ImagenBase64LocaleContent['seo'] = [
   {
     type: 'title',
-    text: 'Online Image to Base64 Converter',
+    text: 'Image to Base64 Converter: Embed Images Without HTTP Requests',
+    level: 2,
   },
   {
     type: 'paragraph',
-    html:
-      'Base64 encoding is a fundamental technique in modern web development. It allows representing binary data (like images) as ASCII text, making it possible to embed images directly in HTML, CSS or JavaScript code without separate files. This is done through what are called Data URIs (Data Uniform Resource Identifiers).',
+    html: 'Base64 is an encoding technique that transforms binary data — like an image — into a pure ASCII text string. The result is a Data URI: a self-contained URL that starts with <code>data:image/png;base64,...</code> and contains the entire encoded image. By embedding this code directly in your HTML, CSS or JSON, the image loads without any additional HTTP request to the server — zero network latency, instant loading.',
+  },
+  {
+    type: 'title',
+    text: 'When to use Base64 images',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'A Data URI for an image follows the format: data:[MIME type];base64,[encoded data]. Our tool automatically generates the correct MIME type based on the image format you upload, whether it is PNG, JPG, WebP, GIF or SVG.',
+    html: 'The main argument for Base64 is the elimination of network requests. Every image on a web page means an HTTP request with its overhead of connection, DNS, TLS handshake and latency. For very small critical images — the main application logo, favicon, a UI icon — embedding them in Base64 in the CSS or HTML eliminates that cost and guarantees they display instantly even before the browser has cached anything.',
   },
   {
     type: 'paragraph',
-    html:
-      'Main use cases for Base64 images include: SVG icons in CSS, small logos in SPA (Single Page Application) apps, critical images for initial page load that should not cause additional network requests, and image data in JSON or REST APIs.',
+    html: 'This technique is especially powerful in SPA (Single Page Application) apps where the JavaScript and CSS bundle is generated at build time: embedding small images in the bundle guarantees they load together with the code without additional requests. It is also indispensable for HTML emails, where mail clients block external images but always display embedded Data URIs.',
   },
   {
-    type: 'tip',
-    html:
-      'Base64 code is approximately 33% larger than the original file. For small images (icons, logos, small sprites) it is efficient. For large photographs, it is better to use separate files and take advantage of browser caching.',
+    type: 'title',
+    text: 'Use cases for Base64 images',
+    level: 3,
+  },
+  {
+    type: 'list',
+    icon: 'mdi:check-circle',
+    items: [
+      'HTML inline: <code>&lt;img src="data:image/png;base64,..."&gt;</code> for critical icons.',
+      'CSS background: <code>background-image: url("data:image/svg+xml;base64,...")</code> for UI SVGs.',
+      'JSON and REST APIs: send images as text data in JSON payloads.',
+      'HTML emails: embedded images that display even when the client blocks external URLs.',
+      'SVG embedding: embed raster images inside SVG files as inline data.',
+    ],
+  },
+  {
+    type: 'title',
+    text: 'How the conversion works in the browser',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'A 1KB PNG image converts to approximately 1.37KB of Base64. A 100KB image would result in about 137KB of Base64 text. This 1.33x factor is constant for any file type.',
+    html: 'When you select or drag an image, the browser\'s <code>FileReader</code> API reads it directly from disk as binary data in RAM. The <code>readAsDataURL()</code> method converts those binary bytes to their Base64 representation using the RFC 4648 algorithm — every 3 bytes of original data are represented as 4 ASCII characters from the Base64 alphabet. The result includes the automatically detected correct MIME type.',
+  },
+  {
+    type: 'tip',
+    title: 'Use it only for small images (under 10 KB)',
+    html: 'Base64 increases file size by approximately 33%: a 10 KB image becomes ~13.3 KB of text. For small icons and logos this cost is minimal and the elimination of the HTTP request compensates for it. For photographs or large images, the size overhead is significant — always use a CDN for large images.',
+  },
+  {
+    type: 'title',
+    text: 'When NOT to use Base64',
+    level: 3,
+  },
+  {
+    type: 'tip',
+    title: 'Avoid Base64 for large images — use a CDN instead',
+    html: 'If you have images larger than 10-20 KB, Base64 hurts performance: it inflates HTML/CSS size, prevents the browser from caching the image independently, and blocks rendering while the parser processes the giant string. For large images, always serve from a CDN with appropriate cache headers.',
+  },
+  {
+    type: 'title',
+    text: 'Compatibility and privacy',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Our tool processes everything locally. The image is read via the browser\'s FileReader API, which converts it directly to Base64 without any data being sent to external servers. This guarantees complete privacy for your images, whether personal or corporate.',
+    html: 'Data URIs are compatible with 100% of modern browsers and most email clients. Our tool processes everything locally via the FileReader API — your images never leave your device. This makes it suitable for corporate images, private screenshots or any confidential visual content that you need to convert to Base64.',
+  },
+  {
+    type: 'title',
+    text: 'Conclusion: The fastest and most private embedding tool',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Convert images to Base64 and Data URI for free and privately. Support for JPG, PNG, WebP, SVG and GIF. Immediate result in your browser without server-side processing.',
+    html: 'Converting images to Base64 is a targeted but very powerful technique when applied correctly. Use it for small, critical images where zero HTTP requests makes a difference, and avoid it for large images where a CDN always wins. With our tool, you get the Data URI in an instant, without uploading anything to any server.',
   },
 ];
 

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

@@ -74,42 +74,83 @@ const bibliography: ImagenBase64LocaleContent['bibliography'] = [
 const seo: ImagenBase64LocaleContent['seo'] = [
   {
     type: 'title',
-    text: 'Convertidor de Imagen a Base64 Online',
+    text: 'Convertidor de Imagen a Base64: Incrusta Imágenes Sin Peticiones HTTP',
+    level: 2,
   },
   {
     type: 'paragraph',
-    html:
-      'La codificación Base64 es una técnica fundamental en el desarrollo web moderno. Permite representar datos binarios (como imágenes) como texto ASCII, lo que hace posible incrustar imágenes directamente en código HTML, CSS o JavaScript sin necesidad de archivos separados. Esto se realiza mediante los llamados Data URIs (Uniform Resource Identifiers de datos).',
+    html: 'Base64 es una técnica de codificación que transforma datos binarios — como una imagen — en una cadena de texto ASCII puro. El resultado es un Data URI: una URL auto-contenida que empieza por <code>data:image/png;base64,...</code> y contiene toda la imagen codificada. Al incrustar este código directamente en tu HTML, CSS o JSON, la imagen se carga sin ninguna petición HTTP adicional al servidor — cero latencia de red, carga instantánea.',
+  },
+  {
+    type: 'title',
+    text: 'Cuándo usar imágenes en Base64',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Un Data URI para una imagen sigue el formato: data:[tipo MIME];base64,[datos codificados]. Por ejemplo, una imagen PNG pequeña podría representarse como data:image/png;base64,iVBORw0KGgo... Nuestra herramienta genera automáticamente el tipo MIME correcto según el formato de la imagen que subas.',
+    html: 'El principal argumento a favor de Base64 es la eliminación de peticiones de red. Cada imagen en una página web supone una petición HTTP con su overhead de conexión, DNS, handshake TLS y latencia. Para imágenes críticas muy pequeñas — el logo principal de la aplicación, el favicon, un icono de UI — incrustarlas en Base64 en el CSS o HTML elimina ese coste y garantiza que se muestren de forma instantánea incluso antes de que el navegador haya cacheado nada.',
   },
   {
     type: 'paragraph',
-    html:
-      'Los principales casos de uso para imágenes en Base64 incluyen: iconos SVG en CSS, logotipos pequeños en aplicaciones SPA (Single Page Applications), imágenes críticas para carga inicial que no deben causar peticiones adicionales de red, y datos de imagen en JSON o APIs REST.',
+    html: 'Esta técnica es especialmente poderosa en aplicaciones SPA (Single Page Applications) donde el bundle JavaScript y CSS se genera en tiempo de compilación: incrustar imágenes pequeñas en el bundle garantiza que se cargan junto con el código sin peticiones adicionales. También es indispensable para emails HTML, donde los clientes de correo bloquean imágenes externas pero siempre muestran Data URIs incrustados.',
   },
   {
-    type: 'tip',
-    html:
-      'El código Base64 es aproximadamente un 33% más grande que el archivo original. Para imágenes pequeñas (iconos, logos, pequeños sprites) es eficiente. Para fotografías grandes, es mejor usar archivos separados y aprovechar la caché del navegador.',
+    type: 'title',
+    text: 'Casos de uso para imágenes en Base64',
+    level: 3,
+  },
+  {
+    type: 'list',
+    icon: 'mdi:check-circle',
+    items: [
+      'HTML inline: <code>&lt;img src="data:image/png;base64,..."&gt;</code> para iconos críticos.',
+      'CSS background: <code>background-image: url("data:image/svg+xml;base64,...")</code> para SVGs de UI.',
+      'JSON y APIs REST: enviar imágenes como datos de texto en payloads JSON.',
+      'Emails HTML: imágenes incrustadas que se muestran aunque el cliente bloquee URLs externas.',
+      'SVG embedding: incrustar imágenes rasterizadas dentro de archivos SVG como datos inline.',
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Cómo funciona la conversión en el navegador',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Una imagen PNG de 1KB se convierte en aproximadamente 1.37KB de Base64. Una imagen de 100KB resultaría en unos 137KB de texto Base64. Este factor de 1.33x es constante para cualquier tipo de archivo.',
+    html: 'Cuando seleccionas o arrastras una imagen, la API <code>FileReader</code> del navegador la lee directamente desde el disco como datos binarios en memoria RAM. El método <code>readAsDataURL()</code> convierte esos bytes binarios a su representación Base64 usando el algoritmo de RFC 4648 — cada 3 bytes de datos originales se representan como 4 caracteres ASCII del alfabeto Base64. El resultado incluye el tipo MIME correcto detectado automáticamente.',
+  },
+  {
+    type: 'tip',
+    title: 'Úsalo solo para imágenes pequeñas (menos de 10 KB)',
+    html: 'Base64 aumenta el tamaño del archivo en aproximadamente un 33%: una imagen de 10 KB se convierte en ~13.3 KB de texto. Para iconos y logos pequeños este coste es mínimo y la eliminación de la petición HTTP lo compensa. Para fotografías o imágenes grandes, el overhead de tamaño es significativo — usa siempre un CDN para imágenes grandes.',
+  },
+  {
+    type: 'title',
+    text: 'Cuándo NO usar Base64',
+    level: 3,
+  },
+  {
+    type: 'tip',
+    title: 'Evita Base64 para imágenes grandes — usa un CDN',
+    html: 'Si tienes imágenes de más de 10-20 KB, Base64 perjudica el rendimiento: infla el tamaño del HTML/CSS, impide que el navegador cachee la imagen de forma independiente, y bloquea el render mientras el parser procesa el string gigante. Para imágenes grandes, sirve siempre desde un CDN con headers de caché apropiados.',
+  },
+  {
+    type: 'title',
+    text: 'Compatibilidad y privacidad',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Nuestra herramienta procesa todo localmente. La imagen se lee mediante la API FileReader del navegador, que la convierte directamente a Base64 sin ningún envío de datos a servidores externos. Esto garantiza la privacidad total de tus imágenes, sean personales o corporativas.',
+    html: 'Los Data URIs son compatibles con el 100% de los navegadores modernos y la mayoría de clientes de email. Nuestra herramienta procesa todo localmente mediante la API FileReader — tus imágenes nunca salen de tu dispositivo. Esto la hace adecuada para imágenes corporativas, capturas de pantalla privadas o cualquier contenido visual confidencial que necesites convertir a Base64.',
+  },
+  {
+    type: 'title',
+    text: 'Conclusión: La herramienta de incrustación más rápida y privada',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Convierte imágenes a Base64 y Data URI de forma gratuita y privada. Soporte para JPG, PNG, WebP, SVG y GIF. Resultado inmediato en tu navegador sin procesamiento en servidores.',
+    html: 'Convertir imágenes a Base64 es una técnica puntual pero muy poderosa cuando se aplica correctamente. Úsala para imágenes pequeñas y críticas donde cero peticiones HTTP marca la diferencia, y evítala para imágenes grandes donde un CDN siempre gana. Con nuestra herramienta, obtienes el Data URI en un instante, sin subir nada a ningún servidor.',
   },
 ];
 

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

@@ -74,37 +74,83 @@ const bibliography: ImagenBase64LocaleContent['bibliography'] = [
 const seo: ImagenBase64LocaleContent['seo'] = [
   {
     type: 'title',
-    text: 'Convertisseur d\'Image vers Base64 en Ligne',
+    text: 'Convertisseur Image vers Base64 : Intégrez des Images Sans Requêtes HTTP',
+    level: 2,
   },
   {
     type: 'paragraph',
-    html:
-      'L\'encodage Base64 est une technique fondamentale dans le développement web moderne. Il permet de représenter des données binaires (comme des images) sous forme de texte ASCII, rendant possible l\'intégration d\'images directement dans le code HTML, CSS ou JavaScript sans fichiers séparés. Cela se fait via ce qu\'on appelle les Data URIs (Uniform Resource Identifiers de données).',
+    html: 'Base64 est une technique d\'encodage qui transforme des données binaires — comme une image — en une chaîne de texte ASCII pur. Le résultat est un Data URI : une URL auto-contenue qui commence par <code>data:image/png;base64,...</code> et contient l\'image entière encodée. En intégrant ce code directement dans votre HTML, CSS ou JSON, l\'image se charge sans aucune requête HTTP supplémentaire au serveur — zéro latence réseau, chargement instantané.',
+  },
+  {
+    type: 'title',
+    text: 'Quand utiliser les images en Base64',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Un Data URI pour une image suit le format : data:[type MIME];base64,[données encodées]. Notre outil génère automatiquement le bon type MIME selon le format de l\'image que vous téléchargez, que ce soit PNG, JPG, WebP, GIF ou SVG.',
+    html: 'Le principal argument en faveur de Base64 est l\'élimination des requêtes réseau. Chaque image sur une page web représente une requête HTTP avec son overhead de connexion, DNS, handshake TLS et latence. Pour les très petites images critiques — le logo principal de l\'application, le favicon, une icône d\'interface — les intégrer en Base64 dans le CSS ou HTML élimine ce coût et garantit leur affichage instantané même avant que le navigateur n\'ait rien mis en cache.',
+  },
+  {
+    type: 'paragraph',
+    html: 'Cette technique est particulièrement puissante dans les applications SPA (Single Page Applications) où le bundle JavaScript et CSS est généré au moment de la compilation : intégrer de petites images dans le bundle garantit qu\'elles se chargent avec le code sans requêtes supplémentaires. Elle est aussi indispensable pour les emails HTML, où les clients de messagerie bloquent les images externes mais affichent toujours les Data URIs intégrés.',
+  },
+  {
+    type: 'title',
+    text: 'Cas d\'utilisation pour les images Base64',
+    level: 3,
+  },
+  {
+    type: 'list',
+    icon: 'mdi:check-circle',
+    items: [
+      'HTML inline : <code>&lt;img src="data:image/png;base64,..."&gt;</code> pour les icônes critiques.',
+      'CSS background : <code>background-image: url("data:image/svg+xml;base64,...")</code> pour les SVGs d\'interface.',
+      'JSON et APIs REST : envoi d\'images comme données texte dans les payloads JSON.',
+      'Emails HTML : images intégrées qui s\'affichent même quand le client bloque les URLs externes.',
+      'Intégration SVG : intégrer des images raster dans des fichiers SVG comme données inline.',
+    ],
+  },
+  {
+    type: 'title',
+    text: 'Comment fonctionne la conversion dans le navigateur',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Les principaux cas d\'utilisation pour les images Base64 incluent : les icônes SVG en CSS, les petits logos dans les applications SPA, les images critiques pour le chargement initial de page qui ne devraient pas causer de requêtes réseau supplémentaires, et les données d\'image en JSON ou APIs REST.',
+    html: 'Lorsque vous sélectionnez ou faites glisser une image, l\'API <code>FileReader</code> du navigateur la lit directement depuis le disque comme données binaires en RAM. La méthode <code>readAsDataURL()</code> convertit ces octets binaires en leur représentation Base64 selon l\'algorithme RFC 4648 — chaque 3 octets de données originales sont représentés par 4 caractères ASCII de l\'alphabet Base64. Le résultat inclut le type MIME correct détecté automatiquement.',
+  },
+  {
+    type: 'tip',
+    title: 'Utilisez-le uniquement pour les petites images (moins de 10 Ko)',
+    html: 'Base64 augmente la taille du fichier d\'environ 33% : une image de 10 Ko devient ~13,3 Ko de texte. Pour les petites icônes et logos, ce coût est minimal et l\'élimination de la requête HTTP le compense. Pour les photographies ou grandes images, le surcoût de taille est significatif — utilisez toujours un CDN pour les grandes images.',
+  },
+  {
+    type: 'title',
+    text: 'Quand NE PAS utiliser Base64',
+    level: 3,
   },
   {
     type: 'tip',
-    html:
-      'Le code Base64 est environ 33% plus grand que le fichier original. Pour les petites images (icônes, logos, petits sprites) c\'est efficace. Pour les grandes photographies, il vaut mieux utiliser des fichiers séparés et profiter du cache du navigateur.',
+    title: 'Évitez Base64 pour les grandes images — utilisez un CDN',
+    html: 'Si vous avez des images de plus de 10-20 Ko, Base64 nuit aux performances : il gonfle la taille du HTML/CSS, empêche le navigateur de mettre l\'image en cache de façon indépendante, et bloque le rendu pendant que le parseur traite la chaîne géante. Pour les grandes images, servez toujours depuis un CDN avec des en-têtes de cache appropriés.',
+  },
+  {
+    type: 'title',
+    text: 'Compatibilité et confidentialité',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Une image PNG de 1Ko se convertit en environ 1,37Ko de Base64. Une image de 100Ko donnerait environ 137Ko de texte Base64. Ce facteur de 1,33x est constant pour tout type de fichier.',
+    html: 'Les Data URIs sont compatibles avec 100% des navigateurs modernes et la plupart des clients de messagerie. Notre outil traite tout localement via l\'API FileReader — vos images ne quittent jamais votre appareil. Cela le rend adapté aux images d\'entreprise, aux captures d\'écran privées ou à tout contenu visuel confidentiel que vous devez convertir en Base64.',
+  },
+  {
+    type: 'title',
+    text: 'Conclusion : L\'outil d\'intégration le plus rapide et le plus privé',
+    level: 3,
   },
   {
     type: 'paragraph',
-    html:
-      'Convertissez des images en Base64 et Data URI gratuitement et en toute confidentialité. Support JPG, PNG, WebP, SVG et GIF. Résultat immédiat dans votre navigateur sans traitement côté serveur.',
+    html: 'Convertir des images en Base64 est une technique ciblée mais très puissante quand elle est appliquée correctement. Utilisez-la pour les petites images critiques où zéro requête HTTP fait la différence, et évitez-la pour les grandes images où un CDN gagne toujours. Avec notre outil, vous obtenez le Data URI en un instant, sans rien téléverser sur aucun serveur.',
   },
 ];