@jjlmoya/utils-developer 1.4.0 → 1.6.0

package/src/tool/duplicateCssRemover/i18n/pl.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 = 'usuwanie-duplikatow-css';
+const title = 'Usuwanie zduplikowanego CSS online. Porządkuj i optymalizuj arkusze stylów';
+const description =
+  'Bezpłatne narzędzie do czyszczenia i usuwania zduplikowanego kodu CSS. Scala nadmiarowe selektory, zachowuje kaskadę i natychmiast zmniejsza rozmiar pliku bezpośrednio w przeglądarce.';
+
+const faqData = [
+  {
+    question: 'Co się dzieje, gdy selektory CSS są zduplikowane?',
+    answer:
+      'Gdy ten sam selektor pojawia się kilka razy, przeglądarka stosuje wszystkie reguły, ale ostatnia deklaracja każdej właściwości nadpisuje poprzednie. Efektem są niepotrzebnie ciężkie pliki, bez żadnych korzyści dla efektu wizualnego.',
+  },
+  {
+    question: 'Czy podczas usuwania duplikatów utracę jakieś właściwości?',
+    answer:
+      'Nie. Algorytm ściśle przestrzega kaskady CSS: w przypadku konfliktów pod tym samym selektorem zawsze zachowuje ostatnio zadeklarowaną właściwość. Unikalne właściwości z każdego bloku są łączone pod jednym scalonym selektorem.',
+  },
+  {
+    question: 'Czy działa z minifikowanym CSS lub CSS z komentarzami?',
+    answer:
+      'Narzędzie automatycznie usuwa komentarze CSS przed przetworzeniem i poprawnie obsługuje kod w jednej linii. W przypadku CSS z zaawansowanym zagnieżdżaniem lub złożonymi at-rules zaleca się wcześniejsze rozdzielenie bloków.',
+  },
+  {
+    question: 'Czy mój CSS jest wysyłany na serwer?',
+    answer:
+      'Nie. Całe przetwarzanie odbywa się bezpośrednio w przeglądarce za pomocą lokalnego JavaScript. Żadna część twojego CSS nie jest przesyłana do żadnego zewnętrznego serwera, co gwarantuje pełną prywatność kodu.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Wklej swój CSS',
+    text: 'Skopiuj zawartość pliku CSS z powtarzającymi się selektorami i wklej ją do lewego pola "Dirty / Duplicate CSS".',
+  },
+  {
+    name: 'Uruchom czyszczenie',
+    text: 'Kliknij przycisk "Wyczyść i scal CSS". Narzędzie przeskanuje wszystkie selektory, połączy właściwości i usunie nadmiarowe bloki.',
+  },
+  {
+    name: 'Sprawdź wyniki i skopiuj',
+    text: 'Sprawdź uzyskane oszczędności w bajtach i skopiuj zoptymalizowany CSS przyciskiem "Kopiuj kod", aby użyć go bezpośrednio w projekcie.',
+  },
+];
+
+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: 'pl',
+};
+
+const ui: DuplicateCssRemoverUI = {
+  labelInput: 'Brudny / Zduplikowany CSS',
+  labelOutput: 'Czysty CSS',
+  placeholderInput: '.btn { padding: 10px; color: red; }\n.btn { margin: 5px; color: blue; }',
+  placeholderOutput: 'Zoptymalizowany i scalony CSS pojawi się tutaj...',
+  btnClean: 'Wyczyść i scal CSS',
+  btnCopy: 'Kopiuj kod',
+  btnCopied: 'Skopiowano!',
+  statBytesOriginal: 'Oryginalne bajty',
+  statBytesClean: 'Czyste bajty',
+  statSaving: 'Oszczędność',
+};
+
+export const content: ToolLocaleContent<DuplicateCssRemoverUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Często zadawane pytania',
+  faq: faqData,
+  bibliographyTitle: 'Źródła i dokumentacja',
+  bibliography: [
+    {
+      name: 'Web Vitals: wpływ CSS na Render-Blocking i FCP',
+      url: 'https://web.dev/articles/render-blocking-resources',
+    },
+    {
+      name: 'Specyfikacja W3C: kaskada i dziedziczenie CSS',
+      url: 'https://www.w3.org/TR/css-cascade-4/',
+    },
+    {
+      name: 'Clean CSS: biblioteka i metody minifikacji CSS',
+      url: 'https://github.com/clean-css/clean-css',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Dlaczego kod CSS się duplikuje?',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Przy utrzymaniu długoterminowych projektów webowych lub pracy z kodem dziedziczonym (<em>legacy code</em>) bardzo często zdarza się, że kilku programistów pisze nakładające się reguły CSS. Z obawy przed zepsuciem istniejącego projektu deweloper woli dodać nową, nadmiarową regułę na końcu dokumentu zamiast edytować lub refaktoryzować oryginał.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Efektem jest nieefektywny plik z dziesiątkami wielokrotnie zadeklarowanych selektorów, który zabija czytelność i znacząco zwiększa wagę pobieranej strony.',
+    },
+    {
+      type: 'title',
+      text: 'Ukryty wpływ na wydajność stron (Web Vitals)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Pliki stylów blokują naturalne renderowanie przeglądarki (zasób <strong>Render-Blocking</strong>). Dopóki przeglądarka nie pobierze i nie zbuduje kompletnego CSSOM, ekran pozostaje pusty.',
+    },
+    {
+      type: 'tip',
+      html: 'Usuwanie nadmiarowych stylów to nie tylko kwestia porządku w kodzie — to mierzalna i natychmiastowa poprawa kluczowych metryk, takich jak <strong>First Contentful Paint (FCP)</strong>.',
+    },
+    {
+      type: 'title',
+      text: 'Jak scalamy zduplikowane reguły',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'To narzędzie działa jak inteligentny asembler. Zamiast tylko kompresować białe znaki (jak robi to tradycyjny minifier), rekurencyjnie przeszukuje tekst w poszukiwaniu identycznych wzorców selektorów.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Wyobraź sobie, że masz regułę <code>.box { color: red; }</code>, a sto linii niżej <code>.box { padding: 10px; color: blue; }</code>. Narzędzie scali oba bloki pod tym samym selektorem <code>.box</code>, łącząc padding.',
+        '<strong>Zachowanie kaskady CSS:</strong> W przypadku bezpośrednich konfliktów algorytm ściśle zachowuje ostatnio zadeklarowaną właściwość. Dzięki temu twój oryginalny układ nie rozpadnie się po wyczyszczeniu dokumentu.',
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'Koniec z wysyłaniem kilobajtów martwego tekstu na telefony twoich użytkowników. Scal swój kod w milisekundy, całkowicie offline, bezpośrednio z przeglądarki.',
+    },
+  ],
+};

