@duckduckgo/autoconsent 1.0.2

package/lib/cmps/sourcepoint.js

@@ -0,0 +1,82 @@
+import AutoConsentBase, { success, waitFor } from "./base";
+export default class SourcePoint extends AutoConsentBase {
+    constructor() {
+        super("Sourcepoint");
+        this.ccpaMode = false;
+        this.prehideSelectors = ["div[id^='sp_message_container_'],.message-overlay"];
+    }
+    detectFrame(_, frame) {
+        try {
+            const url = new URL(frame.url);
+            if (url.searchParams.has('message_id') && url.hostname === 'ccpa-notice.sp-prod.net') {
+                this.ccpaMode = true;
+                return true;
+            }
+            return (url.pathname === '/index.html' || url.pathname === '/privacy-manager/index.html')
+                && url.searchParams.has('message_id') && url.searchParams.has('requestUUID');
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async detectCmp(tab) {
+        return await tab.elementExists("div[id^='sp_message_container_']") || !!tab.frame;
+    }
+    async detectPopup(tab) {
+        return await tab.elementsAreVisible("div[id^='sp_message_container_']");
+    }
+    async optIn(tab) {
+        return tab.clickElement(".sp_choice_type_11", tab.frame.id);
+    }
+    isManagerOpen(tab) {
+        return tab.frame && new URL(tab.frame.url).pathname === "/privacy-manager/index.html";
+    }
+    async optOut(tab) {
+        try {
+            tab.hideElements(["div[id^='sp_message_container_']"]);
+            if (!this.isManagerOpen(tab)) {
+                if (!await waitFor(() => !!tab.frame, 30, 100)) {
+                    throw "Frame never opened";
+                }
+                if (!await tab.elementExists("button.sp_choice_type_12", tab.frame.id)) {
+                    // do not sell button
+                    return tab.clickElement('button.sp_choice_type_13', tab.frame.id);
+                }
+                await success(tab.clickElement("button.sp_choice_type_12", tab.frame.id));
+                await waitFor(() => new URL(tab.frame.url).pathname === "/privacy-manager/index.html", 200, 100);
+            }
+            await tab.waitForElement('.type-modal', 20000, tab.frame.id);
+            // reject all button is offered by some sites
+            try {
+                const path = await Promise.race([
+                    tab.waitForElement('.sp_choice_type_REJECT_ALL', 2000, tab.frame.id).then(r => 0),
+                    tab.waitForElement('.reject-toggle', 2000, tab.frame.id).then(() => 1),
+                    tab.waitForElement('.pm-features', 2000, tab.frame.id).then(r => 2),
+                ]);
+                if (path === 0) {
+                    await tab.wait(1000);
+                    return await success(tab.clickElement('.sp_choice_type_REJECT_ALL', tab.frame.id));
+                }
+                else if (path === 1) {
+                    await tab.clickElement('.reject-toggle', tab.frame.id);
+                }
+                else {
+                    await tab.waitForElement('.pm-features', 10000, tab.frame.id);
+                    await tab.clickElements('.checked > span', tab.frame.id);
+                    if (await tab.elementExists('.chevron', tab.frame.id)) {
+                        await tab.clickElement('.chevron', tab.frame.id);
+                    }
+                }
+            }
+            catch (e) { }
+            return await tab.clickElement('.sp_choice_type_SAVE_AND_EXIT', tab.frame.id);
+        }
+        finally {
+            tab.undoHideElements();
+        }
+    }
+    async test(tab) {
+        await tab.eval("__tcfapi('getTCData', 2, r => window.__rcsResult = r)");
+        return tab.eval("Object.values(window.__rcsResult.purpose.consents).every(c => !c)");
+    }
+}

package/lib/cmps/sourcepoint.ts

@@ -0,0 +1,95 @@
+import AutoConsentBase, { success, waitFor } from "./base";
+import { TabActor } from "../types";
+
+export default class SourcePoint extends AutoConsentBase {
+
+  ccpaMode = false;
+  prehideSelectors = ["div[id^='sp_message_container_'],.message-overlay"]
+
+  constructor() {
+    super("Sourcepoint");
+  }
+
+  detectFrame(_: TabActor, frame: { url: string }) {
+    try {
+      const url = new URL(frame.url);
+      if (url.searchParams.has('message_id') && url.hostname === 'ccpa-notice.sp-prod.net') {
+        this.ccpaMode = true;
+        return true;
+      }
+      return (url.pathname === '/index.html' || url.pathname === '/privacy-manager/index.html')
+        && url.searchParams.has('message_id') && url.searchParams.has('requestUUID');
+    } catch (e) {
+      return false;
+    }
+  }
+
+  async detectCmp(tab: TabActor) {
+    return await tab.elementExists("div[id^='sp_message_container_']") || !!tab.frame
+  }
+
+  async detectPopup(tab: TabActor) {
+    return await tab.elementsAreVisible("div[id^='sp_message_container_']");
+  }
+
+  async optIn(tab: TabActor) {
+    return tab.clickElement(".sp_choice_type_11", tab.frame.id);
+  }
+
+  isManagerOpen(tab: TabActor) {
+    return tab.frame && new URL(tab.frame.url).pathname === "/privacy-manager/index.html";
+  }
+
+  async optOut(tab: TabActor) {
+    try {
+      tab.hideElements(["div[id^='sp_message_container_']"])
+      if (!this.isManagerOpen(tab)) {
+        if (!await waitFor(() => !!tab.frame, 30, 100)) {
+          throw "Frame never opened";
+        }
+        if (!await tab.elementExists("button.sp_choice_type_12", tab.frame.id)) {
+          // do not sell button
+          return tab.clickElement('button.sp_choice_type_13', tab.frame.id);
+        }
+        await success(tab.clickElement("button.sp_choice_type_12", tab.frame.id));
+        await waitFor(
+          () =>
+            new URL(tab.frame.url).pathname === "/privacy-manager/index.html",
+          200,
+          100
+        );
+      }
+      await tab.waitForElement('.type-modal', 20000, tab.frame.id);
+      // reject all button is offered by some sites
+      try {
+        const path = await Promise.race([
+          tab.waitForElement('.sp_choice_type_REJECT_ALL', 2000, tab.frame.id).then(r => 0),
+          tab.waitForElement('.reject-toggle', 2000, tab.frame.id).then(() => 1),
+          tab.waitForElement('.pm-features', 2000, tab.frame.id).then(r => 2),
+        ]);
+        if (path === 0) {
+          await tab.wait(1000);
+          return await success(tab.clickElement('.sp_choice_type_REJECT_ALL', tab.frame.id))
+        } else if (path === 1) {
+          await tab.clickElement('.reject-toggle', tab.frame.id)
+        } else {
+          await tab.waitForElement('.pm-features', 10000, tab.frame.id);
+          await tab.clickElements('.checked > span', tab.frame.id);
+          if (await tab.elementExists('.chevron',  tab.frame.id)) {
+            await tab.clickElement('.chevron', tab.frame.id)
+          }
+        }
+      } catch(e) {}
+      return await tab.clickElement('.sp_choice_type_SAVE_AND_EXIT', tab.frame.id);
+    } finally {
+      tab.undoHideElements();
+    }
+  }
+
+  async test(tab: TabActor) {
+    await tab.eval("__tcfapi('getTCData', 2, r => window.__rcsResult = r)");
+    return tab.eval(
+      "Object.values(window.__rcsResult.purpose.consents).every(c => !c)"
+    );
+  }
+}

package/lib/cmps/trustarc.js

@@ -0,0 +1,106 @@
+import AutoConsentBase, { waitFor } from "./base";
+export default class TrustArc extends AutoConsentBase {
+    constructor() {
+        super("TrustArc");
+        this.prehideSelectors = [
+            ".trustarc-banner-container",
+            ".truste_popframe,.truste_overlay,.truste_box_overlay,#truste-consent-track",
+        ];
+    }
+    detectFrame(_, frame) {
+        return frame.url.startsWith("https://consent-pref.trustarc.com/?");
+    }
+    async detectCmp(tab) {
+        if (tab.frame &&
+            tab.frame.url.startsWith("https://consent-pref.trustarc.com/?")) {
+            return true;
+        }
+        return tab.elementExists("#truste-show-consent");
+    }
+    async detectPopup(tab) {
+        return ((await tab.elementsAreVisible("#truste-consent-content,#trustarc-banner-overlay")) ||
+            (tab.frame &&
+                (await tab.waitForElement("#defaultpreferencemanager", 5000, tab.frame.id))));
+    }
+    async openFrame(tab) {
+        if (await tab.elementExists("#truste-show-consent")) {
+            await tab.clickElement("#truste-show-consent");
+        }
+    }
+    async navigateToSettings(tab, frameId) {
+        // wait for it to load
+        await waitFor(async () => {
+            return ((await tab.elementExists(".shp", frameId)) ||
+                (await tab.elementsAreVisible(".advance", "any", frameId)) ||
+                tab.elementExists(".switch span:first-child", frameId));
+        }, 10, 500);
+        // splash screen -> hit more information
+        if (await tab.elementExists(".shp", frameId)) {
+            await tab.clickElement(".shp", frameId);
+        }
+        await tab.waitForElement(".prefPanel", 5000, frameId);
+        // go to advanced settings if not yet shown
+        if (await tab.elementsAreVisible(".advance", "any", frameId)) {
+            await tab.clickElement(".advance", frameId);
+        }
+        // takes a while to load the opt-in/opt-out buttons
+        return await waitFor(() => tab.elementsAreVisible(".switch span:first-child", "any", frameId), 5, 1000);
+    }
+    async optOut(tab) {
+        // await tab.hideElements(['.truste_overlay', '.truste_box_overlay', '.trustarc-banner', '.truste-banner']);
+        if (await tab.elementExists("#truste-consent-required")) {
+            return tab.clickElement("#truste-consent-required");
+        }
+        if (!tab.frame) {
+            await tab.clickElement("#truste-show-consent");
+            await waitFor(async () => !!tab.frame &&
+                (await tab.elementsAreVisible(".mainContent", "any", tab.frame.id)), 50, 100);
+        }
+        const frameId = tab.frame.id;
+        await waitFor(() => tab.eval("document.readyState === 'complete'", frameId), 20, 100);
+        tab.hideElements([".truste_popframe", ".truste_overlay", ".truste_box_overlay", "#truste-consent-track"]);
+        if (await tab.elementExists('.rejectAll', frameId)) {
+            return tab.clickElement('.rejectAll', frameId);
+        }
+        if (await tab.waitForElement('#catDetails0', 1000, frameId)) {
+            await tab.clickElement("#catDetails0", frameId);
+            return tab.clickElement(".submit", frameId);
+        }
+        if (await tab.elementExists(".required", frameId)) {
+            await tab.clickElement(".required", frameId);
+        }
+        else {
+            await this.navigateToSettings(tab, frameId);
+            await tab.clickElements(".switch span:nth-child(1):not(.active)", frameId);
+            await tab.clickElement(".submit", frameId);
+        }
+        try {
+            await tab.waitForThenClick("#gwt-debug-close_id", 20000, tab.frame.id);
+        }
+        catch (e) {
+            // ignore frame disappearing
+        }
+        return true;
+    }
+    async optIn(tab) {
+        if (!tab.frame) {
+            await this.openFrame(tab);
+            await waitFor(() => !!tab.frame, 10, 200);
+        }
+        const frameId = tab.frame.id;
+        await this.navigateToSettings(tab, frameId);
+        await tab.clickElements(".switch span:nth-child(2)", frameId);
+        await tab.clickElement(".submit", frameId);
+        await waitFor(() => tab.elementExists("#gwt-debug-close_id", frameId), 300, 1000);
+        await tab.clickElement("#gwt-debug-close_id", frameId);
+        return true;
+    }
+    async openCmp(tab) {
+        await tab.eval("truste.eu.clickListener()");
+        return true;
+    }
+    async test() {
+        // TODO: find out how to test TrustArc
+        return true;
+    }
+}

package/lib/cmps/trustarc.ts

@@ -0,0 +1,147 @@
+import AutoConsentBase, { waitFor } from "./base";
+import { TabActor } from "../types";
+
+export default class TrustArc extends AutoConsentBase {
+
+  prehideSelectors = [
+    ".trustarc-banner-container",
+    ".truste_popframe,.truste_overlay,.truste_box_overlay,#truste-consent-track",
+  ]
+
+  constructor() {
+    super("TrustArc");
+  }
+
+  detectFrame(_: TabActor, frame: { url: string }) {
+    return frame.url.startsWith("https://consent-pref.trustarc.com/?");
+  }
+
+  async detectCmp(tab: TabActor) {
+    if (
+      tab.frame &&
+      tab.frame.url.startsWith("https://consent-pref.trustarc.com/?")
+    ) {
+      return true;
+    }
+    return tab.elementExists("#truste-show-consent");
+  }
+
+  async detectPopup(tab: TabActor) {
+    return (
+      (await tab.elementsAreVisible("#truste-consent-content,#trustarc-banner-overlay")) ||
+      (tab.frame &&
+        (await tab.waitForElement(
+          "#defaultpreferencemanager",
+          5000,
+          tab.frame.id
+        )))
+    );
+  }
+
+  async openFrame(tab: TabActor) {
+    if (await tab.elementExists("#truste-show-consent")) {
+      await tab.clickElement("#truste-show-consent");
+    }
+  }
+
+  async navigateToSettings(tab: TabActor, frameId: number) {
+    // wait for it to load
+    await waitFor(
+      async () => {
+        return (
+          (await tab.elementExists(".shp", frameId)) ||
+          (await tab.elementsAreVisible(".advance", "any", frameId)) ||
+          tab.elementExists(".switch span:first-child", frameId)
+        );
+      },
+      10,
+      500
+    );
+    // splash screen -> hit more information
+    if (await tab.elementExists(".shp", frameId)) {
+      await tab.clickElement(".shp", frameId);
+    }
+    await tab.waitForElement(".prefPanel", 5000, frameId);
+    // go to advanced settings if not yet shown
+    if (await tab.elementsAreVisible(".advance", "any", frameId)) {
+      await tab.clickElement(".advance", frameId);
+    }
+    // takes a while to load the opt-in/opt-out buttons
+    return await waitFor(
+      () => tab.elementsAreVisible(".switch span:first-child", "any", frameId),
+      5,
+      1000
+    );
+  }
+
+  async optOut(tab: TabActor) {
+    // await tab.hideElements(['.truste_overlay', '.truste_box_overlay', '.trustarc-banner', '.truste-banner']);
+    if (await tab.elementExists("#truste-consent-required")) {
+      return tab.clickElement("#truste-consent-required");
+    }
+    if (!tab.frame) {
+      await tab.clickElement("#truste-show-consent");
+      await waitFor(
+        async () =>
+          !!tab.frame &&
+          (await tab.elementsAreVisible(".mainContent", "any", tab.frame.id)),
+        50,
+        100
+      );
+    }
+    const frameId = tab.frame!.id;
+    await waitFor(() => tab.eval("document.readyState === 'complete'", frameId), 20, 100);
+    tab.hideElements([".truste_popframe", ".truste_overlay", ".truste_box_overlay", "#truste-consent-track"]);
+    if (await tab.elementExists('.rejectAll', frameId)) {
+      return tab.clickElement('.rejectAll', frameId);
+    }
+    if (await tab.waitForElement('#catDetails0', 1000, frameId)) {
+      await tab.clickElement("#catDetails0", frameId);
+      return tab.clickElement(".submit", frameId);
+    }
+    if (await tab.elementExists(".required", frameId)) {
+      await tab.clickElement(".required", frameId);
+    } else {
+      await this.navigateToSettings(tab, frameId);
+      await tab.clickElements(
+        ".switch span:nth-child(1):not(.active)",
+        frameId
+      );
+      await tab.clickElement(".submit", frameId);
+    }
+    try {
+      await tab.waitForThenClick("#gwt-debug-close_id", 20000, tab.frame.id);
+    } catch (e) {
+      // ignore frame disappearing
+    }
+    return true;
+  }
+
+  async optIn(tab: TabActor) {
+    if (!tab.frame) {
+      await this.openFrame(tab);
+      await waitFor(() => !!tab.frame, 10, 200);
+    }
+    const frameId = tab.frame!.id;
+    await this.navigateToSettings(tab, frameId);
+    await tab.clickElements(".switch span:nth-child(2)", frameId);
+    await tab.clickElement(".submit", frameId);
+    await waitFor(
+      () => tab.elementExists("#gwt-debug-close_id", frameId),
+      300,
+      1000
+    );
+    await tab.clickElement("#gwt-debug-close_id", frameId);
+    return true;
+  }
+
+  async openCmp(tab: TabActor) {
+    await tab.eval("truste.eu.clickListener()");
+    return true;
+  }
+
+  async test() {
+    // TODO: find out how to test TrustArc
+    return true;
+  }
+}

package/lib/consentomatic/index.js

@@ -0,0 +1,52 @@
+export class ConsentOMaticCMP {
+    constructor(name, config) {
+        this.name = name;
+        this.config = config;
+        this.methods = new Map();
+        config.methods.forEach(methodConfig => {
+            if (methodConfig.action) {
+                this.methods.set(methodConfig.name, methodConfig.action);
+            }
+        });
+        this.hasSelfTest = this.methods.has("TEST_CONSENT");
+    }
+    async detectCmp(tab) {
+        return (await Promise.all(this.config.detectors.map(detectorConfig => tab.matches(detectorConfig.presentMatcher)))).some(matched => matched);
+    }
+    async detectPopup(tab) {
+        return (await Promise.all(this.config.detectors.map(detectorConfig => tab.matches(detectorConfig.showingMatcher)))).some(matched => matched);
+    }
+    async executeAction(tab, method, param) {
+        if (this.methods.has(method)) {
+            return tab.executeAction(this.methods.get(method), param);
+        }
+        return true;
+    }
+    async optOut(tab) {
+        await this.executeAction(tab, "HIDE_CMP");
+        await this.executeAction(tab, "OPEN_OPTIONS");
+        await this.executeAction(tab, "HIDE_CMP");
+        await this.executeAction(tab, "DO_CONSENT", []);
+        await this.executeAction(tab, "SAVE_CONSENT");
+        return true;
+    }
+    async optIn(tab) {
+        await this.executeAction(tab, "HIDE_CMP");
+        await this.executeAction(tab, "OPEN_OPTIONS");
+        await this.executeAction(tab, "HIDE_CMP");
+        await this.executeAction(tab, "DO_CONSENT", ['D', 'A', 'B', 'E', 'F', 'X']);
+        await this.executeAction(tab, "SAVE_CONSENT");
+        return true;
+    }
+    async openCmp(tab) {
+        await this.executeAction(tab, "HIDE_CMP");
+        await this.executeAction(tab, "OPEN_OPTIONS");
+        return true;
+    }
+    test(tab) {
+        return this.executeAction(tab, "TEST_CONSENT");
+    }
+    detectFrame(tab, frame) {
+        return false;
+    }
+}

package/lib/consentomatic/index.ts

@@ -0,0 +1,86 @@
+import { AutoCMP, TabActor } from "../types";
+
+export type DetectorConfig = {
+  presentMatcher: {};
+  showingMatcher: {};
+};
+export type MethodConfig = {
+  action?: any;
+  name: string;
+};
+
+export type ConsentOMaticConfig = {
+  detectors: DetectorConfig[];
+  methods: MethodConfig[];
+};
+
+export class ConsentOMaticCMP implements AutoCMP {
+  methods = new Map<string, {}>();
+  hasSelfTest: boolean;
+
+  constructor(public name: string, public config: ConsentOMaticConfig) {
+    config.methods.forEach(methodConfig => {
+      if (methodConfig.action) {
+        this.methods.set(methodConfig.name, methodConfig.action);
+      }
+    });
+    this.hasSelfTest = this.methods.has("TEST_CONSENT");
+  }
+
+  async detectCmp(tab: TabActor): Promise<boolean> {
+    return (
+      await Promise.all(
+        this.config.detectors.map(detectorConfig =>
+          tab.matches(detectorConfig.presentMatcher)
+        )
+      )
+    ).some(matched => matched);
+  }
+
+  async detectPopup(tab: TabActor): Promise<boolean> {
+    return (
+      await Promise.all(
+        this.config.detectors.map(detectorConfig =>
+          tab.matches(detectorConfig.showingMatcher)
+        )
+      )
+    ).some(matched => matched);
+  }
+
+  async executeAction(tab: TabActor, method: string, param?: any) {
+    if (this.methods.has(method)) {
+      return tab.executeAction(this.methods.get(method), param);
+    }
+    return true;
+  }
+
+  async optOut(tab: TabActor): Promise<boolean> {
+    await this.executeAction(tab, "HIDE_CMP");
+    await this.executeAction(tab, "OPEN_OPTIONS");
+    await this.executeAction(tab, "HIDE_CMP");
+    await this.executeAction(tab, "DO_CONSENT", []);
+    await this.executeAction(tab, "SAVE_CONSENT");
+    return true;
+  }
+
+  async optIn(tab: TabActor): Promise<boolean> {
+    await this.executeAction(tab, "HIDE_CMP");
+    await this.executeAction(tab, "OPEN_OPTIONS");
+    await this.executeAction(tab, "HIDE_CMP");
+    await this.executeAction(tab, "DO_CONSENT", ['D', 'A', 'B', 'E', 'F', 'X']);
+    await this.executeAction(tab, "SAVE_CONSENT");
+    return true;
+  }
+  async openCmp(tab: TabActor): Promise<boolean> {
+    await this.executeAction(tab, "HIDE_CMP");
+    await this.executeAction(tab, "OPEN_OPTIONS");
+    return true;
+  }
+
+  test(tab: TabActor): Promise<boolean> {
+    return this.executeAction(tab, "TEST_CONSENT");
+  }
+  detectFrame(tab: TabActor, frame: { url: string }): boolean {
+    return false;
+  }
+}

package/lib/detector.js

@@ -0,0 +1,29 @@
+export default async function detectDialog(tab, retries, rules) {
+    let breakEarly = false;
+    const found = await new Promise(async (resolve) => {
+        let earlyReturn = false;
+        await Promise.all(rules.map(async (r, index) => {
+            try {
+                if (await r.detectCmp(tab)) {
+                    earlyReturn = true;
+                    resolve(index);
+                }
+            }
+            catch (e) {
+                breakEarly = true;
+            }
+        }));
+        if (!earlyReturn) {
+            resolve(-1);
+        }
+    });
+    if (found === -1 && retries > 0 && !breakEarly) {
+        return new Promise((resolve) => {
+            setTimeout(async () => {
+                const result = detectDialog(tab, retries - 1, rules);
+                resolve(result);
+            }, 500);
+        });
+    }
+    return found > -1 ? rules[found] : null;
+}

package/lib/detector.ts

@@ -0,0 +1,30 @@
+import { AutoCMP, TabActor } from './types';
+
+export default async function detectDialog(tab: TabActor, retries: number, rules: AutoCMP[]): Promise<AutoCMP> {
+  let breakEarly = false;
+  const found: number = await new Promise(async (resolve) => {
+    let earlyReturn = false;
+    await Promise.all(rules.map(async (r, index) => {
+      try {
+        if (await r.detectCmp(tab)) {
+          earlyReturn = true;
+          resolve(index)
+        }
+      } catch (e) {
+        breakEarly = true;
+      }
+    }));
+    if (!earlyReturn) {
+      resolve(-1)
+    }
+  })
+  if (found === -1 && retries > 0 && !breakEarly) {
+    return new Promise((resolve) => {
+      setTimeout(async () => {
+        const result = detectDialog(tab, retries - 1, rules);
+        resolve(result);
+      }, 500);
+    });
+  }
+  return found > -1 ? rules[found] : null;
+}

package/lib/hider.js

@@ -0,0 +1,13 @@
+// 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",
+];
+export default async function prehideElements(tab, rules) {
+    const selectors = rules.reduce((selectorList, rule) => {
+        if (rule.prehideSelectors) {
+            return [...selectorList, ...rule.prehideSelectors];
+        }
+        return selectorList;
+    }, globalHidden);
+    await tab.hideElements(selectors);
+}

package/lib/hider.ts

@@ -0,0 +1,16 @@
+import { AutoCMP, TabActor } from './types';
+
+// 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",
+]
+
+export default async function prehideElements(tab: TabActor, rules: AutoCMP[]): Promise<void> {
+    const selectors = rules.reduce((selectorList, rule) => {
+        if (rule.prehideSelectors) {
+          return [...selectorList, ...rule.prehideSelectors];
+        }
+        return selectorList;
+      }, globalHidden);
+    await tab.hideElements(selectors);
+}

package/lib/index.js

@@ -0,0 +1,4 @@
+import _rules, { createAutoCMP } from './cmps/all';
+export { waitFor } from './cmps/base';
+export { createAutoCMP };
+export const rules = _rules;

package/lib/index.ts

@@ -0,0 +1,6 @@
+import _rules, { createAutoCMP } from './cmps/all';
+
+export { waitFor } from './cmps/base';
+
+export { createAutoCMP };
+export const rules = _rules;