@duckduckgo/autoconsent 16.27.0 → 16.29.0

package/dist/types/cmps/base.d.ts

@@ -29,9 +29,10 @@ export default class AutoConsentCMPBase implements AutoCMP, DomActionsProvider {
     elementVisible(selector: ElementSelector, check?: VisibilityCheck): boolean;
     waitForElement(selector: ElementSelector, timeout?: number): Promise<boolean>;
     waitForVisible(selector: ElementSelector, timeout?: number, check?: VisibilityCheck): Promise<boolean>;
-    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean): Promise<boolean>;
+    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean, retries?: number, retryInterval?: number): Promise<boolean>;
     wait(ms: number): Promise<true>;
     hide(selector: string, method?: HideMethod): boolean;
+    stylesheet(cssRule: string, stylesheetId?: string): boolean;
     removeClass(selector: ElementSelector, className: string): boolean;
     setStyle(selector: ElementSelector, css: string): boolean;
     addStyle(selector: ElementSelector, css: string): boolean;

package/dist/types/dom-actions.d.ts

@@ -1,6 +1,7 @@
 import { ElementSelector, HideMethod, VisibilityCheck } from './rules';
 import { DomActionsProvider } from './types';
 import AutoConsent from './web';
+export declare const DEFAULT_CLICK_RETRY_INTERVAL = 300;
 export declare class DomActions implements DomActionsProvider {
     autoconsentInstance: AutoConsent;
     constructor(autoconsentInstance: AutoConsent);
@@ -10,10 +11,11 @@ export declare class DomActions implements DomActionsProvider {
     elementVisible(selector: ElementSelector, check?: VisibilityCheck): boolean;
     waitForElement(selector: ElementSelector, timeout?: number): Promise<boolean>;
     waitForVisible(selector: ElementSelector, timeout?: number, check?: VisibilityCheck): Promise<boolean>;
-    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean): Promise<boolean>;
+    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean, retries?: number, retryInterval?: number): Promise<boolean>;
     wait(ms: number): Promise<true>;
     cookieContains(substring: string): boolean;
     hide(selector: string, method?: HideMethod): boolean;
+    stylesheet(cssRule: string, stylesheetId?: string): boolean;
     removeClass(selector: ElementSelector, className: string): boolean;
     setStyle(selector: ElementSelector, css: string): boolean;
     addStyle(selector: ElementSelector, css: string): boolean;

package/dist/types/rules.d.ts

@@ -1,5 +1,5 @@
 import { snippets } from './eval-snippets';
