@duckduckgo/autoconsent 14.97.0 → 15.1.0

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

@@ -1,4 +1,4 @@
-import { AutoCMP, DomActionsProvider, PopupData } from '../types';
+import { AutoCMP, DomActionsProvider, PopupData, PopupHandlingMode } from '../types';
 import { AutoConsentCMPRule, AutoConsentRuleStep, ElementSelector, HideMethod, RunContext, VisibilityCheck } from '../rules';
 import AutoConsent from '../web';
 import { snippets } from '../eval-snippets';
@@ -62,12 +62,14 @@ export declare class AutoConsentCMP extends AutoConsentCMPBase {
 }
 export declare class AutoConsentHeuristicCMP extends AutoConsentCMPBase {
     popups: PopupData[];
-    constructor(autoconsentInstance: AutoConsent);
+    mode: PopupHandlingMode;
+    constructor(autoconsentInstance: AutoConsent, mode?: PopupHandlingMode);
     get hasSelfTest(): boolean;
     get isIntermediate(): boolean;
     get isCosmetic(): boolean;
     detectCmp(): Promise<boolean>;
     detectPopup(): Promise<boolean>;
+    getTargetButton(): import("../types").ButtonData | undefined;
     optOut(): Promise<boolean>;
     optIn(): Promise<boolean>;
     openCmp(): Promise<boolean>;

package/dist/types/cmps/trustarc-top.d.ts

@@ -5,7 +5,7 @@ export default class TrustArcTop extends AutoConsentCMPBase {
     name: string;
     prehideSelectors: string[];
     runContext: RunContext;
-    _shortcutButton: HTMLElement;
+    _shortcutButton: HTMLElement | null;
     _optInDone: boolean;
     constructor(autoconsentInstance: AutoConsent);
     get hasSelfTest(): boolean;

package/dist/types/eval-handler.d.ts

@@ -3,14 +3,14 @@ import { ContentScriptMessage } from './messages';
 declare class Deferred<T> {
     id: string;
     promise: Promise<T>;
-    resolve: (value?: T) => void;
-    reject: (reason?: any) => void;
+    resolve: (value: T) => void;
+    reject: (reason?: unknown) => void;
     timer: number;
     constructor(id: string, timeout?: number);
 }
 type EvalState = {
     pending: Map<string, Deferred<boolean>>;
-    sendContentMessage: (message: ContentScriptMessage) => void;
+    sendContentMessage: ((message: ContentScriptMessage) => void) | null;
 };
 export declare const evalState: EvalState;
 export declare function requestEval(code: string, snippetId?: keyof typeof snippets): Promise<boolean>;

package/dist/types/heuristic-patterns.d.ts

@@ -4,3 +4,6 @@ export declare const DETECT_PATTERNS: RegExp[];
  */
 export declare const REJECT_PATTERNS: (string | RegExp)[];
 export declare const NEVER_MATCH_PATTERNS: RegExp[];
+export declare const SETTINGS_PATTERNS: (string | RegExp)[];
+export declare const ACCEPT_PATTERNS: (string | RegExp)[];
+export declare const ACKNOWLEDGE_PATTERNS: (string | RegExp)[];

package/dist/types/heuristics.d.ts

@@ -1,15 +1,12 @@
-import { ButtonData, PopupData } from './types';
+import { ButtonData, ButtonRegexClassification, PopupData, PopupHandlingMode } from './types';
 export declare function checkHeuristicPatterns(allText: string, detectPatterns?: RegExp[]): {
     patterns: string[];
     snippets: string[];
 };
-export declare function getActionablePopups(timeout?: number): PopupData[];
-export declare function classifyButtons(buttons: ButtonData[]): {
-    rejectButtons: ButtonData[];
-    otherButtons: ButtonData[];
-};
-export declare function isRejectButton(buttonText: string, rejectPatterns?: (string | RegExp)[], neverMatchPatterns?: RegExp[]): boolean;
+export declare function getActionablePopups(mode?: PopupHandlingMode, timeout?: number): PopupData[];
+export declare function classifyButtons(buttons: ButtonData[]): void;
 export declare function cleanButtonText(buttonText: string): string;
+export declare function classifyButtonTextRegex(buttonText: string): ButtonRegexClassification;
 export declare function isDialogLikeElement(node: HTMLElement): boolean;
 /**
  * Serialize all actionable buttons on the page

package/dist/types/types.d.ts

@@ -74,6 +74,7 @@ export type Config = {
     };
     performanceLoggingEnabled: boolean;
     heuristicPopupSearchTimeout: number;
+    heuristicMode: PopupHandlingMode;
 };
 export type LifecycleState = 'loading' | 'initialized' | 'waitingForInitResponse' | 'started' | 'nothingDetected' | 'cosmeticFiltersDetected' | 'cmpDetected' | 'openPopupDetected' | 'runningOptOut' | 'runningOptIn' | 'optOutSucceeded' | 'optOutFailed' | 'optInSucceeded' | 'optInFailed' | 'done';
 export type ConsentState = {
@@ -92,14 +93,29 @@ export type ConsentState = {
     endTime: number;
     performance?: Record<string, number[]>;
 };
+export type ButtonRegexClassification = 'reject' | 'settings' | 'accept' | 'acknowledge' | 'other';
 export interface ButtonData {
     text: string;
     element: HTMLElement;
+    regexClassification?: ButtonRegexClassification;
 }
 export interface PopupData {
     text: string;
     element: HTMLElement;
     buttons: ButtonData[];
-    rejectButtons?: ButtonData[];
-    otherButtons?: ButtonData[];
+    regexClassification?: PopupHandlingMode;
 }
+/**
+ * Controls the behavior of the heuristic popup detection.
+ *  - Reject: Will click the reject button on a popup if it exists.
+ *  - Tier1: Will also click the acknowledge button on a popup if it exists, and no Reject button exists.
+ *  - Tier2: Will also click the accept button on a popup if it exists, and no Reject or Acknowledge button exists.
+ *  - None: Disabled
+ */
+export declare const PopupHandlingModes: {
+    readonly None: -1;
+    readonly Reject: 0;
+    readonly Tier1: 1;
+    readonly Tier2: 2;
+};
+export type PopupHandlingMode = (typeof PopupHandlingModes)[keyof typeof PopupHandlingModes];

package/lib/cmps/base.ts

@@ -1,4 +1,4 @@
-import { AutoCMP, DomActionsProvider, PopupData } from '../types';
+import { AutoCMP, DomActionsProvider, PopupData, PopupHandlingMode, PopupHandlingModes } from '../types';
 import { AutoConsentCMPRule, AutoConsentRuleStep, ElementSelector, HideMethod, RunContext, VisibilityCheck } from '../rules';
 import { requestEval } from '../eval-handler';
 import AutoConsent from '../web';
@@ -419,14 +419,16 @@ export class AutoConsentCMP extends AutoConsentCMPBase {
 
 export class AutoConsentHeuristicCMP extends AutoConsentCMPBase {
     popups: PopupData[] = [];
+    mode: PopupHandlingMode;
 
-    constructor(autoconsentInstance: AutoConsent) {
+    constructor(autoconsentInstance: AutoConsent, mode: PopupHandlingMode = PopupHandlingModes.Reject) {
         super(autoconsentInstance);
         this.name = 'HEURISTIC';
         this.runContext = {
             main: true,
             frame: false, // do not run in iframes for security reasons
         } as RunContext;
+        this.mode = mode;
     }
 
     get hasSelfTest(): boolean {
@@ -445,11 +447,13 @@ export class AutoConsentHeuristicCMP extends AutoConsentCMPBase {
         // wait for one tick to deprioritize heavy DOM operations
         await new Promise((resolve) => setTimeout(resolve, 0));
         this.autoconsent.config.performanceLoggingEnabled && performance.mark('heuristicDetectorStart');
-        this.popups = getActionablePopups(this.autoconsent.config.heuristicPopupSearchTimeout);
+        this.popups = getActionablePopups(this.mode, this.autoconsent.config.heuristicPopupSearchTimeout);
         this.autoconsent.config.performanceLoggingEnabled && performance.mark('heuristicDetectorEnd');
         this.autoconsent.config.performanceLoggingEnabled &&
             performance.measure('heuristicDetector', 'heuristicDetectorStart', 'heuristicDetectorEnd');
+
         if (this.popups.length > 0) {
+            this.name = `HEURISTIC-TIER${this.popups[0].regexClassification}`;
             return Promise.resolve(true);
         }
         return Promise.resolve(false);
@@ -457,17 +461,26 @@ export class AutoConsentHeuristicCMP extends AutoConsentCMPBase {
 
     async detectPopup() {
         if (this.popups.length > 0) {
-            if (this.popups.length > 1 || (this.popups[0].rejectButtons && this.popups[0].rejectButtons.length > 1)) {
-                this.autoconsent.config.logs.errors && console.warn('Heuristic found multiple reject buttons');
+            if (this.popups.length > 1) {
+                this.autoconsent.config.logs.errors && console.warn('Heuristic found multiple popups');
             }
             return true;
         }
         return false;
     }
 
+    getTargetButton() {
+        const popup = this.popups[0];
+        const level = popup.regexClassification;
+        const buttons = popup.buttons;
+        const targetButtonType =
+            level === PopupHandlingModes.Reject ? 'reject' : level === PopupHandlingModes.Tier1 ? 'acknowledge' : 'accept';
+        return buttons.find((button) => button.regexClassification === targetButtonType);
+    }
+
     optOut(): Promise<boolean> {
         // use only the first found popup candidate
-        const button = this.popups[0]?.rejectButtons?.[0];
+        const button = this.getTargetButton();
         if (button) {
             return this.clickElement(button.element);
         }
@@ -483,7 +496,7 @@ export class AutoConsentHeuristicCMP extends AutoConsentCMPBase {
     }
 
     async test(): Promise<boolean> {
-        const button = this.popups[0].rejectButtons?.[0];
+        const button = this.getTargetButton();
         if (button) {
             await this.wait(500);
             return !isElementVisible(button.element);

package/lib/cmps/conversant.ts

@@ -41,12 +41,15 @@ export default class Conversant extends AutoConsentCMPBase {
             (<HTMLElement>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');
+            if (!content) {
+                return false;
+            }
             content
-                .querySelectorAll('.cmp-toggle-actions .cmp-toggle-deny:not(.cmp-toggle-deny--active)')
-                .forEach((e: HTMLElement) => e.click());
+                .querySelectorAll<HTMLElement>('.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: HTMLElement) => e.click());
+                .querySelectorAll<HTMLElement>('.cmp-toggle-actions .cmp-toggle-checkbox:not(.cmp-toggle-checkbox--active)')
+                .forEach((e) => e.click());
             // await waitFor(() => !item.querySelector('.cmp-toggle-deny--active,.cmp-toggle-checkbox--active'), 5, 50); // this may take a long time
         }
         await this.click('.cmp-main-button:not(.cmp-main-button--primary)');

package/lib/cmps/trustarc-top.ts

@@ -18,7 +18,7 @@ export default class TrustArcTop extends AutoConsentCMPBase {
         frame: false,
     };
 
-    _shortcutButton: HTMLElement;
+    _shortcutButton: HTMLElement | null;
     _optInDone: boolean;
 
     constructor(autoconsentInstance: AutoConsent) {

package/lib/cmps/uniconsent.ts

@@ -29,8 +29,8 @@ export default class Uniconsent extends AutoConsentCMPBase {
 
     async optOut() {
         await this.waitForElement('.unic button', 1000);
-        document.querySelectorAll('.unic button').forEach((button: HTMLButtonElement) => {
-            const text = button.textContent;
+        document.querySelectorAll<HTMLButtonElement>('.unic button').forEach((button) => {
+            const text = button.textContent || '';
             if (text.includes('Manage Options') || text.includes('Optionen verwalten')) {
                 button.click();
             }
@@ -39,14 +39,14 @@ export default class Uniconsent extends AutoConsentCMPBase {
         if (await this.waitForElement('.unic input[type=checkbox]', 1000)) {
             await this.waitForElement('.unic button', 1000);
 
-            document.querySelectorAll('.unic input[type=checkbox]').forEach((c: HTMLInputElement) => {
+            document.querySelectorAll<HTMLInputElement>('.unic input[type=checkbox]').forEach((c) => {
                 if (c.checked) {
                     c.click();
                 }
             });
 
             for (const b of <NodeListOf<HTMLButtonElement>>document.querySelectorAll('.unic button')) {
-                const text = b.textContent;
+                const text = b.textContent || '';
                 for (const pattern of ['Confirm Choices', 'Save Choices', 'Auswahl speichern']) {
                     if (text.includes(pattern)) {
                         b.click();

package/lib/eval-handler.ts

@@ -5,8 +5,8 @@ import { getRandomID } from './random';
 class Deferred<T> {
     id: string;
     promise: Promise<T>;
-    resolve: (value?: T) => void;
-    reject: (reason?: any) => void;
+    resolve!: (value: T) => void;
+    reject!: (reason?: unknown) => void;
     timer: number;
 
     constructor(id: string, timeout = 1000) {
@@ -23,7 +23,7 @@ class Deferred<T> {
 
 type EvalState = {
     pending: Map<string, Deferred<boolean>>;
-    sendContentMessage: (message: ContentScriptMessage) => void;
+    sendContentMessage: ((message: ContentScriptMessage) => void) | null;
 };
 
 export const evalState: EvalState = {
@@ -32,6 +32,9 @@ export const evalState: EvalState = {
 };
 
 export function requestEval(code: string, snippetId?: keyof typeof snippets): Promise<boolean> {
+    if (!evalState.sendContentMessage) {
+        return Promise.reject(new Error('AutoConsent is not initialized yet'));
+    }
     const id = getRandomID();
     evalState.sendContentMessage({
         type: 'eval',

package/lib/heuristic-patterns.ts

@@ -115,14 +115,19 @@ const REJECT_PATTERNS_ENGLISH = [
 
     // e.g. "do not sell or share my personal information", "do not sell my personal information"
     // often used in CCPA
-    /^\s*do\s+not\s+sell(\s+or\s+share)?\s*my\s*personal\s*information\s*$/is,
+    /^\s*do\s+not\s+sell(\s+or\s+share)?\s*my\s*personal\s*info(rmation)?\s*$/is,
 
     'allow selection',
     'disagree and close',
 
     // These are impactful, but look error-prone
+    // // e.g. "disagree"
+    /^(i)?\s*disagree\s*(and\s+close)?$/i,
     // // e.g. "i do not agree"
     // /^\s*(i\s+)?do\s+not\s+agree\s*$/i,
+    'no',
+    /^no,? thanks$/is,
+    /^opt[ -]out$/is,
 ];
 
 const REJECT_PATTERNS_DUTCH = [
@@ -715,3 +720,65 @@ export const NEVER_MATCH_PATTERNS = [
     /sostienici/is,
     /suscribir/is,
 ];
+
+export const SETTINGS_PATTERNS = [
+    'settings',
+    'preferences',
+    /customi(s|z)e/is,
+    'show details',
+    'more options',
+    /(manage|configure) (my|your) (preferences|choices|cookies)/is,
+    'manage choices',
+    /(cookie )?preference center/is,
+    'change settings',
+    'configure',
+    'change my preferences',
+    'cookie manager',
+    'cookie preference',
+    'let me choose',
+    'cookieconsent preferences',
+    /privacy choices/is,
+    /(privacy|cookie|custom) settings/is,
+    /cookies? (settings|preferences|setting)/is,
+    /(manage|customize|customise|opt-out|edit).*(cookies|preferences|settings|options)/is,
+    'cookie consent options',
+    'privacy controls',
+    'show purposes',
+    // German
+    'einstellungen',
+];
+
+export const ACCEPT_PATTERNS = [
+    /^(accept|allow)( all)?( cookies)?$/is,
+    /i (accept|allow)( all)?/is,
+    'yes',
+    /^(i )?agree$/is,
+    'continue with all',
+    'accept and continue',
+    /accept all above/is,
+    /^(accept|agree) and close/is,
+    'accept continue',
+    'agree proceed',
+    'allow and continue',
+    'close and accept',
+    /accept all$/is,
+    'im ok with that',
+    'accept optional cookies',
+
+    /^alle (cookies )?akzeptieren$/is,
+];
+
+export const ACKNOWLEDGE_PATTERNS = [
+    'ok',
+    'close',
+    'continue',
+    'x',
+    /^got it!?$/,
+    'i understand',
+    'dismiss',
+    'okay',
+    'acknowledge',
+    /^close (banner|cookie notification)$/is,
+    /understood$/is,
+    'confirm my choices',
+];

package/lib/heuristics.ts

@@ -1,5 +1,12 @@
-import { DETECT_PATTERNS, NEVER_MATCH_PATTERNS, REJECT_PATTERNS } from './heuristic-patterns';
-import { ButtonData, PopupData } from './types';
+import {
+    ACCEPT_PATTERNS,
+    ACKNOWLEDGE_PATTERNS,
+    DETECT_PATTERNS,
+    NEVER_MATCH_PATTERNS,
+    REJECT_PATTERNS,
+    SETTINGS_PATTERNS,
+} from './heuristic-patterns';
+import { ButtonData, ButtonRegexClassification, PopupData, PopupHandlingMode, PopupHandlingModes } from './types';
 import { isElementVisible, isTopFrame } from './utils';
 
 const BUTTON_LIKE_ELEMENT_SELECTOR = 'button, input[type="button"], input[type="submit"], a, [role="button"], [class*="button"]';
@@ -21,52 +28,78 @@ export function checkHeuristicPatterns(allText: string, detectPatterns = DETECT_
     return { patterns, snippets };
 }
 
-export function getActionablePopups(timeout = POPUP_SEARCH_MAX_TIME): PopupData[] {
+export function getActionablePopups(mode: PopupHandlingMode = PopupHandlingModes.Reject, timeout = POPUP_SEARCH_MAX_TIME): PopupData[] {
     const popups = getPotentialPopups(timeout);
     const result = popups.reduce((acc, popup) => {
         const popupText = popup.text?.trim();
         if (popupText) {
             const { patterns } = checkHeuristicPatterns(popupText);
             if (patterns.length > 0) {
-                const { rejectButtons, otherButtons } = classifyButtons(popup.buttons);
-                if (rejectButtons.length > 0) {
-                    acc.push({
-                        ...popup,
-                        rejectButtons,
-                        otherButtons,
-                    });
-                }
+                classifyButtons(popup.buttons);
+                popup.regexClassification = classifyPopup(popup.buttons);
+                acc.push({
+                    ...popup,
+                });
             }
         }
         return acc;
     }, [] as PopupData[]);
-    return result;
+    // popups filtered by mode and sorted so a popup with reject will always win.
+    return result
+        .filter(
+            (popup) =>
+                popup.regexClassification !== undefined &&
+                popup.regexClassification !== PopupHandlingModes.None &&
+                popup.regexClassification <= mode,
+        )
+        .sort((a, b) => (a.regexClassification ?? 0) - (b.regexClassification ?? 0));
 }
 
-export function classifyButtons(buttons: ButtonData[]): { rejectButtons: ButtonData[]; otherButtons: ButtonData[] } {
-    const rejectButtons = [];
-    const otherButtons = [];
+export function classifyButtons(buttons: ButtonData[]) {
     for (const button of buttons) {
-        if (isRejectButton(button.text)) {
-            rejectButtons.push(button);
-        } else {
-            otherButtons.push(button);
-        }
+        button.regexClassification = classifyButtonTextRegex(button.text);
+    }
+}
+
+function classifyPopup(buttons: ButtonData[]): PopupHandlingMode {
+    const { reject, settings, accept, acknowledge } = buttons.reduce(
+        (acc, button) => {
+            if (button.regexClassification && button.regexClassification !== 'other') {
+                acc[button.regexClassification]++;
+            }
+            return acc;
+        },
+        { reject: 0, settings: 0, accept: 0, acknowledge: 0 },
+    );
+    if (reject > 0) {
+        return PopupHandlingModes.Reject;
+    }
+    if (settings > 0) {
+        return PopupHandlingModes.None;
     }
-    return {
-        rejectButtons,
-        otherButtons,
-    };
+    if (acknowledge > 0) {
+        return PopupHandlingModes.Tier1;
+    }
+    if (accept > 0) {
+        return accept === 1 ? PopupHandlingModes.Tier2 : PopupHandlingModes.None;
+    }
+    return PopupHandlingModes.None;
 }
 
-export function isRejectButton(buttonText: string, rejectPatterns = REJECT_PATTERNS, neverMatchPatterns = NEVER_MATCH_PATTERNS): boolean {
+/**
+ * @param {string} buttonText
+ * @param {Array<string|RegExp>} matchPatterns
+ * @param {Array<string|RegExp>} neverMatchPatterns
+ * @returns {boolean}
+ */
+function testButtonMatches(buttonText: string, matchPatterns: (string | RegExp)[], neverMatchPatterns: (string | RegExp)[]): boolean {
     if (!buttonText) {
         return false;
     }
     const cleanedButtonText = cleanButtonText(buttonText);
     return (
-        !neverMatchPatterns.some((p) => p.test(cleanedButtonText)) &&
-        rejectPatterns.some((p) => (p instanceof RegExp && p.test(cleanedButtonText)) || p === cleanedButtonText)
+        !neverMatchPatterns.some((p) => (p instanceof RegExp && p.test(cleanedButtonText)) || p === cleanedButtonText) &&
+        matchPatterns.some((p) => (p instanceof RegExp && p.test(cleanedButtonText)) || p === cleanedButtonText)
     );
 }
 
@@ -89,6 +122,22 @@ export function cleanButtonText(buttonText: string): string {
     return result;
 }
 
+export function classifyButtonTextRegex(buttonText: string): ButtonRegexClassification {
+    if (testButtonMatches(buttonText, REJECT_PATTERNS, NEVER_MATCH_PATTERNS)) {
+        return 'reject';
+    }
+    if (testButtonMatches(buttonText, SETTINGS_PATTERNS, NEVER_MATCH_PATTERNS)) {
+        return 'settings';
+    }
+    if (testButtonMatches(buttonText, ACCEPT_PATTERNS, NEVER_MATCH_PATTERNS)) {
+        return 'accept';
+    }
+    if (testButtonMatches(buttonText, ACKNOWLEDGE_PATTERNS, NEVER_MATCH_PATTERNS)) {
+        return 'acknowledge';
+    }
+    return 'other';
+}
+
 function getPotentialPopups(timeout = POPUP_SEARCH_MAX_TIME) {
     const isFramed = !isTopFrame();
     // do not inspect frames that are more than one level deep

package/lib/types.ts

@@ -78,6 +78,7 @@ export type Config = {
     };
     performanceLoggingEnabled: boolean;
     heuristicPopupSearchTimeout: number;
+    heuristicMode: PopupHandlingMode; // controls the behavior of the heuristic popup detection. Has no effect if enableHeuristicDetection is false.
 };
 
 export type LifecycleState =
@@ -114,15 +115,32 @@ export type ConsentState = {
     performance?: Record<string, number[]>;
 };
 
+export type ButtonRegexClassification = 'reject' | 'settings' | 'accept' | 'acknowledge' | 'other';
+
 export interface ButtonData {
     text: string;
     element: HTMLElement;
+    regexClassification?: ButtonRegexClassification;
 }
 
 export interface PopupData {
     text: string;
     element: HTMLElement;
     buttons: ButtonData[];
-    rejectButtons?: ButtonData[];
-    otherButtons?: ButtonData[];
+    regexClassification?: PopupHandlingMode;
 }
+
+/**
+ * Controls the behavior of the heuristic popup detection.
+ *  - Reject: Will click the reject button on a popup if it exists.
+ *  - Tier1: Will also click the acknowledge button on a popup if it exists, and no Reject button exists.
+ *  - Tier2: Will also click the accept button on a popup if it exists, and no Reject or Acknowledge button exists.
+ *  - None: Disabled
+ */
+export const PopupHandlingModes = {
+    None: -1,
+    Reject: 0,
+    Tier1: 1,
+    Tier2: 2,
+} as const;
+export type PopupHandlingMode = (typeof PopupHandlingModes)[keyof typeof PopupHandlingModes];

package/lib/utils.ts

@@ -1,5 +1,5 @@
 import { HideMethod } from './rules';
-import { Config } from './types';
+import { Config, PopupHandlingModes } from './types';
 
 // get or create a style container for CSS overrides
 export function getStyleElement(styleOverrideElementId = 'autoconsent-css-rules'): HTMLStyleElement {
@@ -95,6 +95,7 @@ export function normalizeConfig(providedConfig: any): Config {
         },
         performanceLoggingEnabled: false,
         heuristicPopupSearchTimeout: 100,
+        heuristicMode: PopupHandlingModes.Reject,
     };
     const updatedConfig: Config = copyObject(defaultConfig);
     // filter out any unknown entries
@@ -116,13 +117,18 @@ export function scheduleWhenIdle(callback: () => void, timeout = 500) {
     }
 }
 
+type HighlightedHTMLElement = HTMLElement & {
+    __oldStyles?: string;
+};
+
 export function highlightNode(node: HTMLElement) {
+    const highlightedNode = node as HighlightedHTMLElement;
     if (!node.style) return;
-    if (node.__oldStyles !== undefined) {
+    if (highlightedNode.__oldStyles !== undefined) {
         return; // already highlighted
     }
     if (node.hasAttribute('style')) {
-        node.__oldStyles = node.style.cssText;
+        highlightedNode.__oldStyles = node.style.cssText;
     }
     node.style.animation = 'pulsate .5s infinite';
     node.style.outline = 'solid red';
@@ -153,10 +159,11 @@ export function highlightNode(node: HTMLElement) {
 }
 
 export function unhighlightNode(node: HTMLElement) {
+    const highlightedNode = node as HighlightedHTMLElement;
     if (!node.style || !node.hasAttribute('style')) return;
-    if (node.__oldStyles !== undefined) {
-        node.style.cssText = node.__oldStyles;
-        delete node.__oldStyles;
+    if (highlightedNode.__oldStyles !== undefined) {
+        node.style.cssText = highlightedNode.__oldStyles;
+        delete highlightedNode.__oldStyles;
     } else {
         node.removeAttribute('style');
     }

package/lib/web.ts

@@ -296,7 +296,9 @@ export default class AutoConsent {
         });
         // heuristic CMP is only run in the top frame and only if heuristic action is enabled and retries is odd
         const heuristicRules =
-            isTop && this.config.enableHeuristicAction && this.state.findCmpAttempts % 2 === 0 ? [new AutoConsentHeuristicCMP(this)] : [];
+            isTop && this.config.enableHeuristicAction && this.state.findCmpAttempts % 2 === 0
+                ? [new AutoConsentHeuristicCMP(this, this.config.heuristicMode)]
+                : [];
 
         const rulesPriorityStages: [string, AutoCMP[]][] = [
             ['site-specific', siteSpecificRules],

package/package.json

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

package/rules/autoconsent/twitch.json

@@ -1,7 +1,7 @@
 {
     "name": "twitch.tv",
     "runContext": {
-        "urlPattern": "^https?://(www\\.)?twitch\\.tv"
+        "urlPattern": "^https?://([\\w-]+\\.)?twitch\\.tv"
     },
     "prehideSelectors": [
         "div:has(> .consent-banner .consent-banner__content--gdpr-v2),.ReactModalPortal:has([data-a-target=consent-modal-save])"

package/rules/build.ts

@@ -4,6 +4,7 @@ import path from 'path';
 import https from 'https';
 import { encodeRules, deduplicateRules } from '../lib/encoding';
 import { AutoConsentCMPRule } from '../lib/rules';
+import { buildRuleIndex } from './rule-index-builder';
 
 export const rulesDir = __dirname;
 
@@ -61,6 +62,9 @@ export async function buildConsentOMaticRules() {
 
     fs.writeFile(path.join(rulesDir, 'rules.json'), stringify({ autoconsent }), () => console.log('Written rules.json'));
     fs.writeFile(path.join(rulesDir, 'consentomatic.json'), stringify({ consentomatic }), () => console.log('Written consentomatic.json'));
+    fs.writeFile(path.join(rulesDir, 'rule-index.json'), stringify(buildRuleIndex(autoconsent, consentomatic)), () =>
+        console.log('Written rule-index.json'),
+    );
     fs.writeFile(compactRulesPath, stringify(encodeRules(autoconsent, existingCompactRules)), () =>
         console.log('Written compact-rules.json'),
     );