Optimise this code :
// Vérifier l'état actif de l'extension
browser.storage.local.get("isActive").then(function (result) {
	var isExtensionActive = result.isActive;

	// Récupérez la couleur enregistrée en utilisant l'API browser.storage.local.get()
	browser.storage.local.get("color").then(function (result) {
		var color = result.color;
		if (color) {
			// Appliquez la couleur au code CSS en utilisant document.documentElement.style
			document.documentElement.style.setProperty("--antiwoke-highlight-color", color);
		}
	});
	browser.storage.local.get("hover").then(function (result) {
		var hover = result.hover;
		if (hover) {
			// Appliquez la couleur au code CSS en utilisant document.documentElement.style
			document.documentElement.style.setProperty("--afficher-hover", hover);
		}
	});
	browser.storage.local.get("invisible").then(function (result) {
		var invisible = result.invisible;
		var elements = document.getElementsByTagName("antiwoke-text"); // Get all <antiwoke> tags
		if (invisible == "oui") {
			for (var i = 0; i < elements.length; i++) {
				elements[i].classList.remove("antiwoke-highlight");
			}
		} else {
			for (var i = 0; i < elements.length; i++) {
				elements[i].classList.add("antiwoke-highlight");
			}
		}
	});

	// Exécuter le code uniquement si l'extension est active
	if (isExtensionActive) {
		console.log("Extension active");
		console.time("Remplacements");

		function ajouterNumeroEtRenommerNomsDeGroupes(tableau) {
			return tableau.map((element, index) => {
				const patternAvecNumero = new RegExp(
					element.pattern.source.replace(/\<(\w+)\>/g, `<$1${index}>`)
				);
				const modificationAvecNouveauxNoms = element.modification.replace(
					/(\$\{match\.groups\.\w+)}/g,
					`$1${index}}`
				);
				return {
					...element,
					pattern: patternAvecNumero,
					modification: modificationAvecNouveauxNoms,
				};
			});
		}

		const remplacements = ajouterNumeroEtRenommerNomsDeGroupes(remplacements0);
		const regex = new RegExp(
			`${groupeAvantMot}(${remplacements
				.map((r) => `(${r.pattern.source})`)
				.join("|")})${groupeApresMot}`,
			"gmu"
		);

		function remplacer() {
			const nodes = getTextNodes(document.body);
			let remplacementsEffectues = false;

			nodes.forEach((node) => {
				if (
					!node.parentNode.closest("remplacement-text") &&
					!hasAncestorOfType(node, ["STYLE", "SCRIPT"])
				) {
					const content = node.textContent;
					let replacedContent = content;
					let match = regex.exec(content);

					if (match) {
						const remplacement = remplacements.find((r) => r.pattern.test(match[0]));
						const nouveauMot = remplacement.modification.replace(
							/\$\{match\.groups\.(\w+)\}/g,
							(m, p1) => match.groups[p1]
						);

						const avant_motLength = match.groups.avant_mot.length;
						const apres_motLength = match.groups.apres_mot.length;
						const slicedMatch =
							apres_motLength === 0 ? match[0] : match[0].slice(0, -apres_motLength);
						const finalSlicedMatch =
							avant_motLength === 0
								? slicedMatch
								: slicedMatch.slice(avant_motLength);

						replacedContent = replacedContent.replace(
							match[0],
							match.groups.avant_mot +
								"<remplacement-text><woke-text>" +
								finalSlicedMatch +
								"</woke-text><antiwoke-text>" +
								nouveauMot +
								"</antiwoke-text></remplacement-text>" +
								match.groups.apres_mot
						);

						remplacementsEffectues = true;
					}

					if (replacedContent !== content) {
						const span = document.createElement("span");
						span.innerHTML = replacedContent;
						node.replaceWith(span);
					}
				}
			});

			return remplacementsEffectues;
		}

		let remplacementsEffectues = true;
		while (remplacementsEffectues) {
			remplacementsEffectues = remplacer();
		}

		function getTextNodes(node) {
			const textNodes = [];

			if (node.nodeType === Node.TEXT_NODE) {
				textNodes.push(node);
			} else {
				const children = node.childNodes;

				for (let i = 0; i < children.length; i++) {
					textNodes.push(...getTextNodes(children[i]));
				}
			}

			return textNodes;
		}

		function hasAncestorOfType(node, types) {
			if (!node.parentNode) {
				return false;
			} else if (types.includes(node.parentNode.nodeName)) {
				return true;
			} else {
				return hasAncestorOfType(node.parentNode, types);
			}
		}
		console.timeEnd("Remplacements");
	} else {
		console.log("Extension désactivée");
	}
});