@duckduckgo/autoconsent 8.2.0 → 9.0.0

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

@@ -398,181 +398,6 @@
     });
   }
 
-  // lib/config.ts
-  var enableLogs = false;
-
-  // lib/utils.ts
-  function getStyleElement(styleOverrideElementId = "autoconsent-css-rules") {
-    const styleSelector = `style#${styleOverrideElementId}`;
-    const existingElement = document.querySelector(styleSelector);
-    if (existingElement && existingElement instanceof HTMLStyleElement) {
-      return existingElement;
-    } else {
-      const parent = document.head || document.getElementsByTagName("head")[0] || document.documentElement;
-      const css = document.createElement("style");
-      css.id = styleOverrideElementId;
-      parent.appendChild(css);
-      return css;
-    }
-  }
-  function hideElements(styleEl, selector, method = "display") {
-    const hidingSnippet = method === "opacity" ? `opacity: 0` : `display: none`;
-    const rule = `${selector} { ${hidingSnippet} !important; z-index: -1 !important; pointer-events: none !important; } `;
-    if (styleEl instanceof HTMLStyleElement) {
-      styleEl.innerText += rule;
-      return selector.length > 0;
-    }
-    return false;
-  }
-  async function waitFor(predicate, maxTimes, interval) {
-    const result = await predicate();
-    if (!result && maxTimes > 0) {
-      return new Promise((resolve) => {
-        setTimeout(async () => {
-          resolve(waitFor(predicate, maxTimes - 1, interval));
-        }, interval);
-      });
-    }
-    return Promise.resolve(result);
-  }
-  function isElementVisible(elem) {
-    if (!elem) {
-      return false;
-    }
-    if (elem.offsetParent !== null) {
-      return true;
-    } else {
-      const css = window.getComputedStyle(elem);
-      if (css.position === "fixed" && css.display !== "none") {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  // lib/rule-executors.ts
-  function click(selector, all = false) {
-    const elem = elementSelector(selector);
-    enableLogs && console.log("[click]", selector, all, elem);
-    if (elem.length > 0) {
-      if (all) {
-        elem.forEach((e) => e.click());
-      } else {
-        elem[0].click();
-      }
-    }
-    return elem.length > 0;
-  }
-  function elementExists(selector) {
-    const exists = elementSelector(selector).length > 0;
-    return exists;
-  }
-  function elementVisible(selector, check) {
-    const elem = elementSelector(selector);
-    const results = new Array(elem.length);
-    elem.forEach((e, i) => {
-      results[i] = isElementVisible(e);
-    });
-    if (check === "none") {
-      return results.every((r) => !r);
-    } else if (results.length === 0) {
-      return false;
-    } else if (check === "any") {
-      return results.some((r) => r);
-    }
-    return results.every((r) => r);
-  }
-  function waitForElement(selector, timeout = 1e4) {
-    const interval = 200;
-    const times = Math.ceil(timeout / interval);
-    enableLogs && console.log("[waitForElement]", selector);
-    return waitFor(
-      () => elementSelector(selector).length > 0,
-      times,
-      interval
-    );
-  }
-  function waitForVisible(selector, timeout = 1e4, check = "any") {
-    const interval = 200;
-    const times = Math.ceil(timeout / interval);
-    return waitFor(
-      () => elementVisible(selector, check),
-      times,
-      interval
-    );
-  }
-  async function waitForThenClick2(selector, timeout = 1e4, all = false) {
-    await waitForElement(selector, timeout);
-    return click(selector, all);
-  }
-  function wait(ms) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve(true);
-      }, ms);
-    });
-  }
-  function hide(selector, method) {
-    const styleEl = getStyleElement();
-    return hideElements(styleEl, selector, method);
-  }
-  function prehide(selector) {
-    const styleEl = getStyleElement("autoconsent-prehide");
-    enableLogs && console.log("[prehide]", styleEl, location.href);
-    return hideElements(styleEl, selector, "opacity");
-  }
-  function undoPrehide() {
-    const existingElement = getStyleElement("autoconsent-prehide");
-    enableLogs && console.log("[undoprehide]", existingElement, location.href);
-    if (existingElement) {
-      existingElement.remove();
-    }
-    return !!existingElement;
-  }
-  function querySingleReplySelector(selector, parent = document) {
-    if (selector.startsWith("aria/")) {
-      return [];
-    }
-    if (selector.startsWith("xpath/")) {
-      const xpath = selector.slice(6);
-      const result = document.evaluate(xpath, parent, null, XPathResult.ANY_TYPE, null);
-      let node = null;
-      const elements = [];
-      while (node = result.iterateNext()) {
-        elements.push(node);
-      }
-      return elements;
-    }
-    if (selector.startsWith("text/")) {
-      return [];
-    }
-    if (selector.startsWith("pierce/")) {
-      return [];
-    }
-    if (parent.shadowRoot) {
-      return Array.from(parent.shadowRoot.querySelectorAll(selector));
-    }
-    return Array.from(parent.querySelectorAll(selector));
-  }
-  function querySelectorChain(selectors) {
-    let parent = document;
-    let matches2;
-    for (const selector of selectors) {
-      matches2 = querySingleReplySelector(selector, parent);
-      if (matches2.length === 0) {
-        return [];
-      }
-      parent = matches2[0];
-    }
-    return matches2;
-  }
-  function elementSelector(selector) {
-    if (typeof selector === "string") {
-      return querySingleReplySelector(selector);
-    }
-    return querySelectorChain(selector);
-  }
-
   // lib/random.ts
   function getRandomID() {
     if (crypto && typeof crypto.randomUUID !== "undefined") {
@@ -782,20 +607,21 @@
         console.warn("Snippet not found", snippetId);
         return Promise.resolve(false);
       }
+      const logsConfig = this.autoconsent.config.logs;
       if (this.autoconsent.config.isMainWorld) {
-        enableLogs && console.log("inline eval:", snippetId, snippet);
+        logsConfig.evals && console.log("inline eval:", snippetId, snippet);
         let result = false;
         try {
           result = !!snippet.call(globalThis);
         } catch (e) {
-          enableLogs && console.error("error evaluating rule", snippetId, e);
+          logsConfig.evals && console.error("error evaluating rule", snippetId, e);
         }
         return Promise.resolve(result);
       }
       const snippetSrc = getFunctionBody(snippet);
-      enableLogs && console.log("async eval:", snippetId, snippetSrc);
+      logsConfig.evals && console.log("async eval:", snippetId, snippetSrc);
       return requestEval(snippetSrc, snippetId).catch((e) => {
-        enableLogs && console.error("error evaluating rule", snippetId, e);
+        logsConfig.evals && console.error("error evaluating rule", snippetId, e);
         return false;
       });
     }
@@ -834,93 +660,136 @@
     async test() {
       return Promise.resolve(true);
     }
