Tworzenie rozszerzeń przeglądarki: Manifest V3 i API JavaScript

Rozszerzenia przeglądarki to małe programy, które dostosowują doświadczenia z przeglądania. Mogą dodawać nowe funkcje, modyfikować zawartość stron internetowych, blokować reklamy i wiele więcej. Wraz z pojawieniem się Manifest V3 sposób budowania i działania rozszerzeń uległ znaczącym zmianom. Ten kompleksowy przewodnik przybliży tworzenie rozszerzeń przeglądarek przy użyciu Manifest V3 i API JavaScript, dostarczając wiedzy do tworzenia potężnych i bezpiecznych rozszerzeń dla nowoczesnych przeglądarek.

Czym są rozszerzenia przeglądarki?

Rozszerzenia przeglądarki to zasadniczo mini-aplikacje, które działają w przeglądarce internetowej. Rozszerzają funkcjonalność przeglądarki i płynnie integrują się ze stronami internetowymi. Rozszerzenia są pisane przy użyciu standardowych technologii webowych, takich jak HTML, CSS i JavaScript, co czyni je stosunkowo dostępnymi dla programistów webowych.

Przykłady popularnych rozszerzeń przeglądarki to:

• Blokery reklam: Blokują reklamy na stronach internetowych, poprawiając szybkość przeglądania i redukując rozpraszacze.
• Menedżery haseł: Bezpiecznie przechowują i zarządzają hasłami, automatycznie uzupełniając je na stronach internetowych.
• Rozszerzenia do robienia notatek: Pozwalają użytkownikom na robienie notatek i zapisywanie ich bezpośrednio ze stron internetowych.
• Narzędzia zwiększające produktywność: Zwiększają produktywność poprzez dostarczanie funkcji takich jak zarządzanie zadaniami, śledzenie czasu i tryby skupienia.
• Narzędzia do tłumaczenia języków: Tłumaczą strony internetowe na różne języki za pomocą jednego kliknięcia. Przykład: rozszerzenie Google Translate.
• Rozszerzenia VPN: Pośredniczą w ruchu internetowym, aby ominąć ograniczenia geograficzne i zwiększyć prywatność.

Znaczenie Manifest V3

Manifest V3 to najnowsza wersja pliku manifestu, czyli pliku JSON, który opisuje rozszerzenie dla przeglądarki. Określa on nazwę rozszerzenia, wersję, uprawnienia, skrypty działające w tle oraz inne istotne metadane. Manifest V3 wprowadza kilka kluczowych zmian w porównaniu do swojego poprzednika, Manifest V2, koncentrując się przede wszystkim na bezpieczeństwie i wydajności.

Kluczowe zmiany w Manifest V3:

• Service Workers: Manifest V3 zastępuje strony działające w tle (background pages) przez service workers. Service workers to skrypty sterowane zdarzeniami, które działają w tle, nie wymagając stałej strony. Są bardziej wydajne i mniej zasobochłonne niż strony działające w tle.
• Declarative Net Request API: To API pozwala rozszerzeniom modyfikować żądania sieciowe bez ich bezpośredniego przechwytywania. Zwiększa bezpieczeństwo i wydajność poprzez przeniesienie logiki filtrowania do przeglądarki.
• Bardziej rygorystyczna Polityka Bezpieczeństwa Treści (CSP): Manifest V3 wymusza bardziej rygorystyczne zasady CSP, aby zapobiec wykonywaniu dowolnego kodu, co dodatkowo zwiększa bezpieczeństwo.
• API oparte na Promises: Wiele API jest teraz opartych na promises, co ułatwia zarządzanie operacjami asynchronicznymi.

Dlaczego zmiana na Manifest V3?

• Zwiększone bezpieczeństwo: Manifest V3 został zaprojektowany w celu poprawy bezpieczeństwa rozszerzeń przeglądarki i ochrony użytkowników przed złośliwym kodem.
• Poprawiona wydajność: Service workers i Declarative Net Request API przyczyniają się do lepszej wydajności i zmniejszonego zużycia zasobów.
• Większa prywatność: Manifest V3 ma na celu zapewnienie użytkownikom większej kontroli nad ich danymi i prywatnością.

Konfiguracja środowiska programistycznego

Zanim zaczniesz tworzyć rozszerzenia przeglądarki, musisz skonfigurować swoje środowisko programistyczne. Obejmuje to instalację edytora kodu, wybór przeglądarki do testowania i zrozumienie podstawowej struktury plików rozszerzenia.

