@duckduckgo/autoconsent 16.63.0 → 17.1.0

package/tests-wtr/heuristics/get-actionable-popups.ts

@@ -1,5 +1,5 @@
 import { expect } from '@esm-bundle/chai';
-import { getActionablePopups } from '../../lib/heuristics';
+import { getActionablePopups, getPotentialPopups } from '../../lib/heuristics';
 import { ButtonData } from '../../lib/types';
 
 function rejectButtons(buttons: ButtonData[]) {
@@ -81,14 +81,30 @@ describe('getActionablePopups', () => {
             expect(popups[0].regexClassification).to.equal('tier2');
         });
 
-        it('prefers a contentful fixed child over its contentful container', () => {
+        it('prefers a contentful fixed child over its contentful container in the DOM walk', () => {
+            showPopup('popup-with-contentful-fixed-child');
+
+            const popups = getPotentialPopups();
+
+            expect(popups.map((p) => p.element.id)).to.deep.equal(['contentful-fixed-child']);
+        });
+
+        it('acts on a contentful fixed child found by the DOM walk', () => {
             showPopup('popup-with-contentful-fixed-child');
 
             const popups = getActionablePopups('tier2');
 
-            expect(popups).to.have.length(1);
-            expect(popups[0].element.id).to.equal('contentful-fixed-child');
-            expect(popups[0].regexClassification).to.equal('tier2');
+            expect(popups.map((p) => [p.element.id, p.regexClassification])).to.deep.equal([['contentful-fixed-child', 'tier2']]);
+        });
+
+        it('prefers a container with reject found by hit-testing over its fixed child', () => {
+            showPopup('popup-with-contentful-fixed-child');
+
+            const popups = getActionablePopups('tier2', undefined, true);
+
+            expect(popups.map((p) => [p.element.id, p.regexClassification])).to.deep.equal([
+                ['popup-with-contentful-fixed-child', 'reject'],
+            ]);
         });
 
         it('finds acknowledge-only popup with no reject buttons', () => {
@@ -167,7 +183,7 @@ describe('getActionablePopups', () => {
             expect(popups.length).to.equal(1);
         });
 
-        it('ignores static positioned elements', () => {
+        it('ignores static positioned elements without hit-testing', () => {
             showPopup('popup-static');
 
             const popups = getActionablePopups();
@@ -175,6 +191,14 @@ describe('getActionablePopups', () => {
             expect(popups.length).to.equal(0);
         });
 
+        it('finds a static positioned popup on screen by hit-testing', () => {
+            showPopup('popup-static');
+
+            const popups = getActionablePopups('reject', undefined, true);
+
+            expect(popups.map((p) => p.element.id)).to.deep.equal(['popup-static']);
+        });
+
         it('finds popup with role="dialog"', () => {
             showPopup('popup-role-dialog');
 
@@ -202,7 +226,7 @@ describe('getActionablePopups', () => {
             dialog.close();
         });
 
-        it('ignores closed <dialog> element', () => {
+        it('ignores closed <dialog> element without hit-testing', () => {
             const dialog = document.getElementById('popup-dialog-element') as HTMLDialogElement;
             dialog.classList.add('visible');
 
@@ -210,6 +234,16 @@ describe('getActionablePopups', () => {
 
             expect(popups.length).to.equal(0);
         });
+
+        it('finds a closed <dialog> that the page shows anyway only by hit-testing', () => {
+            const dialog = document.getElementById('popup-dialog-element') as HTMLDialogElement;
+            dialog.classList.add('visible');
+
+            const popups = getActionablePopups('reject', undefined, true);
+
+            // not dialog-like while closed, but it is painted on screen
+            expect(popups.map((p) => p.element.id)).to.deep.equal(['popup-dialog-element']);
+        });
     });
 
     describe('button classification', () => {

package/tests-wtr/heuristics/get-potential-popups.test.ts

@@ -1,5 +1,6 @@
 import { expect } from '@esm-bundle/chai';
 import { getActionablePopups, getButtonData, getFramePopupElement, getPotentialPopups } from '../../lib/heuristics';
+import { PopupData } from '../../lib/types';
 import { getHidingStyle } from '../../lib/utils';
 
 const BANNER = `
@@ -44,14 +45,18 @@ describe('getPotentialPopups', () => {
         return attachShadow(container.querySelector('#host')!, html);
     }
 
-    function popupIds(): string[] {
-        return getPotentialPopups(1000).map((p) => p.element.id);
+    function popupIds(hitTest = false): string[] {
+        return getPotentialPopups(1000, hitTest).map((p) => p.element.id);
     }
 
     function findPopup(id: string) {
         return getPotentialPopups(1000).find((p) => p.element.id === id);
     }
 
+    function inContainer(popups: PopupData[]): PopupData[] {
+        return popups.filter((p) => container.contains(p.element));
+    }
+
     it('returns positioned popups with their buttons', () => {
         container.innerHTML = fixedBanner('popup');
         const popup = findPopup('popup');
@@ -240,7 +245,7 @@ describe('getPotentialPopups', () => {
                     <div style="position: fixed; bottom: 0;"><button>Reject all</button><button>Accept all</button></div>
                 </div>
             `;
-            const popups = getPotentialPopups(1000).filter((p) => container.contains(p.element));
+            const popups = inContainer(getPotentialPopups(1000));
             expect(popups.map((p) => p.element.id)).to.deep.equal(['banner']);
         });
 
@@ -298,10 +303,236 @@ describe('getPotentialPopups', () => {
                     <div style="position: sticky; bottom: 0;"><button>Accept all</button></div>
                 </div>
             `;
-            const popups = getActionablePopups('tier2', 1000).filter((p) => container.contains(p.element));
+            const popups = inContainer(getActionablePopups('tier2', 1000));
             expect(popups).to.have.length(0);
         });
     });
+    describe('banners in the normal page flow', () => {
+        const IN_FLOW_BANNER = `
+            <div id="banner">
+                <p>We use cookies to improve your experience. Read our <a href="#">Privacy Policy</a>.</p>
+                <button>Reject all</button>
+                <button>Accept all</button>
+            </div>
+        `;
+
+        it('only hit-tests when asked to', () => {
+            container.innerHTML = IN_FLOW_BANNER;
+            expect(popupIds()).not.to.include('banner');
+            expect(inContainer(getActionablePopups('reject', 1000))).to.have.length(0);
+        });
+
+        it('finds a banner at the top of the page that is not positioned', () => {
+            container.innerHTML = IN_FLOW_BANNER;
+            expect(popupIds(true)).to.include('banner');
+        });
+
+        it('makes an in-flow banner actionable', () => {
+            container.innerHTML = IN_FLOW_BANNER;
+            const popup = getActionablePopups('reject', 1000, true).find((p) => p.element.id === 'banner');
+            expect(popup).to.exist;
+            expect(popup!.regexClassification).to.equal('reject');
+        });
+
+        it('ignores an in-flow banner below the fold', () => {
+            container.innerHTML = `<div style="height: 3000px"></div>${IN_FLOW_BANNER}`;
+            expect(popupIds(true)).not.to.include('banner');
+        });
+
+        it('ignores page copy about cookies without consent buttons', () => {
+            container.innerHTML =
+                '<div id="copy"><p>We use cookies on this site.</p><a href="#">Privacy Policy</a> <a href="#">Contact</a></div>';
+            expect(popupIds(true)).not.to.include('copy');
+        });
+
+        it('ignores a login form with consent wording', () => {
+            container.innerHTML = `
+                <form id="login">
+                    <input type="email" placeholder="Email">
+                    <p>By continuing, you agree to our Terms and acknowledge our Privacy Policy and use of cookies.</p>
+                    <button>Continue</button>
+                </form>
+            `;
+            expect(popupIds(true)).not.to.include('login');
+        });
+
+        it('does not report a positioned popup twice', () => {
+            container.innerHTML = fixedBanner('banner');
+            expect(popupIds(true).filter((id) => id === 'banner')).to.have.length(1);
+        });
+
+        it('prefers a positioned popup with reject over an in-flow accept-only banner', () => {
+            container.innerHTML = `
+                <div id="inflow"><p>We use cookies to improve your experience.</p><button>Accept all</button></div>
+                <div id="fixed" style="position: fixed; bottom: 0;"><p>We use cookies.</p><button>Reject all</button><button>Accept all</button></div>
+            `;
+            const popups = inContainer(getActionablePopups('tier2', 1000, true));
+            expect(popups.map((p) => [p.element.id, p.regexClassification])).to.deep.equal([
+                ['fixed', 'reject'],
+                ['inflow', 'tier2'],
+            ]);
+        });
+
+        it('skips the DOM walk when hit-testing finds a popup with reject', () => {
+            // pointer-events: none keeps the fixed popup out of hit-testing, so only the walk could find it
+            container.innerHTML = `
+                ${IN_FLOW_BANNER}
+                <div id="fixed" style="position: fixed; bottom: 0; pointer-events: none;"><p>We use cookies.</p><button>Reject all</button></div>
+            `;
+            const actionable = inContainer(getActionablePopups('tier2', 1000, true));
+            expect(actionable.map((p) => p.element.id)).to.deep.equal(['banner']);
+            expect(popupIds(true)).to.include.members(['banner', 'fixed']);
+        });
+
+        it('finds an in-flow banner inside a shadow root', () => {
+            shadowHost('', IN_FLOW_BANNER);
+            expect(popupIds(true)).to.include('banner');
+        });
+
+        describe('inside a walk candidate that is not a consent popup', () => {
+            // the fixed wrapper is found by the walk, but its age gate text excludes it
+            function ageGateWrapper(bannerFirst: boolean): string {
+                const banner =
+                    '<div id="banner"><p>We use cookies to improve your experience on our website.</p><button>Accept all</button></div>';
+                const ageGate = '<p>You must be over 18 years old to enter.</p>';
+                return `<div id="wrapper" style="position: fixed; top: 0; left: 0; right: 0;">${bannerFirst ? banner + ageGate : ageGate + banner}</div>`;
+            }
+
+            it('keeps a consent popup found by hit-testing next to the walk candidate', () => {
+                // the top grid row hits the banner, so hit-testing finds the banner rather than the wrapper
+                container.innerHTML = ageGateWrapper(true);
+                const popups = inContainer(getPotentialPopups(1000, true));
+                expect(popups.map((p) => [p.element.id, p.source])).to.deep.equal([
+                    ['wrapper', 'walk'],
+                    ['banner', 'hitTest'],
+                ]);
+                expect(popups[0].hitPoints).to.be.undefined;
+                expect(popups[1].hitPoints).not.to.be.empty;
+            });
+
+            it('makes the consent popup found by hit-testing actionable', () => {
+                container.innerHTML = ageGateWrapper(true);
+                const actionable = inContainer(getActionablePopups('tier2', 1000, true));
+                expect(actionable.map((p) => [p.element.id, p.regexClassification])).to.deep.equal([['banner', 'tier2']]);
+            });
+
+            it('reports the wrapper once when hit-testing also reaches it', () => {
+                // the top grid row hits the age gate text, so the climb reaches the wrapper
+                container.innerHTML = ageGateWrapper(false);
+                const popups = inContainer(getPotentialPopups(1000, true));
+                expect(popups.map((p) => [p.element.id, p.source])).to.deep.equal([['wrapper', 'walk']]);
+                expect(popups[0].hitPoints).not.to.be.empty;
+                expect(inContainer(getActionablePopups('tier2', 1000, true))).to.be.empty;
+            });
+        });
+
+        it('keeps a banner with reject found by hit-testing next to its accept-only fragment found by the walk', () => {
+            // the walk keeps the fixed bar, an accept-only fragment that passes on its own; hit-testing the reject button reaches the banner
+            container.innerHTML = `
+                <div id="banner" style="position: fixed; bottom: 0; left: 0; right: 0; height: 200px;">
+                    <div id="bar" style="position: fixed; bottom: 120px; left: 0; right: 0; height: 40px;"><span>We use cookies to improve your experience.</span><button>Accept all</button></div>
+                    <button style="position: absolute; bottom: 0; left: 0; width: 100%; height: 100px;">Reject all</button>
+                </div>
+            `;
+            const popups = inContainer(getPotentialPopups(1000, true));
+            expect(popups.map((p) => [p.element.id, p.source, p.regexClassification])).to.deep.equal([
+                ['bar', 'walk', 'tier2'],
+                ['banner', 'hitTest', 'reject'],
+            ]);
+            const actionable = inContainer(getActionablePopups('tier2', 1000, true));
+            expect(actionable.map((p) => p.element.id)).to.deep.equal(['banner']);
+        });
+    });
+
+    describe('order', () => {
+        it('sorts actionable popups by classification, and keeps search order within one', () => {
+            container.innerHTML = `
+                <div id="accept1" style="position: fixed; top: 0;"><p>We use cookies on this website.</p><button>Accept all</button></div>
+                <div id="ok" style="position: fixed; top: 100px;"><p>We use cookies on this website.</p><button>OK</button></div>
+                <div id="accept2" style="position: fixed; top: 200px;"><p>We use cookies on this website.</p><button>Accept all</button></div>
+            `;
+            const searchOrder = inContainer(getPotentialPopups(1000))
+                .filter((p) => p.regexClassification === 'tier2')
+                .map((p) => p.element.id);
+            expect(searchOrder).to.have.members(['accept1', 'accept2']);
+            const popups = inContainer(getActionablePopups('tier2', 1000));
+            expect(popups.map((p) => p.element.id)).to.deep.equal(['ok', ...searchOrder]);
+        });
+    });
+
+    describe('labels', () => {
+        it('labels every potential popup with a classification from its buttons', () => {
+            container.innerHTML = fixedBanner('consent');
+            // outside the container, so that the walk does not expand it to the container that holds the consent banner
+            const chat = document.createElement('div');
+            chat.innerHTML = '<div id="chat" style="position: fixed; top: 0;"><p>Chat with us</p><button>Start chat</button></div>';
+            document.body.appendChild(chat);
+            try {
+                const labels = Object.fromEntries(
+                    getPotentialPopups(1000)
+                        .filter((p) => container.contains(p.element) || chat.contains(p.element))
+                        .map((p) => [p.element.id, p.regexClassification]),
+                );
+                expect(labels).to.deep.equal({ consent: 'reject', chat: 'none' });
+            } finally {
+                chat.remove();
+            }
+        });
+    });
+
+    describe('hit-test grid and hit points', () => {
+        const GRID = { columns: [0.25, 0.75], edgeRows: [40] };
+        const columnXs = GRID.columns.map((c) => Math.round(c * window.innerWidth));
+
+        function findGridPopup(id: string) {
+            return getPotentialPopups(1000, true, GRID).find((p) => p.element.id === id);
+        }
+
+        it('records every grid point that reached an in-flow banner', () => {
+            container.innerHTML = `<div id="banner" style="padding: 60px 0;">${BANNER}</div>`;
+            const popup = findGridPopup('banner');
+            expect(popup?.source).to.equal('hitTest');
+            expect(popup!.hitPoints).to.deep.equal(columnXs.map((x) => [x, 40]));
+        });
+
+        it('keeps the walk candidate of a positioned popup, with its hit points', () => {
+            container.innerHTML = `<div id="fixed" style="position: fixed; bottom: 0; left: 0; right: 0; padding: 30px 0;">${BANNER}</div>`;
+            const popup = findGridPopup('fixed');
+            expect(popup?.source).to.equal('walk');
+            const bottomRow = Math.round(window.innerHeight - 40);
+            expect(popup!.hitPoints).to.deep.equal(columnXs.map((x) => [x, bottomRow]));
+        });
+
+        it('leaves out hit points of a positioned popup that is not hit-tested', () => {
+            container.innerHTML = fixedBanner('fixed');
+            const popup = getPotentialPopups(1000).find((p) => p.element.id === 'fixed');
+            expect(popup?.source).to.equal('walk');
+            expect(popup!.hitPoints).to.be.undefined;
+        });
+
+        it('tests rows 30 and 90px from the edges by default', () => {
+            // the banner lies between 100 and 200px from the top; the spacer is outside the container, so climbs from it stop at body
+            const spacer = document.createElement('div');
+            spacer.style.height = '100px';
+            document.body.insertBefore(spacer, document.body.firstChild);
+            document.body.style.margin = '0';
+            container.innerHTML = `<div id="banner" style="height: 100px; overflow: hidden;">${BANNER}</div>`;
+            try {
+                expect(container.querySelector('#banner')!.getBoundingClientRect().top).to.equal(100);
+                expect(inContainer(getPotentialPopups(1000, true))).to.have.length(0);
+                const withRow150 = getPotentialPopups(1000, true, { columns: [0.1, 0.5, 0.9], edgeRows: [30, 90, 150] });
+                expect(withRow150.map((p) => p.element.id)).to.include('banner');
+            } finally {
+                spacer.remove();
+                document.body.style.margin = '';
+            }
+        });
+
+        it('only tests the points of the grid it is given', () => {
+            container.innerHTML = `<div id="banner" style="padding: 60px 0;">${BANNER}</div>`;
+            expect(getPotentialPopups(1000, true, { columns: [0.5], edgeRows: [] }).map((p) => p.element.id)).not.to.include('banner');
+        });
+    });
 });
 
 describe('getFramePopupElement', () => {

package/tests-wtr/heuristics/heuristic-cmp.ts

@@ -5,11 +5,12 @@ import { HeuristicLevel } from '../../lib/types';
 
 // must be run from heuristic-cmp.html
 describe('AutoConsentHeuristicCMP', () => {
-    function createAutoconsent(heuristicMode: HeuristicLevel) {
+    function createAutoconsent(heuristicMode: HeuristicLevel, enableHeuristicHitTest = false) {
         return new Autoconsent(() => Promise.resolve(), {
             enabled: false,
             autoAction: null,
             heuristicMode,
+            enableHeuristicHitTest,
         });
     }
 
@@ -40,6 +41,20 @@ describe('AutoConsentHeuristicCMP', () => {
             expect(cmp.name).to.equal('HEURISTIC-REJECT');
         });
 
+        it('hit-tests for an in-flow banner only when enableHeuristicHitTest is set', async () => {
+            const banner = document.createElement('div');
+            banner.innerHTML = '<p>We use cookies to improve your experience.</p><button>Reject all</button><button>Accept all</button>';
+            document.body.prepend(banner);
+            try {
+                expect(await new AutoConsentHeuristicCMP(createAutoconsent('tier2'), 'tier2').detectCmp()).to.be.false;
+                const cmp = new AutoConsentHeuristicCMP(createAutoconsent('tier2', true), 'tier2');
+                expect(await cmp.detectCmp()).to.be.true;
+                expect(cmp.name).to.equal('HEURISTIC-REJECT');
+            } finally {
+                banner.remove();
+            }
+        });
+
         it('detects a Russian popup using the Cyrillic word for cookies', async () => {
             const autoconsent = createAutoconsent('tier2');
             const cmp = new AutoConsentHeuristicCMP(autoconsent, 'tier2');

package/tests-wtr/heuristics/heuristics-utils.test.ts

@@ -75,7 +75,7 @@ describe('checkHeuristicPatterns', () => {
     });
 });
 
-describe('checkHeuristicPatterns with a qualifier before "cookies"', () => {
+describe('checkHeuristicPatterns with qualifiers before "cookies"', () => {
     it('detects "we use <qualifier> cookies" notices', () => {
         const texts = [
             // openrouter.ai
@@ -83,6 +83,8 @@ describe('checkHeuristicPatterns with a qualifier before "cookies"', () => {
             'We use optional cookies to measure traffic',
             'We use analytics cookies and similar technologies',
             'We serve necessary cookies only',
+            'We use Google Analytics cookies to understand which pages and tools are useful.',
+            'We use third party cookies for advertising',
         ];
         for (const text of texts) {
             expect(checkHeuristicPatterns(text).patterns.length, text).to.be.greaterThan(0);
@@ -90,9 +92,9 @@ describe('checkHeuristicPatterns with a qualifier before "cookies"', () => {
     });
 
     it('does not match when "cookies" is further away', () => {
-        expect(checkHeuristicPatterns('We use the best chocolate in our cookies', [/we use(?: \w+)? cookies/gi]).patterns).to.have.length(
-            0,
-        );
+        expect(
+            checkHeuristicPatterns('We use the best chocolate in our cookies', [/we (?:use|serve)(?: \w+){0,2} cookies/gi]).patterns,
+        ).to.have.length(0);
     });
 });
 
@@ -195,6 +197,23 @@ describe('checkHeuristicPatterns with Danish popups', () => {
     });
 });
 
+describe('checkHeuristicPatterns with Norwegian popups', () => {
+    it('detects Norwegian cookie notices', () => {
+        const texts = [
+            'Kan vi bruke valgfrie informasjonskapsler for å forbedre tjenestene våre?',
+            'Vi bruker informasjonskapsler for å gi deg en bedre opplevelse.',
+            'Nettstedet bruker cookies til statistikk.',
+        ];
+        for (const text of texts) {
+            expect(checkHeuristicPatterns(text).patterns.length, text).to.be.greaterThan(0);
+        }
+    });
+
+    it('does not detect unrelated Norwegian text', () => {
+        expect(checkHeuristicPatterns('Vi bruker skattemeldingen til å beregne skatten din').patterns).to.have.length(0);
+    });
+});
+
 describe('isExcludedPopup', () => {
     it('flags doublelist-style age verification popups', () => {
         // Real-world text from the doublelist.com age gate (listings page)
@@ -349,6 +368,17 @@ describe('classifyButtonTextRegex', () => {
         expect(classifyButtonTextRegex('Læs mere om brugen af cookies på sundhed.dk')).not.to.equal('reject');
     });
 
+    it('matches Norwegian reject buttons', () => {
+        expect(classifyButtonTextRegex('Nei')).to.equal('reject');
+        expect(classifyButtonTextRegex('Nei takk')).to.equal('reject');
+        expect(classifyButtonTextRegex('Avvis alle')).to.equal('reject');
+        expect(classifyButtonTextRegex('Avslå')).to.equal('reject');
+        expect(classifyButtonTextRegex('Godta kun nødvendige')).to.equal('reject');
+        expect(classifyButtonTextRegex('Bare nødvendige informasjonskapsler')).to.equal('reject');
+        expect(classifyButtonTextRegex('Ja')).not.to.equal('reject');
+        expect(classifyButtonTextRegex('Les mer om hvordan vi bruker informasjonskapsler')).not.to.equal('reject');
+    });
+
     it('matches Russian settings buttons', () => {
         expect(classifyButtonTextRegex('Настроить')).to.equal('settings');
         expect(classifyButtonTextRegex('Настройки')).to.equal('settings');

package/rules/generated/auto_CA_plex.tv_ee4.json

@@ -1,40 +0,0 @@
-{
-    "name": "auto_CA_plex.tv_ee4",
-    "cosmetic": false,
-    "_metadata": {
-        "vendorUrl": "http://www.plex.tv/"
-    },
-    "runContext": {
-        "main": true,
-        "frame": false,
-        "urlPattern": "^https?://(www\\.)?plex\\.tv/"
-    },
-    "prehideSelectors": [],
-    "detectCmp": [
-        {
-            "exists": "body > div:not([id]) > div:nth-child(3):not([id]) > div:nth-child(1):not([id]) > div:nth-child(2):not([id]) > a:not([id])"
-        }
-    ],
-    "detectPopup": [
-        {
-            "visible": "body > div:not([id]) > div:nth-child(3):not([id]) > div:nth-child(1):not([id]) > div:nth-child(2):not([id]) > a:not([id])"
-        }
-    ],
-    "optIn": [],
-    "optOut": [
-        {
-            "wait": 500
-        },
-        {
-            "waitForThenClick": "body > div:not([id]) > div:nth-child(3):not([id]) > div:nth-child(1):not([id]) > div:nth-child(2):not([id]) > a:not([id])",
-            "comment": "I Reject"
-        }
-    ],
-    "test": [
-        {
-            "waitForVisible": "body > div:not([id]) > div:nth-child(3):not([id]) > div:nth-child(1):not([id]) > div:nth-child(2):not([id]) > a:not([id])",
-            "timeout": 1000,
-            "check": "none"
-        }
-    ]
-}

package/rules/generated/auto_CA_support.plex.tv_gn3.json

@@ -1,40 +0,0 @@
-{
-    "name": "auto_CA_support.plex.tv_gn3",
-    "cosmetic": false,
-    "_metadata": {
-        "vendorUrl": "http://support.plex.tv/"
-    },
-    "runContext": {
-        "main": true,
-        "frame": false,
-        "urlPattern": "^https?://(www\\.)?support\\.plex\\.tv/"
-    },
-    "prehideSelectors": [],
-    "detectCmp": [
-        {
-            "exists": "body > div:not([id]) > div:nth-child(3):not([id]) > div:nth-child(1):not([id]) > div:nth-child(2):not([id]) > a:not([id])"
-        }
-    ],
-    "detectPopup": [
-        {
-            "visible": "body > div:not([id]) > div:nth-child(3):not([id]) > div:nth-child(1):not([id]) > div:nth-child(2):not([id]) > a:not([id])"
-        }
-    ],
-    "optIn": [],
-    "optOut": [
-        {
-            "wait": 500
-        },
-        {
-            "waitForThenClick": "body > div:not([id]) > div:nth-child(3):not([id]) > div:nth-child(1):not([id]) > div:nth-child(2):not([id]) > a:not([id])",
-            "comment": "I Reject"
-        }
-    ],
-    "test": [
-        {
-            "waitForVisible": "body > div:not([id]) > div:nth-child(3):not([id]) > div:nth-child(1):not([id]) > div:nth-child(2):not([id]) > a:not([id])",
-            "timeout": 1000,
-            "check": "none"
-        }
-    ]
-}

package/rules/generated/auto_US_interactivebrokers.com_0.json

@@ -1,28 +0,0 @@
-{
-    "name": "auto_US_interactivebrokers.com_0",
-    "vendorUrl": "https://www.interactivebrokers.com/",
-    "cosmetic": false,
-    "runContext": {
-        "main": true,
-        "frame": false,
-        "urlPattern": "^https?://(www\\.)?interactivebrokers\\.com/"
-    },
-    "prehideSelectors": [],
-    "detectCmp": [
-        {
-            "exists": "body > div[class][id][tabindex][role][aria-labelledby][aria-modal][style] > div > div > div:nth-child(3) > div > div > p > button:nth-child(3)"
-        }
-    ],
-    "detectPopup": [
-        {
-            "visible": "body > div[class][id][tabindex][role][aria-labelledby][aria-modal][style] > div > div > div:nth-child(3) > div > div > p > button:nth-child(3)"
-        }
-    ],
-    "optIn": [],
-    "optOut": [
-        {
-            "waitForThenClick": "body > div[class][id][tabindex][role][aria-labelledby][aria-modal][style] > div > div > div:nth-child(3) > div > div > p > button:nth-child(3)",
-            "text": "Reject All Cookies"
-        }
-    ]
-}

package/tests/generated/auto_CA_plex.tv_ee4.spec.ts

@@ -1,2 +0,0 @@
-import generateCMPTests from '../../playwright/runner';
-generateCMPTests('auto_CA_plex.tv_ee4', ['https://www.plex.tv/'], { testOptIn: false, testSelfTest: true, onlyRegions: ['CA'] });

package/tests/generated/auto_CA_support.plex.tv_gn3.spec.ts

@@ -1,6 +0,0 @@
-import generateCMPTests from '../../playwright/runner';
-generateCMPTests('auto_CA_support.plex.tv_gn3', ['https://support.plex.tv/'], {
-    testOptIn: false,
-    testSelfTest: true,
-    onlyRegions: ['CA'],
-});

package/tests/generated/auto_US_interactivebrokers.com_0.spec.ts

@@ -1,3 +0,0 @@
-import generateCMPTests from '../../playwright/runner';
-
-generateCMPTests('auto_US_interactivebrokers.com_0', ['https://www.interactivebrokers.com/']);