-export declare const SUPPORTED_RULE_STEP_VERSION = 2;
+export declare const SUPPORTED_RULE_STEP_VERSION = 3;
 export type AutoConsentCMPRule = {
     readonly name: string;
     /**
@@ -33,7 +33,7 @@ export type ElementSelector = string | string[];
 export type AutoConsentRuleStep = {
     optional?: boolean;
     comment?: string;
-} & Partial<ElementExistsRule> & Partial<ElementVisibleRule> & Partial<EvalRule> & Partial<WaitForRule> & Partial<WaitForVisibleRule> & Partial<ClickRule> & Partial<WaitForThenClickRule> & Partial<WaitRule> & Partial<HideRule> & Partial<IfRule> & Partial<AnyRule> & Partial<NegatedRule> & Partial<CookieContainsRule> & Partial<RemoveClassRule> & Partial<SetStyleRule> & Partial<AddStyleRule>;
+} & Partial<ElementExistsRule> & Partial<ElementVisibleRule> & Partial<EvalRule> & Partial<WaitForRule> & Partial<WaitForVisibleRule> & Partial<ClickRule> & Partial<WaitForThenClickRule> & Partial<WaitRule> & Partial<HideRule> & Partial<IfRule> & Partial<AnyRule> & Partial<NegatedRule> & Partial<CookieContainsRule> & Partial<RemoveClassRule> & Partial<SetStyleRule> & Partial<AddStyleRule> & Partial<StylesheetRule>;
 export type NegatedRule = {
     negated: boolean;
 };
@@ -68,6 +68,16 @@ export type WaitForThenClickRule = {
     waitForThenClick: ElementSelector;
     timeout?: number;
     all?: boolean;
+    /**
+     * Number of additional click attempts if the element is still visible after the first click.
+     * Defaults to 0 (no retries). Only use this on elements that are expected to disappear once the
+     * click is handled, otherwise the extra clicks are wasted (or harmful).
+     */
+    retry?: number;
+    /**
+     * How long to wait (in ms) for the element to disappear before clicking it again.
+     */
+    retryInterval?: number;
 };
 export type WaitRule = {
     wait: number;
@@ -97,3 +107,7 @@ export type AddStyleRule = {
     addStyle: string;
     selector: ElementSelector;
 };
+export type StylesheetRule = {
+    stylesheet: string;
+    stylesheetId?: string;
+};

package/dist/types/types.d.ts

@@ -26,7 +26,7 @@ export interface DomActionsProvider {
     elementVisible(selector: ElementSelector, check: VisibilityCheck): boolean;
     waitForElement(selector: ElementSelector, timeout?: number): Promise<boolean>;
     waitForVisible(selector: ElementSelector, timeout?: number, check?: VisibilityCheck): Promise<boolean>;
-    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean): Promise<boolean>;
+    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean, retries?: number, retryInterval?: number): Promise<boolean>;
     wait(ms: number): Promise<true>;
     hide(selector: string, method: HideMethod): boolean;
     removeClass(selector: ElementSelector, className: string): boolean;

package/dist/types/utils.d.ts

@@ -3,6 +3,7 @@ import { Config } from './types';
 export declare function getStyleElement(styleOverrideElementId?: string): HTMLStyleElement;
 export declare function getHidingStyle(method: HideMethod): string;
 export declare function hideElements(styleEl: HTMLStyleElement, selector: string, method?: HideMethod): boolean;
+export declare function appendStylesheetRule(styleEl: HTMLStyleElement, cssRule: string, marker?: string): boolean;
 export declare function waitFor(predicate: () => Promise<boolean> | boolean, maxTimes: number, interval: number): Promise<boolean>;
 export declare function isElementVisible(elem: HTMLElement): boolean;
 export declare function copyObject(data: any): any;

package/docs/rule-syntax.md