1. Edytor kodu

Wybierz edytor kodu, z którym czujesz się komfortowo. Popularne opcje to:

• Visual Studio Code (VS Code): Darmowy i potężny edytor kodu z doskonałym wsparciem dla JavaScript i innych technologii webowych.
• Sublime Text: Szybki i konfigurowalny edytor kodu z szeroką gamą wtyczek.
• Atom: Darmowy i open-source'owy edytor kodu opracowany przez GitHub.

2. Przeglądarka do testowania

Wybierz przeglądarkę do testowania swoich rozszerzeń. Chrome i Firefox są najpopularniejszymi wyborami, ponieważ oferują solidne narzędzia programistyczne i wsparcie dla tworzenia rozszerzeń.

3. Podstawowa struktura plików

Rozszerzenie przeglądarki zazwyczaj składa się z następujących plików:

• manifest.json: Ten plik zawiera metadane rozszerzenia, takie jak jego nazwa, wersja, uprawnienia i skrypty działające w tle.
• background.js (lub skrypt service worker): Ten skrypt działa w tle i obsługuje zdarzenia, takie jak akcje przeglądarki i kliknięcia menu kontekstowego.
• content.js: Ten skrypt działa w kontekście stron internetowych i może modyfikować ich zawartość.
• popup.html: Ten plik definiuje interfejs użytkownika wyskakującego okienka rozszerzenia.
• popup.js: Ten skrypt obsługuje logikę wyskakującego okienka rozszerzenia.
• options.html: Ten plik definiuje interfejs użytkownika strony opcji rozszerzenia.
• options.js: Ten skrypt obsługuje logikę strony opcji rozszerzenia.
• icons: Są to ikony używane do reprezentowania rozszerzenia na pasku narzędzi przeglądarki i na stronie zarządzania rozszerzeniami.

Tworzenie pierwszego rozszerzenia: "Witaj, świecie!"

Stwórzmy proste rozszerzenie "Witaj, świecie!", aby zademonstrować podstawowe zasady tworzenia rozszerzeń przeglądarki.

1. Utwórz plik manifestu (manifest.json)

Utwórz plik o nazwie `manifest.json` w nowym katalogu i dodaj następujący kod:

{
  "manifest_version": 3,
  "name": "Hello, World!",
  "version": "1.0",
  "description": "A simple Hello, World! extension",
  "permissions": [
    "storage"
  ],
  "action": {
    "default_popup": "popup.html",
    "default_icon": {
      "16": "images/icon16.png",
      "48": "images/icon48.png",
      "128": "images/icon128.png"
    }
  },
  "icons": {
    "16": "images/icon16.png",
    "48": "images/icon48.png",
    "128": "images/icon128.png"
  }
}

Wyjaśnienie:

• `manifest_version`: Określa wersję pliku manifestu (3 dla Manifest V3).
• `name`: Nazwa rozszerzenia.
• `version`: Numer wersji rozszerzenia.
• `description`: Krótki opis rozszerzenia.
• `permissions`: Tablica uprawnień, których wymaga rozszerzenie (np. "storage").
• `action`: Definiuje właściwości wyskakującego okienka rozszerzenia, w tym domyślny plik wyskakującego okienka i ikony.
• `icons`: Określa ścieżki do ikon rozszerzenia.

2. Utwórz plik wyskakującego okienka (popup.html)

Utwórz plik o nazwie `popup.html` w tym samym katalogu i dodaj następujący kod:

  
  


  
Hello, World!
  
This is a simple browser extension.

Ten plik definiuje interfejs użytkownika wyskakującego okienka rozszerzenia, które wyświetli komunikat "Witaj, świecie!".

3. Utwórz obrazy ikon

Utwórz trzy obrazy ikon o następujących rozmiarach: 16x16, 48x48 i 128x128 pikseli. Zapisz je jako `icon16.png`, `icon48.png` i `icon128.png` w katalogu `images` wewnątrz katalogu rozszerzenia.

4. Załaduj rozszerzenie do przeglądarki

Chrome:

1. Otwórz Chrome i przejdź do `chrome://extensions`.
2. Włącz "Tryb programisty" w prawym górnym rogu.
3. Kliknij "Załaduj rozpakowane" i wybierz katalog zawierający pliki rozszerzenia.

