@duckduckgo/autoconsent 14.97.0 → 15.1.0

package/dist/addon-mv3/content.bundle.js

@@ -400,6 +400,14 @@
     });
   }
 
+  // lib/types.ts
+  var PopupHandlingModes = {
+    None: -1,
+    Reject: 0,
+    Tier1: 1,
+    Tier2: 2
+  };
+
   // lib/random.ts
   function getRandomID() {
     if (crypto && typeof crypto.randomUUID !== "undefined") {
@@ -426,6 +434,9 @@
     sendContentMessage: null
   };
   function requestEval(code, snippetId) {
+    if (!evalState.sendContentMessage) {
+      return Promise.reject(new Error("AutoConsent is not initialized yet"));
+    }
     const id = getRandomID();
     evalState.sendContentMessage({
       type: "eval",
@@ -709,7 +720,8 @@
         waits: false
       },
       performanceLoggingEnabled: false,
-      heuristicPopupSearchTimeout: 100
+      heuristicPopupSearchTimeout: 100,
+      heuristicMode: PopupHandlingModes.Reject
     };
     const updatedConfig = copyObject(defaultConfig);
     for (const key of Object.keys(defaultConfig)) {
@@ -727,12 +739,13 @@
     }
   }
   function highlightNode(node) {
+    const highlightedNode = node;
     if (!node.style) return;
-    if (node.__oldStyles !== void 0) {
+    if (highlightedNode.__oldStyles !== void 0) {
       return;
     }
     if (node.hasAttribute("style")) {
-      node.__oldStyles = node.style.cssText;
+      highlightedNode.__oldStyles = node.style.cssText;
     }
     node.style.animation = "pulsate .5s infinite";
     node.style.outline = "solid red";
@@ -760,10 +773,11 @@
     document.head.appendChild(styleTag);
   }
   function unhighlightNode(node) {
+    const highlightedNode = node;
     if (!node.style || !node.hasAttribute("style")) return;
-    if (node.__oldStyles !== void 0) {
-      node.style.cssText = node.__oldStyles;
-      delete node.__oldStyles;
+    if (highlightedNode.__oldStyles !== void 0) {
+      node.style.cssText = highlightedNode.__oldStyles;
+      delete highlightedNode.__oldStyles;
     } else {
       node.removeAttribute("style");
     }
@@ -876,12 +890,17 @@
     /^\s*(use|accept|allow|continue\s+with)?\s*only\s*(strictly)?\s*(necessary|essentials?|required)?\s*(cookies)?\s*$/is,
     // e.g. "do not sell or share my personal information", "do not sell my personal information"
     // often used in CCPA
-    /^\s*do\s+not\s+sell(\s+or\s+share)?\s*my\s*personal\s*information\s*$/is,
+    /^\s*do\s+not\s+sell(\s+or\s+share)?\s*my\s*personal\s*info(rmation)?\s*$/is,
     "allow selection",
-    "disagree and close"
+    "disagree and close",
     // These are impactful, but look error-prone
+    // // e.g. "disagree"
+    /^(i)?\s*disagree\s*(and\s+close)?$/i,
     // // e.g. "i do not agree"
     // /^\s*(i\s+)?do\s+not\s+agree\s*$/i,
+    "no",
+    /^no,? thanks$/is,
+    /^opt[ -]out$/is
   ];
   var REJECT_PATTERNS_DUTCH = [
     "weigeren",
@@ -1457,6 +1476,64 @@
     /sostienici/is,
     /suscribir/is
   ];
+  var SETTINGS_PATTERNS = [
+    "settings",
+    "preferences",
+    /customi(s|z)e/is,
+    "show details",
+    "more options",
+    /(manage|configure) (my|your) (preferences|choices|cookies)/is,
+    "manage choices",
+    /(cookie )?preference center/is,
+    "change settings",
+    "configure",
+    "change my preferences",
+    "cookie manager",
+    "cookie preference",
+    "let me choose",
+    "cookieconsent preferences",
+    /privacy choices/is,
+    /(privacy|cookie|custom) settings/is,
+    /cookies? (settings|preferences|setting)/is,
+    /(manage|customize|customise|opt-out|edit).*(cookies|preferences|settings|options)/is,
+    "cookie consent options",
+    "privacy controls",
+    "show purposes",
+    // German
+    "einstellungen"
+  ];
+  var ACCEPT_PATTERNS = [
+    /^(accept|allow)( all)?( cookies)?$/is,
+    /i (accept|allow)( all)?/is,
+    "yes",
+    /^(i )?agree$/is,
+    "continue with all",
+    "accept and continue",
+    /accept all above/is,
+    /^(accept|agree) and close/is,
+    "accept continue",
+    "agree proceed",
+    "allow and continue",
+    "close and accept",
+    /accept all$/is,
+    "im ok with that",
+    "accept optional cookies",
+    /^alle (cookies )?akzeptieren$/is
+  ];
+  var ACKNOWLEDGE_PATTERNS = [
+    "ok",
+    "close",
+    "continue",
+    "x",
+    /^got it!?$/,
+    "i understand",
+    "dismiss",
+    "okay",
+    "acknowledge",
+    /^close (banner|cookie notification)$/is,
+    /understood$/is,
+    "confirm my choices"
+  ];
 
   // lib/heuristics.ts
   var BUTTON_LIKE_ELEMENT_SELECTOR = 'button, input[type="button"], input[type="submit"], a, [role="button"], [class*="button"]';
@@ -1475,48 +1552,61 @@
     }
     return { patterns, snippets: snippets2 };
   }
-  function getActionablePopups(timeout = POPUP_SEARCH_MAX_TIME) {
+  function getActionablePopups(mode = PopupHandlingModes.Reject, timeout = POPUP_SEARCH_MAX_TIME) {
     const popups = getPotentialPopups(timeout);
     const result = popups.reduce((acc, popup) => {
       const popupText = popup.text?.trim();
       if (popupText) {
         const { patterns } = checkHeuristicPatterns(popupText);
         if (patterns.length > 0) {
-          const { rejectButtons, otherButtons } = classifyButtons(popup.buttons);
-          if (rejectButtons.length > 0) {
-            acc.push({
-              ...popup,
-              rejectButtons,
-              otherButtons
-            });
-          }
+          classifyButtons(popup.buttons);
+          popup.regexClassification = classifyPopup(popup.buttons);
+          acc.push({
+            ...popup
+          });
         }
       }
       return acc;
     }, []);
-    return result;
+    return result.filter(
+      (popup) => popup.regexClassification !== void 0 && popup.regexClassification !== PopupHandlingModes.None && popup.regexClassification <= mode
+    ).sort((a, b) => (a.regexClassification ?? 0) - (b.regexClassification ?? 0));
   }
   function classifyButtons(buttons) {
-    const rejectButtons = [];
-    const otherButtons = [];
     for (const button of buttons) {
-      if (isRejectButton(button.text)) {
-        rejectButtons.push(button);
-      } else {
-        otherButtons.push(button);
-      }
+      button.regexClassification = classifyButtonTextRegex(button.text);
     }
-    return {
-      rejectButtons,
-      otherButtons
-    };
   }
-  function isRejectButton(buttonText, rejectPatterns = REJECT_PATTERNS, neverMatchPatterns = NEVER_MATCH_PATTERNS) {
+  function classifyPopup(buttons) {
+    const { reject, settings, accept, acknowledge } = buttons.reduce(
+      (acc, button) => {
+        if (button.regexClassification && button.regexClassification !== "other") {
+          acc[button.regexClassification]++;
+        }
+        return acc;
+      },
+      { reject: 0, settings: 0, accept: 0, acknowledge: 0 }
+    );
+    if (reject > 0) {
+      return PopupHandlingModes.Reject;
+    }
+    if (settings > 0) {
+      return PopupHandlingModes.None;
+    }
+    if (acknowledge > 0) {
+      return PopupHandlingModes.Tier1;
+    }
+    if (accept > 0) {
+      return accept === 1 ? PopupHandlingModes.Tier2 : PopupHandlingModes.None;
+    }
+    return PopupHandlingModes.None;
+  }
+  function testButtonMatches(buttonText, matchPatterns, neverMatchPatterns) {
     if (!buttonText) {
       return false;
     }
     const cleanedButtonText = cleanButtonText(buttonText);
-    return !neverMatchPatterns.some((p) => p.test(cleanedButtonText)) && rejectPatterns.some((p) => p instanceof RegExp && p.test(cleanedButtonText) || p === cleanedButtonText);
+    return !neverMatchPatterns.some((p) => p instanceof RegExp && p.test(cleanedButtonText) || p === cleanedButtonText) && matchPatterns.some((p) => p instanceof RegExp && p.test(cleanedButtonText) || p === cleanedButtonText);
   }
   function cleanButtonText(buttonText) {
     let result = buttonText.toLowerCase();
@@ -1530,6 +1620,21 @@
     result = result.trim();
     return result;
   }
+  function classifyButtonTextRegex(buttonText) {
+    if (testButtonMatches(buttonText, REJECT_PATTERNS, NEVER_MATCH_PATTERNS)) {
+      return "reject";
+    }
+    if (testButtonMatches(buttonText, SETTINGS_PATTERNS, NEVER_MATCH_PATTERNS)) {
+      return "settings";
+    }
+    if (testButtonMatches(buttonText, ACCEPT_PATTERNS, NEVER_MATCH_PATTERNS)) {
+      return "accept";
+    }
+    if (testButtonMatches(buttonText, ACKNOWLEDGE_PATTERNS, NEVER_MATCH_PATTERNS)) {
+      return "acknowledge";
+    }
+    return "other";
+  }
   function getPotentialPopups(timeout = POPUP_SEARCH_MAX_TIME) {
     const isFramed = !isTopFrame();
     if (isFramed && window.parent && window.parent !== window.top) {
@@ -1975,7 +2080,7 @@
     }
   };
   var AutoConsentHeuristicCMP = class extends AutoConsentCMPBase {
-    constructor(autoconsentInstance) {
+    constructor(autoconsentInstance, mode = PopupHandlingModes.Reject) {
       super(autoconsentInstance);
       this.popups = [];
       this.name = "HEURISTIC";
@@ -1984,6 +2089,7 @@
         frame: false
         // do not run in iframes for security reasons
       };
+      this.mode = mode;
     }
     get hasSelfTest() {
       return true;
@@ -1997,25 +2103,33 @@
     async detectCmp() {
       await new Promise((resolve) => setTimeout(resolve, 0));
       this.autoconsent.config.performanceLoggingEnabled && performance.mark("heuristicDetectorStart");
-      this.popups = getActionablePopups(this.autoconsent.config.heuristicPopupSearchTimeout);
+      this.popups = getActionablePopups(this.mode, this.autoconsent.config.heuristicPopupSearchTimeout);
       this.autoconsent.config.performanceLoggingEnabled && performance.mark("heuristicDetectorEnd");
       this.autoconsent.config.performanceLoggingEnabled && performance.measure("heuristicDetector", "heuristicDetectorStart", "heuristicDetectorEnd");
       if (this.popups.length > 0) {
+        this.name = `HEURISTIC-TIER${this.popups[0].regexClassification}`;
         return Promise.resolve(true);
       }
       return Promise.resolve(false);
     }
     async detectPopup() {
       if (this.popups.length > 0) {
-        if (this.popups.length > 1 || this.popups[0].rejectButtons && this.popups[0].rejectButtons.length > 1) {
-          this.autoconsent.config.logs.errors && console.warn("Heuristic found multiple reject buttons");
+        if (this.popups.length > 1) {
+          this.autoconsent.config.logs.errors && console.warn("Heuristic found multiple popups");
         }
         return true;
       }
       return false;
     }
+    getTargetButton() {
+      const popup = this.popups[0];
+      const level = popup.regexClassification;
+      const buttons = popup.buttons;
+      const targetButtonType = level === PopupHandlingModes.Reject ? "reject" : level === PopupHandlingModes.Tier1 ? "acknowledge" : "accept";
+      return buttons.find((button) => button.regexClassification === targetButtonType);
+    }
     optOut() {
-      const button = this.popups[0]?.rejectButtons?.[0];
+      const button = this.getTargetButton();
       if (button) {
         return this.clickElement(button.element);
       }
@@ -2028,7 +2142,7 @@
       throw new Error("Not Implemented");
     }
     async test() {
-      const button = this.popups[0].rejectButtons?.[0];
+      const button = this.getTargetButton();
       if (button) {
         await this.wait(500);
         return !isElementVisible(button.element);
@@ -2709,7 +2823,7 @@
     async optOut() {
       await this.waitForElement(".unic button", 1e3);
       document.querySelectorAll(".unic button").forEach((button) => {
-        const text = button.textContent;
+        const text = button.textContent || "";
         if (text.includes("Manage Options") || text.includes("Optionen verwalten")) {
           button.click();
         }
@@ -2722,7 +2836,7 @@
           }
         });
         for (const b of document.querySelectorAll(".unic button")) {
-          const text = b.textContent;
+          const text = b.textContent || "";
           for (const pattern of ["Confirm Choices", "Save Choices", "Auswahl speichern"]) {
             if (text.includes(pattern)) {
               b.click();
@@ -2779,6 +2893,9 @@
         item.querySelector(".cmp-accordion-item-title").click();
         await waitFor(() => !!item.querySelector(".cmp-accordion-item-content.cmp-active"), 10, 50);
         const content = item.querySelector(".cmp-accordion-item-content.cmp-active");
+        if (!content) {
+          return false;
+        }
         content.querySelectorAll(".cmp-toggle-actions .cmp-toggle-deny:not(.cmp-toggle-deny--active)").forEach((e) => e.click());
         content.querySelectorAll(".cmp-toggle-actions .cmp-toggle-checkbox:not(.cmp-toggle-checkbox--active)").forEach((e) => e.click());
       }
@@ -3497,7 +3614,7 @@
           }
         }
       });
-      const heuristicRules = isTop && this.config.enableHeuristicAction && this.state.findCmpAttempts % 2 === 0 ? [new AutoConsentHeuristicCMP(this)] : [];
+      const heuristicRules = isTop && this.config.enableHeuristicAction && this.state.findCmpAttempts % 2 === 0 ? [new AutoConsentHeuristicCMP(this, this.config.heuristicMode)] : [];
       const rulesPriorityStages = [
         ["site-specific", siteSpecificRules],
         ["generic", genericRules],

package/dist/addon-mv3/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Autoconsent",
-  "version": "2026.6.18",
+  "version": "2026.6.20",
   "background": {
     "service_worker": "background.bundle.js"
   },

package/dist/addon-mv3/popup.bundle.js

@@ -761,6 +761,14 @@
     return parseImpl(url, 5, suffixLookup, options, getEmptyResult());
   }
 
+  // lib/types.ts
+  var PopupHandlingModes = {
+    None: -1,
+    Reject: 0,
+    Tier1: 1,
+    Tier2: 2
+  };
+
   // lib/utils.ts
   function copyObject(data) {
     if (globalThis.structuredClone) {
@@ -795,7 +803,8 @@
         waits: false
       },
       performanceLoggingEnabled: false,
-      heuristicPopupSearchTimeout: 100
+      heuristicPopupSearchTimeout: 100,
+      heuristicMode: PopupHandlingModes.Reject
     };
     const updatedConfig = copyObject(defaultConfig);
     for (const key of Object.keys(defaultConfig)) {
@@ -904,6 +913,7 @@
   }
 
   // addon/popup.ts
+  var maxRenderedRules = 100;
   async function init() {
     const autoconsentConfig = await storageGet("config");
     const enabledCheckbox = document.querySelector("input#enabled");
@@ -917,8 +927,7 @@
     const cosmeticOffRadio = document.querySelector("input#cosmetic-off");
     const generatedOnRadio = document.querySelector("input#generated-on");
     const generatedOffRadio = document.querySelector("input#generated-off");
-    const heuristicActionOnRadio = document.querySelector("input#heuristic-action-on");
-    const heuristicActionOffRadio = document.querySelector("input#heuristic-action-off");
+    const heuristicActionCheckbox = document.querySelector("input#heuristic-action");
     const visualTestOnRadio = document.querySelector("input#visual-test-on");
     const visualTestOffRadio = document.querySelector("input#visual-test-off");
     const popupMutationOnRadio = document.querySelector("input#popup-mutation-on");
@@ -933,6 +942,47 @@
     const logsMessagesCheckbox = document.querySelector("input#logs-messages");
     const ruleReloadButton = document.querySelector("#reload");
     const resetButton = document.querySelector("#reset");
+    const ruleSectionControls = {
+      generated: {
+        details: document.querySelector("#generated-rules-section"),
+        count: document.querySelector("#generated-rules-count"),
+        search: document.querySelector("#generated-rules-search"),
+        enableAll: document.querySelector("#generated-rules-enable-all"),
+        disableAll: document.querySelector("#generated-rules-disable-all"),
+        status: document.querySelector("#generated-rules-status"),
+        list: document.querySelector("#generated-rules-list")
+      },
+      generic: {
+        details: document.querySelector("#generic-rules-section"),
+        count: document.querySelector("#generic-rules-count"),
+        search: document.querySelector("#generic-rules-search"),
+        enableAll: document.querySelector("#generic-rules-enable-all"),
+        disableAll: document.querySelector("#generic-rules-disable-all"),
+        status: document.querySelector("#generic-rules-status"),
+        list: document.querySelector("#generic-rules-list")
+      },
+      code: {
+        details: document.querySelector("#code-rules-section"),
+        count: document.querySelector("#code-rules-count"),
+        search: document.querySelector("#code-rules-search"),
+        enableAll: document.querySelector("#code-rules-enable-all"),
+        disableAll: document.querySelector("#code-rules-disable-all"),
+        status: document.querySelector("#code-rules-status"),
+        list: document.querySelector("#code-rules-list")
+      },
+      consentomatic: {
+        details: document.querySelector("#consentomatic-rules-section"),
+        count: document.querySelector("#consentomatic-rules-count"),
+        search: document.querySelector("#consentomatic-rules-search"),
+        enableAll: document.querySelector("#consentomatic-rules-enable-all"),
+        disableAll: document.querySelector("#consentomatic-rules-disable-all"),
+        status: document.querySelector("#consentomatic-rules-status"),
+        list: document.querySelector("#consentomatic-rules-list")
+      }
+    };
+    let ruleIndexPromise = null;
+    let ruleIndex = null;
+    autoconsentConfig.disabledCmps = autoconsentConfig.disabledCmps || [];
     const [currentTab] = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
     if (!currentTab.url || !currentTab.id) {
       console.error("Current tab is not valid");
@@ -998,11 +1048,7 @@
     } else {
       generatedOffRadio.checked = true;
     }
-    if (autoconsentConfig.enableHeuristicAction) {
-      heuristicActionOnRadio.checked = true;
-    } else {
-      heuristicActionOffRadio.checked = true;
-    }
+    heuristicActionCheckbox.checked = autoconsentConfig.enableHeuristicAction;
     if (autoconsentConfig.visualTest) {
       visualTestOnRadio.checked = true;
     } else {
@@ -1052,11 +1098,10 @@
     generatedOnRadio.addEventListener("change", generatedChange);
     generatedOffRadio.addEventListener("change", generatedChange);
     function heuristicActionChange() {
-      autoconsentConfig.enableHeuristicAction = heuristicActionOnRadio.checked;
+      autoconsentConfig.enableHeuristicAction = heuristicActionCheckbox.checked;
       storageSet({ config: autoconsentConfig });
     }
-    heuristicActionOnRadio.addEventListener("change", heuristicActionChange);
-    heuristicActionOffRadio.addEventListener("change", heuristicActionChange);
+    heuristicActionCheckbox.addEventListener("change", heuristicActionChange);
     function visualTestChange() {
       autoconsentConfig.visualTest = visualTestOnRadio.checked;
       storageSet({ config: autoconsentConfig });
@@ -1102,10 +1147,141 @@
     logsMessagesCheckbox.addEventListener("change", () => {
       updateLogsConfig();
     });
+    async function loadRuleIndex() {
+      if (!ruleIndexPromise) {
+        ruleIndexPromise = fetch("./rule-index.json").then(async (res) => await res.json());
+      }
+      ruleIndex = await ruleIndexPromise;
+      updateRuleCounts();
+      return ruleIndex;
+    }
+    function updateRuleCounts() {
+      if (!ruleIndex) {
+        return;
+      }
+      const disabledCmps = autoconsentConfig.disabledCmps || [];
+      Object.keys(ruleSectionControls).forEach((section) => {
+        const sectionRules = ruleIndex?.filter((rule) => rule.section === section) || [];
+        const disabledInSection = sectionRules.filter((rule) => disabledCmps.includes(rule.name)).length;
+        const count = ruleSectionControls[section].count;
+        count.textContent = `(${disabledInSection}/${sectionRules.length} disabled)`;
+        count.classList.toggle("rule-count-disabled", disabledInSection > 0);
+      });
+    }
+    function setRuleEnabled(ruleName, enabled) {
+      const disabledCmps = new Set(autoconsentConfig.disabledCmps || []);
+      if (enabled) {
+        disabledCmps.delete(ruleName);
+      } else {
+        disabledCmps.add(ruleName);
+      }
+      autoconsentConfig.disabledCmps = Array.from(disabledCmps).sort();
+      storageSet({ config: autoconsentConfig });
+      updateRuleCounts();
+    }
+    function renderOpenRuleSections() {
+      Object.keys(ruleSectionControls).forEach((section) => {
+        if (ruleSectionControls[section].details.open) {
+          renderRuleSection(section);
+        }
+      });
+    }
+    function setRuleSectionEnabled(section, enabled) {
+      if (!ruleIndex) {
+        return;
+      }
+      const disabledCmps = new Set(autoconsentConfig.disabledCmps || []);
+      ruleIndex.filter((rule) => rule.section === section).forEach((rule) => {
+        if (enabled) {
+          disabledCmps.delete(rule.name);
+        } else {
+          disabledCmps.add(rule.name);
+        }
+      });
+      autoconsentConfig.disabledCmps = Array.from(disabledCmps).sort();
+      storageSet({ config: autoconsentConfig });
+      updateRuleCounts();
+      renderOpenRuleSections();
+    }
+    function renderRuleSection(section) {
+      const controls = ruleSectionControls[section];
+      if (!ruleIndex) {
+        controls.status.textContent = "Rules are not loaded yet.";
+        return;
+      }
+      const disabledCmps = autoconsentConfig.disabledCmps || [];
+      const searchQuery = controls.search.value.trim().toLowerCase();
+      const sectionRules = ruleIndex.filter((rule) => rule.section === section);
+      const matchingRules = sectionRules.filter((rule) => {
+        if (!searchQuery) {
+          return disabledCmps.includes(rule.name);
+        }
+        return rule.name.toLowerCase().includes(searchQuery) || !!rule.urlPattern?.toLowerCase().includes(searchQuery);
+      });
+      const renderedRules = matchingRules.slice(0, maxRenderedRules);
+      const disabledInSection = sectionRules.filter((rule) => disabledCmps.includes(rule.name)).length;
+      controls.status.textContent = searchQuery ? `Showing ${renderedRules.length} of ${matchingRules.length} matches. ${disabledInSection} disabled.` : `Showing ${renderedRules.length} of ${disabledInSection} disabled rules. Search to find enabled rules.`;
+      controls.list.replaceChildren(
+        ...renderedRules.map((rule) => {
+          const checkbox = document.createElement("input");
+          checkbox.type = "checkbox";
+          checkbox.checked = !disabledCmps.includes(rule.name);
+          checkbox.addEventListener("change", () => {
+            setRuleEnabled(rule.name, checkbox.checked);
+            renderRuleSection(section);
+          });
+          const label = document.createElement("label");
+          label.className = "rule-row";
+          label.title = rule.urlPattern ? `${rule.name}
+${rule.urlPattern}` : rule.name;
+          label.append(checkbox, document.createTextNode(` ${rule.name}${rule.cosmetic ? " (cosmetic)" : ""}`));
+          return label;
+        })
+      );
+    }
+    async function loadAndRenderRuleSection(section) {
+      ruleSectionControls[section].status.textContent = "Loading rules...";
+      try {
+        await loadRuleIndex();
+        renderRuleSection(section);
+      } catch (e) {
+        console.error("Failed to load rule index", e);
+        ruleSectionControls[section].status.textContent = "Failed to load rules.";
+      }
+    }
+    Object.keys(ruleSectionControls).forEach((section) => {
+      const controls = ruleSectionControls[section];
+      controls.details.addEventListener("toggle", () => {
+        if (controls.details.open) {
+          loadAndRenderRuleSection(section);
+        }
+      });
+      controls.search.addEventListener("input", () => renderRuleSection(section));
+      controls.enableAll.addEventListener("click", async () => {
+        await loadRuleIndex();
+        setRuleSectionEnabled(section, true);
+      });
+      controls.disableAll.addEventListener("click", async () => {
+        await loadRuleIndex();
+        setRuleSectionEnabled(section, false);
+      });
+    });
+    loadRuleIndex().catch((e) => {
+      console.error("Failed to load rule index", e);
+    });
     ruleReloadButton.addEventListener("click", async () => {
-      const res = await fetch("./rules.json");
-      storageSet({
-        rules: await res.json()
+      const [compactRulesRes, fullRulesRes] = await Promise.all([fetch("./compact-rules.json"), fetch("./rules.json")]);
+      const fullRules = await fullRulesRes.json();
+      await storageSet({
+        rules: await compactRulesRes.json(),
+        fullRules: fullRules.autoconsent
+      });
+      ruleIndexPromise = null;
+      ruleIndex = null;
+      Object.keys(ruleSectionControls).forEach((section) => {
+        if (ruleSectionControls[section].details.open) {
+          loadAndRenderRuleSection(section);
+        }
       });
     });
     resetButton.addEventListener("click", async () => {