+    // Implementing DomActionsProvider below:
+    click(selector, all = false) {
+      return this.autoconsent.domActions.click(selector, all);
+    }
+    elementExists(selector) {
+      return this.autoconsent.domActions.elementExists(selector);
+    }
+    elementVisible(selector, check) {
+      return this.autoconsent.domActions.elementVisible(selector, check);
+    }
+    waitForElement(selector, timeout) {
+      return this.autoconsent.domActions.waitForElement(selector, timeout);
+    }
+    waitForVisible(selector, timeout, check) {
+      return this.autoconsent.domActions.waitForVisible(selector, timeout, check);
+    }
+    waitForThenClick(selector, timeout, all) {
+      return this.autoconsent.domActions.waitForThenClick(selector, timeout, all);
+    }
+    wait(ms) {
+      return this.autoconsent.domActions.wait(ms);
+    }
+    hide(selector, method) {
+      return this.autoconsent.domActions.hide(selector, method);
+    }
+    prehide(selector) {
+      return this.autoconsent.domActions.prehide(selector);
+    }
+    undoPrehide() {
+      return this.autoconsent.domActions.undoPrehide();
+    }
+    querySingleReplySelector(selector, parent) {
+      return this.autoconsent.domActions.querySingleReplySelector(selector, parent);
+    }
+    querySelectorChain(selectors) {
+      return this.autoconsent.domActions.querySelectorChain(selectors);
+    }
+    elementSelector(selector) {
+      return this.autoconsent.domActions.elementSelector(selector);
+    }
   };
   var AutoConsentCMP = class extends AutoConsentCMPBase {
-    constructor(config, autoconsentInstance) {
+    constructor(rule, autoconsentInstance) {
       super(autoconsentInstance);
-      this.config = config;
-      this.name = config.name;
-      this.runContext = config.runContext || defaultRunContext;
+      this.rule = rule;
+      this.name = rule.name;
+      this.runContext = rule.runContext || defaultRunContext;
     }
     get hasSelfTest() {
-      return !!this.config.test;
+      return !!this.rule.test;
     }
     get isIntermediate() {
-      return !!this.config.intermediate;
+      return !!this.rule.intermediate;
     }
     get isCosmetic() {
-      return !!this.config.cosmetic;
+      return !!this.rule.cosmetic;
     }
     get prehideSelectors() {
-      return this.config.prehideSelectors;
+      return this.rule.prehideSelectors;
     }
     async detectCmp() {
-      if (this.config.detectCmp) {
-        return this._runRulesParallel(this.config.detectCmp);
+      if (this.rule.detectCmp) {
+        return this._runRulesParallel(this.rule.detectCmp);
       }
       return false;
     }
     async detectPopup() {
-      if (this.config.detectPopup) {
-        return this._runRulesSequentially(this.config.detectPopup);
+      if (this.rule.detectPopup) {
+        return this._runRulesSequentially(this.rule.detectPopup);
       }
       return false;
     }
     async optOut() {
-      if (this.config.optOut) {
-        enableLogs && console.log("Initiated optOut()", this.config.optOut);
-        return this._runRulesSequentially(this.config.optOut);
+      const logsConfig = this.autoconsent.config.logs;
+      if (this.rule.optOut) {
+        logsConfig.lifecycle && console.log("Initiated optOut()", this.rule.optOut);
+        return this._runRulesSequentially(this.rule.optOut);
       }
       return false;
     }
     async optIn() {
-      if (this.config.optIn) {
-        enableLogs && console.log("Initiated optIn()", this.config.optIn);
-        return this._runRulesSequentially(this.config.optIn);
+      const logsConfig = this.autoconsent.config.logs;
+      if (this.rule.optIn) {
+        logsConfig.lifecycle && console.log("Initiated optIn()", this.rule.optIn);
+        return this._runRulesSequentially(this.rule.optIn);
       }
       return false;
     }
     async openCmp() {
-      if (this.config.openCmp) {
-        return this._runRulesSequentially(this.config.openCmp);
+      if (this.rule.openCmp) {
+        return this._runRulesSequentially(this.rule.openCmp);
       }
       return false;
     }
     async test() {
       if (this.hasSelfTest) {
-        return this._runRulesSequentially(this.config.test);
+        return this._runRulesSequentially(this.rule.test);
       }
       return super.test();
     }
     async evaluateRuleStep(rule) {
       const results = [];
+      const logsConfig = this.autoconsent.config.logs;
       if (rule.exists) {
-        results.push(elementExists(rule.exists));
+        results.push(this.elementExists(rule.exists));
       }
       if (rule.visible) {
-        results.push(elementVisible(rule.visible, rule.check));
+        results.push(this.elementVisible(rule.visible, rule.check));
       }
       if (rule.eval) {
         const res = this.mainWorldEval(rule.eval);
         results.push(res);
       }
       if (rule.waitFor) {
-        results.push(waitForElement(rule.waitFor, rule.timeout));
+        results.push(this.waitForElement(rule.waitFor, rule.timeout));
       }
       if (rule.waitForVisible) {
-        results.push(waitForVisible(rule.waitForVisible, rule.timeout, rule.check));
+        results.push(this.waitForVisible(rule.waitForVisible, rule.timeout, rule.check));
       }
       if (rule.click) {
-        results.push(click(rule.click, rule.all));
+        results.push(this.click(rule.click, rule.all));
       }
       if (rule.waitForThenClick) {
-        results.push(waitForThenClick2(rule.waitForThenClick, rule.timeout, rule.all));
+        results.push(this.waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all));
       }
       if (rule.wait) {
-        results.push(wait(rule.wait));
+        results.push(this.wait(rule.wait));
       }
       if (rule.hide) {
-        results.push(hide(rule.hide, rule.method));
+        results.push(this.hide(rule.hide, rule.method));
       }
       if (rule.if) {
         if (!rule.if.exists && !rule.if.visible) {
@@ -928,7 +797,7 @@
           return false;
         }
         const condition = await this.evaluateRuleStep(rule.if);
-        enableLogs && console.log("Condition is", condition);
+        logsConfig.rulesteps && console.log("Condition is", condition);
         if (condition) {
           results.push(this._runRulesSequentially(rule.then));
         } else if (rule.else) {
@@ -944,7 +813,7 @@
         return false;
       }
       if (results.length === 0) {
-        enableLogs && console.warn("Unrecognized rule", rule);
+        logsConfig.errors && console.warn("Unrecognized rule", rule);
         return false;
       }
       const all = await Promise.all(results);
@@ -956,10 +825,11 @@
       return detections.every((r) => !!r);
     }
     async _runRulesSequentially(rules) {
+      const logsConfig = this.autoconsent.config.logs;
       for (const rule of rules) {
-        enableLogs && console.log("Running rule...", rule);
+        logsConfig.rulesteps && console.log("Running rule...", rule);
         const result = await this.evaluateRuleStep(rule);
-        enableLogs && console.log("...rule result", result);
+        logsConfig.rulesteps && console.log("...rule result", result);
         if (!result && !rule.optional) {
           return false;
         }
@@ -1033,6 +903,82 @@
     }
   };
 
+  // lib/utils.ts
+  function getStyleElement(styleOverrideElementId = "autoconsent-css-rules") {
+    const styleSelector = `style#${styleOverrideElementId}`;
+    const existingElement = document.querySelector(styleSelector);
+    if (existingElement && existingElement instanceof HTMLStyleElement) {
+      return existingElement;
+    } else {
+      const parent = document.head || document.getElementsByTagName("head")[0] || document.documentElement;
+      const css = document.createElement("style");
+      css.id = styleOverrideElementId;
+      parent.appendChild(css);
+      return css;
+    }
+  }
+  function hideElements(styleEl, selector, method = "display") {
+    const hidingSnippet = method === "opacity" ? `opacity: 0` : `display: none`;
+    const rule = `${selector} { ${hidingSnippet} !important; z-index: -1 !important; pointer-events: none !important; } `;
+    if (styleEl instanceof HTMLStyleElement) {
+      styleEl.innerText += rule;
+      return selector.length > 0;
+    }
+    return false;
+  }
+  async function waitFor(predicate, maxTimes, interval) {
+    const result = await predicate();
+    if (!result && maxTimes > 0) {
+      return new Promise((resolve) => {
+        setTimeout(async () => {
+          resolve(waitFor(predicate, maxTimes - 1, interval));
+        }, interval);
+      });
+    }
+    return Promise.resolve(result);
+  }
+  function isElementVisible(elem) {
+    if (!elem) {
+      return false;
+    }
+    if (elem.offsetParent !== null) {
+      return true;
+    } else {
+      const css = window.getComputedStyle(elem);
+      if (css.position === "fixed" && css.display !== "none") {
+        return true;
+      }
+    }
+    return false;
+  }
+  function normalizeConfig(providedConfig) {
+    const defaultConfig = {
+      enabled: true,
+      autoAction: "optOut",
+      // if falsy, the extension will wait for an explicit user signal before opting in/out
+      disabledCmps: [],
+      enablePrehide: true,
+      enableCosmeticRules: true,
+      detectRetries: 20,
+      isMainWorld: false,
+      prehideTimeout: 2e3,
+      logs: {
+        lifecycle: false,
+        rulesteps: false,
+        evals: false,
+        errors: true,
+        messages: false
+      }
+    };
+    const updatedConfig = structuredClone(defaultConfig);
+    for (const key of Object.keys(defaultConfig)) {
+      if (typeof providedConfig[key] !== "undefined") {
+        updatedConfig[key] = providedConfig[key];
+      }
+    }
+    return updatedConfig;
+  }
+
   // lib/cmps/trustarc-top.ts
   var cookieSettingsButton = "#truste-show-consent";
   var shortcutOptOut = "#truste-consent-required";
@@ -1068,17 +1014,17 @@
       return false;
     }
     async detectCmp() {
-      const result = elementExists(`${cookieSettingsButton},${bannerContainer}`);
+      const result = this.elementExists(`${cookieSettingsButton},${bannerContainer}`);
       if (result) {
         this._shortcutButton = document.querySelector(shortcutOptOut);
       }
       return result;
     }
     async detectPopup() {
-      return elementVisible(`${popupContent},${bannerOverlay},${bannerContainer}`, "all");
+      return this.elementVisible(`${popupContent},${bannerOverlay},${bannerContainer}`, "all");
     }
     openFrame() {
-      click(cookieSettingsButton);
+      this.click(cookieSettingsButton);
     }
     async optOut() {
       if (this._shortcutButton) {
@@ -1089,7 +1035,7 @@
         getStyleElement(),
         `.truste_popframe, .truste_overlay, .truste_box_overlay, ${bannerContainer}`
       );
-      click(cookieSettingsButton);
+      this.click(cookieSettingsButton);
       setTimeout(() => {
         getStyleElement().remove();
       }, 1e4);
@@ -1097,7 +1043,7 @@
     }
     async optIn() {
       this._optInDone = true;
-      return click(shortcutOptIn);
+      return this.click(shortcutOptIn);
     }
     async openCmp() {
       return true;
@@ -1131,62 +1077,62 @@
       return true;
     }
     async detectPopup() {
-      return elementVisible("#defaultpreferencemanager", "any") && elementVisible(".mainContent", "any");
+      return this.elementVisible("#defaultpreferencemanager", "any") && this.elementVisible(".mainContent", "any");
     }
     async navigateToSettings() {
       await waitFor(
         async () => {
-          return elementExists(".shp") || elementVisible(".advance", "any") || elementExists(".switch span:first-child");
+          return this.elementExists(".shp") || this.elementVisible(".advance", "any") || this.elementExists(".switch span:first-child");
         },
         10,
         500
       );
-      if (elementExists(".shp")) {
-        click(".shp");
+      if (this.elementExists(".shp")) {
+        this.click(".shp");
       }
-      await waitForElement(".prefPanel", 5e3);
-      if (elementVisible(".advance", "any")) {
-        click(".advance");
+      await this.waitForElement(".prefPanel", 5e3);
+      if (this.elementVisible(".advance", "any")) {
+        this.click(".advance");
       }
       return await waitFor(
-        () => elementVisible(".switch span:first-child", "any"),
+        () => this.elementVisible(".switch span:first-child", "any"),
         5,
         1e3
       );
     }
     async optOut() {
       await waitFor(() => document.readyState === "complete", 20, 100);
-      await waitForElement(".mainContent[aria-hidden=false]", 5e3);
-      if (click(".rejectAll")) {
+      await this.waitForElement(".mainContent[aria-hidden=false]", 5e3);
+      if (this.click(".rejectAll")) {
         return true;
       }
-      if (elementExists(".prefPanel")) {
-        await waitForElement('.prefPanel[style="visibility: visible;"]', 3e3);
+      if (this.elementExists(".prefPanel")) {
+        await this.waitForElement('.prefPanel[style="visibility: visible;"]', 3e3);
       }
-      if (click("#catDetails0")) {
-        click(".submit");
-        waitForThenClick("#gwt-debug-close_id", 5e3);
+      if (this.click("#catDetails0")) {
+        this.click(".submit");
+        this.waitForThenClick("#gwt-debug-close_id", 5e3);
         return true;
       }
-      if (click(".required")) {
-        waitForThenClick("#gwt-debug-close_id", 5e3);
+      if (this.click(".required")) {
+        this.waitForThenClick("#gwt-debug-close_id", 5e3);
         return true;
       }
       await this.navigateToSettings();
-      click(".switch span:nth-child(1):not(.active)", true);
-      click(".submit");
-      waitForThenClick("#gwt-debug-close_id", 3e5);
+      this.click(".switch span:nth-child(1):not(.active)", true);
+      this.click(".submit");
+      this.waitForThenClick("#gwt-debug-close_id", 3e5);
       return true;
     }
     async optIn() {
-      if (click(".call")) {
+      if (this.click(".call")) {
         return true;
       }
       await this.navigateToSettings();
-      click(".switch span:nth-child(2)", true);
-      click(".submit");
-      waitForElement("#gwt-debug-close_id", 3e5).then(() => {
-        click("#gwt-debug-close_id");
+      this.click(".switch span:nth-child(2)", true);
+      this.click(".submit");
+      this.waitForElement("#gwt-debug-close_id", 3e5).then(() => {
+        this.click("#gwt-debug-close_id");
       });
       return true;
     }
@@ -1215,23 +1161,23 @@
       return this.mainWorldEval("EVAL_COOKIEBOT_2");
     }
     async optOut() {
-      await wait(500);
+      await this.wait(500);
       let res = await this.mainWorldEval("EVAL_COOKIEBOT_3");
-      await wait(500);
+      await this.wait(500);
       res = res && await this.mainWorldEval("EVAL_COOKIEBOT_4");
       return res;
     }
     async optIn() {
-      if (elementExists("#dtcookie-container")) {
-        return click(".h-dtcookie-accept");
+      if (this.elementExists("#dtcookie-container")) {
+        return this.click(".h-dtcookie-accept");
       }
-      click(".CybotCookiebotDialogBodyLevelButton:not(:checked):enabled", true);
-      click("#CybotCookiebotDialogBodyLevelButtonAccept");
-      click("#CybotCookiebotDialogBodyButtonAccept");
+      this.click(".CybotCookiebotDialogBodyLevelButton:not(:checked):enabled", true);
+      this.click("#CybotCookiebotDialogBodyLevelButtonAccept");
+      this.click("#CybotCookiebotDialogBodyButtonAccept");
       return true;
     }
     async test() {
-      await wait(500);
+      await this.wait(500);
       return await this.mainWorldEval("EVAL_COOKIEBOT_5");
     }
   };
@@ -1275,17 +1221,17 @@
         return true;
       }
       if (this.ccpaPopup) {
-        return await waitForElement(".priv-save-btn", 2e3);
+        return await this.waitForElement(".priv-save-btn", 2e3);
       }
-      await waitForElement(".sp_choice_type_11,.sp_choice_type_12,.sp_choice_type_13,.sp_choice_type_ACCEPT_ALL,.sp_choice_type_SAVE_AND_EXIT", 2e3);
-      return !elementExists(".sp_choice_type_9");
+      await this.waitForElement(".sp_choice_type_11,.sp_choice_type_12,.sp_choice_type_13,.sp_choice_type_ACCEPT_ALL,.sp_choice_type_SAVE_AND_EXIT", 2e3);
+      return !this.elementExists(".sp_choice_type_9");
     }
     async optIn() {
-      await waitForElement(".sp_choice_type_11,.sp_choice_type_ACCEPT_ALL", 2e3);
-      if (click(".sp_choice_type_11")) {
+      await this.waitForElement(".sp_choice_type_11,.sp_choice_type_ACCEPT_ALL", 2e3);
+      if (this.click(".sp_choice_type_11")) {
         return true;
       }
-      if (click(".sp_choice_type_ACCEPT_ALL")) {
+      if (this.click(".sp_choice_type_ACCEPT_ALL")) {
         return true;
       }
       return false;
@@ -1294,6 +1240,7 @@
       return location.pathname === "/privacy-manager/index.html" || location.pathname === "/ccpa_pm/index.html";
     }
     async optOut() {
+      const logsConfig = this.autoconsent.config.logs;
       if (this.ccpaPopup) {
         const toggles = document.querySelectorAll(".priv-purpose-container .sp-switch-arrow-block a.neutral.on .right");
         for (const t of toggles) {
@@ -1303,47 +1250,47 @@
         for (const t of switches) {
           t.click();
         }
-        return click(".priv-save-btn");
+        return this.click(".priv-save-btn");
       }
       if (!this.isManagerOpen()) {
-        const actionable = await waitForElement(".sp_choice_type_12,.sp_choice_type_13");
+        const actionable = await this.waitForElement(".sp_choice_type_12,.sp_choice_type_13");
         if (!actionable) {
           return false;
         }
-        if (!elementExists(".sp_choice_type_12")) {
-          return click(".sp_choice_type_13");
+        if (!this.elementExists(".sp_choice_type_12")) {
+          return this.click(".sp_choice_type_13");
         }
-        click(".sp_choice_type_12");
+        this.click(".sp_choice_type_12");
         await waitFor(
           () => this.isManagerOpen(),
           200,
           100
         );
       }
-      await waitForElement(".type-modal", 2e4);
-      waitForThenClick2(".ccpa-stack .pm-switch[aria-checked=true] .slider", 500, true);
+      await this.waitForElement(".type-modal", 2e4);
+      this.waitForThenClick(".ccpa-stack .pm-switch[aria-checked=true] .slider", 500, true);
       try {
         const rejectSelector1 = ".sp_choice_type_REJECT_ALL";
         const rejectSelector2 = ".reject-toggle";
         const path = await Promise.race([
-          waitForElement(rejectSelector1, 2e3).then((success) => success ? 0 : -1),
-          waitForElement(rejectSelector2, 2e3).then((success) => success ? 1 : -1),
-          waitForElement(".pm-features", 2e3).then((success) => success ? 2 : -1)
+          this.waitForElement(rejectSelector1, 2e3).then((success) => success ? 0 : -1),
+          this.waitForElement(rejectSelector2, 2e3).then((success) => success ? 1 : -1),
+          this.waitForElement(".pm-features", 2e3).then((success) => success ? 2 : -1)
         ]);
         if (path === 0) {
-          await wait(1e3);
-          return click(rejectSelector1);
+          await this.wait(1e3);
+          return this.click(rejectSelector1);
         } else if (path === 1) {
-          click(rejectSelector2);
+          this.click(rejectSelector2);
         } else if (path === 2) {
-          await waitForElement(".pm-features", 1e4);
-          click(".checked > span", true);
-          click(".chevron");
+          await this.waitForElement(".pm-features", 1e4);
+          this.click(".checked > span", true);
+          this.click(".chevron");
         }
       } catch (e) {
-        enableLogs && console.warn(e);
+        logsConfig.errors && console.warn(e);
       }
-      return click(".sp_choice_type_SAVE_AND_EXIT");
+      return this.click(".sp_choice_type_SAVE_AND_EXIT");
     }
   };
 
@@ -1367,42 +1314,42 @@
     async detectCmp() {
       this.apiAvailable = await this.mainWorldEval("EVAL_CONSENTMANAGER_1");
       if (!this.apiAvailable) {
-        return elementExists("#cmpbox");
+        return this.elementExists("#cmpbox");
       } else {
         return true;
       }
     }
     async detectPopup() {
       if (this.apiAvailable) {
-        await wait(500);
+        await this.wait(500);
         return await this.mainWorldEval("EVAL_CONSENTMANAGER_2");
       }
-      return elementVisible("#cmpbox .cmpmore", "any");
+      return this.elementVisible("#cmpbox .cmpmore", "any");
     }
     async optOut() {
-      await wait(500);
+      await this.wait(500);
       if (this.apiAvailable) {
         return await this.mainWorldEval("EVAL_CONSENTMANAGER_3");
       }
-      if (click(".cmpboxbtnno")) {
+      if (this.click(".cmpboxbtnno")) {
         return true;
       }
-      if (elementExists(".cmpwelcomeprpsbtn")) {
-        click(".cmpwelcomeprpsbtn > a[aria-checked=true]", true);
-        click(".cmpboxbtnsave");
+      if (this.elementExists(".cmpwelcomeprpsbtn")) {
+        this.click(".cmpwelcomeprpsbtn > a[aria-checked=true]", true);
+        this.click(".cmpboxbtnsave");
         return true;
       }
-      click(".cmpboxbtncustom");
-      await waitForElement(".cmptblbox", 2e3);
-      click(".cmptdchoice > a[aria-checked=true]", true);
-      click(".cmpboxbtnyescustomchoices");
+      this.click(".cmpboxbtncustom");
+      await this.waitForElement(".cmptblbox", 2e3);
+      this.click(".cmptdchoice > a[aria-checked=true]", true);
+      this.click(".cmpboxbtnyescustomchoices");
       return true;
     }
     async optIn() {
       if (this.apiAvailable) {
         return await this.mainWorldEval("EVAL_CONSENTMANAGER_4");
       }
-      return click(".cmpboxbtnyes");
+      return this.click(".cmpboxbtnyes");
     }
     async test() {
       if (this.apiAvailable) {
@@ -1427,23 +1374,23 @@
       return false;
     }
     async detectCmp() {
-      return elementExists("#_evidon_banner");
+      return this.elementExists("#_evidon_banner");
     }
     async detectPopup() {
-      return elementVisible("#_evidon_banner", "any");
+      return this.elementVisible("#_evidon_banner", "any");
     }
     async optOut() {
-      if (click("#_evidon-decline-button")) {
+      if (this.click("#_evidon-decline-button")) {
         return true;
       }
       hideElements(getStyleElement(), "#evidon-prefdiag-overlay,#evidon-prefdiag-background");
-      click("#_evidon-option-button");
-      await waitForElement("#evidon-prefdiag-overlay", 5e3);
-      click("#evidon-prefdiag-decline");
+      this.click("#_evidon-option-button");
+      await this.waitForElement("#evidon-prefdiag-overlay", 5e3);
+      this.click("#evidon-prefdiag-decline");
       return true;
     }
     async optIn() {
-      return click("#_evidon-accept-button");
+      return this.click("#_evidon-accept-button");
     }
   };
 
@@ -1467,31 +1414,31 @@
       return false;
     }
     async detectCmp() {
-      return elementExists("#onetrust-banner-sdk");
+      return this.elementExists("#onetrust-banner-sdk");
     }
     async detectPopup() {
-      return elementVisible("#onetrust-banner-sdk", "all");
+      return this.elementVisible("#onetrust-banner-sdk", "all");
     }
     async optOut() {
-      if (elementVisible("#onetrust-reject-all-handler,.js-reject-cookies", "any")) {
-        return click("#onetrust-reject-all-handler,.js-reject-cookies");
+      if (this.elementVisible("#onetrust-reject-all-handler,.js-reject-cookies", "any")) {
+        return this.click("#onetrust-reject-all-handler,.js-reject-cookies");
       }
-      if (elementExists("#onetrust-pc-btn-handler")) {
-        click("#onetrust-pc-btn-handler");
+      if (this.elementExists("#onetrust-pc-btn-handler")) {
+        this.click("#onetrust-pc-btn-handler");
       } else {
-        click(".ot-sdk-show-settings,button.js-cookie-settings");
-      }
-      await waitForElement("#onetrust-consent-sdk", 2e3);
-      await wait(1e3);
-      click("#onetrust-consent-sdk input.category-switch-handler:checked,.js-editor-toggle-state:checked", true);
-      await wait(1e3);
-      await waitForElement(".save-preference-btn-handler,.js-consent-save", 2e3);
-      click(".save-preference-btn-handler,.js-consent-save");
-      await waitForVisible("#onetrust-banner-sdk", 5e3, "none");
+        this.click(".ot-sdk-show-settings,button.js-cookie-settings");
+      }
+      await this.waitForElement("#onetrust-consent-sdk", 2e3);
+      await this.wait(1e3);
+      this.click("#onetrust-consent-sdk input.category-switch-handler:checked,.js-editor-toggle-state:checked", true);
+      await this.wait(1e3);
+      await this.waitForElement(".save-preference-btn-handler,.js-consent-save", 2e3);
+      this.click(".save-preference-btn-handler,.js-consent-save");
+      await this.waitForVisible("#onetrust-banner-sdk", 5e3, "none");
       return true;
     }
     async optIn() {
-      return click("#onetrust-accept-btn-handler,.js-accept-cookies");
+      return this.click("#onetrust-accept-btn-handler,.js-accept-cookies");
     }
     async test() {
       return await waitFor(
@@ -1520,39 +1467,39 @@
       return false;
     }
     async detectCmp() {
-      if (elementExists(".klaro > .cookie-modal")) {
+      if (this.elementExists(".klaro > .cookie-modal")) {
         this.settingsOpen = true;
         return true;
       }
-      return elementExists(".klaro > .cookie-notice");
+      return this.elementExists(".klaro > .cookie-notice");
     }
     async detectPopup() {
-      return elementVisible(".klaro > .cookie-notice,.klaro > .cookie-modal", "any");
+      return this.elementVisible(".klaro > .cookie-notice,.klaro > .cookie-modal", "any");
     }
     async optOut() {
-      if (click(".klaro .cn-decline")) {
+      if (this.click(".klaro .cn-decline")) {
         return true;
       }
       if (!this.settingsOpen) {
-        click(".klaro .cn-learn-more,.klaro .cm-button-manage");
-        await waitForElement(".klaro > .cookie-modal", 2e3);
+        this.click(".klaro .cn-learn-more,.klaro .cm-button-manage");
+        await this.waitForElement(".klaro > .cookie-modal", 2e3);
         this.settingsOpen = true;
       }
-      if (click(".klaro .cn-decline")) {
+      if (this.click(".klaro .cn-decline")) {
         return true;
       }
-      click(".cm-purpose:not(.cm-toggle-all) > input:not(.half-checked,.required,.only-required),.cm-purpose:not(.cm-toggle-all) > div > input:not(.half-checked,.required,.only-required)", true);
-      return click(".cm-btn-accept,.cm-button");
+      this.click(".cm-purpose:not(.cm-toggle-all) > input:not(.half-checked,.required,.only-required),.cm-purpose:not(.cm-toggle-all) > div > input:not(.half-checked,.required,.only-required)", true);
+      return this.click(".cm-btn-accept,.cm-button");
     }
     async optIn() {
-      if (click(".klaro .cm-btn-accept-all")) {
+      if (this.click(".klaro .cm-btn-accept-all")) {
         return true;
       }
       if (this.settingsOpen) {
-        click(".cm-purpose:not(.cm-toggle-all) > input.half-checked", true);
-        return click(".cm-btn-accept");
+        this.click(".cm-purpose:not(.cm-toggle-all) > input.half-checked", true);
+        return this.click(".cm-btn-accept");
       }
-      return click(".klaro .cookie-notice .cm-btn-success");
+      return this.click(".klaro .cookie-notice .cm-btn-success");
     }
     async test() {
       return await this.mainWorldEval("EVAL_KLARO_1");
@@ -1578,21 +1525,21 @@
       return false;
     }
     async detectCmp() {
-      return elementExists(".unic .unic-box,.unic .unic-bar");
+      return this.elementExists(".unic .unic-box,.unic .unic-bar");
     }
     async detectPopup() {
-      return elementVisible(".unic .unic-box,.unic .unic-bar", "any");
+      return this.elementVisible(".unic .unic-box,.unic .unic-bar", "any");
     }
     async optOut() {
-      await waitForElement(".unic button", 1e3);
+      await this.waitForElement(".unic button", 1e3);
       document.querySelectorAll(".unic button").forEach((button) => {
         const text = button.textContent;
         if (text.includes("Manage Options") || text.includes("Optionen verwalten")) {
           button.click();
         }
       });
-      if (await waitForElement(".unic input[type=checkbox]", 1e3)) {
-        await waitForElement(".unic button", 1e3);
+      if (await this.waitForElement(".unic input[type=checkbox]", 1e3)) {
+        await this.waitForElement(".unic button", 1e3);
         document.querySelectorAll(".unic input[type=checkbox]").forEach((c) => {
           if (c.checked) {
             c.click();
@@ -1603,7 +1550,7 @@
           for (const pattern of ["Confirm Choices", "Save Choices", "Auswahl speichern"]) {
             if (text.includes(pattern)) {
               b.click();
-              await wait(500);
+              await this.wait(500);
               return true;
             }
           }
@@ -1612,11 +1559,11 @@
       return false;
     }
     async optIn() {
-      return waitForThenClick2(".unic #unic-agree");
+      return this.waitForThenClick(".unic #unic-agree");
     }
     async test() {
-      await wait(1e3);
-      const res = elementExists(".unic .unic-box,.unic .unic-bar");
+      await this.wait(1e3);
+      const res = this.elementExists(".unic .unic-box,.unic .unic-bar");
       return !res;
     }
   };
@@ -1638,20 +1585,20 @@
       return false;
     }
     async detectCmp() {
-      return elementExists(".cmp-root .cmp-receptacle");
+      return this.elementExists(".cmp-root .cmp-receptacle");
     }
     async detectPopup() {
-      return elementVisible(".cmp-root .cmp-receptacle", "any");
+      return this.elementVisible(".cmp-root .cmp-receptacle", "any");
     }
     async optOut() {
-      if (!await waitForThenClick2(".cmp-main-button:not(.cmp-main-button--primary)")) {
+      if (!await this.waitForThenClick(".cmp-main-button:not(.cmp-main-button--primary)")) {
         return false;
       }
-      if (!await waitForElement(".cmp-view-tab-tabs")) {
+      if (!await this.waitForElement(".cmp-view-tab-tabs")) {
         return false;
       }
-      await waitForThenClick2(".cmp-view-tab-tabs > :first-child");
-      await waitForThenClick2(".cmp-view-tab-tabs > .cmp-view-tab--active:first-child");
+      await this.waitForThenClick(".cmp-view-tab-tabs > :first-child");
+      await this.waitForThenClick(".cmp-view-tab-tabs > .cmp-view-tab--active:first-child");
       for (const item of Array.from(document.querySelectorAll(".cmp-accordion-item"))) {
         item.querySelector(".cmp-accordion-item-title").click();
         await waitFor(() => !!item.querySelector(".cmp-accordion-item-content.cmp-active"), 10, 50);
@@ -1659,11 +1606,11 @@
         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());
       }
-      await click(".cmp-main-button:not(.cmp-main-button--primary)");
+      await this.click(".cmp-main-button:not(.cmp-main-button--primary)");
       return true;
     }
     async optIn() {
-      return waitForThenClick2(".cmp-main-button.cmp-main-button--primary");
+      return this.waitForThenClick(".cmp-main-button.cmp-main-button--primary");
     }
     async test() {
       return document.cookie.includes("cmp-data=0");
@@ -1696,31 +1643,33 @@
       return container.shadowRoot;
     }
     async detectCmp() {
-      return elementExists("tiktok-cookie-banner");
+      return this.elementExists("tiktok-cookie-banner");
     }
     async detectPopup() {
       const banner = this.getShadowRoot().querySelector(".tiktok-cookie-banner");
       return isElementVisible(banner);
     }
     async optOut() {
+      const logsConfig = this.autoconsent.config.logs;
       const declineButton = this.getShadowRoot().querySelector(".button-wrapper button:first-child");
       if (declineButton) {
-        enableLogs && console.log("[clicking]", declineButton);
+        logsConfig.rulesteps && console.log("[clicking]", declineButton);
         declineButton.click();
         return true;
       } else {
-        enableLogs && console.log("no decline button found");
+        logsConfig.errors && console.log("no decline button found");
         return false;
       }
     }
     async optIn() {
+      const logsConfig = this.autoconsent.config.logs;
       const acceptButton = this.getShadowRoot().querySelector(".button-wrapper button:last-child");
       if (acceptButton) {
-        enableLogs && console.log("[clicking]", acceptButton);
+        logsConfig.rulesteps && console.log("[clicking]", acceptButton);
         acceptButton.click();
         return true;
       } else {
-        enableLogs && console.log("no accept button found");
+        logsConfig.errors && console.log("no accept button found");
         return false;
       }
     }
@@ -1756,21 +1705,21 @@
       return false;
     }
     async detectCmp() {
-      return elementExists("div[data-testid=main-cookies-banner-container]");
+      return this.elementExists("div[data-testid=main-cookies-banner-container]");
     }
     async detectPopup() {
-      return elementVisible("div[data-testid=main-cookies-banner-container", "any");
+      return this.elementVisible("div[data-testid=main-cookies-banner-container", "any");
     }
     async optOut() {
-      await waitForThenClick2("div[data-testid=main-cookies-banner-container] button._snbhip0");
+      await this.waitForThenClick("div[data-testid=main-cookies-banner-container] button._snbhip0");
       let check;
       while (check = document.querySelector("[data-testid=modal-container] button[aria-checked=true]:not([disabled])")) {
         check.click();
       }
-      return waitForThenClick2("button[data-testid=save-btn]");
+      return this.waitForThenClick("button[data-testid=save-btn]");
     }
     async optIn() {
-      return waitForThenClick2("div[data-testid=main-cookies-banner-container] button._148dgdpk");
+      return this.waitForThenClick("div[data-testid=main-cookies-banner-container] button._148dgdpk");
     }
     async test() {
       return await waitFor(
@@ -1797,6 +1746,134 @@
     Airbnb
   ];
 
+  // lib/dom-actions.ts
+  var DomActions = class {
+    constructor(autoconsentInstance) {
+      this.autoconsentInstance = autoconsentInstance;
+    }
+    click(selector, all = false) {
+      const elem = this.elementSelector(selector);
+      this.autoconsentInstance.config.logs.rulesteps && console.log("[click]", selector, all, elem);
+      if (elem.length > 0) {
+        if (all) {
+          elem.forEach((e) => e.click());
+        } else {
+          elem[0].click();
+        }
+      }
+      return elem.length > 0;
+    }
+    elementExists(selector) {
+      const exists = this.elementSelector(selector).length > 0;
+      return exists;
+    }
+    elementVisible(selector, check) {
+      const elem = this.elementSelector(selector);
+      const results = new Array(elem.length);
+      elem.forEach((e, i) => {
+        results[i] = isElementVisible(e);
+      });
+      if (check === "none") {
+        return results.every((r) => !r);
+      } else if (results.length === 0) {
+        return false;
+      } else if (check === "any") {
+        return results.some((r) => r);
+      }
+      return results.every((r) => r);
+    }
+    waitForElement(selector, timeout = 1e4) {
+      const interval = 200;
+      const times = Math.ceil(timeout / interval);
+      this.autoconsentInstance.config.logs.rulesteps && console.log("[waitForElement]", selector);
+      return waitFor(
+        () => this.elementSelector(selector).length > 0,
+        times,
+        interval
+      );
+    }
+    waitForVisible(selector, timeout = 1e4, check = "any") {
+      const interval = 200;
+      const times = Math.ceil(timeout / interval);
+      return waitFor(
+        () => this.elementVisible(selector, check),
+        times,
+        interval
+      );
+    }
+    async waitForThenClick(selector, timeout = 1e4, all = false) {
+      await this.waitForElement(selector, timeout);
+      return this.click(selector, all);
+    }
+    wait(ms) {
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(true);
+        }, ms);
+      });
+    }
+    hide(selector, method) {
+      const styleEl = getStyleElement();
+      return hideElements(styleEl, selector, method);
+    }
+    prehide(selector) {
+      const styleEl = getStyleElement("autoconsent-prehide");
+      this.autoconsentInstance.config.logs.lifecycle && console.log("[prehide]", styleEl, location.href);
+      return hideElements(styleEl, selector, "opacity");
+    }
+    undoPrehide() {
+      const existingElement = getStyleElement("autoconsent-prehide");
+      this.autoconsentInstance.config.logs.lifecycle && console.log("[undoprehide]", existingElement, location.href);
+      if (existingElement) {
+        existingElement.remove();
+      }
+      return !!existingElement;
+    }
+    querySingleReplySelector(selector, parent = document) {
+      if (selector.startsWith("aria/")) {
+        return [];
+      }
+      if (selector.startsWith("xpath/")) {
+        const xpath = selector.slice(6);
+        const result = document.evaluate(xpath, parent, null, XPathResult.ANY_TYPE, null);
+        let node = null;
+        const elements = [];
+        while (node = result.iterateNext()) {
+          elements.push(node);
+        }
+        return elements;
+      }
+      if (selector.startsWith("text/")) {
+        return [];
+      }
+      if (selector.startsWith("pierce/")) {
+        return [];
+      }
+      if (parent.shadowRoot) {
+        return Array.from(parent.shadowRoot.querySelectorAll(selector));
+      }
+      return Array.from(parent.querySelectorAll(selector));
+    }
+    querySelectorChain(selectors) {
+      let parent = document;
+      let matches2;
+      for (const selector of selectors) {
+        matches2 = this.querySingleReplySelector(selector, parent);
+        if (matches2.length === 0) {
+          return [];
+        }
+        parent = matches2[0];
+      }
+      return matches2;
+    }
+    elementSelector(selector) {
+      if (typeof selector === "string") {
+        return this.querySingleReplySelector(selector);
+      }
+      return this.querySelectorChain(selector);
+    }
+  };
+
   // lib/web.ts
   function filterCMPs(rules, config) {
     return rules.filter((cmp) => {
@@ -1819,7 +1896,6 @@
       evalState.sendContentMessage = sendContentMessage;
       this.sendContentMessage = sendContentMessage;
       this.rules = [];
-      enableLogs && console.log("autoconsent init", window.location.href);
       this.updateState({ lifecycle: "loading" });
       this.addDynamicRules();
       if (config) {
@@ -1835,17 +1911,20 @@
         sendContentMessage(initMsg);
         this.updateState({ lifecycle: "waitingForInitResponse" });
       }
+      this.domActions = new DomActions(this);
     }
     initialize(config, declarativeRules) {
-      this.config = config;
-      if (!config.enabled) {
-        enableLogs && console.log("autoconsent is disabled");
+      const normalizedConfig = normalizeConfig(config);
+      normalizedConfig.logs.lifecycle && console.log("autoconsent init", window.location.href);
+      this.config = normalizedConfig;
+      if (!normalizedConfig.enabled) {
+        normalizedConfig.logs.lifecycle && console.log("autoconsent is disabled");
         return;
       }
       if (declarativeRules) {
         this.parseDeclarativeRules(declarativeRules);
       }
-      this.rules = filterCMPs(this.rules, config);
+      this.rules = filterCMPs(this.rules, normalizedConfig);
       if (config.enablePrehide) {
         if (document.documentElement) {
           this.prehideElements();
@@ -1896,12 +1975,13 @@
       }
     }
     async _start() {
-      enableLogs && console.log(`Detecting CMPs on ${window.location.href}`);
+      const logsConfig = this.config.logs;
+      logsConfig.lifecycle && console.log(`Detecting CMPs on ${window.location.href}`);
       this.updateState({ lifecycle: "started" });
       const foundCmps = await this.findCmp(this.config.detectRetries);
       this.updateState({ detectedCmps: foundCmps.map((c) => c.name) });
       if (foundCmps.length === 0) {
-        enableLogs && console.log("no CMP found", location.href);
+        logsConfig.lifecycle && console.log("no CMP found", location.href);
         if (this.config.enablePrehide) {
           this.undoPrehide();
         }
@@ -1914,7 +1994,7 @@
         foundPopups = await this.detectPopups(foundCmps.filter((r) => r.isCosmetic));
       }
       if (foundPopups.length === 0) {
-        enableLogs && console.log("no popup found");
+        logsConfig.lifecycle && console.log("no popup found");
         if (this.config.enablePrehide) {
           this.undoPrehide();
         }
@@ -1929,7 +2009,7 @@
           msg: `Found multiple CMPs, check the detection rules.`,
           cmps: foundPopups.map((cmp) => cmp.name)
         };
-        enableLogs && console.warn(errorDetails.msg, errorDetails.cmps);
+        logsConfig.errors && console.warn(errorDetails.msg, errorDetails.cmps);
         this.sendContentMessage({
           type: "autoconsentError",
           details: errorDetails
@@ -1941,11 +2021,12 @@
       } else if (this.config.autoAction === "optIn") {
         return await this.doOptIn();
       } else {
-        enableLogs && console.log("waiting for opt-out signal...", location.href);
+        logsConfig.lifecycle && console.log("waiting for opt-out signal...", location.href);
         return true;
       }
     }
     async findCmp(retries) {
+      const logsConfig = this.config.logs;
       this.updateState({ findCmpAttempts: this.state.findCmpAttempts + 1 });
       const foundCMPs = [];
       for (const cmp of this.rules) {
@@ -1955,7 +2036,7 @@
           }
           const result = await cmp.detectCmp();
           if (result) {
-            enableLogs && console.log(`Found CMP: ${cmp.name} ${window.location.href}`);
+            logsConfig.lifecycle && console.log(`Found CMP: ${cmp.name} ${window.location.href}`);
             this.sendContentMessage({
               type: "cmpDetected",
               url: location.href,
@@ -1964,16 +2045,17 @@
             foundCMPs.push(cmp);
           }
         } catch (e) {
-          enableLogs && console.warn(`error detecting ${cmp.name}`, e);
+          logsConfig.errors && console.warn(`error detecting ${cmp.name}`, e);
         }
       }
       if (foundCMPs.length === 0 && retries > 0) {
-        await wait(500);
+        await this.domActions.wait(500);
         return this.findCmp(retries - 1);
       }
       return foundCMPs;
     }
     async detectPopups(cmps) {
+      const logsConfig = this.config.logs;
       const result = [];
       const popupLookups = cmps.map((cmp) => this.waitForPopup(cmp).then((isOpen) => {
         if (isOpen) {
@@ -1986,22 +2068,23 @@
           result.push(cmp);
         }
       }).catch((e) => {
-        enableLogs && console.warn(`error waiting for a popup for ${cmp.name}`, e);
+        logsConfig.errors && console.warn(`error waiting for a popup for ${cmp.name}`, e);
         return null;
       }));
       await Promise.all(popupLookups);
       return result;
     }
     async doOptOut() {
+      const logsConfig = this.config.logs;
       this.updateState({ lifecycle: "runningOptOut" });
       let optOutResult;
       if (!this.foundCmp) {
-        enableLogs && console.log("no CMP to opt out");
+        logsConfig.errors && console.log("no CMP to opt out");
         optOutResult = false;
       } else {
-        enableLogs && console.log(`CMP ${this.foundCmp.name}: opt out on ${window.location.href}`);
+        logsConfig.lifecycle && console.log(`CMP ${this.foundCmp.name}: opt out on ${window.location.href}`);
         optOutResult = await this.foundCmp.optOut();
-        enableLogs && console.log(`${this.foundCmp.name}: opt out result ${optOutResult}`);
+        logsConfig.lifecycle && console.log(`${this.foundCmp.name}: opt out result ${optOutResult}`);
       }
       if (this.config.enablePrehide) {
         this.undoPrehide();
@@ -2027,15 +2110,16 @@
       return optOutResult;
     }
     async doOptIn() {
+      const logsConfig = this.config.logs;
       this.updateState({ lifecycle: "runningOptIn" });
       let optInResult;
       if (!this.foundCmp) {
-        enableLogs && console.log("no CMP to opt in");
+        logsConfig.errors && console.log("no CMP to opt in");
         optInResult = false;
       } else {
-        enableLogs && console.log(`CMP ${this.foundCmp.name}: opt in on ${window.location.href}`);
+        logsConfig.lifecycle && console.log(`CMP ${this.foundCmp.name}: opt in on ${window.location.href}`);
         optInResult = await this.foundCmp.optIn();
-        enableLogs && console.log(`${this.foundCmp.name}: opt in result ${optInResult}`);
+        logsConfig.lifecycle && console.log(`${this.foundCmp.name}: opt in result ${optInResult}`);
       }
       if (this.config.enablePrehide) {
         this.undoPrehide();
@@ -2062,12 +2146,13 @@
       return optInResult;
     }
     async doSelfTest() {
+      const logsConfig = this.config.logs;
       let selfTestResult;
       if (!this.foundCmp) {
-        enableLogs && console.log("no CMP to self test");
+        logsConfig.errors && console.log("no CMP to self test");
         selfTestResult = false;
       } else {
-        enableLogs && console.log(`CMP ${this.foundCmp.name}: self-test on ${window.location.href}`);
+        logsConfig.lifecycle && console.log(`CMP ${this.foundCmp.name}: self-test on ${window.location.href}`);
         selfTestResult = await this.foundCmp.test();
       }
       this.sendContentMessage({
@@ -2080,19 +2165,21 @@
       return selfTestResult;
     }
     async waitForPopup(cmp, retries = 5, interval = 500) {
-      enableLogs && console.log("checking if popup is open...", cmp.name);
+      const logsConfig = this.config.logs;
+      logsConfig.lifecycle && console.log("checking if popup is open...", cmp.name);
       const isOpen = await cmp.detectPopup().catch((e) => {
-        enableLogs && console.warn(`error detecting popup for ${cmp.name}`, e);
+        logsConfig.errors && console.warn(`error detecting popup for ${cmp.name}`, e);
         return false;
       });
       if (!isOpen && retries > 0) {
-        await wait(interval);
+        await this.domActions.wait(interval);
         return this.waitForPopup(cmp, retries - 1, interval);
       }
-      enableLogs && console.log(cmp.name, `popup is ${isOpen ? "open" : "not open"}`);
+      logsConfig.lifecycle && console.log(cmp.name, `popup is ${isOpen ? "open" : "not open"}`);
       return isOpen;
     }
     prehideElements() {
+      const logsConfig = this.config.logs;
       const globalHidden = [
         "#didomi-popup,.didomi-popup-container,.didomi-popup-notice,.didomi-consent-popup-preferences,#didomi-notice,.didomi-popup-backdrop,.didomi-screen-medium"
       ];
@@ -2105,15 +2192,15 @@
       this.updateState({ prehideOn: true });
       setTimeout(() => {
         if (this.config.enablePrehide && this.state.prehideOn && !["runningOptOut", "runningOptIn"].includes(this.state.lifecycle)) {
-          enableLogs && console.log("Process is taking too long, unhiding elements");
+          logsConfig.lifecycle && console.log("Process is taking too long, unhiding elements");
           this.undoPrehide();
         }
       }, this.config.prehideTimeout || 2e3);
-      return prehide(selectors.join(","));
+      return this.domActions.prehide(selectors.join(","));
     }
     undoPrehide() {
       this.updateState({ prehideOn: false });
-      return undoPrehide();
+      return this.domActions.undoPrehide();
     }
     updateState(change) {
       Object.assign(this.state, change);
@@ -2126,7 +2213,8 @@
       });
     }
     async receiveMessageCallback(message) {
-      if (enableLogs && !["evalResp", "report"].includes(message.type)) {
+      const logsConfig = this.config?.logs;
+      if (logsConfig?.messages) {
         console.log("received from background", message, window.location.href);
       }
       switch (message.type) {