package/src/tool/duplicateCssRemover/i18n/pt.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 = 'removedor-de-css-duplicado';
+const title = 'Remover CSS Duplicado Online. Unifique e Limpe as Suas Folhas de Estilo';
+const description =
+  'Ferramenta gratuita para limpar e purgar código CSS duplicado. Unifica seletores redundantes, respeita a cascade e reduz instantaneamente o tamanho dos ficheiros diretamente no browser.';
+
+const faqData = [
+  {
+    question: 'O que acontece quando os seletores CSS são duplicados?',
+    answer:
+      'Quando o mesmo seletor aparece várias vezes, o browser aplica todas as regras, mas a última declaração de cada propriedade substitui as anteriores. O resultado são ficheiros mais pesados do que o necessário, sem qualquer benefício real para o resultado visual.',
+  },
+  {
+    question: 'Perco alguma propriedade ao remover os duplicados?',
+    answer:
+      'Não. O algoritmo respeita rigorosamente a cascade do CSS: em caso de conflitos sob o mesmo seletor, preserva sempre a última propriedade declarada. As propriedades exclusivas de cada bloco são combinadas num único seletor unificado.',
+  },
+  {
+    question: 'Funciona com CSS minificado ou com comentários?',
+    answer:
+      'A ferramenta remove automaticamente os comentários CSS antes de processar e funciona corretamente com código numa só linha. Para CSS com nesting avançado ou at-rules complexas, recomenda-se separar os blocos primeiro.',
+  },
+  {
+    question: 'O meu CSS é enviado para algum servidor?',
+    answer:
+      'Não. Todo o processamento ocorre diretamente no seu browser através de JavaScript local. Nenhuma parte do seu CSS é transmitida para qualquer servidor externo, garantindo total privacidade do seu código.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Cole o seu CSS',
+    text: 'Copie o conteúdo do seu ficheiro CSS com seletores repetidos e cole-o no campo da esquerda "Dirty / Duplicate CSS".',
+  },
+  {
+    name: 'Execute a limpeza',
+    text: 'Clique no botão "Limpar e Unificar CSS". A ferramenta irá analisar todos os seletores, fundir propriedades e remover blocos redundantes.',
+  },
+  {
+    name: 'Reveja os resultados e copie',
+    text: 'Verifique a poupança em bytes obtida e copie o CSS otimizado com o botão "Copiar Código" para o usar diretamente no seu projeto.',
+  },
+];
+
+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: 'pt',
+};
+
+const ui: DuplicateCssRemoverUI = {
+  labelInput: 'CSS Sujo / Duplicado',
+  labelOutput: 'CSS Limpo',
+  placeholderInput: '.btn { padding: 10px; color: red; }\n.btn { margin: 5px; color: blue; }',
+  placeholderOutput: 'O CSS otimizado e unificado aparecerá aqui...',
+  btnClean: 'Limpar e Unificar CSS',
+  btnCopy: 'Copiar Código',
+  btnCopied: 'Copiado!',
+  statBytesOriginal: 'Bytes Originais',
+  statBytesClean: 'Bytes Limpos',
+  statSaving: 'Poupança',
+};
+
+export const content: ToolLocaleContent<DuplicateCssRemoverUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Perguntas Frequentes',
+  faq: faqData,
+  bibliographyTitle: 'Referências e Documentação',
+  bibliography: [
+    {
+      name: 'Web Vitals: impacto do CSS no Render-Blocking e no FCP',
+      url: 'https://web.dev/articles/render-blocking-resources',
+    },
+    {
+      name: 'Especificação W3C: Cascade e Herança CSS',
+      url: 'https://www.w3.org/TR/css-cascade-4/',
+    },
+    {
+      name: 'Clean CSS: biblioteca e metodologias para minificação de CSS',
+      url: 'https://github.com/clean-css/clean-css',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Por que o código CSS acaba por se duplicar?',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Ao manter projetos web a longo prazo ou ao trabalhar com código legado (<em>legacy code</em>), é extremamente comum que vários programadores escrevam regras CSS sobrepostas. Muitas vezes, com medo de estragar um design existente, prefere-se adicionar uma nova regra redundante no final do documento a editar ou refatorar a original.',
+    },
+    {
+      type: 'paragraph',
+      html: 'O resultado é um ficheiro ineficiente com dezenas de seletores declarados repetidamente, que compromete a legibilidade e aumenta consideravelmente o peso de transferência da página web.',
+    },
+    {
+      type: 'title',
+      text: 'O impacto oculto no desempenho web (Web Vitals)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Os ficheiros de folhas de estilo bloqueiam a renderização natural do browser (um recurso <strong>Render-Blocking</strong>). Até o browser transferir e construir o CSSOM completo, o ecrã permanece em branco.',
+    },
+    {
+      type: 'tip',
+      html: 'Purgar estilos redundantes não é apenas uma questão de organização do código — é uma melhoria mensurável e imediata em métricas vitais como o <strong>First Contentful Paint (FCP)</strong>.',
+    },
+    {
+      type: 'title',
+      text: 'Como unificamos as regras duplicadas',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Esta ferramenta funciona como um montador inteligente. Em vez de se limitar a comprimir espaços em branco (como faria um minifier tradicional), percorre o texto recursivamente à procura de padrões de seletores idênticos.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Imagine ter a regra <code>.box { color: red; }</code> e cem linhas abaixo um <code>.box { padding: 10px; color: blue; }</code>. A ferramenta unifica ambos os blocos sob o mesmo seletor <code>.box</code>, combinando o padding.',
+        '<strong>Preservação da Cascade CSS:</strong> Em caso de conflitos diretos, o algoritmo preserva rigorosamente a última propriedade declarada. Assim, o seu layout original não é quebrado ao purgar o documento.',
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'Deixe de enviar kilobytes de texto morto para os telemóveis dos seus utilizadores. Unifique o seu código em milissegundos, completamente offline, diretamente no browser.',
+    },
+  ],
+};

