@duckduckgo/autoconsent 1.0.2

package/lib/cmps/all.js

@@ -0,0 +1,17 @@
+import { AutoConsent } from './base';
+import TrustArc from './trustarc';
+import CookieBot from './cookiebot';
+import SourcePoint from './sourcepoint';
+import ContentManager from './consentmanager';
+import Evidon from './evidon';
+const rules = [
+    new TrustArc(),
+    new CookieBot(),
+    new SourcePoint(),
+    new ContentManager(),
+    new Evidon(),
+];
+export function createAutoCMP(config) {
+    return new AutoConsent(config);
+}
+export default rules;

package/lib/cmps/all.ts

@@ -0,0 +1,21 @@
+import { AutoConsent } from './base';
+import TrustArc from './trustarc';
+import CookieBot from './cookiebot';
+import SourcePoint from './sourcepoint';
+import ContentManager from './consentmanager';
+import Evidon from './evidon';
+import { AutoConsentCMPRule } from '../rules';
+
+const rules = [
+  new TrustArc(),
+  new CookieBot(),
+  new SourcePoint(),
+  new ContentManager(),
+  new Evidon(),
+];
+
+export function createAutoCMP(config: AutoConsentCMPRule): AutoConsent {
+  return new AutoConsent(config);
+}
+
+export default rules;

package/lib/cmps/base.js

