@duckduckgo/autoconsent 5.3.0 → 6.1.0

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

@@ -1,54 +1,406 @@
 (() => {
-  // lib/config.ts
-  var enableLogs = false;
+  // lib/consentomatic/tools.ts
+  var Tools = class _Tools {
+    static {
+      this.base = null;
+    }
+    static setBase(base) {
+      _Tools.base = base;
+    }
+    static findElement(options, parent = null, multiple = false) {
+      let possibleTargets = null;
+      if (parent != null) {
+        possibleTargets = Array.from(parent.querySelectorAll(options.selector));
+      } else {
+        if (_Tools.base != null) {
+          possibleTargets = Array.from(
+            _Tools.base.querySelectorAll(options.selector)
+          );
+        } else {
+          possibleTargets = Array.from(
+            document.querySelectorAll(options.selector)
+          );
+        }
+      }
+      if (options.textFilter != null) {
+        possibleTargets = possibleTargets.filter((possibleTarget) => {
+          const textContent = possibleTarget.textContent.toLowerCase();
+          if (Array.isArray(options.textFilter)) {
+            let foundText = false;
+            for (const text of options.textFilter) {
+              if (textContent.indexOf(text.toLowerCase()) !== -1) {
+                foundText = true;
+                break;
+              }
+            }
+            return foundText;
+          } else if (options.textFilter != null) {
+            return textContent.indexOf(options.textFilter.toLowerCase()) !== -1;
+          }
+        });
+      }
+      if (options.styleFilters != null) {
+        possibleTargets = possibleTargets.filter((possibleTarget) => {
+          const styles = window.getComputedStyle(possibleTarget);
+          let keep = true;
+          for (const styleFilter of options.styleFilters) {
+            const option = styles[styleFilter.option];
+            if (styleFilter.negated) {
+              keep = keep && option !== styleFilter.value;
+            } else {
+              keep = keep && option === styleFilter.value;
+            }
+          }
+          return keep;
+        });
+      }
+      if (options.displayFilter != null) {
+        possibleTargets = possibleTargets.filter((possibleTarget) => {
+          if (options.displayFilter) {
+            return possibleTarget.offsetHeight !== 0;
+          } else {
+            return possibleTarget.offsetHeight === 0;
+          }
+        });
+      }
+      if (options.iframeFilter != null) {
+        possibleTargets = possibleTargets.filter(() => {
+          if (options.iframeFilter) {
+            return window.location !== window.parent.location;
+          } else {
+            return window.location === window.parent.location;
+          }
+        });
+      }
+      if (options.childFilter != null) {
+        possibleTargets = possibleTargets.filter((possibleTarget) => {
+          const oldBase = _Tools.base;
+          _Tools.setBase(possibleTarget);
+          const childResults = _Tools.find(options.childFilter);
+          _Tools.setBase(oldBase);
+          return childResults.target != null;
+        });
+      }
+      if (multiple) {
+        return possibleTargets;
+      } else {
+        if (possibleTargets.length > 1) {
+          console.warn(
+            "Multiple possible targets: ",
+            possibleTargets,
+            options,
+            parent
+          );
+        }
+        return possibleTargets[0];
+      }
+    }
+    static find(options, multiple = false) {
+      const results = [];
+      if (options.parent != null) {
+        const parent = _Tools.findElement(options.parent, null, multiple);
+        if (parent != null) {
+          if (parent instanceof Array) {
+            parent.forEach((p) => {
+              const targets = _Tools.findElement(options.target, p, multiple);
+              if (targets instanceof Array) {
+                targets.forEach((target) => {
+                  results.push({
+                    parent: p,
+                    target
+                  });
+                });
+              } else {
+                results.push({
+                  parent: p,
+                  target: targets
+                });
+              }
+            });
+            return results;
+          } else {
+            const targets = _Tools.findElement(options.target, parent, multiple);
+            if (targets instanceof Array) {
+              targets.forEach((target) => {
+                results.push({
+                  parent,
+                  target
+                });
+              });
+            } else {
+              results.push({
+                parent,
+                target: targets
+              });
+            }
+          }
+        }
+      } else {
+        const targets = _Tools.findElement(options.target, null, multiple);
+        if (targets instanceof Array) {
+          targets.forEach((target) => {
+            results.push({
+              parent: null,
+              target
+            });
+          });
+        } else {
+          results.push({
+            parent: null,
+            target: targets
+          });
+        }
+      }
+      if (results.length === 0) {
+        results.push({
+          parent: null,
+          target: null
+        });
+      }
+      if (multiple) {
+        return results;
+      } else {
+        if (results.length !== 1) {
+          console.warn(
+            "Multiple results found, even though multiple false",
+            results
+          );
+        }
+        return results[0];
+      }
+    }
+  };
 
-  // lib/random.ts
-  function getRandomID() {
-    if (crypto && typeof crypto.randomUUID !== "undefined") {
-      return crypto.randomUUID();
+  // lib/consentomatic/index.ts
+  function matches(config) {
+    const result = Tools.find(config);
+    if (config.type === "css") {
+      return !!result.target;
+    } else if (config.type === "checkbox") {
+      return !!result.target && result.target.checked;
+    }
+  }
+  async function executeAction(config, param) {
+    switch (config.type) {
+      case "click":
+        return clickAction(config);
+      case "list":
+        return listAction(config, param);
+      case "consent":
+        return consentAction(config, param);
+      case "ifcss":
+        return ifCssAction(config, param);
+      case "waitcss":
+        return waitCssAction(config);
+      case "foreach":
+        return forEachAction(config, param);
+      case "hide":
+        return hideAction(config);
+      case "slide":
+        return slideAction(config);
+      case "close":
+        return closeAction();
+      case "wait":
+        return waitAction(config);
+      case "eval":
+        return evalAction(config);
+      default:
+        throw "Unknown action type: " + config.type;
+    }
+  }
+  var STEP_TIMEOUT = 0;
+  function waitTimeout(timeout) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, timeout);
+    });
+  }
+  async function clickAction(config) {
+    const result = Tools.find(config);
+    if (result.target != null) {
+      result.target.click();
+    }
+    return waitTimeout(STEP_TIMEOUT);
+  }
+  async function listAction(config, param) {
+    for (const action of config.actions) {
+      await executeAction(action, param);
+    }
+  }
+  async function consentAction(config, consentTypes) {
+    for (const consentConfig of config.consents) {
+      const shouldEnable = consentTypes.indexOf(consentConfig.type) !== -1;
+      if (consentConfig.matcher && consentConfig.toggleAction) {
+        const isEnabled = matches(consentConfig.matcher);
+        if (isEnabled !== shouldEnable) {
+          await executeAction(consentConfig.toggleAction);
+        }
+      } else {
+        if (shouldEnable) {
+          await executeAction(consentConfig.trueAction);
+        } else {
+          await executeAction(consentConfig.falseAction);
+        }
+      }
+    }
+  }
+  async function ifCssAction(config, param) {
+    const result = Tools.find(config);
+    if (!result.target) {
+      if (config.trueAction) {
+        await executeAction(config.trueAction, param);
+      }
+    } else {
+      if (config.falseAction) {
+        await executeAction(config.falseAction, param);
+      }
+    }
+  }
+  async function waitCssAction(config) {
+    await new Promise((resolve) => {
+      let numRetries = config.retries || 10;
+      const waitTime = config.waitTime || 250;
+      const checkCss = () => {
+        const result = Tools.find(config);
+        if (config.negated && result.target || !config.negated && !result.target) {
+          if (numRetries > 0) {
+            numRetries -= 1;
+            setTimeout(checkCss, waitTime);
+          } else {
+            resolve();
+          }
+        } else {
+          resolve();
+        }
+      };
+      checkCss();
+    });
+  }
+  async function forEachAction(config, param) {
+    const results = Tools.find(config, true);
+    const oldBase = Tools.base;
+    for (const result of results) {
+      if (result.target) {
+        Tools.setBase(result.target);
+        await executeAction(config.action, param);
+      }
+    }
+    Tools.setBase(oldBase);
+  }
+  async function hideAction(config) {
+    const result = Tools.find(config);
+    if (result.target) {
+      result.target.classList.add("Autoconsent-Hidden");
+    }
+  }
+  async function slideAction(config) {
+    const result = Tools.find(config);
+    const dragResult = Tools.find(config.dragTarget);
+    if (result.target) {
+      const targetBounds = result.target.getBoundingClientRect();
+      const dragTargetBounds = dragResult.target.getBoundingClientRect();
+      let yDiff = dragTargetBounds.top - targetBounds.top;
+      let xDiff = dragTargetBounds.left - targetBounds.left;
+      if (this.config.axis.toLowerCase() === "y") {
+        xDiff = 0;
+      }
+      if (this.config.axis.toLowerCase() === "x") {
+        yDiff = 0;
+      }
+      const screenX = window.screenX + targetBounds.left + targetBounds.width / 2;
+      const screenY = window.screenY + targetBounds.top + targetBounds.height / 2;
+      const clientX = targetBounds.left + targetBounds.width / 2;
+      const clientY = targetBounds.top + targetBounds.height / 2;
+      const mouseDown = document.createEvent("MouseEvents");
+      mouseDown.initMouseEvent(
+        "mousedown",
+        true,
+        true,
+        window,
+        0,
+        screenX,
+        screenY,
+        clientX,
+        clientY,
+        false,
+        false,
+        false,
+        false,
+        0,
+        result.target
+      );
+      const mouseMove = document.createEvent("MouseEvents");
+      mouseMove.initMouseEvent(
+        "mousemove",
+        true,
+        true,
+        window,
+        0,
+        screenX + xDiff,
+        screenY + yDiff,
+        clientX + xDiff,
+        clientY + yDiff,
+        false,
+        false,
+        false,
+        false,
+        0,
+        result.target
+      );
+      const mouseUp = document.createEvent("MouseEvents");
+      mouseUp.initMouseEvent(
+        "mouseup",
+        true,
+        true,
+        window,
+        0,
+        screenX + xDiff,
+        screenY + yDiff,
+        clientX + xDiff,
+        clientY + yDiff,
+        false,
+        false,
+        false,
+        false,
+        0,
+        result.target
+      );
+      result.target.dispatchEvent(mouseDown);
+      await this.waitTimeout(10);
+      result.target.dispatchEvent(mouseMove);
+      await this.waitTimeout(10);
+      result.target.dispatchEvent(mouseUp);
     }
-    return Math.random().toString();
   }
