@duckduckgo/autoconsent 8.2.0 → 9.0.0

package/dist/autoconsent.cjs.js

@@ -421,181 +421,6 @@ async function evalAction(config) {
   });
 }
 
-// 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") {
@@ -805,20 +630,21 @@ var AutoConsentCMPBase = class {
       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;
     });
   }
@@ -857,93 +683,136 @@ var AutoConsentCMPBase = class {
   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) {
@@ -951,7 +820,7 @@ var AutoConsentCMP = class extends AutoConsentCMPBase {
         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) {
@@ -967,7 +836,7 @@ var AutoConsentCMP = class extends AutoConsentCMPBase {
       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);
@@ -979,10 +848,11 @@ var AutoConsentCMP = class extends AutoConsentCMPBase {
     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;
       }
@@ -1056,6 +926,82 @@ var ConsentOMaticCMP = class {
   }
 };
 
+// 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";
@@ -1091,17 +1037,17 @@ var TrustArcTop = class extends AutoConsentCMPBase {
     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) {
@@ -1112,7 +1058,7 @@ var TrustArcTop = class extends AutoConsentCMPBase {
       getStyleElement(),
       `.truste_popframe, .truste_overlay, .truste_box_overlay, ${bannerContainer}`
     );
-    click(cookieSettingsButton);
+    this.click(cookieSettingsButton);
     setTimeout(() => {
       getStyleElement().remove();
     }, 1e4);
@@ -1120,7 +1066,7 @@ var TrustArcTop = class extends AutoConsentCMPBase {
   }
   async optIn() {
     this._optInDone = true;
-    return click(shortcutOptIn);
+    return this.click(shortcutOptIn);
   }
   async openCmp() {
     return true;
@@ -1154,62 +1100,62 @@ var TrustArcFrame = class extends AutoConsentCMPBase {
     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;
   }
@@ -1238,23 +1184,23 @@ var Cookiebot = class extends AutoConsentCMPBase {
     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");
   }
 };
@@ -1298,17 +1244,17 @@ var SourcePoint = class extends AutoConsentCMPBase {
       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;
@@ -1317,6 +1263,7 @@ var SourcePoint = class extends AutoConsentCMPBase {
     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) {
@@ -1326,47 +1273,47 @@ var SourcePoint = class extends AutoConsentCMPBase {
       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");
   }
 };
 
@@ -1390,42 +1337,42 @@ var ConsentManager = class extends AutoConsentCMPBase {
   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) {
@@ -1450,23 +1397,23 @@ var Evidon = class extends AutoConsentCMPBase {
     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");
   }
 };
 
@@ -1490,31 +1437,31 @@ var Onetrust = class extends AutoConsentCMPBase {
     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(
@@ -1543,39 +1490,39 @@ var Klaro = class extends AutoConsentCMPBase {
     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");
@@ -1601,21 +1548,21 @@ var Uniconsent = class extends AutoConsentCMPBase {
     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();
@@ -1626,7 +1573,7 @@ var Uniconsent = class extends AutoConsentCMPBase {
         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;
           }
         }
@@ -1635,11 +1582,11 @@ var Uniconsent = class extends AutoConsentCMPBase {
     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;
   }
 };
@@ -1661,20 +1608,20 @@ var Conversant = class extends AutoConsentCMPBase {
     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);
@@ -1682,11 +1629,11 @@ var Conversant = class extends AutoConsentCMPBase {
       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");
@@ -1719,31 +1666,33 @@ var Tiktok = class extends AutoConsentCMPBase {
     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;
     }
   }
@@ -1779,21 +1728,21 @@ var Airbnb = class extends AutoConsentCMPBase {
     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(
@@ -1820,6 +1769,134 @@ var dynamicCMPs = [
   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) => {
@@ -1842,7 +1919,6 @@ var AutoConsent = class {
     evalState.sendContentMessage = sendContentMessage;
     this.sendContentMessage = sendContentMessage;
     this.rules = [];
-    enableLogs && console.log("autoconsent init", window.location.href);
     this.updateState({ lifecycle: "loading" });
     this.addDynamicRules();
     if (config) {
@@ -1858,17 +1934,20 @@ var AutoConsent = class {
       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();
@@ -1919,12 +1998,13 @@ var AutoConsent = class {
     }
   }
   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();
       }
@@ -1937,7 +2017,7 @@ var AutoConsent = class {
       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();
       }
@@ -1952,7 +2032,7 @@ var AutoConsent = class {
         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
@@ -1964,11 +2044,12 @@ var AutoConsent = class {
     } 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) {
@@ -1978,7 +2059,7 @@ var AutoConsent = class {
         }
         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,
@@ -1987,16 +2068,17 @@ var AutoConsent = class {
           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) {
@@ -2009,22 +2091,23 @@ var AutoConsent = class {
         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();
@@ -2050,15 +2133,16 @@ var AutoConsent = class {
     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();
@@ -2085,12 +2169,13 @@ var AutoConsent = class {
     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({
@@ -2103,19 +2188,21 @@ var AutoConsent = class {
     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"
     ];
@@ -2128,15 +2215,15 @@ var AutoConsent = class {
     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);
@@ -2149,7 +2236,8 @@ var AutoConsent = class {
     });
   }
   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) {