@jjlmoya/utils-converters 1.16.0 → 1.18.0

package/src/tests/pagespeed_best_practices.test.ts

@@ -0,0 +1,198 @@
+import { describe, expect, it } from 'vitest';
+import { readdirSync, readFileSync } from 'fs';
+import { join, relative } from 'path';
+import { ALL_TOOLS } from '../tools';
+import type { SEOSection, ToolLocaleContent } from '../types';
+
+const srcDir = join(process.cwd(), 'src');
+const toolDir = join(srcDir, 'tool');
+const geometryReads = [
+  'offsetWidth',
+  'offsetHeight',
+  'offsetTop',
+  'offsetLeft',
+  'clientWidth',
+  'clientHeight',
+  'clientTop',
+  'clientLeft',
+  'scrollWidth',
+  'scrollHeight',
+  'scrollTop',
+  'scrollLeft',
+  'getBoundingClientRect',
+  'getClientRects',
+  'computedStyle',
+  'getComputedStyle',
+];
+const domWrites = [
+  '.style.',
+  '.classList.add',
+  '.classList.remove',
+  '.classList.toggle',
+  '.appendChild',
+  '.insertBefore',
+  '.prepend',
+  '.append',
+  '.remove',
+  '.innerHTML',
+  '.textContent',
+  '.setAttribute',
+];
+
+function findFiles(dir: string, extensions: string[]): string[] {
+  const files: string[] = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...findFiles(fullPath, extensions));
+    else if (extensions.some((extension) => entry.name.endsWith(extension))) files.push(fullPath);
+  }
+  return files;
+}
+
+function relativePath(file: string): string {
+  return relative(process.cwd(), file).replace(/\\/g, '/');
+}
+
+function findFormControls(content: string, tagName: 'input' | 'select'): RegExpMatchArray[] {
+  return Array.from(content.matchAll(new RegExp(`<${tagName}\\b[^>]*>`, 'gi')));
+}
+
+function attrValue(tag: string, attr: string): string | null {
+  const match = tag.match(new RegExp(`\\b${attr}\\s*=\\s*(?:"([^"]+)"|'([^']+)'|\\{([^}]+)\\})`, 'i'));
+  return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+
+function booleanAttr(tag: string, attr: string): boolean {
+  return new RegExp(`\\b${attr}\\b`, 'i').test(tag);
+}
+
+function controlStartIndex(content: string, tag: RegExpMatchArray): number {
+  return tag.index ?? content.indexOf(tag[0]);
+}
+
+function hasWrappingLabel(content: string, tag: RegExpMatchArray): boolean {
+  const index = controlStartIndex(content, tag);
+  const before = content.slice(0, index);
+  const labelOpen = before.lastIndexOf('<label');
+  const labelClose = before.lastIndexOf('</label>');
+  const nextLabelClose = content.indexOf('</label>', index + tag[0].length);
+  return labelOpen > labelClose && nextLabelClose !== -1;
+}
+
+function hasAccessibleName(content: string, tag: RegExpMatchArray): boolean {
+  const source = tag[0];
+  if (attrValue(source, 'aria-label')) return true;
+  if (attrValue(source, 'aria-labelledby')) return true;
+  const id = attrValue(source, 'id');
+  if (id && hasExplicitLabel(content, id)) return true;
+  return hasWrappingLabel(content, tag);
+}
+
+function isVisuallyHiddenFileInput(tag: string): boolean {
+  const type = attrValue(tag, 'type')?.toLowerCase() ?? 'text';
+  const attributes = `${attrValue(tag, 'style') ?? ''} ${attrValue(tag, 'class') ?? ''}`.toLowerCase();
+  const hiddenPatterns = ['display:none', 'display: none', 'file-input'];
+  return type === 'file' && hiddenPatterns.some((pattern) => attributes.includes(pattern));
+}
+
+function isIgnoredInput(tag: string): boolean {
+  const type = attrValue(tag, 'type')?.toLowerCase() ?? 'text';
+  return ['hidden', 'button', 'submit', 'reset'].includes(type) || booleanAttr(tag, 'aria-hidden') || isVisuallyHiddenFileInput(tag);
+}
+
+function controlFailures(content: string, tagName: 'input' | 'select'): string[] {
+  return findFormControls(content, tagName)
+    .filter((tag) => tagName !== 'input' || !isIgnoredInput(tag[0]))
+    .filter((tag) => !hasAccessibleName(content, tag))
+    .map((tag) => tag[0]);
+}
+
+function explicitLabelMessage(tagName: string, path: string, failures: string[]): string {
+  return `${tagName} controls without label, wrapping label, aria-label or aria-labelledby in ${path}:\n${failures.join('\n')}`;
+}
+
+function hasExplicitLabel(content: string, id: string): boolean {
+  const escapedId = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return (
+    new RegExp(`<label\\b[^>]*\\bfor\\s*=\\s*["']${escapedId}["'][^>]*>`, 'i').test(content)
+    || new RegExp(`<label\\b[^>]*\\bfor\\s*=\\s*\\{${escapedId}\\}[^>]*>`, 'i').test(content)
+  );
+}
+
+function headingLevels(sections: SEOSection[]): number[] {
+  return sections
+    .filter((section) => section.type === 'title')
+    .map((section) => Number('level' in section ? section.level : 0))
+    .filter((level) => Number.isInteger(level) && level > 0);
+}
+
+function findHeadingLevelJumps(levels: number[]): string[] {
+  const failures: string[] = [];
+  levels.forEach((level, index) => {
+    const previous = index === 0 ? 1 : levels[index - 1];
+    if (previous && level > previous + 1) {
+      failures.push(`h${previous} -> h${level}`);
+    }
+  });
+  return failures;
+}
+
+function hasDomWriteBeforeGeometryRead(content: string): boolean {
+  const normalized = content.replace(/\s+/g, ' ');
+  return domWrites.some((write) => {
+    const writeIndex = normalized.indexOf(write);
+    if (writeIndex === -1) return false;
+    return geometryReads.some((read) => normalized.indexOf(read, writeIndex + write.length) !== -1);
+  });
+}
+
+describe('PageSpeed best-practice guards', () => {
+  const astroToolFiles = findFiles(toolDir, ['.astro']);
+  const scriptFiles = findFiles(toolDir, ['.astro', '.ts', '.js']);
+
+  astroToolFiles.forEach((file) => {
+    const displayPath = relativePath(file);
+
+    it(`${displayPath} labels every input with an explicit label`, () => {
+      const content = readFileSync(file, 'utf-8');
+      const failures = controlFailures(content, 'input');
+
+      expect(failures, explicitLabelMessage('Input', displayPath, failures)).toEqual([]);
+    });
+
+    it(`${displayPath} labels every select with an explicit label`, () => {
+      const content = readFileSync(file, 'utf-8');
+      const failures = controlFailures(content, 'select');
+
+      expect(failures, explicitLabelMessage('Select', displayPath, failures)).toEqual([]);
+    });
+  });
+
+  ALL_TOOLS.forEach((tool) => {
+    Object.entries(tool.entry.i18n).forEach(([locale, loader]) => {
+      it(`${tool.entry.id}/${locale} keeps SEO headings sequential`, async () => {
+        if (!loader) return;
+        const content = (await loader()) as ToolLocaleContent;
+        const levels = headingLevels(content.seo);
+        const failures = findHeadingLevelJumps(levels);
+
+        expect(
+          failures,
+          `SEO headings in ${tool.entry.id}/${locale} skip levels: ${failures.join(', ')}`,
+        ).toEqual([]);
+      });
+    });
+  });
+
+  scriptFiles.forEach((file) => {
+    const displayPath = relativePath(file);
+
+    it(`${displayPath} avoids static forced-reflow patterns`, () => {
+      const content = readFileSync(file, 'utf-8');
+      expect(
+        hasDomWriteBeforeGeometryRead(content),
+        `${displayPath} appears to read layout geometry after DOM/style mutations. Split writes and reads across frames or measure before mutating.`,
+      ).toBe(false);
+    });
+  });
+});

package/src/tests/script_density.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+type ScriptLocale = keyof typeof SCRIPT_RULES;
+
+const SCRIPT_RULES = {
+  ja: {
+    language: 'Japanese',
+    scriptName: 'kana/kanji',
+    scriptCharacters: /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/gu,
+    minScriptRatio: 0.45,
+  },
+  ko: {
+    language: 'Korean',
+    scriptName: 'hangul',
+    scriptCharacters: /\p{Script=Hangul}/gu,
+    minScriptRatio: 0.55,
+  },
+  ru: {
+    language: 'Russian',
+    scriptName: 'cyrillic',
+    scriptCharacters: /\p{Script=Cyrillic}/gu,
+    minScriptRatio: 0.65,
+  },
+  zh: {
+    language: 'Chinese',
+    scriptName: 'han',
+    scriptCharacters: /\p{Script=Han}/gu,
+    minScriptRatio: 0.45,
+  },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function normalizeText(value: unknown): string {
+  return collectStrings(value).join(' ').normalize('NFC');
+}
+
+function translatableContent(content: Record<string, unknown>) {
+  return TRANSLATABLE_KEYS.map((key) => content[key]);
+}
+
+function letterCount(text: string): number {
+  return text.match(LETTERS)?.length ?? 0;
+}
+
+function scriptCount(text: string, locale: ScriptLocale): number {
+  return text.match(SCRIPT_RULES[locale].scriptCharacters)?.length ?? 0;
+}
+
+function scriptRatio(text: string, locale: ScriptLocale): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return scriptCount(text, locale) / letters;
+}
+
+describe('Native script density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(SCRIPT_RULES).forEach((locale) => {
+        it(`${locale} keeps most translated text in its native script`, async () => {
+          const typedLocale = locale as ScriptLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const rule = SCRIPT_RULES[typedLocale];
+          const text = normalizeText(translatableContent(content as Record<string, unknown>));
+          const letters = letterCount(text);
+          const matches = scriptCount(text, typedLocale);
+          const ratio = scriptRatio(text, typedLocale);
+
+          expect(
+            ratio,
+            [
+              `Possible broken translation detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} ${rule.scriptName} characters out of ${letters} analyzed letters (${(ratio * 100).toFixed(1)}%).`,
+              `Most translatable content should be written in ${rule.scriptName} script.`,
+              'Non-translatable fields such as slug, bibliography, and schemas are ignored to avoid false positives.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minScriptRatio);
+        });
+      });
+    });
+  });
+});