@@ -0,0 +1,170 @@
+/* eslint-disable no-restricted-syntax,no-await-in-loop,no-underscore-dangle */
+export async function waitFor(predicate, maxTimes, interval) {
+    let result = await predicate();
+    if (!result && maxTimes > 0) {
+        return new Promise((resolve) => {
+            setTimeout(async () => {
+                resolve(waitFor(predicate, maxTimes - 1, interval));
+            }, interval);
+        });
+    }
+    return Promise.resolve(result);
+}
+export async function success(action) {
+    const result = await action;
+    if (!result) {
+        throw new Error(`Action failed: ${action}`);
+    }
+    return result;
+}
+export default class AutoConsentBase {
+    constructor(name) {
+        this.hasSelfTest = true;
+        this.name = name;
+    }
+    detectCmp(tab) {
+        throw new Error('Not Implemented');
+    }
+    async detectPopup(tab) {
+        return false;
+    }
+    detectFrame(tab, frame) {
+        return false;
+    }
+    optOut(tab) {
+        throw new Error('Not Implemented');
+    }
+    optIn(tab) {
+        throw new Error('Not Implemented');
+    }
+    openCmp(tab) {
+        throw new Error('Not Implemented');
+    }
+    async test(tab) {
+        // try IAB by default
+        return Promise.resolve(true);
+    }
+}
+async function evaluateRule(rule, tab) {
+    if (rule.frame && !tab.frame) {
+        await waitFor(() => Promise.resolve(!!tab.frame), 10, 500);
+    }
+    const frameId = rule.frame && tab.frame ? tab.frame.id : undefined;
+    const results = [];
+    if (rule.exists) {
+        results.push(tab.elementExists(rule.exists, frameId));
+    }
+    if (rule.visible) {
+        results.push(tab.elementsAreVisible(rule.visible, rule.check, frameId));
+    }
+    if (rule.eval) {
+        results.push(new Promise(async (resolve) => {
+            // catch eval error silently
+            try {
+                resolve(await tab.eval(rule.eval, frameId));
+            }
+            catch (e) {
+                resolve(false);
+            }
+        }));
+    }
+    if (rule.waitFor) {
+        results.push(tab.waitForElement(rule.waitFor, rule.timeout || 10000, frameId));
+    }
+    if (rule.click) {
+        if (rule.all === true) {
+            results.push(tab.clickElements(rule.click, frameId));
+        }
+        else {
+            results.push(tab.clickElement(rule.click, frameId));
+        }
+    }
+    if (rule.waitForThenClick) {
+        results.push(tab.waitForElement(rule.waitForThenClick, rule.timeout || 10000, frameId)
+            .then(() => tab.clickElement(rule.waitForThenClick, frameId)));
+    }
+    if (rule.wait) {
+        results.push(tab.wait(rule.wait));
+    }
+    if (rule.goto) {
+        results.push(tab.goto(rule.goto));
+    }
+    if (rule.hide) {
+        results.push(tab.hideElements(rule.hide, frameId));
+    }
+    if (rule.undoHide) {
+        results.push(tab.undoHideElements(frameId));
+    }
+    if (rule.waitForFrame) {
+        results.push(waitFor(() => !!tab.frame, 40, 500));
+    }
+    // boolean and of results
+    return (await Promise.all(results)).reduce((a, b) => a && b, true);
+}
+export class AutoConsent extends AutoConsentBase {
+    constructor(config) {
+        super(config.name);
+        this.config = config;
+    }
+    get prehideSelectors() {
+        return this.config.prehideSelectors;
+    }
+    get isHidingRule() {
+        return this.config.isHidingRule;
+    }
+    async _runRulesParallel(tab, rules) {
+        const detections = await Promise.all(rules.map(rule => evaluateRule(rule, tab)));
+        return detections.every(r => !!r);
+    }
+    async _runRulesSequentially(tab, rules) {
+        for (const rule of rules) {
+            const result = await evaluateRule(rule, tab);
+            if (!result && !rule.optional) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async detectCmp(tab) {
+        if (this.config.detectCmp) {
+            return this._runRulesParallel(tab, this.config.detectCmp);
+        }
+        return false;
+    }
+    async detectPopup(tab) {
+        if (this.config.detectPopup) {
+            return this._runRulesParallel(tab, this.config.detectPopup);
+        }
+        return false;
+    }
+    detectFrame(tab, frame) {
+        if (this.config.frame) {
+            return frame.url.startsWith(this.config.frame);
+        }
+        return false;
+    }
+    async optOut(tab) {
+        if (this.config.optOut) {
+            return this._runRulesSequentially(tab, this.config.optOut);
+        }
+        return false;
+    }
+    async optIn(tab) {
+        if (this.config.optIn) {
+            return this._runRulesSequentially(tab, this.config.optIn);
+        }
+        return false;
+    }
+    async openCmp(tab) {
+        if (this.config.openCmp) {
+            return this._runRulesSequentially(tab, this.config.openCmp);
+        }
+        return false;
+    }
+    async test(tab) {
+        if (this.config.test) {
+            return this._runRulesSequentially(tab, this.config.test);
+        }
+        return super.test(tab);
+    }
+}

package/lib/cmps/base.ts

@@ -0,0 +1,199 @@
+/* eslint-disable no-restricted-syntax,no-await-in-loop,no-underscore-dangle */
+
+import { AutoCMP, TabActor } from "../types";
+import { AutoConsentCMPRule, AutoConsentRuleStep } from "../rules";
+
+export async function waitFor(predicate: () => Promise<boolean> | boolean, maxTimes: number, interval: number): Promise<boolean> {
+  let result = await predicate();
+  if (!result && maxTimes > 0) {
+    return new Promise((resolve) => {
+      setTimeout(async () => {
+        resolve(waitFor(predicate, maxTimes - 1, interval));
+      }, interval);
+    });
+  }
+  return Promise.resolve(result);
+}
+
+
+export async function success(action: Promise<boolean>): Promise<boolean> {
+  const result = await action;
+  if (!result) {
+    throw new Error(`Action failed: ${action}`)
+  }
+  return result
+}
+
+
+export default class AutoConsentBase implements AutoCMP {
+
+  name: string
+  hasSelfTest = true
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  detectCmp(tab: TabActor): Promise<boolean>  {
+    throw new Error('Not Implemented');
+  }
+
+  async detectPopup(tab: TabActor) {
+    return false;
+  }
+
+  detectFrame(tab: TabActor, frame: { url: string }) {
+    return false;
+  }
+
+  optOut(tab: TabActor): Promise<boolean> {
+    throw new Error('Not Implemented');
+  }
+
+  optIn(tab: TabActor): Promise<boolean> {
+    throw new Error('Not Implemented');
+  }
+
+  openCmp(tab: TabActor): Promise<boolean> {
+    throw new Error('Not Implemented');
+  }
+
+  async test(tab: TabActor): Promise<boolean> {
+    // try IAB by default
+    return Promise.resolve(true);
+  }
+}
+
+async function evaluateRule(rule: AutoConsentRuleStep, tab: TabActor) {
+  if (rule.frame && !tab.frame) {
+    await waitFor(() => Promise.resolve(!!tab.frame), 10, 500);
+  }
+  const frameId = rule.frame && tab.frame ? tab.frame.id : undefined;
+  const results = [];
+  if (rule.exists) {
+    results.push(tab.elementExists(rule.exists, frameId));
+  }
+  if (rule.visible) {
+    results.push(tab.elementsAreVisible(rule.visible, rule.check, frameId));
+  }
+  if (rule.eval) {
+    results.push(new Promise(async (resolve) => {
+      // catch eval error silently
+      try {
+        resolve(await tab.eval(rule.eval!, frameId));
+      } catch (e) {
+        resolve(false);
+      }
+    }));
+  }
+  if (rule.waitFor) {
+    results.push(tab.waitForElement(rule.waitFor, rule.timeout || 10000, frameId));
+  }
+  if (rule.click) {
+    if (rule.all === true) {
+      results.push(tab.clickElements(rule.click, frameId));
+    } else {
+      results.push(tab.clickElement(rule.click, frameId));
+    }
+  }
+  if (rule.waitForThenClick) {
+    results.push(tab.waitForElement(rule.waitForThenClick, rule.timeout || 10000, frameId)
+      .then(() => tab.clickElement(rule.waitForThenClick!, frameId)));
+  }
+  if (rule.wait) {
+    results.push(tab.wait(rule.wait));
+  }
+  if (rule.goto) {
+    results.push(tab.goto(rule.goto));
+  }
+  if (rule.hide) {
+    results.push(tab.hideElements(rule.hide, frameId));
+  }
+  if (rule.undoHide) {
+    results.push(tab.undoHideElements(frameId));
+  }
+  if (rule.waitForFrame) {
+    results.push(waitFor(() => !!tab.frame, 40, 500))
+  }
+  // boolean and of results
+  return (await Promise.all(results)).reduce((a, b) => a && b, true);
+}
+
+export class AutoConsent extends AutoConsentBase {
+
+  constructor(public config: AutoConsentCMPRule) {
+    super(config.name);
+  }
+
+  get prehideSelectors(): string[] {
+    return this.config.prehideSelectors;
+  }
+
+  get isHidingRule(): boolean {
+    return this.config.isHidingRule;
+  }
+
+  async _runRulesParallel(tab: TabActor, rules: AutoConsentRuleStep[]): Promise<boolean> {
+    const detections = await Promise.all(rules.map(rule => evaluateRule(rule, tab)));
+    return detections.every(r => !!r);
+  }
+
+  async _runRulesSequentially(tab: TabActor, rules: AutoConsentRuleStep[]): Promise<boolean> {
+    for (const rule of rules) {
+      const result = await evaluateRule(rule, tab);
+      if (!result && !rule.optional) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  async detectCmp(tab: TabActor) {
+    if (this.config.detectCmp) {
+      return this._runRulesParallel(tab, this.config.detectCmp);
+    }
+    return false;
+  }
+
+  async detectPopup(tab: TabActor) {
+    if (this.config.detectPopup) {
+      return this._runRulesParallel(tab, this.config.detectPopup);
+    }
+    return false;
+  }
+
+  detectFrame(tab: TabActor, frame: { url: string }) {
+    if (this.config.frame) {
+      return frame.url.startsWith(this.config.frame);
+    }
+    return false;
+  }
+
+  async optOut(tab: TabActor) {
+    if (this.config.optOut) {
+      return this._runRulesSequentially(tab, this.config.optOut);
+    }
+    return false;
+  }
+
+  async optIn(tab: TabActor) {
+    if (this.config.optIn) {
+      return this._runRulesSequentially(tab, this.config.optIn);
+    }
+    return false;
+  }
+
+  async openCmp(tab: TabActor) {
+    if (this.config.openCmp) {
+      return this._runRulesSequentially(tab, this.config.openCmp);
+    }
+    return false;
+  }
+
+  async test(tab: TabActor) {
+    if (this.config.test) {
+      return this._runRulesSequentially(tab, this.config.test);
+    }
+    return super.test(tab);
+  }
+}

package/lib/cmps/consentmanager.js

@@ -0,0 +1,31 @@
+import AutoConsentBase from "./base";
+// Note: JS API is also available:
+// https://help.consentmanager.net/books/cmp/page/javascript-api
+export default class ConsentManager extends AutoConsentBase {
+    constructor() {
+        super("consentmanager.net");
+        this.prehideSelectors = ["#cmpbox,#cmpbox2"];
+    }
+    detectCmp(tab) {
+        return tab.elementExists("#cmpbox");
+    }
+    detectPopup(tab) {
+        return tab.elementsAreVisible("#cmpbox .cmpmore", "any");
+    }
+    async optOut(tab) {
+        if (await tab.elementExists(".cmpboxbtnno")) {
+            return tab.clickElement(".cmpboxbtnno");
+        }
+        if (await tab.elementExists(".cmpwelcomeprpsbtn")) {
+            await tab.clickElements(".cmpwelcomeprpsbtn > a[aria-checked=true]");
+            return await tab.clickElement(".cmpboxbtnsave");
+        }
+        await tab.clickElement(".cmpboxbtncustom");
+        await tab.waitForElement(".cmptblbox", 2000);
+        await tab.clickElements(".cmptdchoice > a[aria-checked=true]");
+        return tab.clickElement(".cmpboxbtnyescustomchoices");
+    }
+    async optIn(tab) {
+        return tab.clickElement(".cmpboxbtnyes");
+    }
+}

package/lib/cmps/consentmanager.ts

@@ -0,0 +1,39 @@
+import AutoConsentBase from "./base";
+import { TabActor } from "../types";
+
+// Note: JS API is also available:
+// https://help.consentmanager.net/books/cmp/page/javascript-api
+export default class ConsentManager extends AutoConsentBase {
+
+  prehideSelectors = ["#cmpbox,#cmpbox2"]
+
+  constructor() {
+    super("consentmanager.net");
+  }
+
+  detectCmp(tab: TabActor) {
+    return tab.elementExists("#cmpbox");
+  }
+
+  detectPopup(tab: TabActor) {
+    return tab.elementsAreVisible("#cmpbox .cmpmore", "any");
+  }
+
+  async optOut(tab: TabActor) {
+    if (await tab.elementExists(".cmpboxbtnno")) {
+      return tab.clickElement(".cmpboxbtnno");
+    }
+    if (await tab.elementExists(".cmpwelcomeprpsbtn")) {
+      await tab.clickElements(".cmpwelcomeprpsbtn > a[aria-checked=true]");
+      return await tab.clickElement(".cmpboxbtnsave");
+    }
+    await tab.clickElement(".cmpboxbtncustom");
+    await tab.waitForElement(".cmptblbox", 2000);
+    await tab.clickElements(".cmptdchoice > a[aria-checked=true]");
+    return tab.clickElement(".cmpboxbtnyescustomchoices");
+  }
+
+  async optIn(tab: TabActor) {
+    return tab.clickElement(".cmpboxbtnyes");
+  }
+}

package/lib/cmps/cookiebot.js

@@ -0,0 +1,73 @@
+import AutoConsentBase from './base';
+export default class Cookiebot extends AutoConsentBase {
+    constructor() {
+        super('Cybotcookiebot');
+        this.prehideSelectors = ["#CybotCookiebotDialog,#dtcookie-container,#cookiebanner"];
+    }
+    async detectCmp(tab) {
+        try {
+            return await tab.eval('typeof window.CookieConsent === "object" && typeof window.CookieConsent.name === "string"');
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    detectPopup(tab) {
+        return tab.elementExists('#CybotCookiebotDialog,#dtcookie-container,#cookiebanner');
+    }
+    async optOut(tab) {
+        if (await tab.elementExists('.cookie-alert-extended-detail-link')) {
+            await tab.clickElement('.cookie-alert-extended-detail-link');
+            await tab.waitForElement('.cookie-alert-configuration', 1000);
+            await tab.clickElements('.cookie-alert-configuration-input:checked');
+            return tab.clickElement('.cookie-alert-extended-button-secondary');
+        }
+        if (await tab.elementExists('#dtcookie-container')) {
+            return tab.clickElement('.h-dtcookie-decline');
+        }
+        if (await tab.elementExists('.cookiebot__button--settings')) {
+            await tab.clickElement('.cookiebot__button--settings');
+        }
+        if (await tab.elementsAreVisible('#CybotCookiebotDialogBodyButtonDecline', 'all')) {
+            return await tab.clickElement('#CybotCookiebotDialogBodyButtonDecline');
+        }
+        if (await tab.elementExists('.cookiebanner__link--details')) {
+            await tab.clickElement('.cookiebanner__link--details');
+        }
+        await tab.clickElements('.CybotCookiebotDialogBodyLevelButton:checked:enabled,input[id*="CybotCookiebotDialogBodyLevelButton"]:checked:enabled');
+        if (await tab.elementExists('#CybotCookiebotDialogBodyButtonDecline')) {
+            await tab.clickElement('#CybotCookiebotDialogBodyButtonDecline');
+        }
+        if (await tab.elementExists('input[id^=CybotCookiebotDialogBodyLevelButton]:checked')) {
+            await tab.clickElements('input[id^=CybotCookiebotDialogBodyLevelButton]:checked');
+        }
+        if (await tab.elementExists('#CybotCookiebotDialogBodyButtonAcceptSelected')) {
+            await tab.clickElement('#CybotCookiebotDialogBodyButtonAcceptSelected');
+        }
+        else {
+            await tab.clickElements('#CybotCookiebotDialogBodyLevelButtonAccept,#CybotCookiebotDialogBodyButtonAccept,#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowallSelection');
+        }
+        // some sites have custom submit buttons with no obvious selectors. In this case we just call the submitConsent API.
+        if (await tab.eval('CookieConsent.hasResponse !== true')) {
+            await tab.eval('Cookiebot.dialog.submitConsent() || true');
+            await tab.wait(500);
+        }
+        return true;
+    }
+    async optIn(tab) {
+        if (await tab.elementExists('#dtcookie-container')) {
+            return tab.clickElement('.h-dtcookie-accept');
+        }
+        await tab.clickElements('.CybotCookiebotDialogBodyLevelButton:not(:checked):enabled');
+        await tab.clickElement('#CybotCookiebotDialogBodyLevelButtonAccept');
+        await tab.clickElement('#CybotCookiebotDialogBodyButtonAccept');
+        return true;
+    }
+    async openCmp(tab) {
+        await tab.eval('CookieConsent.renew() || true');
+        return tab.waitForElement('#CybotCookiebotDialog', 10000);
+    }
+    async test(tab) {
+        return tab.eval('CookieConsent.declined === true');
+    }
+}

package/lib/cmps/cookiebot.ts

@@ -0,0 +1,81 @@
+import AutoConsentBase from './base';
+import { TabActor } from '../types';
+
+export default class Cookiebot extends AutoConsentBase {
+
+  prehideSelectors = ["#CybotCookiebotDialog,#dtcookie-container,#cookiebanner"]
+
+  constructor() {
+    super('Cybotcookiebot');
+  }
+
+  async detectCmp(tab: TabActor) {
+    try {
+      return await tab.eval('typeof window.CookieConsent === "object" && typeof window.CookieConsent.name === "string"');
+    } catch (e) {
+      return false;
+    }
+  }
+
+  detectPopup(tab: TabActor) {
+    return tab.elementExists('#CybotCookiebotDialog,#dtcookie-container,#cookiebanner');
+  }
+
+  async optOut(tab: TabActor) {
+    if (await tab.elementExists('.cookie-alert-extended-detail-link')) {
+      await tab.clickElement('.cookie-alert-extended-detail-link');
+      await tab.waitForElement('.cookie-alert-configuration', 1000);
+      await tab.clickElements('.cookie-alert-configuration-input:checked');
+      return tab.clickElement('.cookie-alert-extended-button-secondary');
+    }
+    if (await tab.elementExists('#dtcookie-container')) {
+      return tab.clickElement('.h-dtcookie-decline');
+    }
+    if (await tab.elementExists('.cookiebot__button--settings')) {
+      await tab.clickElement('.cookiebot__button--settings');
+    }
+    if (await tab.elementsAreVisible('#CybotCookiebotDialogBodyButtonDecline', 'all')) {
+      return await tab.clickElement('#CybotCookiebotDialogBodyButtonDecline');
+    }
+    if (await tab.elementExists('.cookiebanner__link--details')) {
+      await tab.clickElement('.cookiebanner__link--details')
+    }
+    await tab.clickElements('.CybotCookiebotDialogBodyLevelButton:checked:enabled,input[id*="CybotCookiebotDialogBodyLevelButton"]:checked:enabled');
+    if (await tab.elementExists('#CybotCookiebotDialogBodyButtonDecline')) {
+      await tab.clickElement('#CybotCookiebotDialogBodyButtonDecline');
+    }
+    if (await tab.elementExists('input[id^=CybotCookiebotDialogBodyLevelButton]:checked')) {
+      await tab.clickElements('input[id^=CybotCookiebotDialogBodyLevelButton]:checked')
+    }
+    if (await tab.elementExists('#CybotCookiebotDialogBodyButtonAcceptSelected')) {
+      await tab.clickElement('#CybotCookiebotDialogBodyButtonAcceptSelected');
+    } else {
+      await tab.clickElements('#CybotCookiebotDialogBodyLevelButtonAccept,#CybotCookiebotDialogBodyButtonAccept,#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowallSelection');
+    }
+    // some sites have custom submit buttons with no obvious selectors. In this case we just call the submitConsent API.
+    if (await tab.eval('CookieConsent.hasResponse !== true')) {
+      await tab.eval('Cookiebot.dialog.submitConsent() || true');
+      await tab.wait(500);
+    }
+    return true;
+  }
+
+  async optIn(tab: TabActor) {
+    if (await tab.elementExists('#dtcookie-container')) {
+      return tab.clickElement('.h-dtcookie-accept');
+    }
+    await tab.clickElements('.CybotCookiebotDialogBodyLevelButton:not(:checked):enabled');
+    await tab.clickElement('#CybotCookiebotDialogBodyLevelButtonAccept');
+    await tab.clickElement('#CybotCookiebotDialogBodyButtonAccept');
+    return true;
+  }
+
+  async openCmp(tab: TabActor) {
+    await tab.eval('CookieConsent.renew() || true');
+    return tab.waitForElement('#CybotCookiebotDialog', 10000);
+  }
+
+  async test(tab: TabActor) {
+    return tab.eval('CookieConsent.declined === true');
+  }
+}

package/lib/cmps/evidon.js

@@ -0,0 +1,26 @@
+import AutoConsentBase from "./base";
+// Note: JS API is also available:
+// https://help.consentmanager.net/books/cmp/page/javascript-api
+export default class Evidon extends AutoConsentBase {
+    constructor() {
+        super("Evidon");
+    }
+    detectCmp(tab) {
+        return tab.elementExists("#_evidon_banner");
+    }
+    detectPopup(tab) {
+        return tab.elementsAreVisible("#_evidon_banner");
+    }
+    async optOut(tab) {
+        if (await tab.elementExists("#_evidon-decline-button")) {
+            return tab.clickElement("#_evidon-decline-button");
+        }
+        tab.hideElements(["#evidon-prefdiag-overlay", "#evidon-prefdiag-background"]);
+        await tab.clickElement("#_evidon-option-button");
+        await tab.waitForElement("#evidon-prefdiag-overlay", 5000);
+        return tab.clickElement("#evidon-prefdiag-decline");
+    }
+    async optIn(tab) {
+        return tab.clickElement("#_evidon-accept-button");
+    }
+}

package/lib/cmps/evidon.ts

@@ -0,0 +1,32 @@
+import AutoConsentBase from "./base";
+import { TabActor } from "../types";
+
+// Note: JS API is also available:
+// https://help.consentmanager.net/books/cmp/page/javascript-api
+export default class Evidon extends AutoConsentBase {
+  constructor() {
+    super("Evidon");
+  }
+
+  detectCmp(tab: TabActor) {
+    return tab.elementExists("#_evidon_banner");
+  }
+
+  detectPopup(tab: TabActor) {
+    return tab.elementsAreVisible("#_evidon_banner");
+  }
+
+  async optOut(tab: TabActor) {
+    if (await tab.elementExists("#_evidon-decline-button")) {
+      return tab.clickElement("#_evidon-decline-button");
+    }
+    tab.hideElements(["#evidon-prefdiag-overlay", "#evidon-prefdiag-background"])
+    await tab.clickElement("#_evidon-option-button");
+    await tab.waitForElement("#evidon-prefdiag-overlay", 5000);
+    return tab.clickElement("#evidon-prefdiag-decline");
+  }
+
+  async optIn(tab: TabActor) {
+    return tab.clickElement("#_evidon-accept-button");
+  }
+}