Firefox:

1. Otwórz Firefox i przejdź do `about:debugging#/runtime/this-firefox`.
2. Kliknij "Załaduj tymczasowy dodatek..." i wybierz plik `manifest.json`.

Twoje rozszerzenie "Witaj, świecie!" powinno być teraz zainstalowane i widoczne na pasku narzędzi przeglądarki. Kliknij ikonę rozszerzenia, aby otworzyć wyskakujące okienko i zobaczyć komunikat "Witaj, świecie!".

Praca z API JavaScript

Rozszerzenia przeglądarki mogą wchodzić w interakcje z przeglądarką i stronami internetowymi za pomocą API JavaScript. Te API zapewniają dostęp do różnych funkcji, takich jak:

• Tabs API: Pozwala zarządzać kartami przeglądarki, w tym tworzyć, aktualizować i odpytywać karty.
• Storage API: Zapewnia sposób na trwałe przechowywanie i pobieranie danych w ramach rozszerzenia.
• Alarms API: Pozwala planować zadania do wykonania w określonych godzinach.
• Notifications API: Umożliwia wyświetlanie powiadomień użytkownikowi.
• Context Menus API: Pozwala dodawać niestandardowe elementy do menu kontekstowego przeglądarki (menu prawego kliknięcia).
• Web Request API (Declarative Net Request w Manifest V3): Umożliwia przechwytywanie i modyfikowanie żądań sieciowych.
• Scripting API: Pozwala na wstrzykiwanie skryptów do stron internetowych.

Przykład: Użycie Storage API

Stwórzmy rozszerzenie, które przechowuje i pobiera imię użytkownika za pomocą Storage API.

1. Zaktualizuj plik manifestu (manifest.json)

Upewnij się, że tablica `permissions` w twoim `manifest.json` zawiera `"storage"`:

{
  "manifest_version": 3,
  "name": "Storage Example",
  "version": "1.0",
  "description": "An extension that uses the Storage API",
  "permissions": [
    "storage"
  ],
  "action": {
    "default_popup": "popup.html"
  },
  "icons": {
    "16": "images/icon16.png",
    "48": "images/icon48.png",
    "128": "images/icon128.png"
  }
}

2. Utwórz plik wyskakującego okienka (popup.html)

Utwórz lub zaktualizuj swój plik `popup.html` o następującą zawartość:

  
  


  
Przykład Storage API
  Wpisz swoje imię:
  
  Zapisz
  

  

3. Utwórz skrypt wyskakującego okienka (popup.js)

Utwórz plik o nazwie `popup.js` i dodaj następujący kod:

document.addEventListener('DOMContentLoaded', () => {
  const nameInput = document.getElementById('name');
  const saveButton = document.getElementById('save');
  const greeting = document.getElementById('greeting');

  // Załaduj zapisane imię z pamięci
  chrome.storage.sync.get('name', (data) => {
    if (data.name) {
      nameInput.value = data.name;
      greeting.textContent = `Witaj, ${data.name}!`;
    }
  });

  // Zapisz imię do pamięci po kliknięciu przycisku
  saveButton.addEventListener('click', () => {
    const name = nameInput.value;
    chrome.storage.sync.set({ name: name }, () => {
      greeting.textContent = `Witaj, ${name}!`;
    });
  });
});

Wyjaśnienie:

• Skrypt nasłuchuje zdarzenia `DOMContentLoaded`, aby upewnić się, że DOM jest w pełni załadowany przed wykonaniem kodu.
• Pobiera odniesienia do pola wprowadzania, przycisku zapisu i akapitu powitalnego.
• Ładuje zapisane imię z pamięci za pomocą `chrome.storage.sync.get()`.
• Zapisuje imię w pamięci po kliknięciu przycisku zapisu za pomocą `chrome.storage.sync.set()`.
• Aktualizuje akapit powitalny o zapisane lub wprowadzone imię.

Przeładuj rozszerzenie w przeglądarce. Teraz, gdy otworzysz wyskakujące okienko, możesz wprowadzić swoje imię, zapisać je i zobaczyć wiadomość powitalną. Imię zostanie zapisane w pamięci rozszerzenia i zostanie załadowane następnym razem, gdy otworzysz wyskakujące okienko.

Przykład: Użycie Tabs API

Stwórzmy rozszerzenie, które wyświetla URL bieżącej karty w wyskakującym okienku.