@@ -103,11 +103,22 @@ Click on an element returned by `selector`. If `all` is `true`, all matching ele
 {
   "waitForThenClick": ElementSelector,
   "timeout": 1000,
-  "all": true | false
+  "all": true | false,
+  "retry": 0,
+  "retryInterval": 300
 }
 ```
 Combines `waitFor` and `click`.
 
+`retry` is the number of extra click attempts if the element is still visible after the click, `0` by
+default. It works around CMPs that insert a button before its click handler is attached.
+Between attempts the step waits up to `retryInterval` ms (300 by default) for the element to
+disappear, and stops retrying as soon as it does. Prefer this over an unconditional `wait` before the
+click: nothing is added to the step's duration when the first click works.
+
+**Only use `retry` on elements that are expected to go away** once the click is handled — a button that
+stays visible (e.g. a toggle) would be clicked repeatedly.
+
 ## Unconditional wait
 ```javascript
 {
@@ -154,6 +165,18 @@ Set the inline style of the elements matched by the `selector`. `style-string` i
 ```
 Append the inline style of the elements matched by the `selector`. `style-string` is a string of CSS properties and values. The style is appended to the existing inline style, separated by a semicolon.
 
+## Stylesheet
+
+```javascript
+{
+  "stylesheet": "css-rule-string",
+  "stylesheetId": "unique-marker"
+}
+```
+Append a CSS rule (e.g. `".overlay { display: none !important; }"`) to the style element injected by autoconsent. Unlike `setStyle`/`addStyle`, which modify inline styles of currently matched elements, an appended stylesheet rule keeps applying to elements matched later — useful when the page re-adds classes or inline styles after the opt-out (e.g. scroll locks reapplied on back/forward navigation).
+
+The optional `stylesheetId` is a marker used to prevent duplicate inserts when the rule runs multiple times; if omitted, the CSS rule text itself is used for deduplication.
+
 ## Cookie match
 ```javascript
 {
@@ -241,11 +264,13 @@ The `minimumRuleStepVersion` field solves this: clients compare the rule's decla
 |---------|-----------------|
 | 1 | All original step types (`exists`, `visible`, `waitFor`, `waitForVisible`, `click`, `waitForThenClick`, `wait`, `hide`, `if`/`then`/`else`, `any`, `eval`, `cookieContains`, `negated`) |
 | 2 | `removeClass`, `setStyle`, `addStyle` |
+| 3 | `stylesheet` |
 
 ### When to set it
 
 - If a rule only uses version-1 step types, omit the field (defaults to `1`).
 - If a rule uses `removeClass`, `setStyle`, or `addStyle`, set `"minimumRuleStepVersion": 2`.
+- If a rule uses `stylesheet`, set `"minimumRuleStepVersion": 3`.
 - When a future version introduces new step types, any rule using them must set `minimumRuleStepVersion` to the corresponding version number.
 
 ### Adding new step types

package/lib/cmps/base.ts

@@ -180,12 +180,12 @@ export default class AutoConsentCMPBase implements AutoCMP, DomActionsProvider {
         return this.autoconsent.domActions.waitForVisible(selector, timeout, check);
     }
 
-    async waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean) {
+    async waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean, retries?: number, retryInterval?: number) {
         if (this.autoconsent.config.visualTest) {
             await this.highlightElements(this.elementSelector(selector), all);
         }
         this.autoconsent.updateState({ clicks: this.autoconsent.state.clicks + 1 });
-        return this.autoconsent.domActions.waitForThenClick(selector, timeout, all);
+        return this.autoconsent.domActions.waitForThenClick(selector, timeout, all, retries, retryInterval);
     }
 
     wait(ms: number) {
@@ -196,6 +196,10 @@ export default class AutoConsentCMPBase implements AutoCMP, DomActionsProvider {
         return this.autoconsent.domActions.hide(selector, method);
     }
 
+    stylesheet(cssRule: string, stylesheetId?: string) {
+        return this.autoconsent.domActions.stylesheet(cssRule, stylesheetId);
+    }
+
     removeClass(selector: ElementSelector, className: string) {
         return this.autoconsent.domActions.removeClass(selector, className);
     }
@@ -332,7 +336,7 @@ export class AutoConsentCMP extends AutoConsentCMPBase {
             results.push(this.click(rule.click, rule.all));
         }
         if (rule.waitForThenClick) {
-            results.push(this.waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all));
+            results.push(this.waitForThenClick(rule.waitForThenClick, rule.timeout, rule.all, rule.retry, rule.retryInterval));
         }
         if (rule.wait) {
             results.push(this.wait(rule.wait));
@@ -340,6 +344,9 @@ export class AutoConsentCMP extends AutoConsentCMPBase {
         if (rule.hide) {
             results.push(this.hide(rule.hide, rule.method));
         }
+        if (rule.stylesheet !== undefined) {
+            results.push(this.stylesheet(rule.stylesheet, rule.stylesheetId));
+        }
         if (rule.removeClass !== undefined) {
             results.push(rule.selector ? this.removeClass(rule.selector, rule.removeClass) : false);
         }

package/lib/dom-actions.ts

@@ -1,8 +1,13 @@
 import { ElementSelector, HideMethod, VisibilityCheck } from './rules';
 import { DomActionsProvider } from './types';
-import { getStyleElement, hideElements, isElementVisible, waitFor } from './utils';
+import { getStyleElement, hideElements, appendStylesheetRule, isElementVisible, waitFor } from './utils';
 import AutoConsent from './web';
 
+// Default for the `retryInterval` option of `waitForThenClick`.
+export const DEFAULT_CLICK_RETRY_INTERVAL = 300;
+// How often we check if the element is gone while waiting out a `retryInterval`.
+const CLICK_RETRY_POLL_INTERVAL = 50;
+
 export class DomActions implements DomActionsProvider {
     constructor(public autoconsentInstance: AutoConsent) {}
 
@@ -66,9 +71,28 @@ export class DomActions implements DomActionsProvider {
         return waitFor(() => this.elementVisible(selector, check), times, interval);
     }
 
-    async waitForThenClick(selector: ElementSelector, timeout = 10000, all = false): Promise<boolean> {
+    async waitForThenClick(
+        selector: ElementSelector,
+        timeout = 10000,
+        all = false,
+        retries = 0,
+        retryInterval = DEFAULT_CLICK_RETRY_INTERVAL,
+    ): Promise<boolean> {
         await this.waitForElement(selector, timeout);
-        return await this.click(selector, all);
+        let clicked = await this.click(selector, all);
+        // Some CMPs insert the button before its click handler is attached, so the first click is
+        // silently dropped. There is usually no DOM signal for this, but a click that was handled
+        // makes the element go away: if it is still visible, we assume the click was lost and repeat it.
+        for (let attempt = 0; clicked && attempt < retries; attempt++) {
+            const pollTimes = Math.ceil(retryInterval / CLICK_RETRY_POLL_INTERVAL);
+            const isGone = await waitFor(() => !this.elementVisible(selector, 'any'), pollTimes, CLICK_RETRY_POLL_INTERVAL);
+            if (isGone) {
+                break;
+            }
+            this.autoconsentInstance.config.logs.rulesteps && console.log('[waitForThenClick] retrying click', selector);
+            clicked = await this.click(selector, all);
+        }
+        return clicked;
     }
 
     wait(ms: number): Promise<true> {
@@ -91,6 +115,12 @@ export class DomActions implements DomActionsProvider {
         return hideElements(styleEl, selector, method);
     }
 
+    stylesheet(cssRule: string, stylesheetId?: string): boolean {
+        this.autoconsentInstance.config.logs.rulesteps && console.log('[stylesheet]', cssRule, stylesheetId);
+        const styleEl = getStyleElement();
+        return appendStylesheetRule(styleEl, cssRule, stylesheetId);
+    }
+
     removeClass(selector: ElementSelector, className: string): boolean {
         const elements = this.elementSelector(selector);
         this.autoconsentInstance.config.logs.rulesteps && console.log('[removeClass]', selector, className, elements);

package/lib/rules.ts

@@ -2,7 +2,8 @@ import { snippets } from './eval-snippets';
 
 // 1 - the first version of the rule step format
 // 2 - added removeClass, setStyle, addStyle
-export const SUPPORTED_RULE_STEP_VERSION = 2;
+// 3 - added stylesheet
+export const SUPPORTED_RULE_STEP_VERSION = 3;
 
 export type AutoConsentCMPRule = {
     readonly name: string;
@@ -52,7 +53,8 @@ export type AutoConsentRuleStep = { optional?: boolean; comment?: string } & Par
     Partial<CookieContainsRule> &
     Partial<RemoveClassRule> &
     Partial<SetStyleRule> &
-    Partial<AddStyleRule>;
+    Partial<AddStyleRule> &
+    Partial<StylesheetRule>;
 
 export type NegatedRule = {
     negated: boolean;
@@ -97,6 +99,16 @@ export type WaitForThenClickRule = {
     waitForThenClick: ElementSelector;
     timeout?: number;
     all?: boolean;
+    /**
+     * Number of additional click attempts if the element is still visible after the first click.
+     * Defaults to 0 (no retries). Only use this on elements that are expected to disappear once the
+     * click is handled, otherwise the extra clicks are wasted (or harmful).
+     */
+    retry?: number;
+    /**
+     * How long to wait (in ms) for the element to disappear before clicking it again.
+     */
+    retryInterval?: number;
 };
 
 export type WaitRule = {
@@ -134,3 +146,8 @@ export type AddStyleRule = {
     addStyle: string;
     selector: ElementSelector;
 };
+
+export type StylesheetRule = {
+    stylesheet: string;
+    stylesheetId?: string;
+};

package/lib/types.ts

@@ -29,7 +29,13 @@ export interface DomActionsProvider {
     elementVisible(selector: ElementSelector, check: VisibilityCheck): boolean;
     waitForElement(selector: ElementSelector, timeout?: number): Promise<boolean>;
     waitForVisible(selector: ElementSelector, timeout?: number, check?: VisibilityCheck): Promise<boolean>;
-    waitForThenClick(selector: ElementSelector, timeout?: number, all?: boolean): Promise<boolean>;
+    waitForThenClick(
+        selector: ElementSelector,
+        timeout?: number,
+        all?: boolean,
+        retries?: number,
+        retryInterval?: number,
+    ): Promise<boolean>;
     wait(ms: number): Promise<true>;
     hide(selector: string, method: HideMethod): boolean;
     removeClass(selector: ElementSelector, className: string): boolean;

package/lib/utils.ts

@@ -32,6 +32,22 @@ export function hideElements(styleEl: HTMLStyleElement, selector: string, method
     return false;
 }
 
+// append a stylesheet rule once; marker is used to avoid duplicate inserts on re-runs
+export function appendStylesheetRule(styleEl: HTMLStyleElement, cssRule: string, marker?: string): boolean {
+    if (!(styleEl instanceof HTMLStyleElement) || cssRule.length === 0) {
+        return false;
+    }
+    const markerComment = marker ? `/* autoconsent:${marker} */` : '';
+    if (markerComment && styleEl.innerText.includes(markerComment)) {
+        return true;
+    }
+    if (!markerComment && styleEl.innerText.includes(cssRule.trim())) {
+        return true;
+    }
+    styleEl.innerText += `${markerComment}${markerComment ? ' ' : ''}${cssRule} `;
+    return true;
+}
+
 export async function waitFor(predicate: () => Promise<boolean> | boolean, maxTimes: number, interval: number): Promise<boolean> {
     const result = await predicate();
     if (!result && maxTimes > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckduckgo/autoconsent",
-  "version": "16.27.0",
+  "version": "16.29.0",
   "description": "",
   "types": "./dist/types/web.d.ts",
   "exports": {

package/rules/autoconsent/amazon-pay.json

@@ -0,0 +1,13 @@
+{
+    "name": "amazon-pay",
+    "vendorUrl": "https://pay.amazon.com/",
+    "runContext": {
+        "urlPattern": "^https?://pay\\.amazon\\."
+    },
+    "prehideSelectors": [".cookie-menu.js-cookie-banner"],
+    "detectCmp": [{ "exists": ".cookie-menu.js-cookie-banner .js-cookie-banner-close" }],
+    "detectPopup": [{ "visible": ".cookie-menu.js-cookie-banner" }],
+    "optIn": [{ "click": ".cookie-menu.js-cookie-banner .js-cookie-banner-close" }],
+    "optOut": [{ "click": ".cookie-menu.js-cookie-banner .js-cookie-banner-close" }],
+    "test": [{ "cookieContains": "apaycnst-mktg=true" }]
+}

package/rules/autoconsent/bbva.json

@@ -0,0 +1,12 @@
+{
+    "name": "bbva",
+    "prehideSelectors": [".cookiesgdpr__base:has(.cookiesgdpr__rejectbtn)"],
+    "detectCmp": [{ "exists": ".cookiesgdpr__base .cookiesgdpr__rejectbtn" }],
+    "detectPopup": [{ "visible": ".cookiesgdpr__base .cookiesgdpr__rejectbtn" }],
+    "optIn": [{ "waitForThenClick": ".cookiesgdpr__base .cookiesgdpr__acceptbtn" }],
+    "optOut": [
+        { "waitForThenClick": ".cookiesgdpr__base .cookiesgdpr__rejectbtn" },
+        { "waitForVisible": ".cookiesgdpr__base .cookiesgdpr__wrapper", "check": "none" }
+    ],
+    "test": [{ "cookieContains": "\"analitica\":false" }]
+}

package/rules/autoconsent/deliveroo.json

@@ -0,0 +1,15 @@
+{
+    "name": "deliveroo",
+    "runContext": {
+        "urlPattern": "^https?://(\\w+\\.)?deliveroo\\.(co\\.uk|\\w+)/"
+    },
+    "prehideSelectors": ["div[role=\"dialog\"][class*=\"CustomCookieBanner\"]"],
+    "detectCmp": [{ "exists": "div[role=\"dialog\"][class*=\"CustomCookieBanner\"]" }],
+    "detectPopup": [{ "visible": "div[role=\"dialog\"][class*=\"CustomCookieBanner\"]" }],
+    "optIn": [{ "waitForThenClick": "#onetrust-consent-sdk #accept-recommended-btn-handler" }],
+    "optOut": [
+        { "waitForThenClick": "#onetrust-consent-sdk .ot-pc-refuse-all-handler" },
+        { "waitForVisible": "div[role=\"dialog\"][class*=\"CustomCookieBanner\"]", "check": "none" }
+    ],
+    "test": [{ "cookieContains": "OptanonAlertBoxClosed" }]
+}

package/rules/autoconsent/ebay.json

@@ -21,11 +21,45 @@
     "optIn": [
         {
             "waitForThenClick": "#gdpr-banner-accept"
+        },
+        {
+            "waitForVisible": "#gdpr-banner",
+            "check": "none",
+            "timeout": 2000,
+            "optional": true
+        },
+        {
+            "if": {
+                "visible": "#gdpr-banner"
+            },
+            "then": [
+                {
+                    "waitForThenClick": "#gdpr-banner-accept",
+                    "timeout": 2000
+                }
+            ]
         }
     ],
     "optOut": [
         {
             "waitForThenClick": "#gdpr-banner-decline"
+        },
+        {
+            "waitForVisible": "#gdpr-banner",
+            "check": "none",
+            "timeout": 2000,
+            "optional": true
+        },
+        {
+            "if": {
+                "visible": "#gdpr-banner"
+            },
+            "then": [
+                {
+                    "waitForThenClick": "#gdpr-banner-decline",
+                    "timeout": 2000
+                }
+            ]
         }
     ]
 }

package/rules/autoconsent/ecbeing.json

@@ -0,0 +1,10 @@
+{
+    "name": "ecbeing",
+    "vendorUrl": "https://www.ecbeing.net/",
+    "cosmetic": true,
+    "prehideSelectors": ["#cookieBox .block-cookie-consent"],
+    "detectCmp": [{ "exists": "#cookieBox #consentButton.block-cookie-consent--btn" }],
+    "detectPopup": [{ "visible": "#cookieBox" }],
+    "optIn": [{ "waitForThenClick": "#cookieBox #consentButton" }],
+    "optOut": [{ "hide": "#cookieBox" }]
+}

package/rules/autoconsent/stright.json

@@ -0,0 +1,29 @@
+{
+    "name": "stright",
+    "prehideSelectors": ["#controlled_banner-cookie_consent-consent_banner", "#controlled_banner-cookie_consent-privacy_setting_banner"],
+    "detectCmp": [{ "exists": "#controlled_banner-cookie_consent-consent_banner" }],
+    "detectPopup": [{ "visible": "#controlled_banner-cookie_consent-consent_banner" }],
+    "optIn": [{ "waitForThenClick": "#controlled_submit-cookie_consent-consent_banner-accept_all" }],
+    "optOut": [
+        {
+            "if": {
+                "visible": "#controlled_banner-cookie_consent-consent_banner [data-search-key-button=reject_all_text]"
+            },
+            "then": [
+                {
+                    "waitForThenClick": "#controlled_banner-cookie_consent-consent_banner [data-search-key-button=reject_all_text]"
+                }
+            ],
+            "else": [
+                {
+                    "waitForThenClick": "#controlled_submit-cookie_consent-consent_banner-privacy_setting_banner_link"
+                },
+                {
+                    "waitForThenClick": "#controlled_banner-cookie_consent-privacy_setting_banner [data-search-key-button=reject_all_text]"
+                }
+            ]
+        },
+        { "waitForVisible": "#controlled_banner-cookie_consent-consent_banner", "check": "none" }
+    ],
+    "test": [{ "visible": "#controlled_banner-cookie_consent-consent_banner", "check": "none" }]
+}

package/rules/autoconsent/theguardian.com.json

@@ -3,7 +3,7 @@
     "vendorUrl": "https://www.theguardian.com/",
     "comment": "Sourcepoint 'consent or pay' wall shown in the EU/EEA (message 1482251) and UK (message 1482252), where the only reject option requires a paid subscription. The container id embeds the Sourcepoint message id, so we target the pay-wall variants specifically to avoid clashing with the free-reject Sourcepoint popup used in other regions (handled by Sourcepoint-frame). Brittle: message ids may change if the campaign is reconfigured.",
     "cosmetic": true,
-    "minimumRuleStepVersion": 2,
+    "minimumRuleStepVersion": 3,
     "runContext": {
         "urlPattern": "^https?://(\\w+\\.)?theguardian\\.com/",
         "main": true,
@@ -11,11 +11,21 @@
     },
     "prehideSelectors": ["div[id='sp_message_container_1482251'],div[id='sp_message_container_1482252']"],
     "detectCmp": [{ "exists": "div[id='sp_message_container_1482251'],div[id='sp_message_container_1482252']" }],
-    "detectPopup": [{ "visible": "div[id='sp_message_container_1482251'],div[id='sp_message_container_1482252']" }],
+    "detectPopup": [
+        {
+            "any": [
+                { "visible": "div[id='sp_message_container_1482251'],div[id='sp_message_container_1482252']" },
+                { "exists": "html.sp-message-open" }
+            ]
+        }
+    ],
     "optIn": [],
     "optOut": [
         { "hide": "div[id='sp_message_container_1482251'],div[id='sp_message_container_1482252']" },
-        { "removeClass": "sp-message-open", "selector": "html", "optional": true }
+        {
+            "stylesheet": "html.sp-message-open body { position: static !important; top: auto !important; width: auto !important; overflow: auto !important; }",
+            "stylesheetId": "theguardian-scroll-unlock"
+        }
     ],
     "test": [{ "visible": "div[id='sp_message_container_1482251'],div[id='sp_message_container_1482252']", "check": "none" }]
 }

package/rules/autoconsent/wpconsent.json

@@ -0,0 +1,30 @@
+{
+    "name": "WPConsent",
+    "vendorUrl": "https://wordpress.org/plugins/wpconsent-cookies-banner-privacy-suite/",
+    "prehideSelectors": ["#wpconsent-root"],
+    "detectCmp": [
+        {
+            "exists": "#wpconsent-container"
+        }
+    ],
+    "detectPopup": [
+        {
+            "visible": ["#wpconsent-container", "#wpconsent-banner-holder.wpconsent-banner-visible"]
+        }
+    ],
+    "optIn": [
+        {
+            "waitForThenClick": ["#wpconsent-container", "#wpconsent-accept-all"]
+        }
+    ],
+    "optOut": [
+        {
+            "waitForThenClick": ["#wpconsent-container", "#wpconsent-cancel-all"]
+        }
+    ],
+    "test": [
+        {
+            "cookieContains": "wpconsent_preferences="
+        }
+    ]
+}