package/src/tests/shared-test-helpers.ts

@@ -0,0 +1,56 @@
+import type { ToolDefinition } from '../types';
+
+export interface ToolExportValidationResult {
+  passed: boolean;
+  failures: string[];
+}
+
+function validateComponentType(
+  toolId: string,
+  componentName: string,
+  component: unknown,
+  failures: string[],
+): void {
+  if (typeof component !== 'function') {
+    failures.push(`${toolId}: ${componentName} is not a function (${typeof component})`);
+  }
+}
+
+async function validateComponentExecution(
+  toolId: string,
+  componentName: string,
+  fn: () => Promise<unknown>,
+  failures: string[],
+): Promise<void> {
+  try {
+    const result = await fn();
+    if (!result || typeof result !== 'object') {
+      failures.push(`${toolId}: ${componentName} import returned invalid result`);
+    }
+  } catch (error) {
+    failures.push(`${toolId}: ${componentName} execution error - ${error instanceof Error ? error.message : 'unknown'}`);
+  }
+}
+
+export async function validateToolExports(tools: ToolDefinition[]): Promise<ToolExportValidationResult> {
+  const failures: string[] = [];
+
+  for (const tool of tools) {
+    validateComponentType(tool.entry.id, 'Component', tool.Component, failures);
+    validateComponentType(tool.entry.id, 'SEOComponent', tool.SEOComponent, failures);
+    validateComponentType(tool.entry.id, 'BibliographyComponent', tool.BibliographyComponent, failures);
+
+    const componentFn = tool.Component as () => Promise<unknown>;
+    const seoFn = tool.SEOComponent as () => Promise<unknown>;
+    const bibFn = tool.BibliographyComponent as () => Promise<unknown>;
+
+    await validateComponentExecution(tool.entry.id, 'Component', componentFn, failures);
+    await validateComponentExecution(tool.entry.id, 'SEOComponent', seoFn, failures);
+    await validateComponentExecution(tool.entry.id, 'BibliographyComponent', bibFn, failures);
+  }
+
+  return {
+    passed: failures.length === 0,
+    failures,
+  };
+}

