@duckduckgo/autoconsent 5.3.0 → 6.0.0

package/dist/autoconsent.cjs.js

@@ -19,62 +19,411 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // lib/web.ts
 var web_exports = {};
 __export(web_exports, {
-  createAutoCMP: () => createAutoCMP,
-  default: () => AutoConsent,
-  rules: () => rules2
+  default: () => AutoConsent
 });
 module.exports = __toCommonJS(web_exports);
 
-// lib/config.ts
-var enableLogs = false;
+// lib/consentomatic/tools.ts
+var _Tools = class _Tools {
+  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];
+    }
+  }
+};
+_Tools.base = null;
+var Tools = _Tools;
 
-// 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}`;
@@ -127,12 +476,6 @@ function isElementVisible(elem) {
 }
 
 // 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);
@@ -254,6 +597,163 @@ function elementSelector(selector) {
   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,
@@ -261,9 +761,9 @@ var defaultRunContext = {
   urlPattern: ""
 };
 var AutoConsentCMPBase = class {
-  constructor(name) {
+  constructor(autoconsentInstance) {
     this.runContext = defaultRunContext;
-    this.name = name;
+    this.autoconsent = autoconsentInstance;
   }
   get hasSelfTest() {
     throw new Error("Not Implemented");
@@ -274,6 +774,29 @@ var AutoConsentCMPBase = class {
   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,
@@ -310,84 +833,11 @@ var AutoConsentCMPBase = class {
     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() {
@@ -404,41 +854,180 @@ var AutoConsentCMP = class extends AutoConsentCMPBase {
   }
   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 _runRulesSequentially(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(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 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() {
+    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;
   }
 };
 
@@ -450,8 +1039,9 @@ var popupContent = "#truste-consent-content";
 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}`
@@ -511,14 +1101,15 @@ var TrustArcTop = class extends AutoConsentCMPBase {
     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,
@@ -602,7 +1193,8 @@ var TrustArcFrame = class extends AutoConsentCMPBase {
 // 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() {
@@ -645,12 +1237,12 @@ var Cookiebot = class extends AutoConsentCMPBase {
     } 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;
   }
@@ -664,14 +1256,15 @@ var Cookiebot = class extends AutoConsentCMPBase {
     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;
@@ -780,7 +1373,8 @@ var SourcePoint = class extends AutoConsentCMPBase {
 // 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;
   }
@@ -794,7 +1388,7 @@ var ConsentManager = class extends AutoConsentCMPBase {
     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 {
@@ -804,14 +1398,14 @@ var ConsentManager = class extends AutoConsentCMPBase {
   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;
@@ -829,278 +1423,25 @@ var ConsentManager = class extends AutoConsentCMPBase {
   }
   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");
+      return await this.mainWorldEval("EVAL_CONSENTMANAGER_5");
     }
   }
 };
 
 // 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());
-    }
-    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 {
-  constructor() {
-    super("tiktok.com");
-    this.runContext = {
-      urlPattern: "tiktok"
-    };
+  constructor() {
+    super(...arguments);
+    this.name = "Evidon";
   }
   get hasSelfTest() {
-    return true;
+    return false;
   }
   get isIntermediate() {
     return false;
@@ -1108,63 +1449,36 @@ var Tiktok = class extends AutoConsentCMPBase {
   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;
@@ -1176,520 +1490,336 @@ var Airbnb = class extends AutoConsentCMPBase {
     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 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;
+  }
+  async optIn() {
+    return click("#onetrust-accept-btn-handler,.js-accept-cookies");
+  }
+  async test() {
+    return await this.mainWorldEval("EVAL_ONETRUST_1");
   }
 };
-_Tools.base = null;
-var Tools = _Tools;
 
-// 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;
+// lib/cmps/klaro.ts
+var Klaro = class extends AutoConsentCMPBase {
+  constructor() {
+    super(...arguments);
+    this.name = "Klaro";
+    this.prehideSelectors = [".klaro"];
+    this.settingsOpen = false;
   }
-}
-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;
+  get hasSelfTest() {
+    return true;
   }
-}
-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();
+  get isIntermediate() {
+    return false;
   }
-  return waitTimeout(STEP_TIMEOUT);
-}
-async function listAction(config, param) {
-  for (const action of config.actions) {
-    await executeAction(action, param);
+  get isCosmetic() {
+    return false;
   }
-}
-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 detectCmp() {
+    if (elementExists(".klaro > .cookie-modal")) {
+      this.settingsOpen = true;
+      return true;
     }
+    return elementExists(".klaro > .cookie-notice");
   }
-}
-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 detectPopup() {
+    return elementVisible(".klaro > .cookie-notice,.klaro > .cookie-modal", "any");
   }
-}
-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 optOut() {
+    if (click(".klaro .cn-decline")) {
+      return true;
     }
-  }
-  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.settingsOpen) {
+      click(".klaro .cn-learn-more");
+      await waitForElement(".klaro > .cookie-modal", 2e3);
+      this.settingsOpen = true;
     }
-    if (this.config.axis.toLowerCase() === "x") {
-      yDiff = 0;
+    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);
+    click(".cm-purpose:not(.cm-toggle-all) > input:not(.half-checked)", true);
+    return click(".cm-btn-accept");
   }
-}
-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);
+  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 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(...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 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());
+    }
+    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 waitForThenClick(".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 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 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);
   });
 }
@@ -1708,14 +1838,15 @@ var AutoConsent = class {
     };
     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",
@@ -1732,7 +1863,7 @@ var AutoConsent = class {
       return;
     }
     if (declarativeRules) {
-      this.parseRules(declarativeRules);
+      this.parseDeclarativeRules(declarativeRules);
     }
     this.rules = filterCMPs(this.rules, config);
     if (config.enablePrehide) {
@@ -1757,17 +1888,22 @@ var AutoConsent = class {
     }
     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));
@@ -1867,7 +2003,10 @@ var AutoConsent = class {
         });
         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;
   }
@@ -1960,7 +2099,10 @@ var AutoConsent = class {
   }
   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);
@@ -2024,8 +2166,3 @@ var AutoConsent = class {
     }
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createAutoCMP,
-  rules
-});