Is AdBlock — block ads across the web safe?

async start() {
    await this.loadUserID();
    // Do 'stuff' when we're first installed...
    // - send a message
    const response = await browser.storage.local.get(this.totalRequestsStorageKey);
    if (!response[this.totalRequestsStorageKey]) {
      if (browser.management && browser.management.getSelf) {
        const info = await browser.management.getSelf();
        if (info) {
          serverLogger.behavior(`new_install_${info.installType}`);
        } else {
          serverLogger.behavior("new_install_unknown");
        }
      } else {
        serverLogger.behavior("new_install_unknown");
      }
    }
    // This will sleep, then ping, then schedule a new ping, then
    // call itself to start the process over again.
    await this.sleepThenPing();
    this.cleanUpLocalStorage();
  }

const userIdStorageKey = "userid";
let userIdPromise = null;
function getUserId() {
    if (userIdPromise) {
        return userIdPromise;
    }
    userIdPromise = (async () => {
        const response = await browser_polyfill.storage.local.get(userIdStorageKey);
        const value = response[userIdStorageKey];
        if (value) {
            return String(value);
        }
        const timeSuffix = (Date.now() % 1e8).toString().padStart(8, "0");
        const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
        const result = [];
        for (let i = 0; i < 8; i++) {
            const choice = Math.floor(Math.random() * alphabet.length);
            result.push(alphabet[choice]);
        }
        const newUserId = result.join("") + timeSuffix;
        await browser_polyfill.storage.local.set({ [userIdStorageKey]: newUserId });
        return newUserId;
    })();
    return userIdPromise;
}

async getTelemetryData() {
    // AdBlock ping compliance: only the fields required for Monthly Active
    // Client (billing) counting are sent. Diagnostic / UI / feature-flag
    // parameters were removed — the diagnostic data product relied on now
    // flows through the compliant eyeometry events instead.
    let data = {};
    await _alias_prefs__WEBPACK_IMPORTED_MODULE_2__/* .Prefs */ .N.untilLoaded;

    data = {
      u: this.userId,
      v: this.version,
      f: this.flavor,
      o: this.os,
      l: (0,_utilities_background_index__WEBPACK_IMPORTED_MODULE_5__.determineUserLanguage)(),
    };

    if (browser.runtime.id) {
      data.extid = browser.runtime.id;
    }
    const aaStatus = await getAAStatus();
    if (aaStatus) {
      data.aa = aaStatus;
    }

    return data;
  }

sendPingData(pingData) {
    return new Promise(async (resolve, reject) => {
      if (prefs/* Prefs */.N.get("data_collection_opt_out")) {
        resolve();
        return;
      }

      const response = await (0,fetch_util/* default */.A)(prefs/* Prefs */.N.get(this.hostURLPref), pingData)
        // Send any network errors during the ping fetch to a dedicated log server
        // to help us determine why there's been a drop in ping requests
        // See https://gitlab.com/adblockinc/ext/adblock/adblock/-/issues/136
        .catch((error) => {
          background.error("network error during ping");
          background.error("ping server URL: ", prefs/* Prefs */.N.get(this.hostURLPref));
          background.error("error: ", error);
          // retry any ping requests that fail for network errors
          this.retrySendPingData(pingData, resolve, reject);
        });
      if (!response) {
        background.error("no response from ping");
        return;
      }
      if (!response.ok) {
        background.error("Ping server returned error: ", response.statusText);
        this.retrySendPingData(pingData, resolve, reject);
        return;
      }
      background.debug("ping success");
      telemetryNotifier.emit("ping.complete");
      resolve();
    });
  }

  // Tell the server we exist.
  async pingNow() {
    const pingData = await this.getTelemetryData();
    if (!pingData.u) {
      return pingData;
    }
    // attempt to stop users that are pinging us 'a lot'
    // by checking the current ping count,
    // if the ping count is above a theshold,
    // then only ping 'occasionally'.
    // The ping count is read locally rather than from the payload, since it is
    // no longer sent to the server (AdBlock ping compliance).
    const totalPings = await this.getTotalPings();
    if (totalPings > 5000) {
      if (totalPings > 5000 && totalPings < 100000 && totalPings % 5000 !== 0) {
        return pingData;
      }
      if (totalPings >= 100000 && totalPings % 50000 !== 0) {
        return pingData;
      }
    }
    pingData.cmd = "ping";
    void this.sendPingData(pingData);
    return pingData;
  }

async function postData(url = "", payload = {}) {
  return fetch(url, {
    method: "POST",
    cache: "no-store",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(payload),
  });
}