@jjlmoya/utils-developer 1.2.0

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

@@ -0,0 +1,167 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { DuplicateCssRemoverUI } from '../ui';
+
+const slug = 'duplicate-css-remover';
+const title = 'Duplicate CSS Remover Online. Unify and Clean Stylesheets';
+const description =
+  'Free tool to clean and purge duplicate CSS code. Unifies redundant selectors, respects the cascade, and reduces your file size instantly in the browser.';
+
+const faqData = [
+  {
+    question: 'What happens when CSS selectors are duplicated?',
+    answer:
+      'When the same selector appears multiple times, the browser applies all the rules but the last declaration of each property overrides the earlier ones. This generates heavier files than necessary with no real benefit to the visual result.',
+  },
+  {
+    question: 'Will any properties be lost when removing duplicates?',
+    answer:
+      'No. The algorithm strictly respects the CSS cascade: for conflicting properties under the same selector, it always preserves the last declared one. Unique properties from each block are combined under a single unified selector.',
+  },
+  {
+    question: 'Does it work with minified CSS or CSS with comments?',
+    answer:
+      'The tool automatically strips CSS comments before processing and works correctly with single-line code. For CSS with advanced nesting or complex at-rules, it is recommended to separate the blocks first.',
+  },
+  {
+    question: 'Is my CSS sent to any server?',
+    answer:
+      'No. All processing happens directly in your browser via local JavaScript. No part of your CSS is transmitted to any external server, guaranteeing complete privacy of your code.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Paste your dirty CSS',
+    text: 'Copy the content of your CSS file with repeated selectors and paste it into the left field labeled "Dirty / Duplicate CSS".',
+  },
+  {
+    name: 'Run the cleanup',
+    text: 'Click the "Clean and Unify CSS" button. The tool will scan all selectors, merge properties, and remove redundant blocks.',
+  },
+  {
+    name: 'Review stats and copy',
+    text: 'Check the byte savings achieved and copy the optimized CSS with the "Copy Code" button to use it directly in your project.',
+  },
+];
+
+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((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.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: DuplicateCssRemoverUI = {
+  labelInput: 'Dirty / Duplicate CSS',
+  labelOutput: 'Clean CSS',
+  placeholderInput: '.btn { padding: 10px; color: red; }\n.btn { margin: 5px; color: blue; }',
+  placeholderOutput: 'Optimized and unified CSS will appear here...',
+  btnClean: 'Clean and Unify CSS',
+  btnCopy: 'Copy Code',
+  btnCopied: 'Copied!',
+  statBytesOriginal: 'Original Bytes',
+  statBytesClean: 'Clean Bytes',
+  statSaving: 'Savings',
+};
+
+export const content: ToolLocaleContent<DuplicateCssRemoverUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Frequently Asked Questions',
+  faq: faqData,
+  bibliographyTitle: 'References and Documentation',
+  bibliography: [
+    {
+      name: 'Web Vitals: CSS Impact on Render-Blocking and FCP',
+      url: 'https://web.dev/articles/render-blocking-resources',
+    },
+    {
+      name: 'W3C Specification: CSS Cascade and Inheritance',
+      url: 'https://www.w3.org/TR/css-cascade-4/',
+    },
+    {
+      name: 'Clean CSS: Library and Methodologies for CSS Minification',
+      url: 'https://github.com/clean-css/clean-css',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Why Does CSS Code Get Duplicated?',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'When maintaining long-term web projects or working with legacy code, it is extremely common for multiple developers to write overlapping CSS rules. Often, out of fear of breaking an existing design, a developer prefers to add a new redundant rule at the end of the document rather than editing or refactoring the original.',
+    },
+    {
+      type: 'paragraph',
+      html: 'The result is an inefficient file with dozens of selectors declared repeatedly, killing readability and significantly increasing the download weight of your web page.',
+    },
+    {
+      type: 'title',
+      text: 'The Hidden Impact on Web Performance (Web Vitals)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Stylesheet files block the natural rendering of the browser (a <strong>Render-Blocking</strong> resource). Until your browser downloads and builds the complete CSSOM, your screen remains blank.',
+    },
+    {
+      type: 'tip',
+      html: 'Purging redundant styles is not just about code cleanliness; it is a measurable and immediate improvement in vital metrics such as <strong>First Contentful Paint (FCP)</strong>.',
+    },
+    {
+      type: 'title',
+      text: 'How We Unify Duplicate Rules',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'This utility acts as an intelligent assembler. Rather than just compressing whitespace (as a traditional minifier would), it recursively scans the text for identical selector patterns.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Imagine having the rule <code>.box { color: red; }</code> and a hundred lines later a <code>.box { padding: 10px; color: blue; }</code>. The tool will unify both blocks under the same selector <code>.box</code>, merging the padding.',
+        '<strong>CSS Cascade Preservation:</strong> For direct conflicts, the algorithm strictly preserves the last declared property. This ensures your original layout does not break when purging the document.',
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'Stop sending kilobytes of dead text to your users\' mobile phones. Unify your code in milliseconds entirely offline from your browser.',
+    },
+  ],
+};

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

@@ -0,0 +1,167 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { DuplicateCssRemoverUI } from '../ui';
+
+const slug = 'eliminador-css-duplicado';
+const title = 'Eliminador de CSS Duplicado Online. Unifica y Limpia Estilos';
+const description =
+  'Herramienta gratuita para limpiar y purgar código CSS duplicado. Unifica selectores redundantes, respeta la cascada y reduce el tamaño de tus archivos al instante.';
+
+const faqData = [
+  {
+    question: '¿Qué ocurre cuando hay selectores CSS duplicados?',
+    answer:
+      'Cuando el mismo selector aparece varias veces, el navegador aplica todas las reglas pero la última declaración de cada propiedad sobreescribe a las anteriores. Esto genera archivos más pesados de lo necesario sin ningún beneficio real en el resultado visual.',
+  },
+  {
+    question: '¿Se perderá alguna propiedad al eliminar duplicados?',
+    answer:
+      'No. El algoritmo respeta estrictamente la cascada CSS: ante propiedades en conflicto bajo el mismo selector, preserva siempre la última declarada. Las propiedades únicas de cada bloque se combinan bajo un único selector unificado.',
+  },
+  {
+    question: '¿Funciona con CSS minificado o con comentarios?',
+    answer:
+      'La herramienta elimina automáticamente los comentarios CSS antes de procesar y trabaja correctamente con código en una sola línea. Para CSS con anidamiento avanzado (nesting, at-rules complejos) se recomienda separar primero los bloques.',
+  },
+  {
+    question: '¿Mis datos se envían a algún servidor?',
+    answer:
+      'No. Todo el procesamiento ocurre directamente en tu navegador mediante JavaScript local. Ningún fragmento de tu CSS es transmitido a ningún servidor externo, garantizando la privacidad total de tu código.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Pega tu CSS sucio',
+    text: 'Copia el contenido de tu archivo CSS con selectores repetidos y pégalo en el campo de la izquierda "CSS Sucio / Duplicado".',
+  },
+  {
+    name: 'Ejecuta la limpieza',
+    text: 'Haz clic en el botón "Limpiar y Unificar CSS". La herramienta escaneará todos los selectores, combinará propiedades y eliminará bloques redundantes.',
+  },
+  {
+    name: 'Revisa las estadísticas y copia',
+    text: 'Observa el ahorro en bytes obtenido y copia el CSS optimizado con el botón "Copiar Código" para usarlo directamente en tu proyecto.',
+  },
+];
+
+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((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.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: DuplicateCssRemoverUI = {
+  labelInput: 'CSS Sucio / Duplicado',
+  labelOutput: 'CSS Limpio',
+  placeholderInput: '.btn { padding: 10px; color: red; }\n.btn { margin: 5px; color: blue; }',
+  placeholderOutput: 'Aquí aparecerá el CSS optimizado y unificado...',
+  btnClean: 'Limpiar y Unificar CSS',
+  btnCopy: 'Copiar Código',
+  btnCopied: '¡Copiado!',
+  statBytesOriginal: 'Bytes Originales',
+  statBytesClean: 'Bytes Limpios',
+  statSaving: 'De Ahorro',
+};
+
+export const content: ToolLocaleContent<DuplicateCssRemoverUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Preguntas Frecuentes',
+  faq: faqData,
+  bibliographyTitle: 'Referencias y Documentación',
+  bibliography: [
+    {
+      name: 'Web Vitals: Impacto del CSS en Render-Blocking y FCP',
+      url: 'https://web.dev/articles/render-blocking-resources',
+    },
+    {
+      name: 'Especificación W3C: Cascada CSS y Herencia',
+      url: 'https://www.w3.org/TR/css-cascade-4/',
+    },
+    {
+      name: 'Clean CSS: Librería y metodologías para CSS minifier',
+      url: 'https://github.com/clean-css/clean-css',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: '¿Por qué se duplica el código CSS?',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Al mantener proyectos web a largo plazo o trabajar con código heredado (<em>legacy code</em>), es extremadamente común que varios desarrolladores escriban reglas CSS superpuestas. A menudo, por miedo a romper un diseño existente, un programador prefiere añadir una nueva regla redundante al final del documento en lugar de editar o refactorizar la original.',
+    },
+    {
+      type: 'paragraph',
+      html: 'El resultado es un archivo ineficiente con docenas de selectores declarados de forma repetida que ahogan la legibilidad y aumentan considerablemente el peso de descarga de tu página web.',
+    },
+    {
+      type: 'title',
+      text: 'El impacto oculto en el Rendimiento Web (Web Vitals)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Los archivos de estilo bloquean el renderizado natural del navegador (recurso <strong>Render-Blocking</strong>). Hasta que tu navegador no descarga y construye el CSSOM completo, tu pantalla permanece en blanco.',
+    },
+    {
+      type: 'tip',
+      html: 'Purgar los estilos redundantes no es una mera cuestión de pulcritud en el código; es una mejora medible e inmediata en métricas vitales como el <strong>First Contentful Paint (FCP)</strong>.',
+    },
+    {
+      type: 'title',
+      text: 'Cómo unificamos las reglas duplicadas',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Esta utilidad actúa como un ensamblador inteligente. En lugar de limitarse a comprimir espacios (como haría un minificador tradicional), escanea recursivamente el texto buscando patrones de selectores idénticos.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Imagina tener la regla <code>.box { color: red; }</code> y cien líneas más abajo un <code>.box { padding: 10px; color: blue; }</code>. La herramienta unificará ambos bloques bajo el mismo selector <code>.box</code> combinando el padding.',
+        '<strong>Preservación de la Cascada CSS:</strong> Ante conflictos directos, el algoritmo preserva estrictamente la última propiedad declarada. Así garantizamos que tu maquetado original no se rompa al purgar el documento.',
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'Se acabó enviar kilobytes de texto muerto a los teléfonos móviles de tus usuarios. Unifica tu código en milésimas de segundo totalmente offline desde tu navegador.',
+    },
+  ],
+};

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

@@ -0,0 +1,167 @@
+import type { WithContext, FAQPage, HowToThing, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { DuplicateCssRemoverUI } from '../ui';
+
+const slug = 'suppression-css-duplique';
+const title = 'Suppression de CSS Dupliqué en Ligne. Unifier et Nettoyer les Styles';
+const description =
+  'Outil gratuit pour nettoyer et purger le code CSS dupliqué. Unifie les sélecteurs redondants, respecte la cascade et réduit la taille de vos fichiers instantanément.';
+
+const faqData = [
+  {
+    question: 'Que se passe-t-il lorsque des sélecteurs CSS sont dupliqués ?',
+    answer:
+      'Lorsque le même sélecteur apparaît plusieurs fois, le navigateur applique toutes les règles mais la dernière déclaration de chaque propriété écrase les précédentes. Cela génère des fichiers plus lourds que nécessaire sans aucun bénéfice réel sur le rendu visuel.',
+  },
+  {
+    question: 'Des propriétés seront-elles perdues lors de la suppression des doublons ?',
+    answer:
+      'Non. L\'algorithme respecte strictement la cascade CSS : pour les propriétés en conflit sous le même sélecteur, il préserve toujours la dernière déclarée. Les propriétés uniques de chaque bloc sont combinées sous un sélecteur unifié.',
+  },
+  {
+    question: 'Fonctionne-t-il avec du CSS minifié ou des commentaires ?',
+    answer:
+      'L\'outil supprime automatiquement les commentaires CSS avant le traitement et fonctionne correctement avec du code sur une seule ligne. Pour du CSS avec des imbrications avancées ou des at-rules complexes, il est recommandé de séparer d\'abord les blocs.',
+  },
+  {
+    question: 'Mon CSS est-il envoyé à un serveur ?',
+    answer:
+      'Non. Tout le traitement se fait directement dans votre navigateur via JavaScript local. Aucune partie de votre CSS n\'est transmise à un serveur externe, garantissant la confidentialité totale de votre code.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Collez votre CSS brut',
+    text: 'Copiez le contenu de votre fichier CSS avec des sélecteurs répétés et collez-le dans le champ gauche "CSS Brut / Dupliqué".',
+  },
+  {
+    name: 'Lancez le nettoyage',
+    text: 'Cliquez sur le bouton "Nettoyer et Unifier le CSS". L\'outil analysera tous les sélecteurs, fusionnera les propriétés et supprimera les blocs redondants.',
+  },
+  {
+    name: 'Vérifiez les statistiques et copiez',
+    text: 'Consultez les économies en octets obtenues et copiez le CSS optimisé avec le bouton "Copier le Code" pour l\'utiliser directement dans votre projet.',
+  },
+];
+
+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((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.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: 'fr',
+};
+
+const ui: DuplicateCssRemoverUI = {
+  labelInput: 'CSS Brut / Dupliqué',
+  labelOutput: 'CSS Propre',
+  placeholderInput: '.btn { padding: 10px; color: red; }\n.btn { margin: 5px; color: blue; }',
+  placeholderOutput: 'Le CSS optimisé et unifié apparaîtra ici...',
+  btnClean: 'Nettoyer et Unifier le CSS',
+  btnCopy: 'Copier le Code',
+  btnCopied: 'Copié !',
+  statBytesOriginal: 'Octets Originaux',
+  statBytesClean: 'Octets Propres',
+  statSaving: 'Économie',
+};
+
+export const content: ToolLocaleContent<DuplicateCssRemoverUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Questions Fréquentes',
+  faq: faqData,
+  bibliographyTitle: 'Références et Documentation',
+  bibliography: [
+    {
+      name: 'Web Vitals: Impact du CSS sur le Render-Blocking et FCP',
+      url: 'https://web.dev/articles/render-blocking-resources',
+    },
+    {
+      name: 'Spécification W3C: Cascade CSS et Héritage',
+      url: 'https://www.w3.org/TR/css-cascade-4/',
+    },
+    {
+      name: 'Clean CSS: Bibliothèque et méthodologies pour la minification CSS',
+      url: 'https://github.com/clean-css/clean-css',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Pourquoi le code CSS se duplique-t-il ?',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Lors de la maintenance de projets web à long terme ou lors du travail avec du code hérité (<em>legacy code</em>), il est extrêmement courant que plusieurs développeurs écrivent des règles CSS qui se chevauchent. Souvent, par peur de casser un design existant, un développeur préfère ajouter une nouvelle règle redondante à la fin du document plutôt que de modifier ou refactoriser l\'originale.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Le résultat est un fichier inefficace avec des dizaines de sélecteurs déclarés de manière répétée, nuisant à la lisibilité et augmentant considérablement le poids de téléchargement de votre page web.',
+    },
+    {
+      type: 'title',
+      text: 'L\'impact caché sur les performances web (Web Vitals)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Les fichiers de style bloquent le rendu naturel du navigateur (ressource <strong>Render-Blocking</strong>). Tant que votre navigateur n\'a pas téléchargé et construit le CSSOM complet, votre écran reste blanc.',
+    },
+    {
+      type: 'tip',
+      html: 'Purger les styles redondants n\'est pas une simple question d\'ordre dans le code ; c\'est une amélioration mesurable et immédiate des métriques vitales comme le <strong>First Contentful Paint (FCP)</strong>.',
+    },
+    {
+      type: 'title',
+      text: 'Comment nous unifions les règles dupliquées',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Cet utilitaire agit comme un assembleur intelligent. Au lieu de se limiter à compresser les espaces (comme le ferait un minificateur traditionnel), il analyse récursivement le texte à la recherche de motifs de sélecteurs identiques.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Imaginez avoir la règle <code>.box { color: red; }</code> et cent lignes plus bas un <code>.box { padding: 10px; color: blue; }</code>. L\'outil unifiera les deux blocs sous le même sélecteur <code>.box</code> en combinant le padding.',
+        '<strong>Préservation de la Cascade CSS :</strong> En cas de conflits directs, l\'algorithme préserve strictement la dernière propriété déclarée. Cela garantit que votre mise en page originale ne se casse pas lors de la purge du document.',
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'Fini d\'envoyer des kilooctets de texte mort aux téléphones mobiles de vos utilisateurs. Unifiez votre code en millisecondes entièrement hors ligne depuis votre navigateur.',
+    },
+  ],
+};

package/src/tool/duplicateCssRemover/index.ts

@@ -0,0 +1,34 @@
+import type { DeveloperToolEntry, ToolLocaleContent, ToolDefinition } from '../../types';
+import DuplicateCssRemoverComponent from './component.astro';
+import DuplicateCssRemoverSEO from './seo.astro';
+import DuplicateCssRemoverBibliography from './bibliography.astro';
+
+import type { DuplicateCssRemoverUI } from './ui';
+
+export type DuplicateCssRemoverLocaleContent = ToolLocaleContent<DuplicateCssRemoverUI>;
+
+import { content as es } from './i18n/es';
+import { content as en } from './i18n/en';
+import { content as fr } from './i18n/fr';
+
+export const duplicateCssRemover: DeveloperToolEntry<DuplicateCssRemoverUI> = {
+  id: 'duplicate-css-remover',
+  icons: {
+    bg: 'mdi:broom',
+    fg: 'mdi:language-css3',
+  },
+  i18n: {
+    es: async () => es,
+    en: async () => en,
+    fr: async () => fr,
+  },
+};
+
+export { DuplicateCssRemoverComponent, DuplicateCssRemoverSEO, DuplicateCssRemoverBibliography };
+
+export const DUPLICATE_CSS_REMOVER_TOOL: ToolDefinition = {
+  entry: duplicateCssRemover,
+  Component: DuplicateCssRemoverComponent,
+  SEOComponent: DuplicateCssRemoverSEO,
+  BibliographyComponent: DuplicateCssRemoverBibliography,
+};

package/src/tool/duplicateCssRemover/seo.astro

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

package/src/tool/duplicateCssRemover/ui.ts

@@ -0,0 +1,12 @@
+export interface DuplicateCssRemoverUI extends Record<string, string> {
+  labelInput: string;
+  labelOutput: string;
+  placeholderInput: string;
+  placeholderOutput: string;
+  btnClean: string;
+  btnCopy: string;
+  btnCopied: string;
+  statBytesOriginal: string;
+  statBytesClean: string;
+  statSaving: string;
+}

package/src/tool/generadorSecurityTxt/bibliography.astro

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