@duckduckgo/autoconsent 8.1.0 → 9.0.0

package/lib/web.ts

@@ -1,13 +1,13 @@
 import { MessageSender, AutoCMP, RuleBundle, Config, ConsentState } from './types';
 import { ConsentOMaticCMP, ConsentOMaticConfig } from './cmps/consentomatic';
 import { AutoConsentCMPRule } from './rules';
-import { enableLogs } from './config';
 import { BackgroundMessage, InitMessage } from './messages';
-import { prehide, undoPrehide, wait } from './rule-executors';
 import { evalState, resolveEval } from './eval-handler';
 import { getRandomID } from './random';
 import { dynamicCMPs } from './cmps/all';
 import { AutoConsentCMP } from './cmps/base';
+import { DomActions } from './dom-actions';
+import { normalizeConfig } from './utils';
 
 function filterCMPs(rules: AutoCMP[], config: Config) {
   return rules.filter((cmp) => {
@@ -32,14 +32,14 @@ export default class AutoConsent {
     detectedPopups: [],
     selfTest: null,
   };
+  domActions: DomActions;
   protected sendContentMessage: MessageSender;
 
-  constructor(sendContentMessage: MessageSender, config: Config = null, declarativeRules: RuleBundle = null) {
+  constructor(sendContentMessage: MessageSender, config: Partial<Config> = null, declarativeRules: RuleBundle = null) {
     evalState.sendContentMessage = sendContentMessage;
     this.sendContentMessage = sendContentMessage;
     this.rules = [];
 
-    enableLogs && console.log('autoconsent init', window.location.href);
     this.updateState({ lifecycle: 'loading' });
 
     this.addDynamicRules();
@@ -56,12 +56,15 @@ export default class AutoConsent {
       sendContentMessage(initMsg);
       this.updateState({ lifecycle: 'waitingForInitResponse' });
     }
+    this.domActions = new DomActions(this);
   }
 
-  initialize(config: Config, declarativeRules: RuleBundle) {
-    this.config = config;
-    if (!config.enabled) {
-      enableLogs && console.log("autoconsent is disabled");
+  initialize(config: Partial<Config>, declarativeRules: RuleBundle) {
+    const normalizedConfig = normalizeConfig(config);
+    normalizedConfig.logs.lifecycle && console.log('autoconsent init', window.location.href);
+    this.config = normalizedConfig;
+    if (!normalizedConfig.enabled) {
+      normalizedConfig.logs.lifecycle && console.log("autoconsent is disabled");
       return;
     }
 
@@ -69,7 +72,7 @@ export default class AutoConsent {
       this.parseDeclarativeRules(declarativeRules);
     }
 
-    this.rules = filterCMPs(this.rules, config);
+    this.rules = filterCMPs(this.rules, normalizedConfig);
 
     if (config.enablePrehide) {
       if (document.documentElement) {
@@ -130,12 +133,13 @@ export default class AutoConsent {
   }
 
   async _start() {
-    enableLogs && console.log(`Detecting CMPs on ${window.location.href}`);
+    const logsConfig = this.config.logs;
+    logsConfig.lifecycle && console.log(`Detecting CMPs on ${window.location.href}`);
     this.updateState({ lifecycle: 'started' });
     const foundCmps = await this.findCmp(this.config.detectRetries);
     this.updateState({ detectedCmps: foundCmps.map(c => c.name) });
     if (foundCmps.length === 0) {
-      enableLogs && console.log("no CMP found", location.href);
+      logsConfig.lifecycle && console.log("no CMP found", location.href);
       if (this.config.enablePrehide) {
         this.undoPrehide();
       }
@@ -151,7 +155,7 @@ export default class AutoConsent {
     }
 
     if (foundPopups.length === 0) {
-      enableLogs && console.log('no popup found');
+      logsConfig.lifecycle && console.log('no popup found');
       if (this.config.enablePrehide) {
         this.undoPrehide();
       }
@@ -168,7 +172,7 @@ export default class AutoConsent {
         msg: `Found multiple CMPs, check the detection rules.`,
         cmps: foundPopups.map((cmp) => cmp.name),
       };
-      enableLogs && console.warn(errorDetails.msg, errorDetails.cmps);
+      logsConfig.errors && console.warn(errorDetails.msg, errorDetails.cmps);
       this.sendContentMessage({
         type: 'autoconsentError',
         details: errorDetails,
@@ -182,12 +186,13 @@ export default class AutoConsent {
     } else if (this.config.autoAction === 'optIn') {
       return await this.doOptIn();
     } else {
-      enableLogs && console.log("waiting for opt-out signal...", location.href);
+      logsConfig.lifecycle && console.log("waiting for opt-out signal...", location.href);
       return true;
     }
   }
 
   async findCmp(retries: number): Promise<AutoCMP[]> {
+    const logsConfig = this.config.logs;
     this.updateState({ findCmpAttempts: this.state.findCmpAttempts + 1 })
     const foundCMPs: AutoCMP[] = [];
 
@@ -198,7 +203,7 @@ export default class AutoConsent {
         }
         const result = await cmp.detectCmp();
         if (result) {
-          enableLogs && console.log(`Found CMP: ${cmp.name} ${window.location.href}`);
+          logsConfig.lifecycle && console.log(`Found CMP: ${cmp.name} ${window.location.href}`);
           this.sendContentMessage({
             type: 'cmpDetected',
             url: location.href,
@@ -207,12 +212,12 @@ export default class AutoConsent {
           foundCMPs.push(cmp);
         }
       } catch (e) {
-        enableLogs && console.warn(`error detecting ${cmp.name}`, e);
+        logsConfig.errors && console.warn(`error detecting ${cmp.name}`, e);
       }
     }
 
     if (foundCMPs.length === 0 && retries > 0) {
-      await wait(500);
+      await this.domActions.wait(500);
       return this.findCmp(retries - 1);
     }
 
@@ -220,6 +225,7 @@ export default class AutoConsent {
   }
 
   async detectPopups(cmps: AutoCMP[]): Promise<AutoCMP[]> {
+    const logsConfig = this.config.logs;
     const result: AutoCMP[] = [];
     const popupLookups = cmps.map((cmp) => this.waitForPopup(cmp).then((isOpen) => {
       if (isOpen) {
@@ -232,7 +238,7 @@ export default class AutoConsent {
         result.push(cmp);
       }
     }).catch((e) => {
-      enableLogs && console.warn(`error waiting for a popup for ${cmp.name}`, e);
+      logsConfig.errors && console.warn(`error waiting for a popup for ${cmp.name}`, e);
       return null
     }));
     await Promise.all(popupLookups);
@@ -240,15 +246,16 @@ export default class AutoConsent {
   }
 
   async doOptOut(): Promise<boolean> {
+    const logsConfig = this.config.logs;
     this.updateState({ lifecycle: 'runningOptOut' })
     let optOutResult;
     if (!this.foundCmp) {
-      enableLogs && console.log('no CMP to opt out');
+      logsConfig.errors && console.log('no CMP to opt out');
       optOutResult = false;
     } else {
-      enableLogs && console.log(`CMP ${this.foundCmp.name}: opt out on ${window.location.href}`);
+      logsConfig.lifecycle && console.log(`CMP ${this.foundCmp.name}: opt out on ${window.location.href}`);
       optOutResult = await this.foundCmp.optOut();
-      enableLogs && console.log(`${this.foundCmp.name}: opt out result ${optOutResult}`);
+      logsConfig.lifecycle && console.log(`${this.foundCmp.name}: opt out result ${optOutResult}`);
     }
 
     if (this.config.enablePrehide) {
@@ -279,15 +286,16 @@ export default class AutoConsent {
   }
 
   async doOptIn(): Promise<boolean> {
+    const logsConfig = this.config.logs;
     this.updateState({ lifecycle: 'runningOptIn' })
     let optInResult;
     if (!this.foundCmp) {
-      enableLogs && console.log('no CMP to opt in');
+      logsConfig.errors && console.log('no CMP to opt in');
       optInResult = false;
     } else {
-      enableLogs && console.log(`CMP ${this.foundCmp.name}: opt in on ${window.location.href}`);
+      logsConfig.lifecycle && console.log(`CMP ${this.foundCmp.name}: opt in on ${window.location.href}`);
       optInResult = await this.foundCmp.optIn();
-      enableLogs && console.log(`${this.foundCmp.name}: opt in result ${optInResult}`);
+      logsConfig.lifecycle && console.log(`${this.foundCmp.name}: opt in result ${optInResult}`);
     }
 
     if (this.config.enablePrehide) {
@@ -318,12 +326,13 @@ export default class AutoConsent {
   }
 
   async doSelfTest(): Promise<boolean> {
+    const logsConfig = this.config.logs;
     let selfTestResult;
     if (!this.foundCmp) {
-      enableLogs && console.log('no CMP to self test');
+      logsConfig.errors && console.log('no CMP to self test');
       selfTestResult = false;
     } else {
-      enableLogs && console.log(`CMP ${this.foundCmp.name}: self-test on ${window.location.href}`);
+      logsConfig.lifecycle && console.log(`CMP ${this.foundCmp.name}: self-test on ${window.location.href}`);
       selfTestResult = await this.foundCmp.test();
     }
 
@@ -338,20 +347,22 @@ export default class AutoConsent {
   }
 
   async waitForPopup(cmp: AutoCMP, retries = 5, interval = 500): Promise<boolean> {
-    enableLogs && console.log('checking if popup is open...', cmp.name);
+    const logsConfig = this.config.logs;
+    logsConfig.lifecycle && console.log('checking if popup is open...', cmp.name);
     const isOpen = await cmp.detectPopup().catch((e) => {
-      enableLogs && console.warn(`error detecting popup for ${cmp.name}`, e);
+      logsConfig.errors && console.warn(`error detecting popup for ${cmp.name}`, e);
       return false;
     }); // ignore possible errors in one-time popup detection
     if (!isOpen && retries > 0) {
-      await wait(interval);
+      await this.domActions.wait(interval);
       return this.waitForPopup(cmp, retries - 1, interval);
     }
-    enableLogs && console.log(cmp.name, `popup is ${isOpen ? 'open' : 'not open'}`);
+    logsConfig.lifecycle && console.log(cmp.name, `popup is ${isOpen ? 'open' : 'not open'}`);
     return isOpen;
   }
 
   prehideElements(): boolean {
+    const logsConfig = this.config.logs;
     // hide rules not specific to a single CMP rule
     const globalHidden = [
       "#didomi-popup,.didomi-popup-container,.didomi-popup-notice,.didomi-consent-popup-preferences,#didomi-notice,.didomi-popup-backdrop,.didomi-screen-medium",
@@ -372,16 +383,16 @@ export default class AutoConsent {
         this.state.prehideOn &&
         !['runningOptOut', 'runningOptIn'].includes(this.state.lifecycle)
       ) {
-        enableLogs && console.log('Process is taking too long, unhiding elements');
+        logsConfig.lifecycle && console.log('Process is taking too long, unhiding elements');
         this.undoPrehide();
       }
     }, this.config.prehideTimeout || 2000);
-    return prehide(selectors.join(','));
+    return this.domActions.prehide(selectors.join(','));
   }
 
   undoPrehide(): boolean {
     this.updateState({ prehideOn: false })
-    return undoPrehide();
+    return this.domActions.undoPrehide();
   }
 
   updateState(change: Partial<ConsentState>) {
@@ -396,7 +407,8 @@ export default class AutoConsent {
   }
 
   async receiveMessageCallback(message: BackgroundMessage) {
-    if (enableLogs && !['evalResp', 'report'].includes(message.type) /* evals are noisy */) {
+    const logsConfig = this.config?.logs;
+    if (logsConfig?.messages) {
       console.log('received from background', message, window.location.href);
     }
     switch (message.type) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duckduckgo/autoconsent",
-  "version": "8.1.0",
+  "version": "9.0.0",
   "description": "",
   "main": "dist/autoconsent.cjs.js",
   "module": "dist/autoconsent.esm.js",
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "clean": "rm -r dist",
-    "lint": "eslint lib/ playwright/ tests/ rules/autoconsent/*.json",
+    "lint": "eslint addon/ lib/ playwright/ tests/ rules/autoconsent/*.json",
     "bundle": "./build.sh",
     "watch": "npm run prepublish && chokidar \"lib\" \"addon\" \"rules/autoconsent\" -c \"npm run prepublish\"",
     "create-rule": "node rules/create-rule.mjs",
@@ -17,7 +17,7 @@
     "test:webkit": "playwright test --project webkit",
     "test:firefox": "playwright test --project firefox",
     "test:chrome": "playwright test --project chrome",
-    "test:lib": "playwright test tests/rule-executors.spec.ts",
+    "test:lib": "playwright test tests/dom-actions.spec.ts",
     "test:sample": "playwright test tests/_sample-test.spec.ts --project webkit",
     "fetch-fanboy-list": "wget https://www.fanboy.co.nz/fanboy-cookiemonster.txt",
     "fetch-site-list": "curl https://s3.amazonaws.com/cdn.cliqz.com/re-consent/supported_sites.txt > sites.txt",
@@ -34,7 +34,7 @@
     "@playwright/test": "^1.17.1",
     "@puppeteer/replay": "^2.11.0",
     "@types/chai": "^4.3.1",
-    "@types/chrome": "^0.0.254",
+    "@types/chrome": "^0.0.256",
     "@types/mocha": "^10.0.1",
     "@typescript-eslint/eslint-plugin": "^6.12.0",
     "@typescript-eslint/parser": "^6.12.0",

package/playwright/runner.ts

@@ -3,9 +3,17 @@ import path from 'path';
 import { test, expect, Page, Frame } from "@playwright/test";
 import { waitFor } from "../lib/utils";
 import { ContentScriptMessage } from "../lib/messages";
-import { enableLogs } from "../lib/config";
 import { AutoAction } from "../lib/types";
 
+const LOG_MESSAGES: ContentScriptMessage['type'][] = [
+  'optInResult',
+  'optOutResult',
+  'autoconsentDone',
+  'autoconsentError',
+  'selfTestResult',
+];
+const LOG_PAGE_LOGS = false;
+
 const testRegion = (process.env.REGION || "NA").trim();
 test.describe.configure({ mode: 'parallel' });
 
@@ -59,7 +67,7 @@ export function generateTest(
         test.skip();
       }
 
-      enableLogs && page.on('console', async msg => {
+      LOG_PAGE_LOGS && page.on('console', async msg => {
         console.log(`    page log:`, msg.text());
       });
       await page.exposeBinding("autoconsentSendMessage", messageCallback);
@@ -79,7 +87,7 @@ export function generateTest(
 
       let selfTestFrame: Frame = null;
       async function messageCallback({ frame }: { frame: Frame }, msg: ContentScriptMessage) {
-        enableLogs && msg.type !== 'eval' && console.log(msg);
+        LOG_MESSAGES.includes(msg.type) && console.log(msg);
         received.push(msg);
         switch (msg.type) {
           case 'init': {

package/playwright/unit.ts

@@ -0,0 +1,15 @@
+import Autoconsent from "../lib/web";
+import { DomActions } from "../lib/dom-actions";
+import * as rules from '../rules/rules.json';
+
+declare global {
+  interface Window {
+    Autoconsent: typeof Autoconsent;
+    DomActions: typeof DomActions;
+    rules: typeof rules;
+  }
+}
+
+window.Autoconsent = Autoconsent;
+window.DomActions = DomActions;
+window.rules = rules;

package/readme.md

@@ -56,7 +56,7 @@ By default, rules will be executed in all top-level documents. Some rules are de
 An autoconsent CMP rule can be written as either:
  * a JSON file adhering to the `AutoConsentCMPRule` type.
  * a class implementing the `AutoCMP` interface, or
-   * common JSON rules are available as reusable functions in [rule-executors.ts](/lib/rule-executors.ts). You can also use existing class-based rules as reference.
+   * common JSON rules are available as reusable functions in [dom-actions.ts](/lib/dom-actions.ts). You can also use existing class-based rules as reference.
 
 In most cases the JSON syntax should be sufficient, unless some complex non-linear logic is required, in which case a class is required.
 

package/tests/{rule-executors.spec.ts → dom-actions.spec.ts}

@@ -1,5 +1,11 @@
 import { test, expect } from "@playwright/test";
-import { click, elementSelector, querySelectorChain, querySingleReplySelector } from "../lib/rule-executors";
+import { DomActions } from "../lib/dom-actions";
+
+declare global {
+  interface Window {
+    domActions: DomActions;
+  }
+}
 
 const mockPage = `<!DOCTYPE html>
 <html>
@@ -11,17 +17,6 @@ const mockPage = `<!DOCTYPE html>
   </body>
 </html>`
 
-function buildRuleEvalString(ruleFn: string, args: any[]) {
-  // console.log(`(${ruleFn})(${args.map(s => JSON.stringify(s)).join(',')})`)
-  return `(() => {
-    const _config = { enableLogs: false };
-    const querySelectorChain = ${querySelectorChain.toString()};
-    const querySingleReplySelector = ${querySingleReplySelector.toString()};
-    const elementSelector = ${elementSelector.toString()};
-    return (${ruleFn})(${args.map(s => JSON.stringify(s)).join(',')})
-  })()`
-}
-
 async function getButtonClickCount(page, id) {
   return await page.evaluate((id) => parseInt(document.querySelector(`#${id} > button`)?.innerHTML || '0', 10), id)
 }
@@ -31,40 +26,44 @@ test.beforeEach(async ({ page }) => {
   // set up a click counter on the buttons
   await page.evaluate(() => {
     document.querySelectorAll('button').forEach(el => el.addEventListener('click', () => el.innerText = JSON.stringify(parseInt(el.innerText, 10) + 1)))
-  })
+  });
+  await page.addScriptTag({
+    path: 'dist/autoconsent.unit.js'
+  });
+  await page.evaluate('window.domActions = new window.DomActions({ config: { logs: { lifecycle: false, rulesteps: false, evals: false, errors: false, messages: false } } })');
 })
 
 test.describe("click", () => {
   test("click on button", async ({ page }) => {
-    expect(await page.evaluate(buildRuleEvalString(click.toString(), ['#test']))).toBe(true);
-    expect(await getButtonClickCount(page, 'first')).toEqual(1)
+    expect(await page.evaluate(() => window.domActions.click('#test'))).toBe(true);
+    expect(await getButtonClickCount(page, 'first')).toEqual(1);
   });
 
   test('click all', async ({page}) => {
-    expect(await page.evaluate(buildRuleEvalString(click.toString(), ['button', true]))).toBe(true);
+    expect(await page.evaluate(() => window.domActions.click('button', true))).toBe(true);
     expect(await getButtonClickCount(page, 'first')).toEqual(1)
     expect(await getButtonClickCount(page, 'second')).toEqual(1)
   })
 
   test('click single with multiple matches', async ({page}) => {
-    expect(await page.evaluate(buildRuleEvalString(click.toString(), ['button']))).toBe(true);
+    expect(await page.evaluate(() => window.domActions.click('button'))).toBe(true);
     expect(await getButtonClickCount(page, 'first')).toEqual(1)
     expect(await getButtonClickCount(page, 'second')).toEqual(0)
   })
 
   test('chained selector', async ({ page }) => {
-    expect(await page.evaluate(buildRuleEvalString(click.toString(), [['#second', 'button']]))).toBe(true);
+    expect(await page.evaluate(() => window.domActions.click(['#second', 'button']))).toBe(true);
     expect(await getButtonClickCount(page, 'first')).toEqual(0)
     expect(await getButtonClickCount(page, 'second')).toEqual(1)
   })
 
   test('xpath selector', async ({ page }) => {
-    expect(await page.evaluate(buildRuleEvalString(click.toString(), ['xpath///*[@id="second"]/button']))).toBe(true);
+    expect(await page.evaluate(() => window.domActions.click(['xpath///*[@id="second"]/button']))).toBe(true);
     expect(await page.evaluate(() => document.querySelector('#first > button')?.innerHTML)).toEqual('0')
     expect(await page.evaluate(() => document.querySelector('#second > button')?.innerHTML)).toEqual('1')
   })
 
-  test('click open shadow dom element', async ({ page}) => {
+  test('click open shadow dom element', async ({ page }) => {
     const shadowRoot = await page.evaluateHandle(() => {
       const shadowDiv = document.createElement('div')
       shadowDiv.id = 'shadow'
@@ -76,7 +75,7 @@ test.describe("click", () => {
       shadowButton.addEventListener('click', () => shadowButton.innerText = JSON.stringify(parseInt(shadowButton.innerText, 10) + 1))
       return shadow
     })
-    expect(await page.evaluate(buildRuleEvalString(click.toString(), [['#shadow', 'button']]))).toBe(true)
+    expect(await page.evaluate(() => window.domActions.click(['#shadow', 'button']))).toBe(true)
     expect(await page.evaluate(() => document.querySelector('#first > button')?.innerHTML)).toEqual('0')
     expect(await page.evaluate(() => document.querySelector('#second > button')?.innerHTML)).toEqual('0')
     expect(await page.evaluate((shadow) => shadow.querySelector('button')?.innerHTML || '0', shadowRoot)).toEqual('1')

package/tests/klaro.spec.ts

@@ -5,5 +5,6 @@ generateCMPTests('Klaro', [
   'https://www.zeitraum-moebel.de/',
   'https://repisalud.isciii.es/',
   'https://www.innogames.com/',
+  'https://www.lebenslauf.de/',
   // 'https://dspace.library.stonybrook.edu', // polyfills Promise so playwright doesn't work
 ]);

package/lib/config.ts

@@ -1,2 +0,0 @@
-// TODO: make this configurable through DevTools (and possibly toggleable per rule step type)
-export const enableLogs = false; // change this to enable debug logs

package/lib/rule-executors.ts

@@ -1,147 +0,0 @@
-import { enableLogs } from "./config";
-import { ElementSelector, HideMethod, VisibilityCheck } from "./rules";
-import { getStyleElement, hideElements, isElementVisible, waitFor } from "./utils";
-
-export function click(selector: ElementSelector, all = false): boolean {
-  const elem = elementSelector(selector)
-  enableLogs && console.log("[click]", selector, all, elem);
-  if (elem.length > 0) {
-    if (all) {
-      elem.forEach((e) => e.click());
-    } else {
-      elem[0].click();
-    }
-  }
-  return elem.length > 0;
-}
-
-export function elementExists(selector: ElementSelector): boolean {
-  const exists = elementSelector(selector).length > 0;
-  // enableLogs && console.log("[exists?]", selector, exists);
-  return exists;
-}
-
-export function elementVisible(selector: ElementSelector, check: VisibilityCheck): boolean {
-  const elem = elementSelector(selector);
-  const results = new Array(elem.length);
-  elem.forEach((e, i) => {
-    // check for display: none
-    results[i] = isElementVisible(e);
-  });
-  // enableLogs && console.log("[visible?]", selector, check, elem, results);
-  if (check === "none") {
-    return results.every(r => !r);
-  } else if (results.length === 0) {
-    return false;
-  } else if (check === "any") {
-    return results.some(r => r);
-  }
-  // all
-  return results.every(r => r);
-}
-
-export function waitForElement(selector: ElementSelector, timeout = 10000): Promise<boolean> {
-  const interval = 200;
-  const times = Math.ceil((timeout) / interval);
-  enableLogs && console.log("[waitForElement]", selector);
-  return waitFor(
-    () => elementSelector(selector).length > 0,
-    times,
-    interval
-  );
-}
-
-export function waitForVisible(selector: ElementSelector, timeout = 10000, check: VisibilityCheck = 'any'): Promise<boolean> {
-  const interval = 200;
-  const times = Math.ceil((timeout) / interval);
-  // enableLogs && console.log("[waitForVisible]", ruleStep.waitFor);
-  return waitFor(
-    () => elementVisible(selector, check),
-    times,
-    interval
-  );
-}
-
-export async function waitForThenClick(selector: ElementSelector, timeout = 10000, all = false): Promise<boolean> {
-  // enableLogs && console.log("[waitForThenClick]", ruleStep.waitForThenClick);
-  await waitForElement(selector, timeout);
-  return click(selector, all);
-}
-
-export function wait(ms: number): Promise<true> {
-  // enableLogs && console.log(`waiting for ${ruleStep.wait}ms`);
-  return new Promise(resolve => {
-    setTimeout(() => {
-      // enableLogs && console.log(`done waiting`);
-      resolve(true);
-    }, ms);
-  });
-}
-
-export function hide(selector: string, method: HideMethod): boolean {
-  // enableLogs && console.log("[hide]", ruleStep.hide, ruleStep.method);
-  const styleEl = getStyleElement();
-  return hideElements(styleEl, selector, method);
-}
-
-export function prehide(selector: string): boolean {
-  const styleEl = getStyleElement('autoconsent-prehide');
-  enableLogs && console.log("[prehide]", styleEl, location.href);
-  return hideElements(styleEl, selector, "opacity");
-}
-
-export function undoPrehide(): boolean {
-  const existingElement = getStyleElement('autoconsent-prehide');
-  enableLogs && console.log("[undoprehide]", existingElement, location.href);
-  if (existingElement) {
-    existingElement.remove();
-  }
-  return !!existingElement;
-}
-
-export function querySingleReplySelector(selector: string, parent: any = document): HTMLElement[] {
-  if (selector.startsWith('aria/')) {
-    return []
-  }
-  if (selector.startsWith('xpath/')) {
-    const xpath = selector.slice(6)
-    const result = document.evaluate(xpath, parent, null, XPathResult.ANY_TYPE, null)
-    let node: Node = null
-    const elements: HTMLElement[] = []
-    // eslint-disable-next-line no-cond-assign
-    while (node = result.iterateNext()) {
-      elements.push(node as HTMLElement)
-    }
-    return elements
-  }
-  if (selector.startsWith('text/')) {
-    return []
-  }
-  if (selector.startsWith('pierce/')) {
-    return []
-  }
-  if (parent.shadowRoot) {
-    return Array.from(parent.shadowRoot.querySelectorAll(selector))
-  }
-  return Array.from(parent.querySelectorAll(selector))
-}
-
-export function querySelectorChain(selectors: string[]): HTMLElement[] {
-  let parent: ParentNode = document
-  let matches: HTMLElement[]
-  for (const selector of selectors) {
-    matches = querySingleReplySelector(selector, parent)
-    if (matches.length === 0) {
-      return []
-    }
-    parent = matches[0]
-  }
-  return matches;
-}
-
-export function elementSelector(selector: ElementSelector): HTMLElement[] {
-  if (typeof selector === 'string') {
-    return querySingleReplySelector(selector)
-  }
-  return querySelectorChain(selector)
-}