-
-  // lib/eval-handler.ts
-  var Deferred = class {
-    constructor(id, timeout = 1e3) {
-      this.id = id;
-      this.promise = new Promise((resolve, reject) => {
-        this.resolve = resolve;
-        this.reject = reject;
-      });
-      this.timer = window.setTimeout(() => {
-        this.reject(new Error("timeout"));
-      }, timeout);
-    }
-  };
-  var evalState = {
-    pending: /* @__PURE__ */ new Map(),
-    sendContentMessage: null
-  };
-  function requestEval(code) {
-    const id = getRandomID();
-    evalState.sendContentMessage({
-      type: "eval",
-      id,
-      code
-    });
-    const deferred = new Deferred(id);
-    evalState.pending.set(deferred.id, deferred);
-    return deferred.promise;
+  async function waitAction(config) {
+    await waitTimeout(config.waitTime);
   }
-  function resolveEval(id, value) {
-    const deferred = evalState.pending.get(id);
-    if (deferred) {
-      evalState.pending.delete(id);
-      deferred.timer && window.clearTimeout(deferred.timer);
-      deferred.resolve(value);
-    } else {
-      console.warn("no eval #", id);
-    }
+  async function closeAction() {
+    window.close();
+  }
+  async function evalAction(config) {
+    console.log("eval!", config.code);
+    return new Promise((resolve) => {
+      try {
+        if (config.async) {
+          window.eval(config.code);
+          setTimeout(() => {
+            resolve(window.eval("window.__consentCheckResult"));
+          }, config.timeout || 250);
+        } else {
+          resolve(window.eval(config.code));
+        }
+      } catch (e) {
+        console.warn("eval error", e, config.code);
+        resolve(false);
+      }
+    });
   }
 
+  // lib/config.ts
+  var enableLogs = false;
+
   // lib/utils.ts
   function getStyleElement(styleOverrideElementId = "autoconsent-css-rules") {
     const styleSelector = `style#${styleOverrideElementId}`;
@@ -101,12 +453,6 @@
   }
 
   // lib/rule-executors.ts
-  function doEval(expr) {
-    return requestEval(expr).catch((e) => {
-      enableLogs && console.error("error evaluating rule", expr, e);
-      return false;
-    });
-  }
   function click(selector, all = false) {
     const elem = elementSelector(selector);
     enableLogs && console.log("[click]", selector, all, elem);
@@ -156,7 +502,7 @@
       interval
     );
   }
-  async function waitForThenClick(selector, timeout = 1e4, all = false) {
+  async function waitForThenClick2(selector, timeout = 1e4, all = false) {
     await waitForElement(selector, timeout);
     return click(selector, all);
   }
@@ -228,6 +574,163 @@
     return querySelectorChain(selector);
   }
 
+  // lib/random.ts
+  function getRandomID() {
+    if (crypto && typeof crypto.randomUUID !== "undefined") {
+      return crypto.randomUUID();
+    }
+    return Math.random().toString();
+  }
+
+  // lib/eval-handler.ts
+  var Deferred = class {
+    constructor(id, timeout = 1e3) {
+      this.id = id;
+      this.promise = new Promise((resolve, reject) => {
+        this.resolve = resolve;
+        this.reject = reject;
+      });
+      this.timer = window.setTimeout(() => {
+        this.reject(new Error("timeout"));
+      }, timeout);
+    }
+  };
+  var evalState = {
+    pending: /* @__PURE__ */ new Map(),
+    sendContentMessage: null
+  };
+  function requestEval(code) {
+    const id = getRandomID();
+    evalState.sendContentMessage({
+      type: "eval",
+      id,
+      code
+    });
+    const deferred = new Deferred(id);
+    evalState.pending.set(deferred.id, deferred);
+    return deferred.promise;
+  }
+  function resolveEval(id, value) {
+    const deferred = evalState.pending.get(id);
+    if (deferred) {
+      evalState.pending.delete(id);
+      deferred.timer && window.clearTimeout(deferred.timer);
+      deferred.resolve(value);
+    } else {
+      console.warn("no eval #", id);
+    }
+  }
+
+  // lib/eval-snippets.ts
+  var snippets = {
+    // code-based rules
+    EVAL_0: () => console.log(1),
+    EVAL_CONSENTMANAGER_1: () => window.__cmp && typeof __cmp("getCMPData") === "object",
+    EVAL_CONSENTMANAGER_2: () => !__cmp("consentStatus").userChoiceExists,
+    EVAL_CONSENTMANAGER_3: () => __cmp("setConsent", 0),
+    EVAL_CONSENTMANAGER_4: () => __cmp("setConsent", 1),
+    EVAL_CONSENTMANAGER_5: () => __cmp("consentStatus").userChoiceExists,
+    EVAL_COOKIEBOT_1: () => window.CookieConsent.hasResponse !== true,
+    EVAL_COOKIEBOT_2: () => window.Cookiebot.dialog.submitConsent(),
+    EVAL_COOKIEBOT_3: () => endCookieProcess(),
+    EVAL_COOKIEBOT_4: () => window.CookieConsent.declined === true,
+    EVAL_KLARO_1: () => klaro.getManager().config.services.every((c) => c.required || !klaro.getManager().consents[c.name]),
+    EVAL_ONETRUST_1: () => window.OnetrustActiveGroups.split(",").filter((s) => s.length > 0).length <= 1,
+    EVAL_TRUSTARC_TOP: () => window && window.truste && window.truste.eu.bindMap.prefCookie === "0",
+    // declarative rules
+    EVAL_ADROLL_0: () => !document.cookie.includes("__adroll_fpc"),
+    EVAL_AFFINITY_SERIF_COM_0: () => document.cookie.includes("serif_manage_cookies_viewed") && !document.cookie.includes("serif_allow_analytics"),
+    EVAL_AXEPTIO_0: () => document.cookie.includes("axeptio_authorized_vendors=%2C%2C"),
+    EVAL_BING_0: () => document.cookie.includes("AL=0") && document.cookie.includes("AD=0") && document.cookie.includes("SM=0"),
+    EVAL_BORLABS_0: () => !JSON.parse(decodeURIComponent(document.cookie.split(";").find((c) => c.indexOf("borlabs-cookie") !== -1).split("=", 2)[1])).consents.statistics,
+    EVAL_BUNDESREGIERUNG_DE_0: () => document.cookie.match("cookie-allow-tracking=0"),
+    EVAL_CANVA_0: () => !document.cookie.includes("gtm_fpc_engagement_event"),
+    EVAL_CLICKIO_0: () => document.cookie.includes("__lxG__consent__v2_daisybit="),
+    EVAL_CLINCH_0: () => document.cookie.includes("ctc_rejected=1"),
+    EVAL_COINBASE_0: () => JSON.parse(decodeURIComponent(document.cookie.match(/cm_(eu|default)_preferences=([0-9a-zA-Z\\{\\}\\[\\]%:]*);?/)[2])).consent.length <= 1,
+    EVAL_COMPLIANZ_BANNER_0: () => document.cookie.includes("cmplz_banner-status=dismissed"),
+    EVAL_COMPLIANZ_CATEGORIES_0: () => !!document.cookie.match(/cmplz_[^=]+=deny/),
+    EVAL_COMPLIANZ_OPTIN_0: () => !!document.cookie.match(/cookieconsent_preferences_disabled=[^;]+/),
+    EVAL_COOKIE_LAW_INFO_0: () => CLI.disableAllCookies() || CLI.reject_close() || true,
+    EVAL_COOKIE_LAW_INFO_1: () => document.cookie.indexOf("cookielawinfo-checkbox-non-necessary=yes") === -1,
+    EVAL_COOKIE_MANAGER_POPUP_0: () => JSON.parse(document.cookie.split(";").find((c) => c.trim().startsWith("CookieLevel")).split("=")[1]).social === false,
+    EVAL_COOKIEALERT_0: () => document.querySelector("body").removeAttribute("style") || true,
+    EVAL_COOKIEALERT_1: () => document.querySelector("body").removeAttribute("style") || true,
+    EVAL_COOKIEALERT_2: () => window.CookieConsent.declined === true,
+    EVAL_COOKIEFIRST_0: () => ((o) => o.performance === false && o.functional === false && o.advertising === false)(JSON.parse(decodeURIComponent(document.cookie.split(";").find((c) => c.indexOf("cookiefirst") !== -1).trim()).split("=")[1])),
+    EVAL_COOKIEFIRST_1: () => document.querySelectorAll("button[data-cookiefirst-accent-color=true][role=checkbox]:not([disabled])").forEach((i) => i.getAttribute("aria-checked") == "true" && i.click()) || true,
+    EVAL_COOKIEINFORMATION_0: () => CookieInformation.declineAllCategories() || true,
+    EVAL_COOKIEINFORMATION_1: () => CookieInformation.submitAllCategories() || true,
+    EVAL_COOKIEINFORMATION_2: () => document.cookie.includes("CookieInformationConsent="),
+    EVAL_DAILYMOTION_0: () => !!document.cookie.match("dm-euconsent-v2"),
+    EVAL_DSGVO_0: () => !document.cookie.includes("sp_dsgvo_cookie_settings"),
+    EVAL_DUNELM_0: () => document.cookie.includes("cc_functional=0") && document.cookie.includes("cc_targeting=0"),
+    EVAL_ETSY_0: () => document.querySelectorAll(".gdpr-overlay-body input").forEach((toggle) => {
+      toggle.checked = false;
+    }) || true,
+    EVAL_ETSY_1: () => document.querySelector(".gdpr-overlay-view button[data-wt-overlay-close]").click() || true,
+    EVAL_EU_COOKIE_COMPLIANCE_0: () => document.cookie.indexOf("cookie-agreed=2") === -1,
+    EVAL_EU_COOKIE_LAW_0: () => !document.cookie.includes("euCookie"),
+    EVAL_EZOIC_0: () => ezCMP.handleAcceptAllClick(),
+    EVAL_EZOIC_1: () => !!document.cookie.match(/ezCMPCookieConsent=[^;]+\|2=0\|3=0\|4=0/),
+    EVAL_GOOGLE_0: () => !!document.cookie.match(/SOCS=CAE/),
+    EVAL_IUBENDA_0: () => document.querySelectorAll(".purposes-item input[type=checkbox]:not([disabled])").forEach((x) => {
+      if (x.checked)
+        x.click();
+    }) || true,
+    EVAL_IUBENDA_1: () => !!document.cookie.match(/_iub_cs-\d+=/),
+    EVAL_JQUERY_COOKIEBAR_0: () => !document.cookie.includes("cookies-state=accepted"),
+    EVAL_MEDIAVINE_0: () => document.querySelectorAll('[data-name="mediavine-gdpr-cmp"] input[type=checkbox]').forEach((x) => x.checked && x.click()) || true,
+    EVAL_MICROSOFT_0: () => Array.from(document.querySelectorAll("div > button")).filter((el) => el.innerText.match("Reject|Ablehnen"))[0].click() || true,
+    EVAL_MICROSOFT_1: () => Array.from(document.querySelectorAll("div > button")).filter((el) => el.innerText.match("Accept|Annehmen"))[0].click() || true,
+    EVAL_MICROSOFT_2: () => !!document.cookie.match("MSCC"),
+    EVAL_MOOVE_0: () => document.querySelectorAll("#moove_gdpr_cookie_modal input").forEach((i) => {
+      if (!i.disabled && i.name !== "moove_gdpr_strict_cookies")
+        i.checked = false;
+    }) || true,
+    EVAL_ONENINETWO_0: () => document.cookie.includes("CC_ADVERTISING=NO") && document.cookie.includes("CC_ANALYTICS=NO"),
+    EVAL_PAYPAL_0: () => document.cookie.includes("cookie_prefs") === true,
+    EVAL_PRIMEBOX_0: () => !document.cookie.includes("cb-enabled=accepted"),
+    EVAL_PUBTECH_0: () => document.cookie.includes("euconsent-v2") && (document.cookie.match(/.YAAAAAAAAAAA/) || document.cookie.match(/.aAAAAAAAAAAA/) || document.cookie.match(/.YAAACFgAAAAA/)),
+    EVAL_REDDIT_0: () => document.cookie.includes("eu_cookie={%22opted%22:true%2C%22nonessential%22:false}"),
+    EVAL_SIBBO_0: () => !!window.localStorage.getItem("euconsent-v2"),
+    EVAL_SIRDATA_0: () => document.cookie.includes("euconsent-v2"),
+    EVAL_SNIGEL_0: () => !!document.cookie.match("snconsent"),
+    EVAL_STEAMPOWERED_0: () => JSON.parse(decodeURIComponent(document.cookie.split(";").find((s) => s.trim().startsWith("cookieSettings")).split("=")[1])).preference_state === 2,
+    EVAL_TARTEAUCITRON_0: () => tarteaucitron.userInterface.respondAll(false) || true,
+    EVAL_TARTEAUCITRON_1: () => tarteaucitron.userInterface.respondAll(true) || true,
+    EVAL_TARTEAUCITRON_2: () => document.cookie.match(/tarteaucitron=[^;]*/)[0].includes("false"),
+    EVAL_TEALIUM_0: () => typeof window.utag !== "undefined" && typeof utag.gdpr === "object",
+    EVAL_TEALIUM_1: () => utag.gdpr.setConsentValue(false) || true,
+    EVAL_TEALIUM_2: () => utag.gdpr.setConsentValue(true) || true,
+    EVAL_TEALIUM_3: () => utag.gdpr.getConsentState() !== 1,
+    EVAL_TESTCMP_0: () => window.results.results[0] === "button_clicked",
+    EVAL_TESTCMP_COSMETIC_0: () => window.results.results[0] === "banner_hidden",
+    EVAL_THEFREEDICTIONARY_0: () => cmpUi.showPurposes() || cmpUi.rejectAll() || true,
+    EVAL_THEFREEDICTIONARY_1: () => cmpUi.allowAll() || true,
+    EVAL_THEVERGE_0: () => document.cookie.includes("_duet_gdpr_acknowledged=1"),
+    EVAL_UBUNTU_COM_0: () => document.cookie === "_cookies_accepted=essential",
+    EVAL_UK_COOKIE_CONSENT_0: () => !document.cookie.includes("catAccCookies"),
+    EVAL_USERCENTRICS_API_0: () => typeof UC_UI === "object",
+    EVAL_USERCENTRICS_API_1: () => !!UC_UI.closeCMP(),
+    EVAL_USERCENTRICS_API_2: () => !!UC_UI.denyAllConsents(),
+    EVAL_USERCENTRICS_API_3: () => !!UC_UI.acceptAllConsents(),
+    EVAL_USERCENTRICS_API_4: () => !!UC_UI.closeCMP(),
+    EVAL_USERCENTRICS_API_5: () => UC_UI.areAllConsentsAccepted() === true,
+    EVAL_USERCENTRICS_API_6: () => UC_UI.areAllConsentsAccepted() === false,
+    EVAL_USERCENTRICS_BUTTON_0: () => JSON.parse(localStorage.getItem("usercentrics")).consents.every((c) => c.isEssential || !c.consentStatus),
+    EVAL_WAITROSE_0: () => Array.from(document.querySelectorAll("label[id$=cookies-deny-label]")).forEach((e) => e.click()) || true,
+    EVAL_WAITROSE_1: () => document.cookie.includes("wtr_cookies_advertising=0") && document.cookie.includes("wtr_cookies_analytics=0"),
+    EVAL_WP_COOKIE_NOTICE_0: () => document.cookie.includes("wpl_viewed_cookie=no"),
+    EVAL_XING_0: () => document.cookie.includes("userConsent=%7B%22marketing%22%3Afalse"),
+    EVAL_YOUTUBE_DESKTOP_0: () => !!document.cookie.match(/SOCS=CAE/),
+    EVAL_YOUTUBE_MOBILE_0: () => !!document.cookie.match(/SOCS=CAE/)
+  };
+  function getFunctionBody(snippetFunc) {
+    const snippetStr = snippetFunc.toString();
+    return snippetStr.substring(snippetStr.indexOf("=>") + 2);
+  }
+
   // lib/cmps/base.ts
   var defaultRunContext = {
     main: true,
@@ -235,9 +738,9 @@
     urlPattern: ""
   };
   var AutoConsentCMPBase = class {
-    constructor(name) {
+    constructor(autoconsentInstance) {
       this.runContext = defaultRunContext;
-      this.name = name;
+      this.autoconsent = autoconsentInstance;
     }
     get hasSelfTest() {
       throw new Error("Not Implemented");
@@ -248,6 +751,29 @@
     get isCosmetic() {
       throw new Error("Not Implemented");
     }
+    mainWorldEval(snippetId) {
+      const snippet = snippets[snippetId];
+      if (!snippet) {
+        console.warn("Snippet not found", snippetId);
+        return Promise.resolve(false);
+      }
+      if (this.autoconsent.config.isMainWorld) {
+        enableLogs && console.log("inline eval:", snippetId, snippet);
+        let result = false;
+        try {
+          result = !!snippet.call(globalThis);
+        } catch (e) {
+          enableLogs && console.error("error evaluating rule", snippetId, e);
+        }
+        return Promise.resolve(result);
+      }
+      const snippetSrc = getFunctionBody(snippet);
+      enableLogs && console.log("async eval:", snippetId, snippetSrc);
+      return requestEval(snippetSrc).catch((e) => {
+        enableLogs && console.error("error evaluating rule", snippetId, e);
+        return false;
+      });
+    }
     checkRunContext() {
       const runCtx = {
         ...defaultRunContext,
@@ -284,84 +810,11 @@
       return Promise.resolve(true);
     }
   };
-  async function evaluateRuleStep(rule) {
-    const results = [];
-    if (rule.exists) {
-      results.push(elementExists(rule.exists));
-    }
-    if (rule.visible) {
-      results.push(elementVisible(rule.visible, rule.check));
-    }
-    if (rule.eval) {
-      const res = doEval(rule.eval);
-      results.push(res);
-    }
-    if (rule.waitFor) {
-      results.push(waitForElement(rule.waitFor, rule.timeout));
-    }
-    if (rule.waitForVisible) {
-      results.push(waitForVisible(rule.waitForVisible, rule.timeout, rule.check));
-    }
-    if (rule.click) {
-      results.push(click(rule.click, rule.all));
-    }
-    if (rule.waitForThenClick) {
-      results.push(waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all));
-    }
-    if (rule.wait) {
-      results.push(wait(rule.wait));
-    }
-    if (rule.hide) {
-      results.push(hide(rule.hide, rule.method));
-    }
-    if (rule.if) {
-      if (!rule.if.exists && !rule.if.visible) {
-        console.error("invalid conditional rule", rule.if);
-        return false;
-      }
-      const condition = await evaluateRuleStep(rule.if);
-      enableLogs && console.log("Condition is", condition);
-      if (condition) {
-        results.push(_runRulesSequentially(rule.then));
-      } else if (rule.else) {
-        results.push(_runRulesSequentially(rule.else));
-      }
-    }
-    if (rule.any) {
-      for (const step of rule.any) {
-        if (await evaluateRuleStep(step)) {
-          return true;
-        }
-      }
-      return false;
-    }
-    if (results.length === 0) {
-      enableLogs && console.warn("Unrecognized rule", rule);
-      return false;
-    }
-    const all = await Promise.all(results);
-    return all.reduce((a, b) => a && b, true);
-  }
-  async function _runRulesParallel(rules3) {
-    const results = rules3.map((rule) => evaluateRuleStep(rule));
-    const detections = await Promise.all(results);
-    return detections.every((r) => !!r);
-  }
-  async function _runRulesSequentially(rules3) {
-    for (const rule of rules3) {
-      enableLogs && console.log("Running rule...", rule);
-      const result = await evaluateRuleStep(rule);
-      enableLogs && console.log("...rule result", result);
-      if (!result && !rule.optional) {
-        return false;
-      }
-    }
-    return true;
-  }
   var AutoConsentCMP = class extends AutoConsentCMPBase {
-    constructor(config) {
-      super(config.name);
+    constructor(config, autoconsentInstance) {
+      super(autoconsentInstance);
       this.config = config;
+      this.name = config.name;
       this.runContext = config.runContext || defaultRunContext;
     }
     get hasSelfTest() {
@@ -378,41 +831,180 @@
     }
     async detectCmp() {
       if (this.config.detectCmp) {
-        return _runRulesParallel(this.config.detectCmp);
+        return this._runRulesParallel(this.config.detectCmp);
       }
       return false;
     }
     async detectPopup() {
       if (this.config.detectPopup) {
-        return _runRulesSequentially(this.config.detectPopup);
+        return this._runRulesSequentially(this.config.detectPopup);
       }
       return false;
     }
     async optOut() {
       if (this.config.optOut) {
         enableLogs && console.log("Initiated optOut()", this.config.optOut);
-        return _runRulesSequentially(this.config.optOut);
+        return this._runRulesSequentially(this.config.optOut);
       }
       return false;
     }
     async optIn() {
       if (this.config.optIn) {
         enableLogs && console.log("Initiated optIn()", this.config.optIn);
-        return _runRulesSequentially(this.config.optIn);
+        return this._runRulesSequentially(this.config.optIn);
+      }
+      return false;
+    }
+    async openCmp() {
+      if (this.config.openCmp) {
+        return this._runRulesSequentially(this.config.openCmp);
+      }
+      return false;
+    }
+    async test() {
+      if (this.hasSelfTest) {
+        return this._runRulesSequentially(this.config.test);
+      }
+      return super.test();
+    }
+    async evaluateRuleStep(rule) {
+      const results = [];
+      if (rule.exists) {
+        results.push(elementExists(rule.exists));
+      }
+      if (rule.visible) {
+        results.push(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));
+      }
+      if (rule.waitForVisible) {
+        results.push(waitForVisible(rule.waitForVisible, rule.timeout, rule.check));
+      }
+      if (rule.click) {
+        results.push(click(rule.click, rule.all));
+      }
+      if (rule.waitForThenClick) {
+        results.push(waitForThenClick2(rule.waitForThenClick, rule.timeout, rule.all));
+      }
+      if (rule.wait) {
+        results.push(wait(rule.wait));
+      }
+      if (rule.hide) {
+        results.push(hide(rule.hide, rule.method));
+      }
+      if (rule.if) {
+        if (!rule.if.exists && !rule.if.visible) {
+          console.error("invalid conditional rule", rule.if);
+          return false;
+        }
+        const condition = await this.evaluateRuleStep(rule.if);
+        enableLogs && console.log("Condition is", condition);
+        if (condition) {
+          results.push(this._runRulesSequentially(rule.then));
+        } else if (rule.else) {
+          results.push(this._runRulesSequentially(rule.else));
+        }
+      }
+      if (rule.any) {
+        for (const step of rule.any) {
+          if (await this.evaluateRuleStep(step)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      if (results.length === 0) {
+        enableLogs && console.warn("Unrecognized rule", rule);
+        return false;
+      }
+      const all = await Promise.all(results);
+      return all.reduce((a, b) => a && b, true);
+    }
+    async _runRulesParallel(rules) {
+      const results = rules.map((rule) => this.evaluateRuleStep(rule));
+      const detections = await Promise.all(results);
+      return detections.every((r) => !!r);
+    }
+    async _runRulesSequentially(rules) {
+      for (const rule of rules) {
+        enableLogs && console.log("Running rule...", rule);
+        const result = await this.evaluateRuleStep(rule);
+        enableLogs && console.log("...rule result", result);
+        if (!result && !rule.optional) {
+          return false;
+        }
       }
+      return true;
+    }
+  };
+
+  // lib/cmps/consentomatic.ts
+  var ConsentOMaticCMP = class {
+    constructor(name, config) {
+      this.name = name;
+      this.config = config;
+      this.methods = /* @__PURE__ */ new Map();
+      this.runContext = defaultRunContext;
+      this.isCosmetic = false;
+      config.methods.forEach((methodConfig) => {
+        if (methodConfig.action) {
+          this.methods.set(methodConfig.name, methodConfig.action);
+        }
+      });
+      this.hasSelfTest = false;
+    }
+    get isIntermediate() {
       return false;
     }
+    checkRunContext() {
+      return true;
+    }
+    async detectCmp() {
+      const matchResults = this.config.detectors.map(
+        (detectorConfig) => matches(detectorConfig.presentMatcher)
+      );
+      return matchResults.some((r) => !!r);
+    }
+    async detectPopup() {
+      const matchResults = this.config.detectors.map(
+        (detectorConfig) => matches(detectorConfig.showingMatcher)
+      );
+      return matchResults.some((r) => !!r);
+    }
+    async executeAction(method, param) {
+      if (this.methods.has(method)) {
+        return executeAction(this.methods.get(method), param);
+      }
+      return true;
+    }
+    async optOut() {
+      await this.executeAction("HIDE_CMP");
+      await this.executeAction("OPEN_OPTIONS");
+      await this.executeAction("HIDE_CMP");
+      await this.executeAction("DO_CONSENT", []);
+      await this.executeAction("SAVE_CONSENT");
+      return true;
+    }
+    async optIn() {
+      await this.executeAction("HIDE_CMP");
+      await this.executeAction("OPEN_OPTIONS");
+      await this.executeAction("HIDE_CMP");
+      await this.executeAction("DO_CONSENT", ["D", "A", "B", "E", "F", "X"]);
+      await this.executeAction("SAVE_CONSENT");
+      return true;
+    }
     async openCmp() {
-      if (this.config.openCmp) {
-        return _runRulesSequentially(this.config.openCmp);
-      }
-      return false;
+      await this.executeAction("HIDE_CMP");
+      await this.executeAction("OPEN_OPTIONS");
+      return true;
     }
     async test() {
-      if (this.hasSelfTest) {
-        return _runRulesSequentially(this.config.test);
-      }
-      return super.test();
+      return true;
     }
   };
 
@@ -424,8 +1016,9 @@
   var bannerOverlay = "#trustarc-banner-overlay";
   var bannerContainer = "#truste-consent-track";
   var TrustArcTop = class extends AutoConsentCMPBase {
-    constructor() {
-      super("TrustArc-top");
+    constructor(autoconsentInstance) {
+      super(autoconsentInstance);
+      this.name = "TrustArc-top";
       this.prehideSelectors = [
         ".trustarc-banner-container",
         `.truste_popframe,.truste_overlay,.truste_box_overlay,${bannerContainer}`
@@ -485,14 +1078,15 @@
       return true;
     }
     async test() {
-      return await doEval("window && window.truste && window.truste.eu.bindMap.prefCookie === '0'");
+      return await this.mainWorldEval("EVAL_TRUSTARC_TOP");
     }
   };
 
   // lib/cmps/trustarc-frame.ts
   var TrustArcFrame = class extends AutoConsentCMPBase {
     constructor() {
-      super("TrustArc-frame");
+      super(...arguments);
+      this.name = "TrustArc-frame";
       this.runContext = {
         main: false,
         frame: true,
@@ -546,17 +1140,17 @@
       }
       if (click("#catDetails0")) {
         click(".submit");
+        waitForThenClick("#gwt-debug-close_id", 5e3);
         return true;
       }
       if (click(".required")) {
+        waitForThenClick("#gwt-debug-close_id", 5e3);
         return true;
       }
       await this.navigateToSettings();
       click(".switch span:nth-child(1):not(.active)", true);
       click(".submit");
-      waitForElement("#gwt-debug-close_id", 3e5).then(() => {
-        click("#gwt-debug-close_id");
-      });
+      waitForThenClick("#gwt-debug-close_id", 3e5);
       return true;
     }
     async optIn() {
@@ -576,7 +1170,8 @@
   // lib/cmps/cookiebot.ts
   var Cookiebot = class extends AutoConsentCMPBase {
     constructor() {
-      super("Cybotcookiebot");
+      super(...arguments);
+      this.name = "Cybotcookiebot";
       this.prehideSelectors = ["#CybotCookiebotDialog,#dtcookie-container,#cookiebanner,#cb-cookieoverlay"];
     }
     get hasSelfTest() {
@@ -619,12 +1214,12 @@
       } else {
         click("#CybotCookiebotDialogBodyLevelButtonAccept,#CybotCookiebotDialogBodyButtonAccept,#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowallSelection", true);
       }
-      if (await doEval("window.CookieConsent.hasResponse !== true")) {
-        await doEval("window.Cookiebot.dialog.submitConsent()");
+      if (await this.mainWorldEval("EVAL_COOKIEBOT_1")) {
+        await this.mainWorldEval("EVAL_COOKIEBOT_2");
         await wait(500);
       }
       if (elementExists("#cb-confirmedSettings")) {
-        await doEval("endCookieProcess()");
+        await this.mainWorldEval("EVAL_COOKIEBOT_3");
       }
       return true;
     }
@@ -638,14 +1233,15 @@
       return true;
     }
     async test() {
-      return doEval("window.CookieConsent.declined === true");
+      return this.mainWorldEval("EVAL_COOKIEBOT_4");
     }
   };
 
   // lib/cmps/sourcepoint-frame.ts
   var SourcePoint = class extends AutoConsentCMPBase {
     constructor() {
-      super("Sourcepoint-frame");
+      super(...arguments);
+      this.name = "Sourcepoint-frame";
       this.prehideSelectors = ["div[id^='sp_message_container_'],.message-overlay", "#sp_privacy_manager_container"];
       this.ccpaNotice = false;
       this.ccpaPopup = false;
@@ -754,7 +1350,8 @@
   // lib/cmps/consentmanager.ts
   var ConsentManager = class extends AutoConsentCMPBase {
     constructor() {
-      super("consentmanager.net");
+      super(...arguments);
+      this.name = "consentmanager.net";
       this.prehideSelectors = ["#cmpbox,#cmpbox2"];
       this.apiAvailable = false;
     }
@@ -768,7 +1365,7 @@
       return false;
     }
     async detectCmp() {
-      this.apiAvailable = await doEval('window.__cmp && typeof __cmp("getCMPData") === "object"');
+      this.apiAvailable = await this.mainWorldEval("EVAL_CONSENTMANAGER_1");
       if (!this.apiAvailable) {
         return elementExists("#cmpbox");
       } else {
@@ -778,14 +1375,14 @@
     async detectPopup() {
       if (this.apiAvailable) {
         await wait(500);
-        return await doEval("!__cmp('consentStatus').userChoiceExists");
+        return await this.mainWorldEval("EVAL_CONSENTMANAGER_2");
       }
       return elementVisible("#cmpbox .cmpmore", "any");
     }
     async optOut() {
       await wait(500);
       if (this.apiAvailable) {
-        return await doEval("__cmp('setConsent', 0)");
+        return await this.mainWorldEval("EVAL_CONSENTMANAGER_3");
       }
       if (click(".cmpboxbtnno")) {
         return true;
@@ -803,278 +1400,25 @@
     }
     async optIn() {
       if (this.apiAvailable) {
-        return await doEval("__cmp('setConsent', 1)");
+        return await this.mainWorldEval("EVAL_CONSENTMANAGER_4");
       }
       return click(".cmpboxbtnyes");
     }
     async test() {
       if (this.apiAvailable) {
-        return await doEval("__cmp('consentStatus').userChoiceExists");
-      }
-    }
-  };
-
-  // lib/cmps/evidon.ts
-  var Evidon = class extends AutoConsentCMPBase {
-    constructor() {
-      super("Evidon");
-    }
-    get hasSelfTest() {
-      return false;
-    }
-    get isIntermediate() {
-      return false;
-    }
-    get isCosmetic() {
-      return false;
-    }
-    async detectCmp() {
-      return elementExists("#_evidon_banner");
-    }
-    async detectPopup() {
-      return elementVisible("#_evidon_banner", "any");
-    }
-    async optOut() {
-      if (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");
-      return true;
-    }
-    async optIn() {
-      return click("#_evidon-accept-button");
-    }
-  };
-
-  // lib/cmps/onetrust.ts
-  var Onetrust = class extends AutoConsentCMPBase {
-    constructor() {
-      super("Onetrust");
-      this.prehideSelectors = ["#onetrust-banner-sdk,#onetrust-consent-sdk,.onetrust-pc-dark-filter,.js-consent-banner"];
-      this.runContext = {
-        urlPattern: "^(?!.*https://www\\.nba\\.com/)"
-      };
-    }
-    get hasSelfTest() {
-      return true;
-    }
-    get isIntermediate() {
-      return false;
-    }
-    get isCosmetic() {
-      return false;
-    }
-    async detectCmp() {
-      return elementExists("#onetrust-banner-sdk");
-    }
-    async detectPopup() {
-      return elementVisible("#onetrust-banner-sdk", "all");
-    }
-    async optOut() {
-      if (elementExists("#onetrust-pc-btn-handler")) {
-        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 waitFor(
-        () => elementVisible("#onetrust-banner-sdk", "none"),
-        10,
-        500
-      );
-      return true;
-    }
-    async optIn() {
-      return click("#onetrust-accept-btn-handler,.js-accept-cookies");
-    }
-    async test() {
-      return await doEval("window.OnetrustActiveGroups.split(',').filter(s => s.length > 0).length <= 1");
-    }
-  };
-
-  // lib/cmps/klaro.ts
-  var Klaro = class extends AutoConsentCMPBase {
-    constructor() {
-      super("Klaro");
-      this.prehideSelectors = [".klaro"];
-      this.settingsOpen = false;
-    }
-    get hasSelfTest() {
-      return true;
-    }
-    get isIntermediate() {
-      return false;
-    }
-    get isCosmetic() {
-      return false;
-    }
-    async detectCmp() {
-      if (elementExists(".klaro > .cookie-modal")) {
-        this.settingsOpen = true;
-        return true;
-      }
-      return elementExists(".klaro > .cookie-notice");
-    }
-    async detectPopup() {
-      return elementVisible(".klaro > .cookie-notice,.klaro > .cookie-modal", "any");
-    }
-    async optOut() {
-      if (click(".klaro .cn-decline")) {
-        return true;
-      }
-      if (!this.settingsOpen) {
-        click(".klaro .cn-learn-more");
-        await waitForElement(".klaro > .cookie-modal", 2e3);
-        this.settingsOpen = true;
-      }
-      if (click(".klaro .cn-decline")) {
-        return true;
-      }
-      click(".cm-purpose:not(.cm-toggle-all) > input:not(.half-checked)", true);
-      return click(".cm-btn-accept");
-    }
-    async optIn() {
-      if (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");
-      }
-      return click(".klaro .cookie-notice .cm-btn-success");
-    }
-    async test() {
-      return await doEval("klaro.getManager().config.services.every(c => c.required || !klaro.getManager().consents[c.name])");
-    }
-  };
-
-  // lib/cmps/uniconsent.ts
-  var Uniconsent = class extends AutoConsentCMPBase {
-    constructor() {
-      super("Uniconsent");
-    }
-    get prehideSelectors() {
-      return [".unic", ".modal:has(.unic)"];
-    }
-    get hasSelfTest() {
-      return true;
-    }
-    get isIntermediate() {
-      return false;
-    }
-    get isCosmetic() {
-      return false;
-    }
-    async detectCmp() {
-      return elementExists(".unic .unic-box,.unic .unic-bar");
-    }
-    async detectPopup() {
-      return elementVisible(".unic .unic-box,.unic .unic-bar", "any");
-    }
-    async optOut() {
-      await 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);
-        document.querySelectorAll(".unic input[type=checkbox]").forEach((c) => {
-          if (c.checked) {
-            c.click();
-          }
-        });
-        for (const b of document.querySelectorAll(".unic button")) {
-          const text = b.textContent;
-          for (const pattern of ["Confirm Choices", "Save Choices", "Auswahl speichern"]) {
-            if (text.includes(pattern)) {
-              b.click();
-              await wait(500);
-              return true;
-            }
-          }
-        }
-      }
-      return false;
-    }
-    async optIn() {
-      return waitForThenClick(".unic #unic-agree");
-    }
-    async test() {
-      await wait(1e3);
-      const res = elementExists(".unic .unic-box,.unic .unic-bar");
-      return !res;
-    }
-  };
-
-  // lib/cmps/conversant.ts
-  var Conversant = class extends AutoConsentCMPBase {
-    constructor() {
-      super("Conversant");
-      this.prehideSelectors = [".cmp-root"];
-    }
-    get hasSelfTest() {
-      return true;
-    }
-    get isIntermediate() {
-      return false;
-    }
-    get isCosmetic() {
-      return false;
-    }
-    async detectCmp() {
-      return elementExists(".cmp-root .cmp-receptacle");
-    }
-    async detectPopup() {
-      return elementVisible(".cmp-root .cmp-receptacle", "any");
-    }
-    async optOut() {
-      if (!await waitForThenClick(".cmp-main-button:not(.cmp-main-button--primary)")) {
-        return false;
-      }
-      if (!await waitForElement(".cmp-view-tab-tabs")) {
-        return false;
-      }
-      await waitForThenClick(".cmp-view-tab-tabs > :first-child");
-      await 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);
-        const content = item.querySelector(".cmp-accordion-item-content.cmp-active");
-        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());
+        return await this.mainWorldEval("EVAL_CONSENTMANAGER_5");
       }
-      await click(".cmp-main-button:not(.cmp-main-button--primary)");
-      return true;
-    }
-    async optIn() {
-      return waitForThenClick(".cmp-main-button.cmp-main-button--primary");
-    }
-    async test() {
-      return document.cookie.includes("cmp-data=0");
     }
   };
-
-  // lib/cmps/tiktok.ts
-  var Tiktok = class extends AutoConsentCMPBase {
+
+  // lib/cmps/evidon.ts
+  var Evidon = class extends AutoConsentCMPBase {
     constructor() {
-      super("tiktok.com");
-      this.runContext = {
-        urlPattern: "tiktok"
-      };
+      super(...arguments);
+      this.name = "Evidon";
     }
     get hasSelfTest() {
-      return true;
+      return false;
     }
     get isIntermediate() {
       return false;
@@ -1082,63 +1426,36 @@
     get isCosmetic() {
       return false;
     }
-    getShadowRoot() {
-      const container = document.querySelector("tiktok-cookie-banner");
-      if (!container) {
-        return null;
-      }
-      return container.shadowRoot;
-    }
     async detectCmp() {
-      return elementExists("tiktok-cookie-banner");
+      return elementExists("#_evidon_banner");
     }
     async detectPopup() {
-      const banner = this.getShadowRoot().querySelector(".tiktok-cookie-banner");
-      return isElementVisible(banner);
+      return elementVisible("#_evidon_banner", "any");
     }
     async optOut() {
-      const declineButton = this.getShadowRoot().querySelector(".button-wrapper button:first-child");
-      if (declineButton) {
-        enableLogs && console.log("[clicking]", declineButton);
-        declineButton.click();
+      if (click("#_evidon-decline-button")) {
         return true;
-      } else {
-        enableLogs && console.log("no decline button found");
-        return false;
       }
+      hideElements(getStyleElement(), ["#evidon-prefdiag-overlay", "#evidon-prefdiag-background"]);
+      click("#_evidon-option-button");
+      await waitForElement("#evidon-prefdiag-overlay", 5e3);
+      click("#evidon-prefdiag-decline");
+      return true;
     }
     async optIn() {
-      const acceptButton = this.getShadowRoot().querySelector(".button-wrapper button:last-child");
-      if (acceptButton) {
-        enableLogs && console.log("[clicking]", acceptButton);
-        acceptButton.click();
-        return true;
-      } else {
-        enableLogs && console.log("no accept button found");
-        return false;
-      }
-    }
-    async test() {
-      const match = document.cookie.match(/cookie-consent=([^;]+)/);
-      if (!match) {
-        return false;
-      }
-      const value = JSON.parse(decodeURIComponent(match[1]));
-      return Object.values(value).every((x) => typeof x !== "boolean" || x === false);
+      return click("#_evidon-accept-button");
     }
   };
 
-  // lib/cmps/airbnb.ts
-  var Airbnb = class extends AutoConsentCMPBase {
+  // lib/cmps/onetrust.ts
+  var Onetrust = class extends AutoConsentCMPBase {
     constructor() {
-      super("airbnb");
+      super(...arguments);
+      this.name = "Onetrust";
+      this.prehideSelectors = ["#onetrust-banner-sdk,#onetrust-consent-sdk,.onetrust-pc-dark-filter,.js-consent-banner"];
       this.runContext = {
-        urlPattern: "^https://(www\\.)?airbnb\\.[^/]+/"
+        urlPattern: "^(?!.*https://www\\.nba\\.com/)"
       };
-      this.prehideSelectors = [
-        "div[data-testid=main-cookies-banner-container]",
-        'div:has(> div:first-child):has(> div:last-child):has(> section [data-testid="strictly-necessary-cookies"])'
-      ];
     }
     get hasSelfTest() {
       return true;
@@ -1150,521 +1467,336 @@
       return false;
     }
     async detectCmp() {
-      return elementExists("div[data-testid=main-cookies-banner-container]");
+      return elementExists("#onetrust-banner-sdk");
     }
     async detectPopup() {
-      return elementVisible("div[data-testid=main-cookies-banner-container", "any");
+      return elementVisible("#onetrust-banner-sdk", "all");
     }
     async optOut() {
-      await 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 waitForThenClick("button[data-testid=save-btn]");
-    }
-    async optIn() {
-      return waitForThenClick("div[data-testid=main-cookies-banner-container] button._148dgdpk");
-    }
-    async test() {
-      return await waitFor(
-        () => !!document.cookie.match("OptanonAlertBoxClosed"),
-        20,
-        200
-      );
-    }
-  };
-
-  // lib/cmps/all.ts
-  var rules = [
-    new TrustArcTop(),
-    new TrustArcFrame(),
-    new Cookiebot(),
-    new SourcePoint(),
-    new ConsentManager(),
-    new Evidon(),
-    new Onetrust(),
-    new Klaro(),
-    new Uniconsent(),
-    new Conversant(),
-    new Tiktok(),
-    new Airbnb()
-  ];
-  function createAutoCMP(config) {
-    return new AutoConsentCMP(config);
-  }
-  var all_default = rules;
-
-  // lib/index.ts
-  var rules2 = all_default;
-
-  // lib/consentomatic/tools.ts
-  var Tools = class _Tools {
-    static {
-      this.base = null;
-    }
-    static setBase(base) {
-      _Tools.base = base;
-    }
-    static findElement(options, parent = null, multiple = false) {
-      let possibleTargets = null;
-      if (parent != null) {
-        possibleTargets = Array.from(parent.querySelectorAll(options.selector));
-      } else {
-        if (_Tools.base != null) {
-          possibleTargets = Array.from(
-            _Tools.base.querySelectorAll(options.selector)
-          );
-        } else {
-          possibleTargets = Array.from(
-            document.querySelectorAll(options.selector)
-          );
-        }
-      }
-      if (options.textFilter != null) {
-        possibleTargets = possibleTargets.filter((possibleTarget) => {
-          const textContent = possibleTarget.textContent.toLowerCase();
-          if (Array.isArray(options.textFilter)) {
-            let foundText = false;
-            for (const text of options.textFilter) {
-              if (textContent.indexOf(text.toLowerCase()) !== -1) {
-                foundText = true;
-                break;
-              }
-            }
-            return foundText;
-          } else if (options.textFilter != null) {
-            return textContent.indexOf(options.textFilter.toLowerCase()) !== -1;
-          }
-        });
-      }
-      if (options.styleFilters != null) {
-        possibleTargets = possibleTargets.filter((possibleTarget) => {
-          const styles = window.getComputedStyle(possibleTarget);
-          let keep = true;
-          for (const styleFilter of options.styleFilters) {
-            const option = styles[styleFilter.option];
-            if (styleFilter.negated) {
-              keep = keep && option !== styleFilter.value;
-            } else {
-              keep = keep && option === styleFilter.value;
-            }
-          }
-          return keep;
-        });
-      }
-      if (options.displayFilter != null) {
-        possibleTargets = possibleTargets.filter((possibleTarget) => {
-          if (options.displayFilter) {
-            return possibleTarget.offsetHeight !== 0;
-          } else {
-            return possibleTarget.offsetHeight === 0;
-          }
-        });
-      }
-      if (options.iframeFilter != null) {
-        possibleTargets = possibleTargets.filter(() => {
-          if (options.iframeFilter) {
-            return window.location !== window.parent.location;
-          } else {
-            return window.location === window.parent.location;
-          }
-        });
-      }
-      if (options.childFilter != null) {
-        possibleTargets = possibleTargets.filter((possibleTarget) => {
-          const oldBase = _Tools.base;
-          _Tools.setBase(possibleTarget);
-          const childResults = _Tools.find(options.childFilter);
-          _Tools.setBase(oldBase);
-          return childResults.target != null;
-        });
-      }
-      if (multiple) {
-        return possibleTargets;
-      } else {
-        if (possibleTargets.length > 1) {
-          console.warn(
-            "Multiple possible targets: ",
-            possibleTargets,
-            options,
-            parent
-          );
-        }
-        return possibleTargets[0];
-      }
-    }
-    static find(options, multiple = false) {
-      const results = [];
-      if (options.parent != null) {
-        const parent = _Tools.findElement(options.parent, null, multiple);
-        if (parent != null) {
-          if (parent instanceof Array) {
-            parent.forEach((p) => {
-              const targets = _Tools.findElement(options.target, p, multiple);
-              if (targets instanceof Array) {
-                targets.forEach((target) => {
-                  results.push({
-                    parent: p,
-                    target
-                  });
-                });
-              } else {
-                results.push({
-                  parent: p,
-                  target: targets
-                });
-              }
-            });
-            return results;
-          } else {
-            const targets = _Tools.findElement(options.target, parent, multiple);
-            if (targets instanceof Array) {
-              targets.forEach((target) => {
-                results.push({
-                  parent,
-                  target
-                });
-              });
-            } else {
-              results.push({
-                parent,
-                target: targets
-              });
-            }
-          }
-        }
-      } else {
-        const targets = _Tools.findElement(options.target, null, multiple);
-        if (targets instanceof Array) {
-          targets.forEach((target) => {
-            results.push({
-              parent: null,
-              target
-            });
-          });
-        } else {
-          results.push({
-            parent: null,
-            target: targets
-          });
-        }
-      }
-      if (results.length === 0) {
-        results.push({
-          parent: null,
-          target: null
-        });
-      }
-      if (multiple) {
-        return results;
+      if (elementExists("#onetrust-pc-btn-handler")) {
+        click("#onetrust-pc-btn-handler");
       } else {
-        if (results.length !== 1) {
-          console.warn(
-            "Multiple results found, even though multiple false",
-            results
-          );
-        }
-        return results[0];
+        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 waitFor(
+        () => elementVisible("#onetrust-banner-sdk", "none"),
+        10,
+        500
+      );
+      return true;
     }
-  };
-
-  // lib/consentomatic/index.ts
-  function matches(config) {
-    const result = Tools.find(config);
-    if (config.type === "css") {
-      return !!result.target;
-    } else if (config.type === "checkbox") {
-      return !!result.target && result.target.checked;
+    async optIn() {
+      return click("#onetrust-accept-btn-handler,.js-accept-cookies");
     }
-  }
-  async function executeAction(config, param) {
-    switch (config.type) {
-      case "click":
-        return clickAction(config);
-      case "list":
-        return listAction(config, param);
-      case "consent":
-        return consentAction(config, param);
-      case "ifcss":
-        return ifCssAction(config, param);
-      case "waitcss":
-        return waitCssAction(config);
-      case "foreach":
-        return forEachAction(config, param);
-      case "hide":
-        return hideAction(config);
-      case "slide":
-        return slideAction(config);
-      case "close":
-        return closeAction();
-      case "wait":
-        return waitAction(config);
-      case "eval":
-        return evalAction(config);
-      default:
-        throw "Unknown action type: " + config.type;
+    async test() {
+      return await this.mainWorldEval("EVAL_ONETRUST_1");
     }
-  }
-  var STEP_TIMEOUT = 0;
-  function waitTimeout(timeout) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve();
-      }, timeout);
-    });
-  }
-  async function clickAction(config) {
-    const result = Tools.find(config);
-    if (result.target != null) {
-      result.target.click();
+  };
+
+  // lib/cmps/klaro.ts
+  var Klaro = class extends AutoConsentCMPBase {
+    constructor() {
+      super(...arguments);
+      this.name = "Klaro";
+      this.prehideSelectors = [".klaro"];
+      this.settingsOpen = false;
     }
-    return waitTimeout(STEP_TIMEOUT);
-  }
-  async function listAction(config, param) {
-    for (const action of config.actions) {
-      await executeAction(action, param);
+    get hasSelfTest() {
+      return true;
     }
-  }
-  async function consentAction(config, consentTypes) {
-    for (const consentConfig of config.consents) {
-      const shouldEnable = consentTypes.indexOf(consentConfig.type) !== -1;
-      if (consentConfig.matcher && consentConfig.toggleAction) {
-        const isEnabled = matches(consentConfig.matcher);
-        if (isEnabled !== shouldEnable) {
-          await executeAction(consentConfig.toggleAction);
-        }
-      } else {
-        if (shouldEnable) {
-          await executeAction(consentConfig.trueAction);
-        } else {
-          await executeAction(consentConfig.falseAction);
-        }
-      }
+    get isIntermediate() {
+      return false;
     }
-  }
-  async function ifCssAction(config, param) {
-    const result = Tools.find(config);
-    if (!result.target) {
-      if (config.trueAction) {
-        await executeAction(config.trueAction, param);
-      }
-    } else {
-      if (config.falseAction) {
-        await executeAction(config.falseAction, param);
-      }
+    get isCosmetic() {
+      return false;
     }
-  }
-  async function waitCssAction(config) {
-    await new Promise((resolve) => {
-      let numRetries = config.retries || 10;
-      const waitTime = config.waitTime || 250;
-      const checkCss = () => {
-        const result = Tools.find(config);
-        if (config.negated && result.target || !config.negated && !result.target) {
-          if (numRetries > 0) {
-            numRetries -= 1;
-            setTimeout(checkCss, waitTime);
-          } else {
-            resolve();
-          }
-        } else {
-          resolve();
-        }
-      };
-      checkCss();
-    });
-  }
-  async function forEachAction(config, param) {
-    const results = Tools.find(config, true);
-    const oldBase = Tools.base;
-    for (const result of results) {
-      if (result.target) {
-        Tools.setBase(result.target);
-        await executeAction(config.action, param);
+    async detectCmp() {
+      if (elementExists(".klaro > .cookie-modal")) {
+        this.settingsOpen = true;
+        return true;
       }
+      return elementExists(".klaro > .cookie-notice");
     }
-    Tools.setBase(oldBase);
-  }
-  async function hideAction(config) {
-    const result = Tools.find(config);
-    if (result.target) {
-      result.target.classList.add("Autoconsent-Hidden");
+    async detectPopup() {
+      return elementVisible(".klaro > .cookie-notice,.klaro > .cookie-modal", "any");
     }
-  }
-  async function slideAction(config) {
-    const result = Tools.find(config);
-    const dragResult = Tools.find(config.dragTarget);
-    if (result.target) {
-      const targetBounds = result.target.getBoundingClientRect();
-      const dragTargetBounds = dragResult.target.getBoundingClientRect();
-      let yDiff = dragTargetBounds.top - targetBounds.top;
-      let xDiff = dragTargetBounds.left - targetBounds.left;
-      if (this.config.axis.toLowerCase() === "y") {
-        xDiff = 0;
-      }
-      if (this.config.axis.toLowerCase() === "x") {
-        yDiff = 0;
+    async optOut() {
+      if (click(".klaro .cn-decline")) {
+        return true;
       }
-      const screenX = window.screenX + targetBounds.left + targetBounds.width / 2;
-      const screenY = window.screenY + targetBounds.top + targetBounds.height / 2;
-      const clientX = targetBounds.left + targetBounds.width / 2;
-      const clientY = targetBounds.top + targetBounds.height / 2;
-      const mouseDown = document.createEvent("MouseEvents");
-      mouseDown.initMouseEvent(
-        "mousedown",
-        true,
-        true,
-        window,
-        0,
-        screenX,
-        screenY,
-        clientX,
-        clientY,
-        false,
-        false,
-        false,
-        false,
-        0,
-        result.target
-      );
-      const mouseMove = document.createEvent("MouseEvents");
-      mouseMove.initMouseEvent(
-        "mousemove",
-        true,
-        true,
-        window,
-        0,
-        screenX + xDiff,
-        screenY + yDiff,
-        clientX + xDiff,
-        clientY + yDiff,
-        false,
-        false,
-        false,
-        false,
-        0,
-        result.target
-      );
-      const mouseUp = document.createEvent("MouseEvents");
-      mouseUp.initMouseEvent(
-        "mouseup",
-        true,
-        true,
-        window,
-        0,
-        screenX + xDiff,
-        screenY + yDiff,
-        clientX + xDiff,
-        clientY + yDiff,
-        false,
-        false,
-        false,
-        false,
-        0,
-        result.target
-      );
-      result.target.dispatchEvent(mouseDown);
-      await this.waitTimeout(10);
-      result.target.dispatchEvent(mouseMove);
-      await this.waitTimeout(10);
-      result.target.dispatchEvent(mouseUp);
-    }
-  }
-  async function waitAction(config) {
-    await waitTimeout(config.waitTime);
-  }
-  async function closeAction() {
-    window.close();
-  }
-  async function evalAction(config) {
-    console.log("eval!", config.code);
-    return new Promise((resolve) => {
-      try {
-        if (config.async) {
-          window.eval(config.code);
-          setTimeout(() => {
-            resolve(window.eval("window.__consentCheckResult"));
-          }, config.timeout || 250);
-        } else {
-          resolve(window.eval(config.code));
-        }
-      } catch (e) {
-        console.warn("eval error", e, config.code);
-        resolve(false);
+      if (!this.settingsOpen) {
+        click(".klaro .cn-learn-more");
+        await waitForElement(".klaro > .cookie-modal", 2e3);
+        this.settingsOpen = true;
       }
-    });
-  }
+      if (click(".klaro .cn-decline")) {
+        return true;
+      }
+      click(".cm-purpose:not(.cm-toggle-all) > input:not(.half-checked)", true);
+      return click(".cm-btn-accept");
+    }
+    async optIn() {
+      if (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");
+      }
+      return click(".klaro .cookie-notice .cm-btn-success");
+    }
+    async test() {
+      return await this.mainWorldEval("EVAL_KLARO_1");
+    }
+  };
 
-  // lib/cmps/consentomatic.ts
-  var ConsentOMaticCMP = class {
-    constructor(name, config) {
-      this.name = name;
-      this.config = config;
-      this.methods = /* @__PURE__ */ new Map();
-      this.runContext = defaultRunContext;
-      this.isCosmetic = false;
-      config.methods.forEach((methodConfig) => {
-        if (methodConfig.action) {
-          this.methods.set(methodConfig.name, methodConfig.action);
-        }
-      });
-      this.hasSelfTest = false;
+  // lib/cmps/uniconsent.ts
+  var Uniconsent = class extends AutoConsentCMPBase {
+    constructor() {
+      super(...arguments);
+      this.name = "Uniconsent";
+    }
+    get prehideSelectors() {
+      return [".unic", ".modal:has(.unic)"];
+    }
+    get hasSelfTest() {
+      return true;
     }
     get isIntermediate() {
       return false;
     }
-    checkRunContext() {
-      return true;
+    get isCosmetic() {
+      return false;
     }
     async detectCmp() {
-      const matchResults = this.config.detectors.map(
-        (detectorConfig) => matches(detectorConfig.presentMatcher)
-      );
-      return matchResults.some((r) => !!r);
+      return elementExists(".unic .unic-box,.unic .unic-bar");
     }
     async detectPopup() {
-      const matchResults = this.config.detectors.map(
-        (detectorConfig) => matches(detectorConfig.showingMatcher)
-      );
-      return matchResults.some((r) => !!r);
+      return elementVisible(".unic .unic-box,.unic .unic-bar", "any");
     }
-    async executeAction(method, param) {
-      if (this.methods.has(method)) {
-        return executeAction(this.methods.get(method), param);
+    async optOut() {
+      await 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);
+        document.querySelectorAll(".unic input[type=checkbox]").forEach((c) => {
+          if (c.checked) {
+            c.click();
+          }
+        });
+        for (const b of document.querySelectorAll(".unic button")) {
+          const text = b.textContent;
+          for (const pattern of ["Confirm Choices", "Save Choices", "Auswahl speichern"]) {
+            if (text.includes(pattern)) {
+              b.click();
+              await wait(500);
+              return true;
+            }
+          }
+        }
       }
+      return false;
+    }
+    async optIn() {
+      return waitForThenClick2(".unic #unic-agree");
+    }
+    async test() {
+      await wait(1e3);
+      const res = elementExists(".unic .unic-box,.unic .unic-bar");
+      return !res;
+    }
+  };
+
+  // lib/cmps/conversant.ts
+  var Conversant = class extends AutoConsentCMPBase {
+    constructor() {
+      super(...arguments);
+      this.prehideSelectors = [".cmp-root"];
+      this.name = "Conversant";
+    }
+    get hasSelfTest() {
       return true;
     }
+    get isIntermediate() {
+      return false;
+    }
+    get isCosmetic() {
+      return false;
+    }
+    async detectCmp() {
+      return elementExists(".cmp-root .cmp-receptacle");
+    }
+    async detectPopup() {
+      return elementVisible(".cmp-root .cmp-receptacle", "any");
+    }
     async optOut() {
-      await this.executeAction("HIDE_CMP");
-      await this.executeAction("OPEN_OPTIONS");
-      await this.executeAction("HIDE_CMP");
-      await this.executeAction("DO_CONSENT", []);
-      await this.executeAction("SAVE_CONSENT");
+      if (!await waitForThenClick2(".cmp-main-button:not(.cmp-main-button--primary)")) {
+        return false;
+      }
+      if (!await 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");
+      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);
+        const content = item.querySelector(".cmp-accordion-item-content.cmp-active");
+        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)");
       return true;
     }
     async optIn() {
-      await this.executeAction("HIDE_CMP");
-      await this.executeAction("OPEN_OPTIONS");
-      await this.executeAction("HIDE_CMP");
-      await this.executeAction("DO_CONSENT", ["D", "A", "B", "E", "F", "X"]);
-      await this.executeAction("SAVE_CONSENT");
-      return true;
+      return waitForThenClick2(".cmp-main-button.cmp-main-button--primary");
     }
-    async openCmp() {
-      await this.executeAction("HIDE_CMP");
-      await this.executeAction("OPEN_OPTIONS");
+    async test() {
+      return document.cookie.includes("cmp-data=0");
+    }
+  };
+
+  // lib/cmps/tiktok.ts
+  var Tiktok = class extends AutoConsentCMPBase {
+    constructor() {
+      super(...arguments);
+      this.name = "tiktok.com";
+      this.runContext = {
+        urlPattern: "tiktok"
+      };
+    }
+    get hasSelfTest() {
       return true;
     }
+    get isIntermediate() {
+      return false;
+    }
+    get isCosmetic() {
+      return false;
+    }
+    getShadowRoot() {
+      const container = document.querySelector("tiktok-cookie-banner");
+      if (!container) {
+        return null;
+      }
+      return container.shadowRoot;
+    }
+    async detectCmp() {
+      return elementExists("tiktok-cookie-banner");
+    }
+    async detectPopup() {
+      const banner = this.getShadowRoot().querySelector(".tiktok-cookie-banner");
+      return isElementVisible(banner);
+    }
+    async optOut() {
+      const declineButton = this.getShadowRoot().querySelector(".button-wrapper button:first-child");
+      if (declineButton) {
+        enableLogs && console.log("[clicking]", declineButton);
+        declineButton.click();
+        return true;
+      } else {
+        enableLogs && console.log("no decline button found");
+        return false;
+      }
+    }
+    async optIn() {
+      const acceptButton = this.getShadowRoot().querySelector(".button-wrapper button:last-child");
+      if (acceptButton) {
+        enableLogs && console.log("[clicking]", acceptButton);
+        acceptButton.click();
+        return true;
+      } else {
+        enableLogs && console.log("no accept button found");
+        return false;
+      }
+    }
     async test() {
+      const match = document.cookie.match(/cookie-consent=([^;]+)/);
+      if (!match) {
+        return false;
+      }
+      const value = JSON.parse(decodeURIComponent(match[1]));
+      return Object.values(value).every((x) => typeof x !== "boolean" || x === false);
+    }
+  };
+
+  // lib/cmps/airbnb.ts
+  var Airbnb = class extends AutoConsentCMPBase {
+    constructor() {
+      super(...arguments);
+      this.runContext = {
+        urlPattern: "^https://(www\\.)?airbnb\\.[^/]+/"
+      };
+      this.prehideSelectors = [
+        "div[data-testid=main-cookies-banner-container]",
+        'div:has(> div:first-child):has(> div:last-child):has(> section [data-testid="strictly-necessary-cookies"])'
+      ];
+    }
+    get hasSelfTest() {
       return true;
     }
+    get isIntermediate() {
+      return false;
+    }
+    get isCosmetic() {
+      return false;
+    }
+    async detectCmp() {
+      return elementExists("div[data-testid=main-cookies-banner-container]");
+    }
+    async detectPopup() {
+      return elementVisible("div[data-testid=main-cookies-banner-container", "any");
+    }
+    async optOut() {
+      await waitForThenClick2("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]");
+    }
+    async optIn() {
+      return waitForThenClick2("div[data-testid=main-cookies-banner-container] button._148dgdpk");
+    }
+    async test() {
+      return await waitFor(
+        () => !!document.cookie.match("OptanonAlertBoxClosed"),
+        20,
+        200
+      );
+    }
   };
 
+  // lib/cmps/all.ts
+  var dynamicCMPs = [
+    TrustArcTop,
+    TrustArcFrame,
+    Cookiebot,
+    SourcePoint,
+    ConsentManager,
+    Evidon,
+    Onetrust,
+    Klaro,
+    Uniconsent,
+    Conversant,
+    Tiktok,
+    Airbnb
+  ];
+
   // lib/web.ts
-  function filterCMPs(rules3, config) {
-    return rules3.filter((cmp) => {
+  function filterCMPs(rules, config) {
+    return rules.filter((cmp) => {
       return (!config.disabledCmps || !config.disabledCmps.includes(cmp.name)) && (config.enableCosmeticRules || !cmp.isCosmetic);
     });
   }
@@ -1683,14 +1815,15 @@
       };
       evalState.sendContentMessage = sendContentMessage;
       this.sendContentMessage = sendContentMessage;
-      this.rules = [...rules2];
+      this.rules = [];
       enableLogs && console.log("autoconsent init", window.location.href);
       this.updateState({ lifecycle: "loading" });
+      this.addDynamicRules();
       if (config) {
         this.initialize(config, declarativeRules);
       } else {
         if (declarativeRules) {
-          this.parseRules(declarativeRules);
+          this.parseDeclarativeRules(declarativeRules);
         }
         const initMsg = {
           type: "init",
@@ -1707,7 +1840,7 @@
         return;
       }
       if (declarativeRules) {
-        this.parseRules(declarativeRules);
+        this.parseDeclarativeRules(declarativeRules);
       }
       this.rules = filterCMPs(this.rules, config);
       if (config.enablePrehide) {
@@ -1732,17 +1865,22 @@
       }
       this.updateState({ lifecycle: "initialized" });
     }
-    parseRules(declarativeRules) {
+    addDynamicRules() {
+      dynamicCMPs.forEach((cmp) => {
+        this.rules.push(new cmp(this));
+      });
+    }
+    parseDeclarativeRules(declarativeRules) {
       Object.keys(declarativeRules.consentomatic).forEach((name) => {
         this.addConsentomaticCMP(name, declarativeRules.consentomatic[name]);
       });
-      declarativeRules.autoconsent.forEach((rule) => {
-        this.addCMP(rule);
+      declarativeRules.autoconsent.forEach((ruleset) => {
+        this.addDeclarativeCMP(ruleset);
       });
       enableLogs && console.log("added rules", this.rules);
     }
-    addCMP(config) {
-      this.rules.push(createAutoCMP(config));
+    addDeclarativeCMP(ruleset) {
+      this.rules.push(new AutoConsentCMP(ruleset, this));
     }
     addConsentomaticCMP(name, config) {
       this.rules.push(new ConsentOMaticCMP(`com_${name}`, config));
@@ -1842,7 +1980,10 @@
           });
           result.push(cmp);
         }
-      }).catch(() => null));
+      }).catch((e) => {
+        enableLogs && console.warn(`error waiting for a popup for ${cmp.name}`, e);
+        return null;
+      }));
       await Promise.all(popupLookups);
       return result;
     }
@@ -1935,7 +2076,10 @@
     }
     async waitForPopup(cmp, retries = 5, interval = 500) {
       enableLogs && console.log("checking if popup is open...", cmp.name);
-      const isOpen = await cmp.detectPopup();
+      const isOpen = await cmp.detectPopup().catch((e) => {
+        enableLogs && console.warn(`error detecting popup for ${cmp.name}`, e);
+        return false;
+      });
       if (!isOpen && retries > 0) {
         await wait(interval);
         return this.waitForPopup(cmp, retries - 1, interval);