package/src/tool/duplicateCssRemover/i18n/ru.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 = 'udalenie-dublikatov-css';
+const title = 'Удаление дублирующегося CSS онлайн. Объединяйте и очищайте стили';
+const description =
+  'Бесплатный инструмент для очистки и удаления дублирующегося CSS-кода. Объединяет избыточные селекторы, соблюдает каскад и мгновенно уменьшает размер файла прямо в браузере.';
+
+const faqData = [
+  {
+    question: 'Что происходит при дублировании CSS-селекторов?',
+    answer:
+      'Когда один и тот же селектор встречается несколько раз, браузер применяет все правила, но последнее объявление каждого свойства перекрывает предыдущие. В итоге получаются файлы тяжелее, чем нужно, без какого-либо реального выигрыша в визуальном результате.',
+  },
+  {
+    question: 'Потеряются ли свойства при удалении дубликатов?',
+    answer:
+      'Нет. Алгоритм строго соблюдает каскад CSS: при конфликте свойств в рамках одного селектора всегда сохраняется последнее объявленное. Уникальные свойства из каждого блока объединяются под одним общим селектором.',
+  },
+  {
+    question: 'Работает ли инструмент с минифицированным CSS или CSS с комментариями?',
+    answer:
+      'Инструмент автоматически удаляет комментарии CSS перед обработкой и корректно работает с однострочным кодом. Для CSS с продвинутой вложенностью или сложными at-rules рекомендуется сначала разделить блоки.',
+  },
+  {
+    question: 'Отправляется ли мой CSS на сервер?',
+    answer:
+      'Нет. Вся обработка происходит прямо в браузере с помощью локального JavaScript. Никакая часть вашего CSS не передаётся на внешние серверы — полная конфиденциальность кода гарантирована.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Вставьте свой CSS',
+    text: 'Скопируйте содержимое вашего CSS-файла с повторяющимися селекторами и вставьте его в левое поле "Dirty / Duplicate CSS".',
+  },
+  {
+    name: 'Запустите очистку',
+    text: 'Нажмите кнопку "Очистить и объединить CSS". Инструмент просканирует все селекторы, объединит свойства и удалит избыточные блоки.',
+  },
+  {
+    name: 'Проверьте результат и скопируйте',
+    text: 'Посмотрите, сколько байт удалось сэкономить, и скопируйте оптимизированный CSS кнопкой "Скопировать код" для использования в проекте.',
+  },
+];
+
+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: 'ru',
+};
+
+const ui: DuplicateCssRemoverUI = {
+  labelInput: 'Грязный / Дублирующийся CSS',
+  labelOutput: 'Очищенный CSS',
+  placeholderInput: '.btn { padding: 10px; color: red; }\n.btn { margin: 5px; color: blue; }',
+  placeholderOutput: 'Здесь появится оптимизированный и объединённый CSS...',
+  btnClean: 'Очистить и объединить CSS',
+  btnCopy: 'Скопировать код',
+  btnCopied: 'Скопировано!',
+  statBytesOriginal: 'Исходный размер',
+  statBytesClean: 'Очищенный размер',
+  statSaving: 'Экономия',
+};
+
+export const content: ToolLocaleContent<DuplicateCssRemoverUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Часто задаваемые вопросы',
+  faq: faqData,
+  bibliographyTitle: 'Ссылки и документация',
+  bibliography: [
+    {
+      name: 'Web Vitals: влияние CSS на Render-Blocking и FCP',
+      url: 'https://web.dev/articles/render-blocking-resources',
+    },
+    {
+      name: 'Спецификация W3C: каскад и наследование CSS',
+      url: 'https://www.w3.org/TR/css-cascade-4/',
+    },
+    {
+      name: 'Clean CSS: библиотека и методы минификации CSS',
+      url: 'https://github.com/clean-css/clean-css',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Почему CSS-код дублируется?',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'При долгосрочном обслуживании веб-проектов или работе с унаследованным кодом очень часто несколько разработчиков пишут перекрывающиеся CSS-правила. Боясь сломать существующий дизайн, разработчик предпочитает добавить новое избыточное правило в конец документа, вместо того чтобы редактировать или рефакторить исходное.',
+    },
+    {
+      type: 'paragraph',
+      html: 'В итоге получается неэффективный файл с десятками многократно объявленных селекторов, который засоряет читаемость кода и существенно увеличивает вес загружаемой страницы.',
+    },
+    {
+      type: 'title',
+      text: 'Скрытое влияние на производительность сайта (Web Vitals)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Файлы стилей блокируют естественный рендеринг браузера (ресурс <strong>Render-Blocking</strong>). Пока браузер не загрузит и не построит полный CSSOM, экран остаётся пустым.',
+    },
+    {
+      type: 'tip',
+      html: 'Удаление лишних стилей — это не просто вопрос чистоты кода. Это измеримое и немедленное улучшение ключевых показателей, таких как <strong>First Contentful Paint (FCP)</strong>.',
+    },
+    {
+      type: 'title',
+      text: 'Как мы объединяем дублирующиеся правила',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Этот инструмент работает как интеллектуальный сборщик. Вместо того чтобы просто сжимать пробелы, как обычный минификатор, он рекурсивно сканирует текст в поисках идентичных паттернов селекторов.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Представьте, что у вас есть правило <code>.box { color: red; }</code>, а сотню строк спустя — <code>.box { padding: 10px; color: blue; }</code>. Инструмент объединит оба блока под одним селектором <code>.box</code>, включив padding.',
+        '<strong>Сохранение каскада CSS:</strong> При прямых конфликтах алгоритм строго сохраняет последнее объявленное свойство. Это гарантирует, что ваша вёрстка не сломается после очистки документа.',
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'Перестаньте отправлять килобайты мёртвого текста на телефоны ваших пользователей. Объединяйте код за миллисекунды, полностью офлайн, прямо в браузере.',
+    },
+  ],
+};