1. Zaktualizuj plik manifestu (manifest.json)

Dodaj uprawnienie `"tabs"` do tablicy `permissions` w swoim `manifest.json`:

{
  "manifest_version": 3,
  "name": "Tabs Example",
  "version": "1.0",
  "description": "An extension that uses the Tabs API",
  "permissions": [
    "tabs"
  ],
  "action": {
    "default_popup": "popup.html"
  },
  "icons": {
    "16": "images/icon16.png",
    "48": "images/icon48.png",
    "128": "images/icon128.png"
  }
}

2. Utwórz plik wyskakującego okienka (popup.html)

Utwórz lub zaktualizuj swój plik `popup.html` o następującą zawartość:

  
  


  
Przykład Tabs API
  
URL bieżącej karty:
  

  

3. Utwórz skrypt wyskakującego okienka (popup.js)

Utwórz plik o nazwie `popup.js` i dodaj następujący kod:

document.addEventListener('DOMContentLoaded', () => {
  const urlDisplay = document.getElementById('url');

  // Pobierz URL bieżącej karty
  chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
    const tab = tabs[0];
    urlDisplay.textContent = tab.url;
  });
});

Wyjaśnienie:

• Skrypt nasłuchuje zdarzenia `DOMContentLoaded`.
• Używa `chrome.tabs.query()` do pobrania aktualnie aktywnej karty w bieżącym oknie.
• Pobiera URL karty i wyświetla go w akapicie `url`.

Przeładuj rozszerzenie w przeglądarce. Teraz, gdy otworzysz wyskakujące okienko, wyświetli ono URL bieżącej karty.

Skrypty tła i Service Workers

W Manifest V3 skrypty działające w tle zostały zastąpione przez service workers. Service workers to skrypty sterowane zdarzeniami, które działają w tle, nie wymagając stałej strony. Są bardziej wydajne i mniej zasobochłonne niż strony działające w tle.

Kluczowe cechy Service Workers:

• Sterowane zdarzeniami: Service workers reagują na zdarzenia, takie jak akcje przeglądarki, alarmy i wiadomości ze skryptów treści.
• Asynchroniczne: Service workers używają asynchronicznych API, aby uniknąć blokowania głównego wątku.
• Zakończenie, gdy bezczynne: Service workers są kończone, gdy nie obsługują aktywnie zdarzeń, co oszczędza zasoby.

Przykład: Użycie Service Worker

Stwórzmy rozszerzenie, które wyświetla powiadomienie po uruchomieniu przeglądarki.

1. Zaktualizuj plik manifestu (manifest.json)

Zaktualizuj swój plik `manifest.json` o następującą zawartość:

{
  "manifest_version": 3,
  "name": "Service Worker Example",
  "version": "1.0",
  "description": "An extension that uses a service worker",
  "permissions": [
    "notifications"
  ],
  "background": {
    "service_worker": "background.js"
  },
  "icons": {
    "16": "images/icon16.png",
    "48": "images/icon48.png",
    "128": "images/icon128.png"
  }
}

Wyjaśnienie:

• Właściwość `"background"` określa ścieżkę do skryptu service worker (`background.js`).
• Tablica `"permissions"` zawiera `"notifications"`, co jest wymagane do wyświetlania powiadomień.

2. Utwórz skrypt Service Worker (background.js)

Utwórz plik o nazwie `background.js` i dodaj następujący kod:

chrome.runtime.onStartup.addListener(() => {
  // Wyświetl powiadomienie po uruchomieniu przeglądarki
  chrome.notifications.create('startup-notification', {
    type: 'basic',
    iconUrl: 'images/icon48.png',
    title: 'Przeglądarka uruchomiona',
    message: 'Przeglądarka została uruchomiona.',
  });
});

Wyjaśnienie:

• Skrypt nasłuchuje zdarzenia `chrome.runtime.onStartup`, które jest wyzwalane po uruchomieniu przeglądarki.
• Używa `chrome.notifications.create()` do wyświetlania powiadomienia z określonymi właściwościami.

Przeładuj rozszerzenie w przeglądarce. Teraz, po ponownym uruchomieniu przeglądarki, powinieneś zobaczyć powiadomienie od rozszerzenia.

Skrypty treści

Skrypty treści to pliki JavaScript, które działają w kontekście stron internetowych. Mogą uzyskiwać dostęp do DOM stron internetowych i modyfikować go, umożliwiając dostosowanie zachowania i wyglądu witryn.