package/src/tests/tool_exports.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import { validateToolExports } from './shared-test-helpers';
+
+describe('Tool Exports Pattern Validation', () => {
+  describe('Component Exports Format', () => {
+    ALL_TOOLS.forEach((tool) => {
+      it(`${tool.entry.id}: Component should be a lazy-loaded function`, () => {
+        expect(typeof tool.Component).toBe('function');
+        expect(tool.Component).toBeInstanceOf(Function);
+      });
+
+      it(`${tool.entry.id}: SEOComponent should be a lazy-loaded function`, () => {
+        expect(typeof tool.SEOComponent).toBe('function');
+        expect(tool.SEOComponent).toBeInstanceOf(Function);
+      });
+
+      it(`${tool.entry.id}: BibliographyComponent should be a lazy-loaded function`, () => {
+        expect(typeof tool.BibliographyComponent).toBe('function');
+        expect(tool.BibliographyComponent).toBeInstanceOf(Function);
+      });
+    });
+  });
+
+  describe('Dynamic Import Validation', () => {
+    it('all tools must have functional dynamic imports', async () => {
+      const result = await validateToolExports(ALL_TOOLS);
+      if (!result.passed) {
+        throw new Error(`Tool export validation failed:\n${result.failures.join('\n')}`);
+      }
+      expect(result.passed).toBe(true);
+    });
+  });
+});

