@jjlmoya/utils-audiovisual 1.2.0

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

@@ -0,0 +1,241 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { SubtitleSyncUI, SubtitleSyncLocaleContent } from '../index';
+
+const slug = 'sincronizar-subtitulos';
+const title = 'Sincronizar Subtítulos SRT Online - Ajusta el Tiempo Gratis';
+const description = 'Herramienta online para adelantar o retrasar subtítulos SRT. Corrige el desfase de tiempo de forma sencilla y descarga el archivo sincronizado al instante.';
+
+const ui: SubtitleSyncUI = {
+    dropTitle: "Arrastra tu archivo .SRT aquí",
+    dropSubtitle: "o haz clic para explorar",
+    adjustTitle: "Ajustar Tiempo",
+    offsetLabel: "Desplazamiento (segundos)",
+    offsetHelp: "Usa valores negativos para adelantar (ej: -1.5) y positivos para retrasar.",
+    linesStat: "Líneas",
+    firstStat: "Primer Subtítulo",
+    lastStat: "Último Subtítulo",
+    originalLabel: "ORIGINAL",
+    resultLabel: "RESULTADO",
+    downloadButton: "Descargar Corregido",
+    previewBadge: "VISTA PREVIA",
+    unitSeconds: "seg"
+};
+
+const faq: SubtitleSyncLocaleContent['faq'] = [
+    {
+        question: "¿Cómo puedo sincronizar mis subtítulos si el audio va por delante?",
+        answer: "Si el audio aparece antes que el texto, debes retrasar los subtítulos. Introduce un valor positivo en la calculadora (ej. 2.0 para retrasarlos 2 segundos).",
+    },
+    {
+        question: "¿Qué formato de archivos acepta esta herramienta?",
+        answer: "Actualmente la herramienta está optimizada para archivos .SRT (SubRip), que es el estándar más común en reproductores de vídeo y plataformas de streaming.",
+    },
+    {
+        question: "¿Es seguro subir mis archivos de subtítulos?",
+        answer: "Sí, porque el procesamiento es 100% local en tu dispositivo. Tus archivos no se envían a ningún servidor; la sincronización ocurre directamente en tu navegador.",
+    },
+    {
+        question: "¿Puedo sincronizar solo una parte del archivo?",
+        answer: "No, esta herramienta aplica un desplazamiento constante a todo el archivo. Si el desfase es progresivo, podrías necesitar una edición más avanzada.",
+    },
+];
+
+const howTo: SubtitleSyncLocaleContent['howTo'] = [
+    {
+        name: "Carga tu archivo SRT",
+        text: "Arrastra el archivo de subtítulos que quieres corregir al área de carga.",
+    },
+    {
+        name: "Identifica el desfase",
+        text: "Mide cuánto tiempo de retraso o adelanto tienen los subtítulos respecto al audio en tu reproductor.",
+    },
+    {
+        name: "Ajusta el desplazamiento",
+        text: "Introduce los segundos positivos (retrasar) o negativos (adelantar) en el panel de control.",
+    },
+    {
+        name: "Descarga el archivo",
+        text: "Verifica en la vista previa que los tiempos son correctos y haz clic en descargar para obtener tu nuevo SRT.",
+    },
+];
+
+const bibliography: SubtitleSyncLocaleContent['bibliography'] = [
+    {
+        name: "SubRip (SRT) format specification",
+        url: "https://matroska.org/technical/subtitles.html#srt-subtitles",
+    },
+    {
+        name: "MDN Web Docs - FileReader API",
+        url: "https://developer.mozilla.org/en-US/docs/Web/API/FileReader",
+    },
+];
+
+const seo: SubtitleSyncLocaleContent['seo'] = [
+    {
+        type: 'summary',
+        title: 'Sincronización de Subtítulos Profesional',
+        items: [
+            'Corrección instantánea de desfases de audio-subtítulos',
+            'Soporta archivos SRT (SubRip) estándar',
+            'Procesamiento 100% local - máxima privacidad',
+            'Sin instalación, sin suscripción, completamente gratuito'
+        ]
+    },
+    { type: 'title', text: 'Sincronización Perfecta de Subtítulos SRT', level: 2 },
+    { type: 'paragraph', html: 'No hay nada más frustrante para un espectador que ver diálogos que no coinciden con las voces. El desfase de subtítulos suele ocurrir por diferencias entre versiones de vídeo: variaciones en framerate, cortes de publicidad, intros de productoras o cambios en la compresión. Con esta herramienta, corriges el problema en segundos.' },
+
+    { type: 'stats', items: [
+        { value: '100%', label: 'Procesamiento Local', icon: 'mdi:shield' },
+        { value: 'Milisegundos', label: 'Precisión', icon: 'mdi:clock-outline' },
+        { value: 'Cualquier Tamaño', label: 'SIN Límite de Archivo', icon: 'mdi:file-document' }
+    ], columns: 3 },
+
+    { type: 'title', text: 'Adelantar vs Retrasar: Guía Práctica', level: 3 },
+    { type: 'paragraph', html: 'El primer paso es identificar correctamente el tipo de desfase. Aquí está la lógica:' },
+    { type: 'list', items: [
+        '<strong>Retrasar (Valor Positivo):</strong> Cuando ves el texto aparecer ANTES que el sonido. Los subtítulos van adelantados. Ejemplo: +2.0 segundos.',
+        '<strong>Adelantar (Valor Negativo):</strong> Cuando ves el texto aparecer DESPUÉS que el sonido. Los subtítulos van retrasados. Ejemplo: -2.0 segundos.',
+        '<strong>Prueba y Ajusta:</strong> Comienza con incrementos pequeños (0.5s) y usa la vista previa para validar.'
+    ], icon: 'mdi:arrow-right' },
+
+    { type: 'card', title: 'Privacidad de Nivel Profesional', html: 'Al procesar el archivo mediante JavaScript en el lado del cliente, garantizamos que el contenido de tus subtítulos nunca abandona tu ordenador. Esencial para traductores y profesionales que manejan material confidencial o bajo contrato de confidencialidad.' },
+
+    { type: 'title', text: 'Casos de Uso Comunes', level: 3 },
+    { type: 'comparative', items: [
+        {
+            title: 'Traductores y Subtituladores',
+            description: 'Sincronizar traducciones después de trabajar con múltiples versiones de vídeo',
+            icon: 'mdi:translate',
+            points: [
+                'Archivos SRT de diferentes fuentes',
+                'Versionado de contenido (theatrical vs streaming)',
+                'Entrega rápida sin cambiar herramientas'
+            ]
+        },
+        {
+            title: 'Creadores de Contenido',
+            description: 'Recuperar subtítulos cuando el vídeo se procesó con diferente framerate',
+            icon: 'mdi:video',
+            points: [
+                'Reutilizar subtítulos existentes',
+                'Cambios de formato (720p a 1080p)',
+                'Evitar retiming manual de 1000+ líneas'
+            ],
+            highlight: true
+        },
+        {
+            title: 'Usuarios Casuales',
+            description: 'Corregir subtítulos descargados que no encajan perfectamente',
+            icon: 'mdi:account',
+            points: [
+                'Subtítulos genéricos desincronizados',
+                'Películas en diferente región (PAL vs NTSC)',
+                'Streaming con versiones editadas'
+            ]
+        }
+    ], columns: 3 },
+
+    { type: 'title', text: 'Por Qué los Subtítulos Se Desincroniza', level: 3 },
+    { type: 'table', headers: ['Causa Común', 'Descripción Técnica', 'Solución'], rows: [
+        ['Diferencia de Framerate', '23.976 fps vs 25 fps - acumulación de diferencia', 'Ajuste de offset único (esta herramienta)'],
+        ['Editorialización', 'Cortes de publicidad o contenido adicional removido', 'Cálculo manual + sincronización'],
+        ['Versión Regional', 'PAL (25 fps Europa) vs NTSC (29.97 fps USA)', 'Offset matemático simple'],
+        ['Cambio de Resolución', 'Reencoding con diferente velocidad de procesamiento', 'Recálculo del archivo original']
+    ] },
+
+    { type: 'diagnostic', variant: 'info', title: 'Limitaciones Técnicas a Considerar', icon: 'mdi:information', badge: 'Importante', html: 'Esta herramienta aplica un desplazamiento <strong>constante</strong> a todo el archivo. Si el desfase es <strong>progresivo</strong> (empieza bien pero se va desincronizando), significa una diferencia de framerate persistente. En ese caso, el archivo original necesita re-procesamiento en software de edición profesional.' },
+
+    { type: 'proscons', items: [
+        {
+            pro: 'Velocidad extrema - procesa archivos grandes en milisegundos',
+            con: 'Solo ajusta offset fijo, no desfases progresivos'
+        },
+        {
+            pro: 'Privacidad total - el contenido nunca abandona tu navegador',
+            con: 'Requiere navegador moderno con JavaScript habilitado'
+        },
+        {
+            pro: 'Formato universal - funciona con cualquier SRT estándar',
+            con: 'No soporta otros formatos (ASS, VTT, SCC, etc.)'
+        },
+        {
+            pro: 'Completamente gratuito, sin publicidad, sin tracking',
+            con: 'Sin historial de cambios o versioning'
+        }
+    ], proTitle: 'Ventajas', conTitle: 'Limitaciones' },
+
+    { type: 'glossary', items: [
+        {
+            term: 'SRT (SubRip)',
+            definition: 'Formato de subtítulos más universal: archivo de texto con números de secuencia, tiempos (hh:mm:ss,mmm) y texto. Estándar de facto en reproductores y plataformas.'
+        },
+        {
+            term: 'Offset (Desplazamiento)',
+            definition: 'Cantidad fija de tiempo que se suma o resta a todos los tiempos del archivo. Pueden ser segundos positivos (retrasar) o negativos (adelantar).'
+        },
+        {
+            term: 'Framerate (fps)',
+            definition: 'Fotogramas por segundo. 24p (cine), 25p (PAL/Europa), 29.97p (NTSC/USA), 60p (video fluido). Diferencias causan desfases acumulativos.'
+        },
+        {
+            term: 'NTSC vs PAL',
+            definition: 'Estándares de televisión regional: PAL (25 fps, 50 Hz) en Europa/Australia; NTSC (29.97 fps, 60 Hz) en USA/Japón. Diferencias de ~4% en velocidad total.'
+        },
+        {
+            term: 'Desfase Progresivo',
+            definition: 'Cuando la sincronización empieza correcta pero se va desincronizando gradualmente. Indica diferencia de framerate persistente, requiere re-procesamiento.'
+        }
+    ] },
+
+    { type: 'message', title: 'Edición Profesional con Control Total', ariaLabel: 'Información técnica sobre sincronización', html: 'Nuestro enfoque es simple pero poderoso: un desplazamiento único, aplicado instantáneamente, procesado 100% en tu navegador. Sin cloud, sin almacenamiento, sin seguimiento. Simplemente carga, ajusta, descarga. Control total sobre tu contenido.' },
+
+    { type: 'title', text: 'Conclusión: Cine Sin Interrupciones', level: 3 },
+    { type: 'paragraph', html: 'La sincronización perfecta de subtítulos es fundamental para una experiencia audiovisual de calidad. Con esta herramienta, transformas una experiencia frustrante en una noche de cine perfecta, sin necesidad de software costoso o complicado.' }
+];
+
+const faqSchema: WithContext<FAQPage> = {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faq.map((item) => ({
+        '@type': 'Question',
+        name: item.question,
+        acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: title,
+    description,
+    step: howTo.map((step) => ({
+        '@type': 'HowToStep',
+        name: step.name,
+        text: step.text,
+    })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'UtilitiesApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+    inLanguage: 'es',
+};
+
+export const content: SubtitleSyncLocaleContent = {
+    slug,
+    title,
+    description,
+    ui,
+    seo,
+    faq,
+    faqTitle: 'Preguntas frecuentes sobre sincronización',
+    bibliography,
+    bibliographyTitle: 'Recursos técnicos sobre formatos de subtítulos',
+    howTo,
+    schemas: [faqSchema as any, howToSchema as any, appSchema],
+};

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

@@ -0,0 +1,241 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { SubtitleSyncUI, SubtitleSyncLocaleContent } from '../index';
+
+const slug = 'synchroniser-sous-titres-srt-en-ligne-ajuster-temps-gratuit';
+const title = 'Synchroniser les Sous-titres SRT en Ligne - Ajustez le Temps Gratuitement';
+const description = 'Outil en ligne pour avancer ou retarder les sous-titres SRT. Corrigez le décalage de temps simplement et téléchargez le fichier synchronisé instantanément.';
+
+const ui: SubtitleSyncUI = {
+    dropTitle: "Faites glisser votre fichier .SRT ici",
+    dropSubtitle: "ou cliquez pour parcourir",
+    adjustTitle: "Ajuster le temps",
+    offsetLabel: "Décalage (secondes)",
+    offsetHelp: "Utilisez des valeurs négatives pour avancer (ex : -1.5) et positives pour retarder.",
+    linesStat: "Lignes",
+    firstStat: "Premier sous-titre",
+    lastStat: "Dernier sous-titre",
+    originalLabel: "ORIGINAL",
+    resultLabel: "RÉSULTAT",
+    downloadButton: "Télécharger le corrigé",
+    previewBadge: "APERÇU",
+    unitSeconds: "sec"
+};
+
+const faq: SubtitleSyncLocaleContent['faq'] = [
+    {
+        question: "Comment synchroniser mes sous-titres si l'audio est en avance ?",
+        answer: "Si l'audio apparaît avant le texte, vous devez retarder les sous-titres. Entrez une valeur positive dans la calculatrice (ex : 2.0 pour les retarder de 2 secondes).",
+    },
+    {
+        question: "Quels formats de fichiers cet outil accepte-t-il ?",
+        answer: "Actuellement, l'outil est optimisé pour les fichiers .SRT (SubRip), qui est le standard le plus courant pour les lecteurs vidéo et les plateformes de streaming.",
+    },
+    {
+        question: "Est-il sûr de télécharger mes fichiers de sous-titres ?",
+        answer: "Oui, car le traitement est 100 % local sur votre appareil. Vos fichiers ne sont envoyés à aucun serveur ; la synchronisation se fait directement dans votre navigateur.",
+    },
+    {
+        question: "Puis-je synchroniser seulement une partie du fichier ?",
+        answer: "Non, cet outil applique un décalage constant à l'ensemble du fichier. Si le décalage est progressif, vous pourriez avoir besoin d'une édition plus avancée.",
+    },
+];
+
+const howTo: SubtitleSyncLocaleContent['howTo'] = [
+    {
+        name: "Importez votre fichier SRT",
+        text: "Faites glisser le fichier de sous-titres que vous souhaitez corriger dans la zone de téléchargement.",
+    },
+    {
+        name: "Identifiez le décalage",
+        text: "Mesurez le retard ou l'avance des sous-titres par rapport à l'audio dans votre lecteur.",
+    },
+    {
+        name: "Ajustez le décalage",
+        text: "Entrez les secondes positives (retarder) ou négatives (avancer) dans le panneau de contrôle.",
+    },
+    {
+        name: "Téléchargez le fichier",
+        text: "Vérifiez dans l'aperçu que les temps sont corrects et cliquez sur télécharger pour obtenir votre nouveau SRT.",
+    },
+];
+
+const bibliography: SubtitleSyncLocaleContent['bibliography'] = [
+    {
+        name: "Spécification du format SubRip (SRT)",
+        url: "https://matroska.org/technical/subtitles.html#srt-subtitles",
+    },
+    {
+        name: "MDN Web Docs - FileReader API",
+        url: "https://developer.mozilla.org/fr/docs/Web/API/FileReader",
+    },
+];
+
+const seo: SubtitleSyncLocaleContent['seo'] = [
+    {
+        type: 'summary',
+        title: 'Synchronisation de Sous-titres Professionnelle',
+        items: [
+            'Correction instantanée des décalages audio-sous-titres',
+            'Supporte les fichiers SRT (SubRip) standards',
+            'Traitement 100 % local - confidentialité maximale',
+            'Sans installation, sans abonnement, complètement gratuit'
+        ]
+    },
+    { type: 'title', text: 'Synchronisation Parfaite de Sous-titres SRT', level: 2 },
+    { type: 'paragraph', html: 'Il n\'y a rien de plus frustrant que de voir des dialogues qui ne correspondent pas aux voix. Le décalage des sous-titres survient souvent à cause de différences entre les versions vidéo : variations de fréquence d\'images, coupures publicitaires, intros de production ou changements de compression. Avec cet outil, vous réglez le problème en quelques secondes.' },
+
+    { type: 'stats', items: [
+        { value: '100 %', label: 'Traitement Local', icon: 'mdi:shield' },
+        { value: 'Millisecondes', label: 'Précision', icon: 'mdi:clock-outline' },
+        { value: 'Illimité', label: 'Sans Limite de Fichier', icon: 'mdi:file-document' }
+    ], columns: 3 },
+
+    { type: 'title', text: 'Avancer vs Retarder : Guide Pratique', level: 3 },
+    { type: 'paragraph', html: 'La première étape consiste à identifier correctement le type de décalage. Voici la logique :' },
+    { type: 'list', items: [
+        '<strong>Retarder (Valeur Positive) :</strong> Quand le texte apparaît AVANT le son. Les sous-titres sont en avance. Exemple : +2.0 secondes.',
+        '<strong>Avancer (Valeur Négative) :</strong> Quand le texte apparaît APRÈS le son. Les sous-titres sont en retard. Exemple : -2.0 secondes.',
+        '<strong>Testez et Ajustez :</strong> Commencez par de petits incréments (0,5 s) et utilisez l\'aperçu pour valider.'
+    ], icon: 'mdi:arrow-right' },
+
+    { type: 'card', title: 'Confidentialité de Niveau Professionnel', html: 'En traitant le fichier via JavaScript côté client, nous garantissons que le contenu de vos sous-titres ne quitte jamais votre ordinateur. Essentiel pour les traducteurs et les professionnels manipulant du matériel confidentiel ou sous contrat de confidentialité.' },
+
+    { type: 'title', text: 'Cas d\'Utilisation Courants', level: 3 },
+    { type: 'comparative', items: [
+        {
+            title: 'Traducteurs et Sous-titreurs',
+            description: 'Synchroniser des traductions après avoir travaillé avec plusieurs versions vidéo',
+            icon: 'mdi:translate',
+            points: [
+                'Fichiers SRT de sources différentes',
+                'Gestion des versions de contenu (cinéma vs streaming)',
+                'Livraison rapide sans changer d\'outils'
+            ]
+        },
+        {
+            title: 'Créateurs de Contenu',
+            description: 'Récupérer des sous-titres quand la vidéo a été traitée avec une fréquence d\'images différente',
+            icon: 'mdi:video',
+            points: [
+                'Réutilisation de sous-titres existants',
+                'Changements de format (720p vers 1080p)',
+                'Éviter le resynchronisation manuelle de plus de 1000 lignes'
+            ],
+            highlight: true
+        },
+        {
+            title: 'Utilisateurs Particuliers',
+            description: 'Corriger des sous-titres téléchargés qui ne s\'adaptent pas parfaitement',
+            icon: 'mdi:account',
+            points: [
+                'Sous-titres génériques désynchronisés',
+                'Films de différentes régions (PAL vs NTSC)',
+                'Streaming avec versions éditées'
+            ]
+        }
+    ], columns: 3 },
+
+    { type: 'title', text: 'Pourquoi les Sous-titres se Désynchronisent', level: 3 },
+    { type: 'table', headers: ['Cause Commune', 'Description Technique', 'Solution'], rows: [
+        ['Différence de Framerate', '23,976 fps vs 25 fps - accumulation de différence', 'Ajustement du décalage unique (cet outil)'],
+        ['Éditorialisation', 'Coupures publicitaires ou contenu supprimé', 'Calcul manuel + synchronisation'],
+        ['Version Régionale', 'PAL (25 fps Europe) vs NTSC (29,97 fps USA)', 'Décalage mathématique simple'],
+        ['Changement de Résolution', 'Réencodage avec une vitesse de traitement différente', 'Recalcul du fichier original']
+    ] },
+
+    { type: 'diagnostic', variant: 'info', title: 'Limitations Techniques à Considérer', icon: 'mdi:information', badge: 'Important', html: 'Cet outil applique un décalage <strong>constant</strong> à l\'ensemble du fichier. Si le décalage est <strong>progressif</strong> (commence bien mais se décale peu à peu), c\'est une différence de fréquence d\'images persistante. Dans ce cas, le fichier nécessite un traitement dans un logiciel professionnel.' },
+
+    { type: 'proscons', items: [
+        {
+            pro: 'Vitesse extrême - traite de gros fichiers en millisecondes',
+            con: 'Ajuste uniquement un décalage fixe, pas progressif'
+        },
+        {
+            pro: 'Confidentialité totale - le contenu ne quitte jamais votre navigateur',
+            con: 'Nécessite un navigateur moderne avec JavaScript activé'
+        },
+        {
+            pro: 'Format universel - fonctionne avec tout SRT standard',
+            con: 'Ne supporte pas les autres formats (ASS, VTT, etc.)'
+        },
+        {
+            pro: 'Complètement gratuit, sans publicité, sans suivi',
+            con: 'Pas d\'historique des modifications ou de versionnage'
+        }
+    ], proTitle: 'Avantages', conTitle: 'Limitations' },
+
+    { type: 'glossary', items: [
+        {
+            term: 'SRT (SubRip)',
+            definition: 'Format de sous-titres le plus universel : fichier texte avec numéros de séquence, temps et texte.'
+        },
+        {
+            term: 'Offset (Décalage)',
+            definition: 'Quantité fixe de temps ajoutée ou soustraite à tous les temps du fichier.'
+        },
+        {
+            term: 'Framerate (fps)',
+            definition: 'Images par seconde. Les différences entre 24, 25 ou 30 fps causent des décalages cumulatifs.'
+        },
+        {
+            term: 'NTSC vs PAL',
+            definition: 'Standards régionaux de télévision. Les différences de ~4 % de vitesse causent des décalages.'
+        },
+        {
+            term: 'Décalage Progressif',
+            definition: 'Quand la synchronisation est correcte au début mais se décale graduellement. Indique une fréquence d\'images différente.'
+        }
+    ] },
+
+    { type: 'message', title: 'Édition Professionnelle avec Contrôle Total', ariaLabel: 'Informations techniques sur la synchronisation', html: 'Notre approche est simple mais puissante : un décalage unique, appliqué instantanément, traité à 100 % dans votre navigateur. Pas de cloud, pas de stockage, pas de suivi. Simplement importez, ajustez, téléchargez. Un contrôle total sur votre contenu.' },
+
+    { type: 'title', text: 'Conclusion : Le Cinéma Sans Interruptions', level: 3 },
+    { type: 'paragraph', html: 'Une synchronisation parfaite des sous-titres est fondamentale pour une expérience audiovisuelle de qualité. Avec cet outil, vous transformez une expérience frustrante en une soirée cinéma parfaite.' }
+];
+
+const faqSchema: WithContext<FAQPage> = {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faq.map((item) => ({
+        '@type': 'Question',
+        name: item.question,
+        acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: title,
+    description,
+    step: howTo.map((step) => ({
+        '@type': 'HowToStep',
+        name: step.name,
+        text: step.text,
+    })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    description,
+    applicationCategory: 'UtilitiesApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+    inLanguage: 'fr',
+};
+
+export const content: SubtitleSyncLocaleContent = {
+    slug,
+    title,
+    description,
+    ui,
+    seo,
+    faq,
+    faqTitle: 'Foire Aux Questions sur la Synchronisation des Sous-titres',
+    bibliography,
+    bibliographyTitle: 'Ressources Techniques sur les Formats de Sous-titres',
+    howTo,
+    schemas: [faqSchema as any, howToSchema as any, appSchema],
+};

package/src/tool/subtitleSync/index.ts

@@ -0,0 +1,49 @@
+import type { AudiovisualToolEntry, ToolLocaleContent, ToolDefinition } from '../../types';
+import SubtitleSync from './component.astro';
+import SubtitleSyncSEO from './seo.astro';
+import SubtitleSyncBibliography from './bibliography.astro';
+
+export interface SubtitleSyncUI {
+    dropTitle: string;
+    dropSubtitle: string;
+    adjustTitle: string;
+    offsetLabel: string;
+    offsetHelp: string;
+    linesStat: string;
+    firstStat: string;
+    lastStat: string;
+    originalLabel: string;
+    resultLabel: string;
+    downloadButton: string;
+    previewBadge: string;
+    unitSeconds: string;
+    [key: string]: string;
+}
+
+export type SubtitleSyncLocaleContent = ToolLocaleContent<SubtitleSyncUI>;
+
+import { content as es } from './i18n/es';
+import { content as en } from './i18n/en';
+import { content as fr } from './i18n/fr';
+
+export const subtitleSync: AudiovisualToolEntry<SubtitleSyncUI> = {
+    id: 'sincronizar-subtitulos',
+    icons: {
+        bg: 'mdi:movie-open-edit-outline',
+        fg: 'mdi:clock-time-four-outline',
+    },
+    i18n: {
+        es: async () => es as unknown as SubtitleSyncLocaleContent,
+        en: async () => en as unknown as SubtitleSyncLocaleContent,
+        fr: async () => fr as unknown as SubtitleSyncLocaleContent,
+    },
+};
+
+export { SubtitleSync, SubtitleSyncSEO, SubtitleSyncBibliography };
+
+export const SUBTITLE_SYNC_TOOL: ToolDefinition = {
+    entry: subtitleSync as unknown as AudiovisualToolEntry,
+    Component: SubtitleSync,
+    SEOComponent: SubtitleSyncSEO,
+    BibliographyComponent: SubtitleSyncBibliography,
+};

package/src/tool/subtitleSync/logic.ts

@@ -0,0 +1,91 @@
+export interface SrtItem {
+    id: string;
+    start: number;
+    end: number;
+    text: string;
+}
+
+export function parseSRT(data: string): SrtItem[] {
+    const cleanData = data.replace(/\r/g, "");
+    const parts = cleanData.split("\n\n");
+
+    return parts
+        .map((part) => {
+            const lines = part.trim().split("\n");
+            if (lines.length < 3) return null;
+
+            const id = lines[0];
+            const timeLine = lines[1];
+            if (!timeLine || !timeLine.includes("-->")) return null;
+
+            const timeParts = timeLine.split(" --> ");
+            const start = timeParts[0];
+            const end = timeParts[1];
+            if (!start || !end) return null;
+
+            const text = lines.slice(2).join("\n");
+
+            return {
+                id,
+                start: timeMs(start),
+                end: timeMs(end),
+                text,
+            };
+        })
+        .filter((x): x is SrtItem => x !== null);
+}
+
+export function timeMs(timeStr: string): number {
+    const parts = timeStr.split(",");
+    const hms = parts[0];
+    const ms = parts[1] || "0";
+    
+    if (!hms) return 0;
+    
+    const hmsParts = hms.split(":");
+    const h = Number(hmsParts[0] || 0);
+    const m = Number(hmsParts[1] || 0);
+    const s = Number(hmsParts[2] || 0);
+    
+    return h * 3600000 + m * 60000 + s * 1000 + Number(ms);
+}
+
+export function msToTime(duration: number): string {
+    if (duration < 0) return "00:00:00,000";
+
+    const h = Math.floor(duration / 3600000);
+    const m = Math.floor((duration % 3600000) / 60000);
+    const s = Math.floor((duration % 60000) / 1000);
+    const ms = Math.floor(duration % 1000);
+
+    const hh = h.toString().padStart(2, "0");
+    const mm = m.toString().padStart(2, "0");
+    const ss = s.toString().padStart(2, "0");
+    const msStr = ms.toString().padStart(3, "0");
+
+    return `${hh}:${mm}:${ss},${msStr}`;
+}
+
+export function generateSRT(items: SrtItem[]): string {
+    return items
+        .map((item, index) => {
+            return `${index + 1}\n${msToTime(item.start)} --> ${msToTime(item.end)}\n${item.text}`;
+        })
+        .join("\n\n");
+}
+
+export function shiftSubtitles(items: SrtItem[], offsetMs: number): SrtItem[] {
+    return items.map((item) => {
+        let newStart = item.start + offsetMs;
+        let newEnd = item.end + offsetMs;
+
+        if (newStart < 0) newStart = 0;
+        if (newEnd < 0) newEnd = 0;
+
+        return {
+            ...item,
+            start: newStart,
+            end: newEnd,
+        };
+    });
+}

package/src/tool/subtitleSync/seo.astro

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