package/src/tool/duplicateCssRemover/i18n/sv.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 = 'ta-bort-dubblett-css';
+const title = 'Ta bort duplicerad CSS online. Sammanfoga och rensa dina stilmallar';
+const description =
+  'Gratis verktyg för att rensa och ta bort duplicerad CSS-kod. Sammanfogar redundanta selektorer, respekterar cascade och minskar filstorleken direkt i webbläsaren.';
+
+const faqData = [
+  {
+    question: 'Vad händer när CSS-selektorer är duplicerade?',
+    answer:
+      'När samma selektor förekommer flera gånger tillämpar webbläsaren alla regler, men den sista deklarationen av varje egenskap skriver över de tidigare. Det ger onödigt tunga filer utan någon verklig fördel för det visuella resultatet.',
+  },
+  {
+    question: 'Försvinner några egenskaper när dubbletter tas bort?',
+    answer:
+      'Nej. Algoritmen följer CSS-cascaden strikt: vid konflikter under samma selektor bevaras alltid den senast deklarerade egenskapen. Unika egenskaper från varje block slås samman under en enda enhetlig selektor.',
+  },
+  {
+    question: 'Fungerar det med minifierad CSS eller CSS med kommentarer?',
+    answer:
+      'Verktyget tar automatiskt bort CSS-kommentarer innan bearbetning och fungerar korrekt med kod på en enda rad. För CSS med avancerad nesting eller komplexa at-rules rekommenderas att du separerar blocken först.',
+  },
+  {
+    question: 'Skickas min CSS till någon server?',
+    answer:
+      'Nej. All bearbetning sker direkt i din webbläsare via lokal JavaScript. Ingen del av din CSS skickas till någon extern server, vilket garanterar full sekretess för din kod.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Klistra in din CSS',
+    text: 'Kopiera innehållet i din CSS-fil med upprepade selektorer och klistra in det i det vänstra fältet "Dirty / Duplicate CSS".',
+  },
+  {
+    name: 'Starta rensningen',
+    text: 'Klicka på "Rensa och sammanfoga CSS". Verktyget söker igenom alla selektorer, slår samman egenskaper och tar bort redundanta block.',
+  },
+  {
+    name: 'Granska resultatet och kopiera',
+    text: 'Kontrollera hur många bytes som sparats och kopiera den optimerade CSS:en med knappen "Kopiera kod" för att använda den direkt i ditt projekt.',
+  },
+];
+
+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: 'sv',
+};
+
+const ui: DuplicateCssRemoverUI = {
+  labelInput: 'Smutsig / Duplicerad CSS',
+  labelOutput: 'Ren CSS',
+  placeholderInput: '.btn { padding: 10px; color: red; }\n.btn { margin: 5px; color: blue; }',
+  placeholderOutput: 'Optimerad och sammanfogad CSS visas här...',
+  btnClean: 'Rensa och sammanfoga CSS',
+  btnCopy: 'Kopiera kod',
+  btnCopied: 'Kopierad!',
+  statBytesOriginal: 'Ursprungliga bytes',
+  statBytesClean: 'Rena bytes',
+  statSaving: 'Besparing',
+};
+
+export const content: ToolLocaleContent<DuplicateCssRemoverUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Vanliga frågor',
+  faq: faqData,
+  bibliographyTitle: 'Källor och dokumentation',
+  bibliography: [
+    {
+      name: 'Web Vitals: CSS påverkan på Render-Blocking och FCP',
+      url: 'https://web.dev/articles/render-blocking-resources',
+    },
+    {
+      name: 'W3C-specifikation: CSS Cascade och arv',
+      url: 'https://www.w3.org/TR/css-cascade-4/',
+    },
+    {
+      name: 'Clean CSS: bibliotek och metoder för CSS-minifiering',
+      url: 'https://github.com/clean-css/clean-css',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Varför dupliceras CSS-kod?',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Vid underhåll av långsiktiga webbprojekt eller arbete med äldre kod är det mycket vanligt att flera utvecklare skriver överlappande CSS-regler. Av rädsla för att förstöra en befintlig design lägger man hellre till en ny redundant regel i slutet av dokumentet än att redigera eller refaktorera originalet.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Resultatet är en ineffektiv fil med dussintals upprepade selektorer som förstör läsbarheten och avsevärt ökar nedladdningsstorleken för din webbsida.',
+    },
+    {
+      type: 'title',
+      text: 'Den dolda påverkan på webbprestanda (Web Vitals)',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Stilmallsfiler blockerar webbläsarens naturliga rendering (en <strong>Render-Blocking</strong>-resurs). Tills webbläsaren har laddat ner och byggt upp hela CSSOM förblir skärmen tom.',
+    },
+    {
+      type: 'tip',
+      html: 'Att rensa bort redundanta stilar handlar inte bara om kodordning — det är en mätbar och omedelbar förbättring av viktiga mätvärden som <strong>First Contentful Paint (FCP)</strong>.',
+    },
+    {
+      type: 'title',
+      text: 'Hur vi sammanfogar duplicerade regler',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Det här verktyget fungerar som en intelligent assembler. Istället för att enbart komprimera blanksteg (som en traditionell minifierare) skannar det rekursivt igenom texten efter identiska selektormönster.',
+    },
+    {
+      type: 'list',
+      items: [
+        'Tänk dig att du har regeln <code>.box { color: red; }</code> och hundra rader senare en <code>.box { padding: 10px; color: blue; }</code>. Verktyget sammanfogar båda blocken under samma selektor <code>.box</code> och kombinerar padding-värdet.',
+        '<strong>Bevarande av CSS-cascade:</strong> Vid direkta konflikter bevarar algoritmen strikt den senast deklarerade egenskapen. Det säkerställer att din ursprungliga layout inte går sönder när dokumentet rensas.',
+      ],
+    },
+    {
+      type: 'paragraph',
+      html: 'Sluta skicka kilobytes av död text till dina användares mobiltelefoner. Sammanfoga din kod på millisekunder, helt offline, direkt från webbläsaren.',
+    },
+  ],
+};