package/src/tool/avifAJpg/bibliography.ts

@@ -0,0 +1,12 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'AV1 Image File Format (AVIF)',
+    url: 'https://aomediacodec.github.io/av1-avif/',
+  },
+  {
+    name: 'Allgemeine Informationen zu JPG',
+    url: 'https://en.wikipedia.org/wiki/JPEG',
+  },
+];

package/src/tool/avifAJpg/entry.ts

@@ -27,3 +27,5 @@ export const avifAJpg: ConvertersToolEntry<ImageConverterUI> = {
     zh: () => import('./i18n/zh').then((m) => m.content),
   },
 };
+
+export { bibliography } from './bibliography';

package/src/tool/avifAJpg/i18n/de.ts

@@ -1,3 +1,4 @@
+import { bibliography } from '../bibliography';
 import type { ImageConverterUI } from '../../../shared/ImageConverter.astro';
 import { generateSchemas } from '../../../shared/logic/schemas';
 import type { AvifAJpgLocaleContent } from '../index';
@@ -51,17 +52,6 @@ const howTo: AvifAJpgLocaleContent['howTo'] = [
   },
 ];
 
-const bibliography: AvifAJpgLocaleContent['bibliography'] = [
-  {
-    name: 'AV1 Image File Format (AVIF)',
-    url: 'https://aomediacodec.github.io/av1-avif/',
-  },
-  {
-    name: 'Allgemeine Informationen zu JPG',
-    url: 'https://en.wikipedia.org/wiki/JPEG',
-  },
-];
-
 const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'title',
@@ -135,7 +125,7 @@ const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'tip',
     title: 'Das perfekte Gleichgewicht zwischen Kompression und Kompatibilität',
-    html: 'AVIF ist bei gleicher Qualität um 50 % kleiner als JPG – aber JPG bietet 100 % Kompatibilität mit jeder Software. Wenn Sie AVIF-Bilder vom Server erhalten und diese bearbeiten, per E-Mail versenden oder in Desktop-Tools öffnen müssen, konvertieren Sie sie zuerst in JPG.',
+    html: 'AVIF ist bei gleicher Qualität um 50 % kleiner als JPG - aber JPG bietet 100 % Kompatibilität mit jeder Software. Wenn Sie AVIF-Bilder vom Server erhalten und diese bearbeiten, per E-Mail versenden oder in Desktop-Tools öffnen müssen, konvertieren Sie sie zuerst in JPG.',
   },
   {
     type: 'title',

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

@@ -1,3 +1,4 @@
+import { bibliography } from '../bibliography';
 import type { ImageConverterUI } from '../../../shared/ImageConverter.astro';
 import { generateSchemas } from '../../../shared/logic/schemas';
 import type { AvifAJpgLocaleContent } from '../index';
@@ -51,17 +52,6 @@ const howTo: AvifAJpgLocaleContent['howTo'] = [
   },
 ];
 
