diff --git a/src/background/background.js b/src/background/background.js
index 98054e48151f5a2f390eb3056285e7c8f257ee46..c384f373d90c81be8d2a5eb4e6ea27e92ace4870 100644
--- a/src/background/background.js
+++ b/src/background/background.js
@@ -96,6 +96,10 @@ async function refreshAllUI() {
 // ─────────────────────────────────────────────────────────────────────────────
 // Fonctions d'authentification & de redirection
 // ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Gère la connexion ou la déconnexion de l'utilisateur
+ * @param {Object} port - Le port de communication avec le plugin
+ */
 browser.runtime.onConnect.addListener((port) => {
   if (port.name === "auth") {
     port.onMessage.addListener(async (message) => {
@@ -348,7 +352,7 @@ browser.runtime.onMessage.addListener(async (message, sender, sendResponse) => {
           }],
         });
       } else {
-        console.warn("⚠️ Texte sélectionné vide. Annulation de la requête.");
+        console.warn("️ Texte sélectionné vide. Annulation de la requête.");
       }
       break;
     }
@@ -368,7 +372,7 @@ browser.runtime.onMessage.addListener(async (message, sender, sendResponse) => {
       if (message.token) {
         await saveToken(message.token);
       } else {
-        console.warn("⚠️ Aucune valeur de token reçue.");
+        console.warn("️ Aucune valeur de token reçue.");
       }
       break;
     }
@@ -388,7 +392,7 @@ browser.runtime.onMessage.addListener(async (message, sender, sendResponse) => {
             command: message.isActive ? "activate-highlighting" : "deactivate-highlighting",
             lexiconId: message.lexiconId
           });
-          log(`✅ Message de surlignage transmis à l'onglet ${tabs[0].id}`);
+          log(`Message de surlignage transmis à l'onglet ${tabs[0].id}`);
         } catch (error) {
           log("Erreur lors de la gestion du surlignage:", error);
         }
@@ -524,6 +528,10 @@ browser.runtime.onMessage.addListener(async (message, sender, sendResponse) => {
 // ─────────────────────────────────────────────────────────────────────────────
 // Fonction : Chargement des lexiques personnels dans le local storage
 // ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Sauvegarde les lexiques personnels dans le stockage local
+ * @returns {Promise<void>}
+ */
 async function saveUserLexicons() {
   const { accessToken } = await browser.storage.local.get("accessToken");
   if (!accessToken) {
@@ -542,11 +550,13 @@ async function saveUserLexicons() {
   
 }
 
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Envoi des données au WebWorker : lexiques personnels et token
 // ─────────────────────────────────────────────────────────────────────────────
-
+/**
+ * Envoie les lexiques et stoplists au WebWorker
+ * @param {Array} userLexicons - Les lexiques personnels
+ */
 // Charger et envoyer les lexiques au worker à la connexion + les stoplists associées 
 browser.storage.onChanged.addListener(async (changes, area) => {
   if (area === "local" && changes.accessToken) {
@@ -557,7 +567,10 @@ browser.storage.onChanged.addListener(async (changes, area) => {
   }
 });
 
-// Envoyer les lexiques et stoplists au Worker
+/**
+ * Envoie les lexiques au WebWorker
+ * @param {Array} userLexicons - Les lexiques personnels
+ */
 async function sendLexiconsToWorker(userLexicons = null) { 
   if (!userLexicons) {
     const storedData = await browser.storage.local.get("lexicons");
@@ -582,8 +595,9 @@ async function sendLexiconsToWorker(userLexicons = null) {
   }
 }
 
-
-// Charger et envoyer le token au worker à la connexion 
+/**
+ * Envoie le token d'authentification au WebWorker
+ */
 async function sendAuthTokenToWorker() {
   if (!worker) {
     console.warn("Worker non initialisé. Impossible d'envoyer le token.");
@@ -601,6 +615,10 @@ async function sendAuthTokenToWorker() {
 // ─────────────────────────────────────────────────────────────────────────────
 // Stoplists : Chargement et envoi au Worker
 // ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Charge et envoie les stoplists pour les langues spécifiées au WebWorker
+ * @param {Array} languages - Les langues pour lesquelles les stoplists doivent être chargées
+ */
 async function loadStoplistsForLanguages(languages) {
   const stoplists = {};
   // Charger toutes les stoplists en parallèle
@@ -613,7 +631,7 @@ async function loadStoplistsForLanguages(languages) {
         stoplists[lang] = text.split("\n").map(word => word.trim());
         log(`[Background] Stoplist chargée pour '${lang}' : ${stoplists[lang].length} mots`);
       } catch (error) {
-        console.warn(`[Background] ⚠ Stoplist introuvable pour '${lang}', aucun filtrage ne sera appliqué.`);
+        console.warn(`[Background] Stoplist introuvable pour '${lang}', aucun filtrage ne sera appliqué.`);
       }
     })
   );
@@ -668,7 +686,7 @@ async function checkAndUpdateTracking() {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Statistiques : Gestion des onglets
+// Statistiques
 // ─────────────────────────────────────────────────────────────────────────────
 /**
  * Envoie un message à tous les onglets.
@@ -683,9 +701,9 @@ async function notifyAllTabs(message) {
   });
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Statistiques : Écoute des modifications du stockage et mise à jour du tracking
-// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Écoute les changements dans le stockage local et met à jour le suivi des statistiques
+ */
 browser.storage.onChanged.addListener(async (changes, area) => {
   // Vérifie si les changements concernent le stockage local et les paramètres de suivi
   if (area === "local" && (changes.isTrackingActive || changes.pyodideSimplemmaReady)) {
@@ -712,7 +730,7 @@ browser.storage.onChanged.addListener(async (changes, area) => {
     });
   }
 
-  //Écoute sur le bouton d'inclusion des mots outils
+  // Écoute sur le bouton d'inclusion des mots outils
   if (area === "local" && changes.includeStopwords) {
     const includeStopwords = changes.includeStopwords.newValue;
     log(`[Background] Inclusion des mots outils activé/désactivé: ${includeStopwords}`);
@@ -723,9 +741,11 @@ browser.storage.onChanged.addListener(async (changes, area) => {
   }
 });
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Écoute de l'inscription de stats.js
-// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Écoute l'inscription de stats.js
+ * @param {Object} message - Le message reçu
+ * @param {Object} sender - L'expéditeur du message
+ */
 browser.runtime.onMessage.addListener(async (message, sender) => {
   if (message.command === "register-stats-script") {
     log("[Background] stats.js s'est enregistré.");
@@ -737,9 +757,10 @@ browser.runtime.onMessage.addListener(async (message, sender) => {
   }
 });
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Connexion entre stats.js et le Worker via un port dédié
-// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Gère la connexion entre stats.js et le Worker via un port dédié
+ * @param {Object} port - Le port de communication avec le Worker
+ */
 browser.runtime.onConnect.addListener((port) => {
   log("[Background] Connexion établie :", port.name);
   if (port.name === "stats-worker-port") {
@@ -773,7 +794,7 @@ browser.runtime.onConnect.addListener((port) => {
  * @returns {Promise<boolean>} - True si le surlignage a été effectué, false sinon.
  */
 async function handleHighlighting(command, lexiconId, tabId) {
-  log(`🎯 Gestion du surlignage: ${command} pour le lexique ${lexiconId}`);
+  log(`Gestion du surlignage: ${command} pour le lexique ${lexiconId}`);
   
   try {
       // S'assurer que le script est injecté
diff --git a/src/context_menu/browser_context_menu.js b/src/context_menu/browser_context_menu.js
index 3d1d36180bcc146cd286ec3786c2cc3d23abde4a..8b56032c714da72fecf187a61463b69725d9c421 100644
--- a/src/context_menu/browser_context_menu.js
+++ b/src/context_menu/browser_context_menu.js
@@ -68,7 +68,7 @@ async function createContextMenu() {
       contexts: ["all"],
     });
   } else {
-    log("⚠️ L'extension est désactivée, aucune option d'analyse ne sera affichée.");
+    log("️ L'extension est désactivée, aucune option d'analyse ne sera affichée.");
   }
 
   // Création de l'élément de menu pour la connexion/déconnexion
@@ -79,7 +79,6 @@ async function createContextMenu() {
   });
 }
 
-
 // Chargement du token et création du menu contextuel
 loadAuthToken().then(createContextMenu);
 
@@ -201,12 +200,12 @@ browser.contextMenus.onClicked.addListener(async (info, tab) => {
   }
 
   const selectedText = info.selectionText.trim();
-  log(`📩 Texte sélectionné : ${selectedText}`);
+  log(`Texte sélectionné : ${selectedText}`);
 
   // Item "Ajouter ce mot à mes lexiques"
   if (info.menuItemId === "addToLexicon") {
     if (!authToken) {
-      alert("⚠️ Vous devez être connecté pour ajouter un mot à un lexique.");
+      alert("️ Vous devez être connecté pour ajouter un mot à un lexique.");
       return;
     }
     browser.runtime.sendMessage({
@@ -229,12 +228,12 @@ browser.contextMenus.onClicked.addListener(async (info, tab) => {
   switch (info.menuItemId) {
     case "searchInLexicons":
       if (!authToken) {
-        alert("⚠️ Vous devez être connecté pour utiliser cette fonction.");
+        alert("️ Vous devez être connecté pour utiliser cette fonction.");
         return;
       }
       await searchInLexicons(selectedText);
       break;
   }
   
-  log(`❌ Action inconnue : ${info.menuItemId}`);
+  log(`Action inconnue : ${info.menuItemId}`);
 });
diff --git a/src/context_menu/custom_context_menu.js b/src/context_menu/custom_context_menu.js
index 50d28753ba96da1c7e8cb2cf584991c4dad10a2d..759d1d82c8fd5670c2d9fae8f6a46f8b153d90d6 100644
--- a/src/context_menu/custom_context_menu.js
+++ b/src/context_menu/custom_context_menu.js
@@ -166,7 +166,7 @@ function updateMenuVisibility() {
   const loginBtn = document.getElementById("loginButton");
 
   if (!addLexiconBtn || !getDefinitionBtn || !loginBtn) {
-    console.warn("⚠️ Un des boutons n'a pas été trouvé dans le DOM.");
+    console.warn("️ Un des boutons n'a pas été trouvé dans le DOM.");
     return;
   }
 
@@ -285,15 +285,15 @@ async function showPicker(event, selectedText) {
 
         iconContainer.addEventListener("click", () => {
           if (selectedLexicons.has(id)) {
-            selectedLexicons.delete(id); // Supprime l'ID si déjà sélectionné
-            iconContainer.classList.remove("selected"); // Retire la classe sélectionnée
+            selectedLexicons.delete(id); 
+            iconContainer.classList.remove("selected"); 
           } else {
-            selectedLexicons.add(id); // Ajoute l'ID si non sélectionné
-            iconContainer.classList.add("selected"); // Ajoute la classe sélectionnée
+            selectedLexicons.add(id); 
+            iconContainer.classList.add("selected"); 
           }
         });
-        iconContainer.appendChild(circleIcon); // Ajoute l'icône au conteneur
-        picker.appendChild(iconContainer); // Ajoute le conteneur au sélecteur
+        iconContainer.appendChild(circleIcon); 
+        picker.appendChild(iconContainer); 
       }
 
       // Crée le bouton de confirmation pour ajouter le mot
@@ -305,18 +305,18 @@ async function showPicker(event, selectedText) {
           alert("Veuillez sélectionner au moins un lexique.");
           return;
         }
-        log(`🔍 Vérification si le mot "${selectedText}" existe déjà dans les lexiques sélectionnés...`);
+        log(`Vérification si le mot "${selectedText}" existe déjà dans les lexiques sélectionnés...`);
         let definitions = [];
         try {
-          definitions = await fetchLexiconDefinitions(selectedText); // Récupère les définitions du mot
+          definitions = await fetchLexiconDefinitions(selectedText); 
         } catch (error) {
           log("Erreur lors de la récupération des définitions :", error);
         }
-        const existingLexiconIds = new Set(); // Ensemble pour stocker les IDs des lexiques existants
+        const existingLexiconIds = new Set(); 
         if (Array.isArray(definitions)) {
           for (const def of definitions) {
             if (selectedLexicons.has(def.lexiconId)) {
-              existingLexiconIds.add(def.lexiconId); // Ajoute l'ID si le mot existe déjà
+              existingLexiconIds.add(def.lexiconId); 
             }
           }
         }
@@ -326,15 +326,15 @@ async function showPicker(event, selectedText) {
         }
         const lexiconsToAdd = [...selectedLexicons].filter(id => !existingLexiconIds.has(id)); // Filtre les lexiques à ajouter
         if (lexiconsToAdd.length === 0) {
-          return; // Sort si aucun lexique à ajouter
+          return; 
         }
         try {
-          log(`📡 Ajout du mot "${selectedText}" dans les lexiques :`, lexiconsToAdd);
-          const result = await AddWord(authToken, selectedText, lexiconsToAdd, false); // Ajoute le mot aux lexiques
+          log(`Ajout du mot "${selectedText}" dans les lexiques :`, lexiconsToAdd);
+          const result = await AddWord(authToken, selectedText, lexiconsToAdd, false); 
           log("Réponse API :", result);
-          await new Promise(resolve => setTimeout(resolve, 300)); // Attente pour la réponse
+          await new Promise(resolve => setTimeout(resolve, 300));
           browser.runtime.sendMessage({ action: "refreshUI" }); // Rafraîchit l'interface utilisateur
-          const successMsg = `✅ Mot ajouté avec succès dans : ${lexiconsToAdd.map(id => lexiconDescriptions[id]).join(", ")}`; // Message de succès
+          const successMsg = `Mot ajouté avec succès dans : ${lexiconsToAdd.map(id => lexiconDescriptions[id]).join(", ")}`; // Message de succès
           picker.innerHTML = `<p style="color: green;">${successMsg}</p>`;
           setTimeout(() => picker.style.display = "none", 2000);
           browser.runtime.sendMessage({
@@ -343,7 +343,7 @@ async function showPicker(event, selectedText) {
           });
         } catch (error) {
           log("Erreur lors de l'ajout du mot :", error);
-          const errorMsg = `❌ Erreur lors de l'ajout du mot : ${error.message}`;
+          const errorMsg = `Erreur lors de l'ajout du mot : ${error.message}`;
           picker.innerHTML = `<p style="color: red;">${errorMsg}</p>`;
           setTimeout(() => picker.style.display = "none", 3000);
           browser.runtime.sendMessage({
diff --git a/src/plugin/displayStats.js b/src/plugin/displayStats.js
index cc949856424e2b7c38170150ab2076b9428d1749..0888207dafb2bfba8fc86bfe70017dc8ca06c998 100644
--- a/src/plugin/displayStats.js
+++ b/src/plugin/displayStats.js
@@ -1,6 +1,10 @@
-// stats.js
+log("displayStats.js chargé");
+
 document.addEventListener("DOMContentLoaded", async () => {
-  // Fonction pour recalculer et stocker le résumé des statistiques
+  /**
+   * Met à jour le résumé des statistiques
+   * @returns {Promise<Object>} - Un objet contenant les statistiques
+   */
   async function updateStatsSummary() {
     console.log("[Stats Page] Mise à jour du résumé des statistiques...");
     
@@ -43,7 +47,11 @@ document.addEventListener("DOMContentLoaded", async () => {
     return { summary, lemmaFrequencies, trackedLanguages };
   }
   
-  // Générer le HTML du résumé global
+  /**
+   * Génère le HTML du résumé global
+   * @param {Object} summary - Les statistiques
+   * @returns {string} - Le HTML du résumé
+   */
   function generateSummaryHTML(summary) {
     if (summary.totalWords === 0) {
       return `<h2>Résumé des statistiques</h2>
@@ -57,7 +65,11 @@ document.addEventListener("DOMContentLoaded", async () => {
     `;
   }
   
-  // Générer le contrôle de tri (placé juste au-dessus des tableaux)
+  /**
+   * Génère le HTML du contrôle de tri
+   * @param {string} currentSortOrder - L'ordre de tri actuel
+   * @returns {string} - Le HTML du contrôle de tri
+   */
   function generateSortControlHTML(currentSortOrder) {
     return `
       <div id="sort-container">
@@ -70,7 +82,13 @@ document.addEventListener("DOMContentLoaded", async () => {
     `;
   }
   
-  // Générer le HTML détaillé pour chaque langue avec le total par langue
+  /**
+   * Génère le HTML détaillé pour chaque langue avec le total par langue
+   * @param {Object} lemmaFrequencies - Les fréquences des mots
+   * @param {Array} trackedLanguages - Les langues suivies
+   * @param {string} sortOrder - L'ordre de tri
+   * @returns {string} - Le HTML détaillé
+   */
   function generateDetailedFrequenciesHTML(lemmaFrequencies, trackedLanguages, sortOrder) {
     let detailsHTML = `<div id="detailed-frequencies">`;
     let hasData = false;
@@ -100,13 +118,6 @@ document.addEventListener("DOMContentLoaded", async () => {
                               <td>${freq}</td>
                             </tr>`;
           }
-          // // Ligne de récapitulation pour le total de mots de la langue
-          // detailsHTML += `<tr>
-          //                   <td colspan="2" style="text-align:right; font-weight:bold;">
-          //                     AJOUT: Total 
-          //                     : ${totalForLang}
-          //                   </td>
-          //                 </tr>`;
           detailsHTML += `</table>
                           </div>`;
         }
diff --git a/src/plugin/plugin.js b/src/plugin/plugin.js
index 2a675f20ab1de1381de697f481b609f7efe8e775..520d123418cca60e4cf183b633bed6b877c69eab 100644
--- a/src/plugin/plugin.js
+++ b/src/plugin/plugin.js
@@ -1,7 +1,5 @@
 log("plugin.js chargé.");
-// ─────────────────────────────────────────────────────────────────────────────
-// ▌ Fonctions utilitaires
-// ─────────────────────────────────────────────────────────────────────────────  
+
 /**
  * Récupère le token d'accès depuis le stockage local.
  * @returns {Promise<string>} Le token d'accès.
@@ -11,15 +9,18 @@ async function getAccessToken() {
   return accessToken;
 }
 
-// =========
-// Fonction d'actualisation générale de la popup : 1. Récupération des valeurs 2. Màj UI
+/**
+ * Actualise l'extension en fonction des valeurs du local storage
+ */
 async function updateExtension() {
-  states = await fetchExtensionState(); //Récupérer les valeurs 
-  updateUI(states); // Selon les valeurs, mettre à jour l'UI
+  states = await fetchExtensionState();  
+  updateUI(states); 
 }
 
-// =========
-// 1. Récupérer les valeurs du local storage
+/**
+ * Récupère les valeurs du local storage
+ * @returns {Promise<Object>} - Un objet contenant les valeurs
+ */
 async function fetchExtensionState() {
   const accessToken = await getAccessToken();
   const storedValues = await browser.storage.local.get([
@@ -41,25 +42,21 @@ async function fetchExtensionState() {
   };
 }
 
-// =========
-// 2.Fonction de mise à jour de l'UI
+/**
+ * Met à jour l'interface utilisateur en fonction des états
+ * @param {Object} states - Les états de l'extension
+ */
 async function updateUI(states) {
   await updateConnectionButton(states.isLoggedIn); //Actualisation du bouton de connexion
   await updateToggleExtensionButton(states.isLoggedIn, states.extensionActive, states.autoAdd, states.isTrackingActive,  states.pyodideSimplemmaReady,  states.includeStopwords);
-  // éventuellement ajouter des fonctions issues du toggleExtensionButton pour la lisibilité :
-  //await updateStatsButtons(states.isLoggedIn, states.extensionActive, states.isTrackingActive);
-  // await updateAutoAddOptions(states.isLoggedIn, states.extensionActive, states.autoAdd);
-  // await updatePyodideStatus(states.isLoggedIn, states.extensionActive, states.isTrackingActive, state.pyodideSimplemmaReady);
   await updateLanguageSelection();
   await updateStopwordsOption(states.includeStopwords);
-  console.log("✅ Interface mise à jour :", states);
+  console.log("Interface mise à jour :", states);
 }
 
-
-
-// ====================================================================================
-// Fonction contenant les écouteurs d'évènements et gestion des valeurs du local storage
-// ====================================================================================
+/**
+ * Configure les écouteurs d'évènements
+ */
 function setupEventListeners() {
   // Bouton Connexion / Déconnexion
   document.getElementById("auth-button")?.addEventListener("click", handleAuthToggle);
@@ -86,17 +83,16 @@ function setupEventListeners() {
   });
 }
 
-// ===========
-//Description de chaque évènement
-
-//Connexion / Déconnexion
+/**
+ * Gestion de la connexion / déconnexion
+ */
 async function handleAuthToggle() {
   const accessToken = await getAccessToken();
   if (!accessToken) {
-    console.log("🔓 Connexion demandée...");
+    console.log("Connexion demandée...");
     await browser.runtime.sendMessage({ action: "toggleAuth" });
   } else {
-    console.log("🔒 Déconnexion demandée...");
+    console.log("Déconnexion demandée...");
     await browser.storage.local.set({
       accessToken: null,
       autoAdd: false,
@@ -109,12 +105,14 @@ async function handleAuthToggle() {
       includeStopwords: false,
       isTrackingActive: false
     });
-    console.log("✅ Paramètres réinitialisés après déconnexion.");
+    console.log("Paramètres réinitialisés après déconnexion.");
   }
   await updateExtension();
 }
 
-//Statistiques
+/**
+ * Gestion du bouton des statistiques
+ */
 async function handleStatsToggle() {
   const accessToken = await getAccessToken();
   if (!accessToken) return;
@@ -123,7 +121,7 @@ async function handleStatsToggle() {
   const newState = !isTrackingActive;
   // Mise à jour uniquement de `isTrackingActive`
   await browser.storage.local.set({ isTrackingActive: newState });
-  console.log("📊 Nouvel état des statistiques :", newState);
+  console.log("Nouvel état des statistiques :", newState);
   // Envoi du message de mise à jour
   browser.runtime.sendMessage({ command: "toggle-stats", isActive: newState });
   // Ouvrir la page des statistiques si désactivé
@@ -134,15 +132,11 @@ async function handleStatsToggle() {
   if (newState) {
     browser.runtime.sendMessage({ command: "pyodide-simplemma" });
   }
-
-//   if (isUpdatingLexicons) return; 
-//   isUpdatingLexicons = true;
-//   await updateLexiconsDisplay(); 
-//   isUpdatingLexicons = false;
-//   await updateExtension();
 }
 
-// Activer l'extension
+/**
+ * Gestion du bouton d'activation de l'extension
+ */
 async function handleToggleExtension() {
   const accessToken = await getAccessToken();
   if (!accessToken) return;
@@ -161,12 +155,13 @@ async function handleToggleExtension() {
   browser.runtime.sendMessage({ action: "toggleExtension", isActive: newState });
   await updateExtension();
   
-  // Fermer tous les blocs de la barre latérale
   browser.runtime.sendMessage({ action: "closeAllBlocks" });
 }
 
 
-//Ajout automatique
+/**
+ * Gestion du bouton d'ajout automatique
+ */
 function handleAutoAddToggle() {
   const autoAddCheckbox = document.getElementById("auto-add");
   const autoAddOptions = document.getElementById("auto-add-options");
@@ -188,8 +183,9 @@ function handleAutoAddToggle() {
   }
 }
 
-
-// Gestion de l'activation/désactivation des stopwords
+/**
+ * Gestion de l'activation/désactivation des stopwords
+ */
 function handleStopwordsToggle() {
   const stopwordsCheckbox = document.getElementById("include-stopwords");
   if (!stopwordsCheckbox) return;
@@ -202,8 +198,9 @@ function handleStopwordsToggle() {
 }
 
 
-
-// Sauvegarde des options utilisateur
+/**
+ * Sauvegarde des options utilisateur
+ */
 async function handleSaveOptions() {
   const autoAddCheckbox = document.getElementById("auto-add");
   const stopwordsCheckbox = document.getElementById("include-stopwords");
@@ -234,23 +231,18 @@ async function handleSaveOptions() {
   });
 
   await updateExtension();
-  console.log("✅ Options sauvegardées.");
+  console.log("Options sauvegardées.");
 }
 
 
-//Ouverture de la page des statistiques
-
-// ====================================================================================
-// Fonction actualisation UI des boutons
-// ====================================================================================
-
-// Gestion de la connexion
+/**
+ * Met à jour le bouton de connexion
+ */
 async function updateConnectionButton() {
   const accessToken = await getAccessToken();
-  //Vérification du bouton de connexion
   const button = document.getElementById("auth-button");
   if (!button) {
-    console.error("❌ Le bouton de connexion n'a pas été trouvé.");
+    console.error("Le bouton de connexion n'a pas été trouvé.");
     return;
   }
   if (accessToken) {
@@ -278,9 +270,6 @@ async function updateConnectionButton() {
   };
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// ▌ Gestion de la sélection des langues
-// ─────────────────────────────────────────────────────────────────────────────
 /**
  * Met à jour la sélection des langues.
  */
@@ -334,8 +323,9 @@ async function updateLanguageSelection() {
   log("Sélection des langues mise à jour avec :", userLanguages);
 }
 
-// =========
-// Gestion bouton d'activation de l'extension
+/**
+ * Met à jour le bouton d'activation de l'extension
+ */
 async function updateToggleExtensionButton(isLoggedIn, extensionActive, autoAdd, isTrackingActive, pyodideSimplemmaReady, includeStopwords) {
   const toggleExtensionBtn = document.getElementById("toggleExtensionBtn");
 
@@ -457,7 +447,9 @@ async function updateToggleExtensionButton(isLoggedIn, extensionActive, autoAdd,
   });
 }
 
-//Activer/désactiver les stoplists
+/**
+ * Met à jour l'option des stopwords
+ */
 async function updateStopwordsOption(includeStopwords) {
   const stopwordsCheckbox = document.getElementById("include-stopwords");
   if (stopwordsCheckbox) {
@@ -465,27 +457,19 @@ async function updateStopwordsOption(includeStopwords) {
   }
 }
 
-
-
-// ✅ Actualisation de l'UI au chargement de la page
+/**
+ * Mise à jour de l'extension au chargement de la page
+ */
 document.addEventListener("DOMContentLoaded", async () => {
   await updateExtension(); // Mise à jour de l'extension selon les valeurs du local storage
   setupEventListeners(); // Configuration des écouteurs d'événements
 });
 
-// !! boucle infinie ???
-// // Actualisation de l'UI en cas de changement dans le stockage local : ça c'est dans background qu'il faut le mettre xd
-// browser.storage.onChanged.addListener((changes, area) => {
-//   if (area === "local" && changes.accessToken) {
-//     updateExtension();
-//   }
-// });
-
-// ==========================
-// Gestion des messages et du stockage
-// ==========================
+/**
+ * Gère les messages reçus du worker.
+ */
 browser.runtime.onMessage.addListener(async (message) => {
-  log("📩 Message reçu dans popup.js :", message);
+  log("Message reçu dans popup.js :", message);
   if (message.action === "updateUI") {
     await updateExtension();
   } else if (message.action === "notify") {
@@ -534,11 +518,9 @@ function handleWorkerMessage(event) {
   }}
 
 
-// ==========================
-// Affichage des statistiques
-// ==========================
-
-// Bouton pour ouvrir la page des statistiques
+/**
+ * Ouvre la page des statistiques
+ */
 document.getElementById("open-stats")?.addEventListener("click", async () => {
   openStatsPage();
 });
diff --git a/src/sidebar/sidebar.js b/src/sidebar/sidebar.js
index d0e02aa04bcb7c7dae58a2106609e9f461f8cb3d..a2115f76fda74efd7d45b3588d2c4fd4d9903654 100644
--- a/src/sidebar/sidebar.js
+++ b/src/sidebar/sidebar.js
@@ -17,12 +17,12 @@ async function getAuthTokenFromStorage() {
   try {
     const { accessToken } = await browser.storage.local.get("accessToken");
     if (accessToken) {
-      log(`🔑 Token récupéré depuis le stockage local : [${accessToken}]`);
+      log(`Token récupéré depuis le stockage local : [${accessToken}]`);
       authToken = accessToken;
       window.authToken = accessToken; 
       return authToken;
     }
-    log("⚠️ Aucun token trouvé dans le stockage local.");
+    log("️ Aucun token trouvé dans le stockage local.");
   } catch (error) {
     log("Erreur lors de la récupération du token :", error);
   }
@@ -65,7 +65,7 @@ function updateAuthButton(isLoggedIn) {
     authButton.textContent = isLoggedIn ? "Se déconnecter" : "Se connecter";
     log("Bouton d'authentification mis à jour :", authButton.textContent);
   } else {
-    console.warn("⚠️ Bouton d'authentification (#auth-button) introuvable.");
+    console.warn("️ Bouton d'authentification (#auth-button) introuvable.");
   }
 }
 
@@ -84,9 +84,9 @@ function toggleElementsVisibility(isLoggedIn) {
     const element = document.getElementById(id);
     if (element) {
       element.style.display = shouldShow ? "block" : "none";
-      log(`🔄 Élément #${id} ${shouldShow ? "affiché" : "masqué"}.`);
+      log(`Élément #${id} ${shouldShow ? "affiché" : "masqué"}.`);
     } else {
-      console.warn(`⚠️ Élément #${id} introuvable.`);
+      console.warn(`️ Élément #${id} introuvable.`);
     }
   });
 }
@@ -268,7 +268,7 @@ async function fetchLexicons() {
 
     // Vérifie si le token d'authentification est disponible
     if (!authToken) {
-      throw new Error("⚠️ Aucun token disponible. Veuillez vous connecter.");
+      throw new Error("️ Aucun token disponible. Veuillez vous connecter.");
     }
 
     // Récupère les lexiques depuis l'API
@@ -277,7 +277,7 @@ async function fetchLexicons() {
 
     // Vérifie si la réponse est un tableau et s'il contient des lexiques
     if (!Array.isArray(lexicons) || lexicons.length === 0) {
-      throw new Error("⚠️ Aucun lexique trouvé.");
+      throw new Error("️ Aucun lexique trouvé.");
     }
 
     // Vide la carte des lexiques existants
@@ -338,7 +338,7 @@ async function displayLexiconsWithCheckbox(lexicons) {
   const lexiquesContainer = document.getElementById("lexiques");
   // Vérifie si le conteneur des lexiques existe
   if (!lexiquesContainer) {
-    console.warn("⚠️ Élément #lexiques introuvable.");
+    console.warn("️ Élément #lexiques introuvable.");
     return;
   }
   
@@ -347,7 +347,7 @@ async function displayLexiconsWithCheckbox(lexicons) {
   
   // Vérifie si la liste des lexiques est vide
   if (lexicons.length === 0) {
-    log("⚠️ Aucun lexique à afficher.");
+    log("️ Aucun lexique à afficher.");
     lexiquesContainer.textContent = "Aucun lexique disponible.";
     return;
   }
@@ -466,7 +466,7 @@ async function displayLexiconsWithCheckbox(lexicons) {
 async function updateLexiconsDisplay() {
   const token = await getAuthTokenFromStorage(); 
   if (!token) {
-    console.warn("⚠️ Aucun token d'authentification disponible.");
+    console.warn("️ Aucun token d'authentification disponible.");
     return;
   }
 
@@ -540,9 +540,9 @@ async function toggleLexiconHighlight(lexiconId, isActive) {
       });
     });
 
-    log(`✅ Surlignage ${isActive ? 'activé' : 'désactivé'} pour le lexique ${lexiconId}`);
+    log(`Surlignage ${isActive ? 'activé' : 'désactivé'} pour le lexique ${lexiconId}`);
   } catch (error) {
-    log(`❌ Erreur lors du toggle du surlignage pour le lexique ${lexiconId}:`, error);
+    log(`Erreur lors du toggle du surlignage pour le lexique ${lexiconId}:`, error);
   }
 }
 
@@ -558,7 +558,7 @@ async function handleAddWordClick() {
   
   // 1) Vérifier la présence du token et du mot
   if (!authToken) {
-    console.warn("⚠️ Pas de token d'authentification : impossible d'ajouter le mot.");
+    console.warn("️ Pas de token d'authentification : impossible d'ajouter le mot.");
     return;
   }
 
@@ -567,14 +567,14 @@ async function handleAddWordClick() {
 
   // Vérifie si l'élément contenant le mot sélectionné existe
   if (!selectedWordElement) {
-    console.warn("⚠️ Élément #motSelectionne introuvable.");
+    console.warn("️ Élément #motSelectionne introuvable.");
     return;
   }
   
   // Récupère le mot sélectionné et le "nettoie"
   const selectedWord = selectedWordElement.textContent.trim();
   if (!selectedWord || selectedWord === "Aucun mot sélectionné") {
-    console.warn("⚠️ Aucun mot à ajouter.");
+    console.warn("️ Aucun mot à ajouter.");
     if (lexiconResultElement) lexiconResultElement.textContent = "Aucun mot à ajouter.";
     return;
   }
@@ -585,7 +585,7 @@ async function handleAddWordClick() {
 
   // Vérifie si au moins un lexique a été sélectionné
   if (selectedLexiconIds.length === 0) {
-    console.warn("⚠️ Aucun lexique sélectionné.");
+    console.warn("️ Aucun lexique sélectionné.");
     if (lexiconResultElement) lexiconResultElement.textContent = "Veuillez cocher au moins un lexique.";
     return;
   }
@@ -635,7 +635,7 @@ async function handleAddWordClick() {
 
   // 5) Envoi d'une seule requête pour tous les lexiques restants
   try {
-    log(`📡 Envoi de l'ajout du mot "${selectedWord}" dans les lexiques :`, lexiconsToAdd);
+    log(`Envoi de l'ajout du mot "${selectedWord}" dans les lexiques :`, lexiconsToAdd);
     const result = await window.AddWord(authToken, selectedWord, lexiconsToAdd, false);
     
     log("Réponse API :", result);
@@ -682,12 +682,12 @@ browser.runtime.onMessage.addListener(async (message) => {
       case "mot_selectionne":
         // Gère le mot sélectionné
         if (message.selectedText) {
-          log("🖋️ Mot sélectionné :", message.selectedText);
+          log("️ Mot sélectionné :", message.selectedText);
           const selectedWordElement = document.getElementById("motSelectionne");
           if (selectedWordElement) {
             selectedWordElement.textContent = message.selectedText;
           } else {
-            console.warn("⚠️ Élément #motSelectionne introuvable.");
+            console.warn("️ Élément #motSelectionne introuvable.");
           }
           const lexiconResultElement = document.getElementById("lexiconResult");
           if (lexiconResultElement) {
@@ -716,7 +716,7 @@ browser.runtime.onMessage.addListener(async (message) => {
       case "fetchWiktionaryDefinitionResponse":
         // Gère la réponse de définition du Wiktionnaire
         if (message.selectedText) {
-          log(`📖 Réception de la définition du Wiktionnaire pour '${message.selectedText}'`);
+          log(`Réception de la définition du Wiktionnaire pour '${message.selectedText}'`);
           window.displayDefinitions(message.definitions);
         }
         break;
@@ -817,7 +817,7 @@ browser.runtime.onMessage.addListener(async (message) => {
 
       default:
         // Gère les actions inconnues
-        console.warn("⚠️ Action inconnue reçue :", message.command);
+        console.warn("️ Action inconnue reçue :", message.command);
     }
   }
 });
@@ -848,10 +848,10 @@ document.addEventListener("DOMContentLoaded", async () => {
       openBlock("definitionContent");
       const selectedWord = document.getElementById("motSelectionne")?.textContent?.trim();
       if (selectedWord && selectedWord !== "Aucun mot sélectionné") {
-        log(`📩 Recherche des définitions pour '${selectedWord}'`);
+        log(`Recherche des définitions pour '${selectedWord}'`);
         await window.showDefinitions(selectedWord);
       } else {
-        console.warn("⚠️ Aucun mot sélectionné pour la recherche.");
+        console.warn("️ Aucun mot sélectionné pour la recherche.");
       }
     });
     log("Bouton #chercherDef détecté dans le DOM.");
@@ -884,7 +884,7 @@ document.addEventListener("DOMContentLoaded", async () => {
   if (addWordButton) {
     addWordButton.addEventListener("click", handleAddWordClick);
   } else {
-    console.warn("⚠️ Bouton #add-word-button introuvable dans le DOM.");
+    console.warn("️ Bouton #add-word-button introuvable dans le DOM.");
   }
 
   // Gère les boutons de bascule pour afficher/masquer les blocs
diff --git a/src/utils/api.js b/src/utils/api.js
index bf833a23530ef542724ba837c32b667943f39916..4f0ca2a51fcea0512d9fb0134f3ce98516ae7d54 100644
--- a/src/utils/api.js
+++ b/src/utils/api.js
@@ -46,12 +46,12 @@ async function callApi(url, authToken = null, method = 'GET', data = null) {
     const response = await fetch(url, fetchOptions);
     // Vérifier si la réponse est correcte
     if (!response.ok) {
-      throw new Error(`❌ Erreur API (${response.status}): ${response.statusText}`);
+      throw new Error(`Erreur API (${response.status}): ${response.statusText}`);
     }
     // Retourner la réponse en JSON
     return await response.json();
   } catch (error) {
-    log(`🚨 Erreur lors de l'appel API [${url}]:`, error);
+    log(`Erreur lors de l'appel API [${url}]:`, error);
     throw error;
   }
 }
@@ -99,7 +99,7 @@ async function getAllLexiconWords(authToken) {
 
         // Vérification si la liste des lexiques est valide
         if (!Array.isArray(lexicons) || lexicons.length === 0) {
-          console.warn("⚠️ Aucun lexique retourné par l'API pour ces paramètres.");
+          console.warn("️ Aucun lexique retourné par l'API pour ces paramètres.");
           return {};
         }
     
@@ -111,7 +111,7 @@ async function getAllLexiconWords(authToken) {
           const entries = await getLexiconEntries(authToken, lexicon.id);
           // Vérification que entries est bien un tableau
           if (!Array.isArray(entries)) {
-            console.warn(`⚠️ Format invalide pour les entrées du lexique ${lexicon.id}:`, entries);
+            console.warn(`️ Format invalide pour les entrées du lexique ${lexicon.id}:`, entries);
             continue;
           }
           // Extraction des graphies des entrées
@@ -161,7 +161,7 @@ async function getWiktionaryDefinition(word) {
     // Extraction de la définition ou message par défaut si aucune définition n'est trouvée
     const definition = page?.extract?.trim() || "Aucune définition trouvée.";
 
-    log(`📖 Définition trouvée pour '${word}':`, definition);
+    log(`Définition trouvée pour '${word}':`, definition);
     return [definition]; // Retourner la définition sous forme de tableau
   } catch (error) {
     log("Erreur lors de la récupération du Wiktionnaire :", error);
diff --git a/src/utils/definitions.js b/src/utils/definitions.js
index d8ff193d60da2a0cbceb271731b6b58b08dfd646..1a00a3a63f5cc23f55250810369173320555d4b3 100644
--- a/src/utils/definitions.js
+++ b/src/utils/definitions.js
@@ -11,7 +11,7 @@ window.lexiconMap = new Map();
  */
 async function fetchLexiconDefinitions(word) {
   try {
-    log(`🔍 Recherche des définitions de '${word}' dans les lexiques de l'utilisateur...`);
+    log(`Recherche des définitions de '${word}' dans les lexiques de l'utilisateur...`);
 
     if (!authToken) {
       console.warn("Aucun token disponible, impossible de requêter l'API protégée.");
@@ -24,13 +24,13 @@ async function fetchLexiconDefinitions(word) {
       headers: { Authorization: `Bearer ${authToken}` }
     });
     if (!lexResponse.ok) {
-      throw new Error(`❌ Erreur API lors de la récupération des lexiques: ${lexResponse.statusText}`);
+      throw new Error(`Erreur API lors de la récupération des lexiques: ${lexResponse.statusText}`);
     }
     const userLexicons = await lexResponse.json();
     log("Lexiques de l'utilisateur :", userLexicons);
 
     if (!Array.isArray(userLexicons) || userLexicons.length === 0) {
-      console.warn("⚠️ Aucun lexique trouvé pour cet utilisateur.");
+      console.warn("️ Aucun lexique trouvé pour cet utilisateur.");
       return [];
     }
 
@@ -48,13 +48,13 @@ async function fetchLexiconDefinitions(word) {
     // 2) Pour chaque lexique, rechercher le mot en ajoutant target_lex
     const definitionsPromises = userLexicons.map(async (lex) => {
       const searchUrl = `https://babalex.lezinter.net/api/entry/search?graphy=${encodeURIComponent(word)}&language=fr&target_lex=${lex.id}`;
-      log(`🔎 Appel API pour le lexique ${lex.id} avec l'URL : ${searchUrl}`);
+      log(`Appel API pour le lexique ${lex.id} avec l'URL : ${searchUrl}`);
 
       const searchResponse = await fetch(searchUrl, {
         headers: { Authorization: `Bearer ${authToken}` }
       });
       if (!searchResponse.ok) {
-        console.warn(`⚠️ Erreur pour le lexique ${lex.id} : ${searchResponse.statusText}`);
+        console.warn(`️ Erreur pour le lexique ${lex.id} : ${searchResponse.statusText}`);
         return { lexiconId: lex.id, entries: [] };
       }
       const entries = await searchResponse.json();
@@ -121,7 +121,7 @@ async function fetchLexiconDefinitions(word) {
     log("Résultats filtré depuis les lexiques utilisateurs :", allDefinitions);
         return allDefinitions;
       } catch (error) {
-        log("❌ Erreur générale lors de la récupération des définitions :", error);
+        log("Erreur générale lors de la récupération des définitions :", error);
         return [];
       }
     }
@@ -135,7 +135,7 @@ async function fetchWiktionaryDefinition(word) {
     const result = await browser.storage.local.get("accessToken");
     authToken = result.accessToken;
 
-    // 🔹 Initialisation d'une structure vide pour éviter les erreurs
+    // Initialisation d'une structure vide pour éviter les erreurs
     let formattedData = {
       definitions: [],
       pronunciations: [],
@@ -143,15 +143,15 @@ async function fetchWiktionaryDefinition(word) {
     };
 
     if (!authToken) {
-      log(`🔍 Requête Wiktionnaire pour "${word}"...`);
+      log(`Requête Wiktionnaire pour "${word}"...`);
       if (!word || word.trim() === "") {
-        throw new Error("⚠️ Mot vide, impossible d'envoyer la requête.");
+        throw new Error("️ Mot vide, impossible d'envoyer la requête.");
       }
       
       const wiktionaryURL = `https://fr.wiktionary.org/w/api.php?action=query&format=json&origin=*&prop=extracts&explaintext=true&redirects=1&titles=${encodeURIComponent(word)}`;
       const response = await fetch(wiktionaryURL);
       if (!response.ok) {
-        throw new Error(`❌ Erreur API Wiktionnaire: ${response.statusText}`);
+        throw new Error(`Erreur API Wiktionnaire: ${response.statusText}`);
       }
       const data = await response.json();
       log("Réponse API (Wiktionnaire) :", data);
@@ -185,7 +185,7 @@ async function fetchWiktionaryDefinition(word) {
         return [];  // Retourne un tableau vide si aucune définition
       }
 
-      // 🛠 Formatage des données récupérées
+      // Formatage des données récupérées
       formattedData = formatDefinitionData(apiResponse);
       log(" Données formatées :", formattedData);
 
@@ -210,7 +210,7 @@ async function fetchWiktionaryDefinition(word) {
       ];
     }
   } catch (error) {
-    log("❌ Erreur lors de la récupération de la définition :", error);
+    log("Erreur lors de la récupération de la définition :", error);
     return [{ 
       source: "Wiktionnaire", 
       text: "Erreur lors de la récupération sur le Wiktionnaire.", 
@@ -220,8 +220,11 @@ async function fetchWiktionaryDefinition(word) {
   }
 }
 
-
-
+/**
+ * Récupère la réponse de l'API Wiktionnaire pour un mot donné.
+ * @param {string} word - Le mot à rechercher.
+ * @returns {Promise<object>} - La réponse de l'API.
+ */
 async function wikiApiResponse(word) {
   const result = await browser.storage.local.get("accessToken");
   authToken = result.accessToken;
@@ -251,6 +254,11 @@ async function wikiApiResponse(word) {
   }
 }
 
+/**
+ * Formate les données de la réponse de l'API Wiktionnaire.
+ * @param {object} apiResponse - La réponse de l'API.
+ * @returns {object} - Les données formatées.
+ */
 function formatDefinitionData(apiResponse) {
   let formattedData = {
       word: apiResponse[0]?.id.split("-").slice(2).join("-") || "",
@@ -316,9 +324,6 @@ function formatDefinitionData(apiResponse) {
   return formattedData;
 }
 
-
-
-
 // ─────────────────────────────────────────────────────────────────────────────
 // ▌ Affichage des définitions dans la barre latérale
 // ─────────────────────────────────────────────────────────────────────────────
@@ -491,44 +496,35 @@ function displayDefinitions(definitions) {
     const lexiconContainer = document.createElement("div");
     lexiconContainer.className = "lexicon-section";
   
-    // Création d'un conteneur pour l'en-tête et l'icône (l'icône est en dehors de l'en-tête)
     const headerContainer = document.createElement("div");
     headerContainer.className = "header-container";
-    headerContainer.style.position = "relative"; // Pour positionner l'icône absolument
+    headerContainer.style.position = "relative"; 
     headerContainer.style.cursor = "pointer";
   
-    // Création de l'en-tête qui contiendra le titre seul
     const lexiconHeader = document.createElement("div");
     lexiconHeader.className = "lexicon-header";
     
-    // Ajout du titre
     const titleSpan = document.createElement("span");
     titleSpan.textContent = lexiconName;
     lexiconHeader.appendChild(titleSpan);
   
-    // Ajout de l'en-tête dans le conteneur
     headerContainer.appendChild(lexiconHeader);
   
-    // Création de l'icône BaLex en dehors de l'en-tête
     const balexButton = createBaLexButton(lexiconName, balexIdMap);
     if (balexButton) {
-      // Positionnement absolu pour que l'icône reste à droite du conteneur
       balexButton.style.position = "absolute";
       balexButton.style.top = "50%";
       balexButton.style.transform = "translateY(-50%)";
-      balexButton.style.right = "5px"; // Ajustez cet espace si besoin
+      balexButton.style.right = "5px"; 
   
-      // Empêche que le clic sur l'icône ne déclenche le toggle du contenu
       balexButton.addEventListener("click", (e) => e.stopPropagation());
       headerContainer.appendChild(balexButton);
     }
   
-    // Clic sur le conteneur pour dérouler ou masquer les définitions
     headerContainer.addEventListener("click", () => {
       lexiconContent.classList.toggle("hidden");
     });
   
-    // Création du conteneur pour les définitions (contenu déroulant)
     const lexiconContent = document.createElement("div");
     lexiconContent.className = "lexicon-content hidden";
     definitionItems.forEach(item => lexiconContent.appendChild(item));
@@ -548,11 +544,13 @@ function displayDefinitions(definitions) {
   }
 }
 
-
 // ─────────────────────────────────────────────────────────────────────────────
 // ▌ Gestion du popup pour afficher la définition complète du Wiktionnaire
 // ─────────────────────────────────────────────────────────────────────────────
-
+/**
+ * Ouvre le popup pour afficher la définition complète du Wiktionnaire
+ * @param {string} fullText - Le texte complet à afficher dans le popup.
+ */
 function openDefinitionPopup(fullText) {
   const modalOverlay = document.getElementById("modalOverlay");
   const modalFullText = document.getElementById("modalFullText");
@@ -625,7 +623,7 @@ async function showDefinitions(word) {
 
     if (!allDefinitions || allDefinitions.length === 0) {
       if (noDefinitionsContainer) {
-        noDefinitionsContainer.textContent = "⚠️ Aucune définition trouvée.";
+        noDefinitionsContainer.textContent = "️ Aucune définition trouvée.";
       }
       return;
     }
@@ -655,7 +653,7 @@ async function showDefinitions(word) {
  * @param {string} word - Le mot dont on veut la définition.
  */
 async function fetchDefinition(word) {
-  log(`🔍 Recherche de la définition pour '${word}'...`);
+  log(`Recherche de la définition pour '${word}'...`);
 
   const noDefinitionsContainer = document.getElementById("noDefinitionsContainer");
   if (!noDefinitionsContainer) {
@@ -668,7 +666,7 @@ async function fetchDefinition(word) {
     log("Résultat API :", definition);
 
     if (!definition || definition.length === 0) {
-      console.warn(`⚠️ Aucune définition trouvée pour '${word}'`);
+      console.warn(`️ Aucune définition trouvée pour '${word}'`);
       noDefinitionsContainer.style.display = "block";
       return;
     }
@@ -704,7 +702,7 @@ function displayLexiconResults(lexicons) {
 
   lexicons.forEach((lexicon) => {
     if (!lexicon) {
-      console.warn("⚠️ Lexique incorrect :", lexicon);
+      console.warn("️ Lexique incorrect :", lexicon);
       return;
     }
     if (!lexicon.id) {
@@ -737,7 +735,7 @@ function createBaLexButton(lexiconName, balexIdMap) {
 
   // Vérifie si `balex_id` est valide
   if (!balex_id) {
-      console.warn(`⚠️ Aucun balex_id trouvé pour "${lexiconName}". Bouton non créé.`);
+      console.warn(`️ Aucun balex_id trouvé pour "${lexiconName}". Bouton non créé.`);
       return null;
   }
 
@@ -755,7 +753,7 @@ function createBaLexButton(lexiconName, balexIdMap) {
 
   // Ajout du lien
   balexButton.addEventListener("click", (event) => {
-    event.stopPropagation(); // Pour éviter de déclencher le clic sur le conteneur parent
+    event.stopPropagation(); 
     window.open(balexUrl, "_blank");
   });
 
diff --git a/src/utils/highlighting.js b/src/utils/highlighting.js
index 6391763a890f1b149bec182845e403574d205273..b55029a71088bf1fa80bed37e86eeb84d34d761c 100644
--- a/src/utils/highlighting.js
+++ b/src/utils/highlighting.js
@@ -32,7 +32,7 @@ async function initAuthToken() {
             log("Token récupéré depuis le stockage local");
             return true;
         } else {
-            log("⚠️ Aucun token trouvé dans le stockage local");
+            log("️ Aucun token trouvé dans le stockage local");
             return false;
         }
     } catch (error) {
@@ -54,7 +54,10 @@ browser.runtime.onMessage.addListener((message) => {
 // ─────────────────────────────────────────────────────────────
 // ▌ Gestion des événements globaux
 // ─────────────────────────────────────────────────────────────
-// Réinitialisation du surlignage lors du retour sur la page
+/**
+ * Gestion de l'événement visibilitychange pour réinitialiser le surlignage
+ * @param {Event} event - L'événement visibilitychange
+ */
 document.addEventListener('visibilitychange', async () => {
     if (document.visibilityState === 'visible' && window.highlightingActive && activeLexiconIds.size > 0) {
         log("Page redevenue visible, réinitialisation du surlignage");
@@ -64,6 +67,10 @@ document.addEventListener('visibilitychange', async () => {
         attachMutationObserver();
     }
 });
+/**
+ * Gestion de l'événement pageshow pour réinitialiser le surlignage
+ * @param {Event} event - L'événement pageshow
+ */
 window.addEventListener('pageshow', async () => {
     if (window.highlightingActive && activeLexiconIds.size > 0) {
         log("Page affichée (pageshow), réinitialisation du surlignage");
@@ -85,7 +92,7 @@ log("Initialisation de highlighting.js");
 (function () {
     try {
         if (window.hasRunHighlighting) {
-            log("⚠️ highlighting.js déjà chargé");
+            log("️ highlighting.js déjà chargé");
             return;
         }
         window.hasRunHighlighting = true;        
@@ -116,7 +123,7 @@ log("Initialisation de highlighting.js");
         function getLexiconIdFromName(lexiconName) {
             const match = lexiconName.match(/\[(\d+)\]$/);
             const id = match ? parseInt(match[1]) : null;
-            log(`🏷️ Extraction de l'ID depuis '${lexiconName}': ${id}`);
+            log(`️ Extraction de l'ID depuis '${lexiconName}': ${id}`);
             return id;
         }
         
@@ -180,7 +187,7 @@ log("Initialisation de highlighting.js");
                     throw new Error("Pas de token d'authentification");
                 }
                 if (typeof window.getAllLexiconWords !== 'function') {
-                    log("⚠️ getAllLexiconWords n'est pas une fonction");
+                    log("️ getAllLexiconWords n'est pas une fonction");
                     log("Type de getAllLexiconWords:", typeof window.getAllLexiconWords);
                     log("Contenu de window.getAllLexiconWords:", window.getAllLexiconWords);
                     throw new Error("getAllLexiconWords n'est pas disponible");
@@ -194,26 +201,26 @@ log("Initialisation de highlighting.js");
                 }
                 lexiconWordsCache.clear();
                 if (Object.keys(allWords).length === 0) {
-                    log("⚠️ Aucun lexique reçu de getAllLexiconWords");
+                    log("️ Aucun lexique reçu de getAllLexiconWords");
                     return false;
                 }
                 // Traite chaque lexique reçu
                 for (const [lexiconName, words] of Object.entries(allWords)) {
                     if (!Array.isArray(words)) {
-                        console.warn(`⚠️ Format invalide pour le lexique ${lexiconName}:`, words);
+                        console.warn(`️ Format invalide pour le lexique ${lexiconName}:`, words);
                         continue;
                     }
                     // Extrait l'ID du lexique 
                     const lexiconId = lexiconName.match(/\[(\d+)\]$/)?.[1];
                     if (!lexiconId) {
-                        console.warn(`⚠️ Impossible d'extraire l'ID du lexique depuis: ${lexiconName}`);
+                        console.warn(`️ Impossible d'extraire l'ID du lexique depuis: ${lexiconName}`);
                         continue;
                     }
-                    log(`📎 Traitement du lexique ${lexiconName} (ID: ${lexiconId})`);
+                    log(`Traitement du lexique ${lexiconName} (ID: ${lexiconId})`);
                     // Si l'ID du lexique est actif, met à jour le cache
                     if (activeLexiconIds.has(Number(lexiconId))) {
                         lexiconWordsCache.set(lexiconId, new Set(words));
-                        log(`📖 Lexique ${lexiconId} chargé avec ${words.length} mots`);
+                        log(`Lexique ${lexiconId} chargé avec ${words.length} mots`);
                     }
                 }
                 log("Cache des lexiques mis à jour:",
@@ -289,7 +296,7 @@ log("Initialisation de highlighting.js");
             try {
                 await initAuthToken();
                 if (!window.authToken) {
-                    throw new Error("❌ Pas de token d'authentification disponible");
+                    throw new Error("Pas de token d'authentification disponible");
                 }
                 // Vérifie si un identifiant de lexique a été fourni
                 if (lexiconId) {
@@ -392,7 +399,7 @@ log("Initialisation de highlighting.js");
             while (node = walker.nextNode()) {
                 textNodes.push(node);
             }
-            log(`🔤 ${textNodes.length} nœuds de texte trouvés à traiter`);
+            log(`${textNodes.length} nœuds de texte trouvés à traiter`);
             // Fonction pour traiter le prochain lot de nœuds de texte
             const processNextBatch = (startIndex) => {
                 // Vérifie si le surlignage est toujours actif et si des nœuds restent à traiter
@@ -419,11 +426,11 @@ log("Initialisation de highlighting.js");
          */
         function processTextNode(textNode) {
             if (activeLexiconIds.size === 0) {
-                log("⚠️ Aucun lexique actif, sortie du processTextNode");
+                log("️ Aucun lexique actif, sortie du processTextNode");
                 return;
             }
             const text = textNode.textContent; // Récupère le texte du nœud
-            log(`🔍 Traitement du texte: "${text.substring(0, 50)}..."`); 
+            log(`Traitement du texte: "${text.substring(0, 50)}..."`); 
             let lastIndex = 0; // Index de la dernière correspondance trouvée
             let fragments = []; // Tableau pour stocker les parties de texte
             const allWords = new Set(); // Ensemble pour stocker tous les mots à rechercher
@@ -432,10 +439,10 @@ log("Initialisation de highlighting.js");
             // Parcourt chaque lexique dans le cache
             for (const [lexiconId, words] of lexiconWordsCache.entries()) {
                 const numericId = parseInt(lexiconId); // Convertit l'ID du lexique en nombre
-                log(`🔄 Vérification du lexique ${lexiconId} (ID: ${numericId})`);
+                log(`Vérification du lexique ${lexiconId} (ID: ${numericId})`);
                 // Vérifie si le lexique est actif
                 if (activeLexiconIds.has(numericId)) {
-                    log(`✅ Lexique ${lexiconId} actif, ajout de ${words.size} mots`);
+                    log(`Lexique ${lexiconId} actif, ajout de ${words.size} mots`);
                     // Ajoute chaque mot à l'ensemble des mots à rechercher
                     words.forEach(word => allWords.add(word));
                     // Associe chaque mot à son identifiant de lexique
@@ -448,10 +455,10 @@ log("Initialisation de highlighting.js");
                     });
                 }
             }
-            log(`🔤 Nombre total de mots à rechercher: ${allWords.size}`);
+            log(`Nombre total de mots à rechercher: ${allWords.size}`);
             // Vérifie si des mots sont disponibles pour la recherche
             if (allWords.size === 0) {
-                log("⚠️ Aucun mot à rechercher dans les lexiques actifs");
+                log("️ Aucun mot à rechercher dans les lexiques actifs");
                 return;
             }
             // Crée une expression régulière pour rechercher les mots
@@ -461,7 +468,7 @@ log("Initialisation de highlighting.js");
                 .join("|"); // Joint les mots avec un séparateur "ou"
             // Vérifie si le motif de recherche est valide
             if (!wordsPattern) {
-                log("⚠️ Aucun mot à rechercher, sortie");
+                log("️ Aucun mot à rechercher, sortie");
                 return;
             }
             const regex = new RegExp(`\\b(${wordsPattern})\\b`, "gi"); // Crée l'expression régulière
@@ -493,7 +500,7 @@ log("Initialisation de highlighting.js");
                 lastIndex = regex.lastIndex; // Met à jour l'index de la dernière correspondance
             }
             if (matchCount > 0) {
-                log(`✨ ${matchCount} correspondances trouvées dans le nœud`);
+                log(`${matchCount} correspondances trouvées dans le nœud`);
             }
             // Ajoute le texte restant après la dernière correspondance
             if (lastIndex < text.length) {
@@ -516,7 +523,7 @@ log("Initialisation de highlighting.js");
         function removeAllHighlights() {
             log("Suppression de tous les surlignages");
             const highlights = document.querySelectorAll('.lexicon-highlight');
-            log(`📊 ${highlights.length} surlignages à supprimer`);
+            log(`${highlights.length} surlignages à supprimer`);
             highlights.forEach(highlight => {
                 const text = highlight.textContent;
                 const textNode = document.createTextNode(text);
@@ -540,7 +547,7 @@ log("Initialisation de highlighting.js");
                 }
                 // Définit un nouveau timer 
                 debounceTimer = setTimeout(() => {
-                    log(`🔄 Traitement groupé de ${mutations.length} mutations DOM`);
+                    log(`Traitement groupé de ${mutations.length} mutations DOM`);
                     let shouldHighlight = false;
                     for (const mutation of mutations) {
                         // Vérifie si la mutation concerne des nœuds enfants
@@ -593,7 +600,7 @@ log("Initialisation de highlighting.js");
             
             // Vérifie si la commande est pour activer le surlignage
             if (message.command === "activate-highlighting") {
-                log(`🎯 Activation du surlignage pour le lexique ${message.lexiconId}`);
+                log(`Activation du surlignage pour le lexique ${message.lexiconId}`);
                 // Démarre le surlignage pour le lexique spécifié
                 startHighlighting(message.lexiconId)
                     .then(() => {
@@ -609,7 +616,7 @@ log("Initialisation de highlighting.js");
             
             // Vérifie si la commande est pour désactiver le surlignage
             if (message.command === "deactivate-highlighting") {
-                log(`🚫 Désactivation du surlignage pour le lexique ${message.lexiconId}`);
+                log(`Désactivation du surlignage pour le lexique ${message.lexiconId}`);
                 // Arrête le surlignage pour le lexique spécifié
                 stopHighlighting(message.lexiconId)
                     .then(() => {
diff --git a/src/utils/stats.js b/src/utils/stats.js
index 1f1912c79f09c46227f87b29fba08a1d27abae0b..fca6b402b1f7241c7a7865cc242bc77727cf87a8 100644
--- a/src/utils/stats.js
+++ b/src/utils/stats.js
@@ -7,10 +7,12 @@
     // ─────────────────────────────────────────────────────────────────────────────
     // Connexion/Transmission des données avec le WebWorker
     // ─────────────────────────────────────────────────────────────────────────────
-    //Connexion au port
+    /**
+     * Connexion au port
+     */
     function connectToWorker() {
         if (!workerPort) {
-            // log("[Stats] Connexion au WebWorker...");
+            log("[Stats] Connexion au WebWorker...");
             workerPort = browser.runtime.connect({ name: "stats-worker-port" });
             workerPort.onMessage.addListener((message) => {
                 log("[Stats] Message reçu du Worker :", message);
@@ -28,19 +30,22 @@
                                 continue;
                             }
             
-                        alertMessage += `\n🔹 ${lang.toUpperCase()} : ${words.join(", ")}`;
+                        alertMessage += `\n${lang.toUpperCase()} : ${words.join(", ")}`;
                     }
             
                     alert(alertMessage);
                 }
             });
             workerPort.onDisconnect.addListener(() => {
-                // log("[Stats] Déconnexion du WebWorker.");
+                log("[Stats] Déconnexion du WebWorker.");
                 workerPort = null;
             });
         }
     }
-    //Fonction pour envoyer le texte directement au Worker
+    /**
+     * Envoi du texte directement au Worker
+     * @param {string} text - Le texte à envoyer.
+     */
     function sendTextToWorker(text) {
         if (!workerPort) {
             connectToWorker();
@@ -231,18 +236,27 @@
     // ─────────────────────────────────────────────────────────────────────────────
     // Gestion de l'activation/désactivation des statistiques
     // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Démarre le suivi des statistiques
+     */
     function startTracking() {
             log("[Stats] Suivi des statistiques activé.");
             addViewportBorder();
             attachScrollListener();
-        }
+    }
 
+    /**
+     * Désactive le suivi des statistiques
+     */
     function stopTracking() {
         log("[Stats] Suivi des statistiques désactivé.");
         removeViewportBorder();
         detachScrollListener();
     }
 
+    /**
+     * Attache l'écouteur de défilement
+     */
     function attachScrollListener() {
         if (!scrollListenerAttached) {
             window.addEventListener("scroll", trackVisibleContent);
@@ -251,6 +265,9 @@
         }
     }
 
+    /**
+     * Détache l'écouteur de défilement
+     */
     function detachScrollListener() {
         if (scrollListenerAttached) {
             window.removeEventListener("scroll", trackVisibleContent);
@@ -259,7 +276,9 @@
         }
     }
 
-    // Indice visuel des statistiques actives 
+    /**
+     * Injecte la bordure
+     */
     function injectBorder() {
         const css = `
         #border-svg {
@@ -329,7 +348,9 @@
         document.body.appendChild(svg);
     }
     
-    // Fonction pour ajouter la bordure 
+    /**
+     * Ajoute la bordure
+     */
     function addViewportBorder() {
         if (window.hasRunStats) {
             if (!document.getElementById("border-svg")) {
@@ -337,7 +358,9 @@
             }
         }
     }
-    // Fonction pour retirer la bordure 
+    /**
+     * Retire la bordure
+     */
     function removeViewportBorder() {
         const svg = document.getElementById("border-svg");
         if (svg) {
diff --git a/src/workers/pyodide_worker.js b/src/workers/pyodide_worker.js
index 8131c19d0c0bfe3000271d0f01b2a70122d9a2aa..fc9bb22f55cf1acd7a067ef9a88a88461c91b51f 100644
--- a/src/workers/pyodide_worker.js
+++ b/src/workers/pyodide_worker.js
@@ -18,8 +18,8 @@ let trackedLanguages = [];      // Aucune langue suivie par défaut
 let notifiedWords = {};         // Mots déjà notifiés (pour éviter les doublons)
 let includeStopwords = false;   // Stocker l'état de l'inclusion des mots outils
 let stoplistsByLang = {};       // Objet stockant les stoplists par langue
-let userLexicons = [] //Contient les lexiques et leurs ID (lexiques personnels)
-let authToken = null; // Stockage local du token
+let userLexicons = []           // Contient les lexiques et leurs ID (lexiques personnels)
+let authToken = null;           // Stockage local du token
 
 // --- Attente de la mise à jour de la stoplist ---
 let stoplistsReady = new Promise((resolve) => resolve()); 
@@ -170,7 +170,7 @@ self.onmessage = async (event) => {
             log(`[Worker] Stoplist mise à jour pour '${lang}' : ${stoplistsByLang[lang].size} mots.`);
           }
         } else {
-          log("[Worker] ⚠ Stoplists reçues incorrectes ou vides.");
+          log("[Worker] Stoplists reçues incorrectes ou vides.");
         }
         resolve(); // Stoplist prête
       });
@@ -192,16 +192,16 @@ async function checkThreshold(lang) {
   await stoplistsReady; // Attendre que les stoplists soient chargées
   
   if (!autoAddEnabled || !isAuthenticated) {
-    log("[Worker] ⚠ Auto-Add désactivé ou utilisateur non connecté.");
+    log("[Worker] Auto-Add désactivé ou utilisateur non connecté.");
   } else if (!trackedLanguages.includes(lang)) {
-    log(`[Worker] âš  La langue '${lang}' n'est pas suivie.`);
+    log(`[Worker] La langue '${lang}' n'est pas suivie.`);
   } else {
     log(`[Worker] Vérification des fréquences pour la langue '${lang}'...`);
   
     const stoplist = stoplistsByLang[lang] || new Set();
     const shouldFilterStopwords = stoplist.size > 0 && includeStopwords;
 
-    log(`[Worker] 📝 Stoplist pour '${lang}' : ${shouldFilterStopwords ? "Appliquée" : "Non appliquée"}`);
+    log(`[Worker] Stoplist pour '${lang}' : ${shouldFilterStopwords ? "Appliquée" : "Non appliquée"}`);
 
     const wordsFrequencies = storedFrequencies[lang] || {};
     const notifiedSet = new Set(notifiedWords[lang] || []);
@@ -246,7 +246,9 @@ async function checkThreshold(lang) {
   }
 }
 
-//Traiter les ajouts groupés
+/**
+ * Traite les ajouts groupés
+ */
 async function processPendingWords() {
   log("Traitement des mots à ajouter en lot...");
 
@@ -262,6 +264,11 @@ async function processPendingWords() {
   addWordTimeout = null;
 }
 
+/**
+ * Ajoute un mot au lexique
+ * @param {string} lang - La langue du mot.
+ * @param {string} word - Le mot à ajouter.
+ */
 async function addWordToLexicon(lang, word) {
   if (!authToken) {
     log("Impossible d'ajouter le mot : Aucun token d’authentification.");