Kluczowe cechy skryptów treści:

• Dostęp do DOM: Skrypty treści mogą uzyskiwać dostęp do DOM stron internetowych i manipulować nim.
• Izolacja od skryptów stron internetowych: Skrypty treści działają w izolowanym środowisku, zapobiegając konfliktom ze skryptami stron internetowych.
• Komunikacja ze skryptami działającymi w tle: Skrypty treści mogą komunikować się ze skryptami działającymi w tle za pomocą przekazywania wiadomości.

Przykład: Użycie skryptu treści

Stwórzmy rozszerzenie, które zmienia kolor tła stron internetowych na jasnoniebieski.

1. Zaktualizuj plik manifestu (manifest.json)

Zaktualizuj swój plik `manifest.json` o następującą zawartość:

{
  "manifest_version": 3,
  "name": "Content Script Example",
  "version": "1.0",
  "description": "An extension that uses a content script",
  "permissions": [
    "activeTab",
    "scripting"
  ],
  "background": {
    "service_worker": "background.js"
  },
  "content_scripts": [
    {
      "matches": [""],
      "js": ["content.js"]
    }
  ],
  "icons": {
    "16": "images/icon16.png",
    "48": "images/icon48.png",
    "128": "images/icon128.png"
  }
}

Wyjaśnienie:

• Właściwość `"content_scripts"` określa tablicę skryptów treści do wstrzyknięcia na strony internetowe.
• `"matches"` określa adresy URL, do których skrypt treści powinien zostać wstrzyknięty (`` pasuje do wszystkich adresów URL).
• `"js"` określa ścieżkę do skryptu treści (`content.js`).
• Tablica `"permissions"` zawiera `"activeTab"` i `"scripting"`, które są wymagane do wstrzykiwania skryptów.

2. Utwórz skrypt treści (content.js)

Utwórz plik o nazwie `content.js` i dodaj następujący kod:

document.body.style.backgroundColor = 'lightblue';

3. Utwórz Service Worker (background.js)

Utwórz plik o nazwie `background.js` i dodaj następujący kod:

chrome.action.onClicked.addListener((tab) => {
  chrome.scripting.executeScript({
    target: { tabId: tab.id },
    function: () => {
      document.body.style.backgroundColor = 'lightblue';
    }
  });
});

Wyjaśnienie:

• Skrypt treści po prostu ustawia kolor tła elementu `body` na jasnoniebieski.
• Service worker nasłuchuje zdarzenia kliknięcia i wykonuje funkcję w bieżącej karcie, która zmienia kolor tła.

Przeładuj rozszerzenie w przeglądarce. Teraz, gdy otworzysz dowolną stronę internetową, kolor tła będzie jasnoniebieski.

Debugowanie rozszerzeń przeglądarki

Debugowanie rozszerzeń przeglądarki jest istotną częścią procesu deweloperskiego. Chrome i Firefox oferują doskonałe narzędzia deweloperskie do debugowania rozszerzeń.

Debugowanie w Chrome:

1. Otwórz Chrome i przejdź do `chrome://extensions`.
2. Włącz "Tryb programisty" w prawym górnym rogu.
3. Kliknij "Sprawdź widoki strony działającej w tle" dla swojego rozszerzenia. Spowoduje to otwarcie Chrome DevTools dla skryptu działającego w tle.
4. Aby debugować skrypty treści, otwórz stronę internetową, na którą wstrzyknięto skrypt treści, a następnie otwórz Chrome DevTools dla tej strony. Powinieneś zobaczyć swój skrypt treści wymieniony w panelu "Źródła".

Debugowanie w Firefox:

1. Otwórz Firefox i przejdź do `about:debugging#/runtime/this-firefox`.
2. Znajdź swoje rozszerzenie na liście i kliknij "Sprawdź". Spowoduje to otwarcie narzędzi deweloperskich Firefox dla rozszerzenia.
3. Aby debugować skrypty treści, otwórz stronę internetową, na którą wstrzyknięto skrypt treści, a następnie otwórz narzędzia deweloperskie Firefox dla tej strony. Powinieneś zobaczyć swój skrypt treści wymieniony w panelu "Debugger".

Popularne techniki debugowania:

• Logowanie do konsoli: Użyj `console.log()` do wyświetlania wiadomości w konsoli.
• Punkty przerwania: Ustaw punkty przerwania w swoim kodzie, aby wstrzymać wykonanie i sprawdzić zmienne.
• Mapy źródłowe (Source maps): Użyj map źródłowych, aby debugować swój kod w jego oryginalnej formie, nawet jeśli został zminimalizowany lub przetranspilowany.
• Obsługa błędów: Zaimplementuj obsługę błędów, aby wyłapywać i logować błędy.

Publikowanie rozszerzenia

Po opracowaniu i przetestowaniu rozszerzenia możesz je opublikować w Chrome Web Store lub na platformie Firefox Add-ons.

Publikowanie w Chrome Web Store:

1. Utwórz konto dewelopera w Chrome Web Store.
2. Spakuj swoje rozszerzenie do pliku `.zip`.
3. Prześlij plik `.zip` do Chrome Web Store.
4. Podaj wymagane metadane, takie jak nazwa rozszerzenia, opis i zrzuty ekranu.
5. Prześlij swoje rozszerzenie do recenzji.

Publikowanie w Firefox Add-ons Marketplace:

1. Utwórz konto dewelopera na platformie Firefox Add-ons marketplace.
2. Spakuj swoje rozszerzenie do pliku `.zip`.
3. Prześlij plik `.zip` do Firefox Add-ons marketplace.
4. Podaj wymagane metadane, takie jak nazwa rozszerzenia, opis i zrzuty ekranu.
5. Prześlij swoje rozszerzenie do recenzji.

Najlepsze praktyki publikowania:

• Napisz jasny i zwięzły opis swojego rozszerzenia.
• Dostarcz wysokiej jakości zrzuty ekranu i filmy, aby zaprezentować funkcje swojego rozszerzenia.
• Dokładnie przetestuj swoje rozszerzenie przed przesłaniem.
• Szybko odpowiadaj na recenzje i opinie użytkowników.
• Utrzymuj swoje rozszerzenie aktualne z najnowszymi wersjami przeglądarek i poprawkami bezpieczeństwa.

Kwestie bezpieczeństwa

Bezpieczeństwo jest kluczowym aspektem tworzenia rozszerzeń przeglądarki. Rozszerzenia mogą potencjalnie uzyskiwać dostęp do wrażliwych danych użytkownika i modyfikować zawartość stron internetowych, dlatego istotne jest przestrzeganie najlepszych praktyk bezpieczeństwa w celu ochrony użytkowników przed złośliwym kodem.

Kluczowe kwestie bezpieczeństwa:

• Minimalizuj uprawnienia: Żądaj tylko tych uprawnień, których Twoje rozszerzenie faktycznie potrzebuje.
• Weryfikuj dane wejściowe użytkownika: Dezynfekuj i weryfikuj wszystkie dane wejściowe użytkownika, aby zapobiec atakom typu cross-site scripting (XSS).
• Używaj HTTPS: Zawsze używaj HTTPS do komunikacji z serwerami zdalnymi.
• Polityka Bezpieczeństwa Treści (CSP): Wprowadź ścisłą CSP, aby zapobiec wykonaniu dowolnego kodu.
• Regularnie aktualizuj swoje rozszerzenie: Utrzymuj swoje rozszerzenie aktualne z najnowszymi poprawkami bezpieczeństwa.

Przestrzegając tych wytycznych bezpieczeństwa, możesz pomóc zapewnić, że Twoje rozszerzenie przeglądarki będzie bezpieczne dla użytkowników.

Podsumowanie

Tworzenie rozszerzeń przeglądarki przy użyciu Manifest V3 i API JavaScript oferuje potężny sposób na dostosowanie doświadczeń z przeglądania i dodawanie nowych funkcji do przeglądarek internetowych. Rozumiejąc kluczowe koncepcje, API i najlepsze praktyki przedstawione w tym przewodniku, możesz tworzyć potężne i bezpieczne rozszerzenia, które zwiększają produktywność, poprawiają bezpieczeństwo i zapewniają lepsze doświadczenia z przeglądania użytkownikom na całym świecie. W miarę ewolucji sieci, rozszerzenia przeglądarek będą odgrywać coraz ważniejszą rolę w kształtowaniu przyszłości interakcji online. Wykorzystaj możliwości, jakie daje Manifest V3 i bogactwo API JavaScript do tworzenia innowacyjnych i wartościowych rozszerzeń.