-const bibliography: AvifAJpgLocaleContent['bibliography'] = [
-  {
-    name: 'AV1 Image File Format (AVIF)',
-    url: 'https://aomediacodec.github.io/av1-avif/',
-  },
-  {
-    name: 'JPEG Overview',
-    url: 'https://en.wikipedia.org/wiki/JPEG',
-  },
-];
-
 const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'title',
@@ -135,7 +125,7 @@ const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'tip',
     title: 'The perfect balance between compression and compatibility',
-    html: 'AVIF is 50% smaller than JPG at equal quality — but JPG has 100% compatibility with any software. If you receive AVIF images from the server and need to edit them, send them by email or open them in desktop tools, convert them to JPG first.',
+    html: 'AVIF is 50% smaller than JPG at equal quality - but JPG has 100% compatibility with any software. If you receive AVIF images from the server and need to edit them, send them by email or open them in desktop tools, convert them to JPG first.',
   },
   {
     type: 'title',

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

@@ -1,3 +1,4 @@
+import { bibliography } from '../bibliography';
 import type { ImageConverterUI } from '../../../shared/ImageConverter.astro';
 import { generateSchemas } from '../../../shared/logic/schemas';
 import type { AvifAJpgLocaleContent } from '../index';
@@ -51,17 +52,6 @@ const howTo: AvifAJpgLocaleContent['howTo'] = [
   },
 ];
 
-const bibliography: AvifAJpgLocaleContent['bibliography'] = [
-  {
-    name: 'AV1 Image File Format (AVIF)',
-    url: 'https://aomediacodec.github.io/av1-avif/',
-  },
-  {
-    name: 'Información General del JPG',
-    url: 'https://en.wikipedia.org/wiki/JPEG',
-  },
-];
-
 const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'title',
@@ -135,7 +125,7 @@ const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'tip',
     title: 'El equilibrio perfecto entre compresión y compatibilidad',
-    html: 'AVIF es un 50% más pequeño que JPG a igual calidad — pero JPG tiene compatibilidad del 100% con cualquier software. Si recibes imágenes AVIF del servidor y necesitas editarlas, enviarlas por email o abrirlas en herramientas de escritorio, conviértelas a JPG primero.',
+    html: 'AVIF es un 50% más pequeño que JPG a igual calidad - pero JPG tiene compatibilidad del 100% con cualquier software. Si recibes imágenes AVIF del servidor y necesitas editarlas, enviarlas por email o abrirlas en herramientas de escritorio, conviértelas a JPG primero.',
   },
   {
     type: 'title',

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

@@ -1,3 +1,4 @@
+import { bibliography } from '../bibliography';
 import type { ImageConverterUI } from '../../../shared/ImageConverter.astro';
 import { generateSchemas } from '../../../shared/logic/schemas';
 import type { AvifAJpgLocaleContent } from '../index';
@@ -51,35 +52,24 @@ const howTo: AvifAJpgLocaleContent['howTo'] = [
   },
 ];
 
-const bibliography: AvifAJpgLocaleContent['bibliography'] = [
-  {
-    name: 'Format de fichier image AV1 (AVIF)',
-    url: 'https://aomediacodec.github.io/av1-avif/',
-  },
-  {
-    name: 'Aperçu JPEG',
-    url: 'https://en.wikipedia.org/wiki/JPEG',
-  },
-];
-
 const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'title',
-    text: 'Convertisseur AVIF vers JPG : Compatibilité Universelle pour Vos Images Modernes',
+    text: 'Convertisseur AVIF vers JPG: Compatibilité Universelle pour Vos Images Modernes',
     level: 2,
   },
   {
     type: 'paragraph',
-    html: 'AVIF (AV1 Image File Format) est le format d\'image le plus efficace disponible aujourd\'hui. Développé par l\'Alliance for Open Media et basé sur le codec vidéo AV1, il offre une compression 50% meilleure que le JPG à la même qualité visuelle. Cependant, cet avantage technique a un prix : AVIF n\'est pas pris en charge par Photoshop, Lightroom, la visionneuse de photos Windows, ni par la plupart des outils d\'édition et de visualisation traditionnels. Convertir en JPG résout ce problème à la racine.',
+    html: 'AVIF (AV1 Image File Format) est le format d\'image le plus efficace disponible aujourd\'hui. Développé par l\'Alliance for Open Media et basé sur le codec vidéo AV1, il offre une compression 50% meilleure que le JPG à la même qualité visuelle. Cependant, cet avantage technique a un prix: AVIF n\'est pas pris en charge par Photoshop, Lightroom, la visionneuse de photos Windows, ni par la plupart des outils d\'édition et de visualisation traditionnels. Convertir en JPG résout ce problème à la racine.',
   },
   {
     type: 'title',
-    text: 'AVIF vs JPG : Efficacité versus Compatibilité Universelle',
+    text: 'AVIF vs JPG: Efficacité versus Compatibilité Universelle',
     level: 3,
   },
   {
     type: 'paragraph',
-    html: 'AVIF compresse de manière extraordinaire : une photo haute résolution qui pèse 4 Mo en JPG peut peser à peine 2 Mo en AVIF à la même qualité perçue. Cela le rend parfait pour la livraison web où les performances de chargement sont critiques. Cependant, en dehors du navigateur, AVIF est pratiquement invisible : Windows Explorer ne le prévisualise pas, les appareils photo ne l\'exportent pas, et les designers ne l\'accueillent pas favorablement dans leurs flux de travail.',
+    html: 'AVIF compresse de manière extraordinaire: une photo haute résolution qui pèse 4 Mo en JPG peut peser à peine 2 Mo en AVIF à la même qualité perçue. Cela le rend parfait pour la livraison web où les performances de chargement sont critiques. Cependant, en dehors du navigateur, AVIF est pratiquement invisible: Windows Explorer ne le prévisualise pas, les appareils photo ne l\'exportent pas, et les designers ne l\'accueillent pas favorablement dans leurs flux de travail.',
   },
   {
     type: 'paragraph',
@@ -87,7 +77,7 @@ const seo: AvifAJpgLocaleContent['seo'] = [
   },
   {
     type: 'title',
-    text: 'Comparatif : Convertisseurs Cloud vs Notre Architecture Locale',
+    text: 'Comparatif: Convertisseurs Cloud vs Notre Architecture Locale',
     level: 3,
   },
   {
@@ -135,11 +125,11 @@ const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'tip',
     title: 'L\'équilibre parfait entre compression et compatibilité',
-    html: 'AVIF est 50% plus petit que JPG à qualité égale — mais JPG a une compatibilité de 100% avec n\'importe quel logiciel. Si vous recevez des images AVIF du serveur et devez les éditer, les envoyer par email ou les ouvrir dans des outils de bureau, convertissez-les d\'abord en JPG.',
+    html: 'AVIF est 50% plus petit que JPG à qualité égale - mais JPG a une compatibilité de 100% avec n\'importe quel logiciel. Si vous recevez des images AVIF du serveur et devez les éditer, les envoyer par email ou les ouvrir dans des outils de bureau, convertissez-les d\'abord en JPG.',
   },
   {
     type: 'title',
-    text: 'Cas d\'utilisation : quand convertir AVIF en JPG',
+    text: 'Cas d\'utilisation: quand convertir AVIF en JPG',
     level: 3,
   },
   {
@@ -150,17 +140,17 @@ const seo: AvifAJpgLocaleContent['seo'] = [
       'Partage d\'images avec des utilisateurs sur des appareils ou systèmes d\'exploitation anciens.',
       'Pièces jointes d\'emails pour garantir la visualisation dans n\'importe quel client de messagerie.',
       'Publication sur des plateformes qui n\'acceptent pas l\'AVIF comme format de téléversement.',
-      'Impression : les services d\'impression professionnels travaillent nativement avec le JPG.',
+      'Impression: les services d\'impression professionnels travaillent nativement avec le JPG.',
     ],
   },
   {
     type: 'title',
-    text: 'Conclusion : La compatibilité universelle en une seule étape',
+    text: 'Conclusion: La compatibilité universelle en une seule étape',
     level: 3,
   },
   {
     type: 'paragraph',
-    html: 'AVIF est l\'avenir de la compression d\'images, mais le présent exige de la compatibilité. Notre convertisseur vous permet d\'obtenir le meilleur des deux mondes : recevez et stockez des images en AVIF pour une efficacité maximale, et convertissez-les instantanément en JPG quand vous avez besoin qu\'elles fonctionnent dans n\'importe quel contexte. Le tout en toute confidentialité, gratuitement et sans limites.',
+    html: 'AVIF est l\'avenir de la compression d\'images, mais le présent exige de la compatibilité. Notre convertisseur vous permet d\'obtenir le meilleur des deux mondes: recevez et stockez des images en AVIF pour une efficacité maximale, et convertissez-les instantanément en JPG quand vous avez besoin qu\'elles fonctionnent dans n\'importe quel contexte. Le tout en toute confidentialité, gratuitement et sans limites.',
   },
 ];
 

package/src/tool/avifAJpg/i18n/id.ts

@@ -1,3 +1,4 @@
+import { bibliography } from '../bibliography';
 import type { ImageConverterUI } from '../../../shared/ImageConverter.astro';
 import { generateSchemas } from '../../../shared/logic/schemas';
 import type { AvifAJpgLocaleContent } from '../index';
@@ -51,17 +52,6 @@ const howTo: AvifAJpgLocaleContent['howTo'] = [
   },
 ];
 
-const bibliography: AvifAJpgLocaleContent['bibliography'] = [
-  {
-    name: 'AV1 Image File Format (AVIF)',
-    url: 'https://aomediacodec.github.io/av1-avif/',
-  },
-  {
-    name: 'Informasi Umum JPG',
-    url: 'https://en.wikipedia.org/wiki/JPEG',
-  },
-];
-
 const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'title',
@@ -135,7 +125,7 @@ const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'tip',
     title: 'Keseimbangan sempurna antara kompresi dan kompatibilitas',
-    html: 'AVIF 50% lebih kecil dari JPG untuk kualitas yang sama — tetapi JPG memiliki kompatibilitas 100% dengan perangkat lunak apa pun. Jika Anda menerima gambar AVIF dari server dan perlu mengeditnya, mengirimnya melalui email, atau membukanya di alat desktop, ubah ke JPG terlebih dahulu.',
+    html: 'AVIF 50% lebih kecil dari JPG untuk kualitas yang sama - tetapi JPG memiliki kompatibilitas 100% dengan perangkat lunak apa pun. Jika Anda menerima gambar AVIF dari server dan perlu mengeditnya, mengirimnya melalui email, atau membukanya di alat desktop, ubah ke JPG terlebih dahulu.',
   },
   {
     type: 'title',

package/src/tool/avifAJpg/i18n/it.ts

@@ -1,3 +1,4 @@
+import { bibliography } from '../bibliography';
 import type { ImageConverterUI } from '../../../shared/ImageConverter.astro';
 import { generateSchemas } from '../../../shared/logic/schemas';
 import type { AvifAJpgLocaleContent } from '../index';
@@ -51,17 +52,6 @@ const howTo: AvifAJpgLocaleContent['howTo'] = [
   },
 ];
 
-const bibliography: AvifAJpgLocaleContent['bibliography'] = [
-  {
-    name: 'AV1 Image File Format (AVIF)',
-    url: 'https://aomediacodec.github.io/av1-avif/',
-  },
-  {
-    name: 'Informazioni Generali sul JPG',
-    url: 'https://en.wikipedia.org/wiki/JPEG',
-  },
-];
-
 const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'title',
@@ -135,7 +125,7 @@ const seo: AvifAJpgLocaleContent['seo'] = [
   {
     type: 'tip',
     title: 'L\'equilibrio perfetto tra compressione e compatibilità',
-    html: 'L\'AVIF è più piccolo del 50% rispetto al JPG a parità di qualità — ma il JPG ha una compatibilità del 100% con qualsiasi software. Se ricevi immagini AVIF dal server e hai bisogno di modificarle, inviarle via email o aprirle in strumenti desktop, convertile prima in JPG.',
+    html: 'L\'AVIF è più piccolo del 50% rispetto al JPG a parità di qualità - ma il JPG ha una compatibilità del 100% con qualsiasi software. Se ricevi immagini AVIF dal server e hai bisogno di modificarle, inviarle via email o aprirle in strumenti desktop, convertile prima in JPG.',
   },
   {
     type: 'title',