Is Clean Adblocker safe?

"use strict";

class ConsentGate {
  container = new DataContainer('dataProcessingConsent', {
    hasConsent: "chrome" !== 'firefox'
  });
  async getConsent() {
    const data = await this.container.get();
    return data.hasConsent;
  }
  async setConsent(hasConsent) {
    await this.container.set({
      hasConsent
    });
  }
}
const dataProcessingConsent = new ConsentGate();

async create(url) {
  const isValidSite = url.startsWith('http');
  const host = getUrlHost(url);
  const settings = await userData.getSettings();
  const shouldWorkOnThisSite = isValidSite && settings.enabled;
  let enabled = shouldWorkOnThisSite;
  let hideCookieBanners = shouldWorkOnThisSite && !!settings.hideCookieBanners;
  let blockPopups = shouldWorkOnThisSite && settings.blockPopups;
  let showBlockedPopupNotification = blockPopups;
  if (shouldWorkOnThisSite) {
    const [isHostDeactivated, isPopupsAllowed, isPopupShowNotification, isCookieBannersAllowed] = await Promise.all([deactivatedSites.isHostDeactivated(host), popupAllowedSites.isAllowed(host), popupShowNotificationList.getValueByHost(host), cookieBannersAllowedSites.isAllowed(host)]);
    enabled = enabled && !isHostDeactivated;
    blockPopups = blockPopups && !isPopupsAllowed;
    showBlockedPopupNotification = blockPopups && isPopupShowNotification !== false;
    hideCookieBanners = hideCookieBanners && !isCookieBannersAllowed;
  }
  return {
    pageUrl: url,
    hostAddress: host,
    enabled,
    hideCookieBanners,
    blockPopups,
    showBlockedPopupNotification,
    isValidSite,
    blockTracking: settings.blockTracking,
    previousUrl: '',
    clickId: crypto.randomUUID(),
    stats: {
      total: 0,
      ads: 0,
      trackers: 0,
      popups: 0,
      cookieBanners: 0,
      timeSaved: 0
    }
  };
}

const [pageData, tabData] = await Promise.all([pageDataStore.create(url), this.container.get()]);
tabData.lastCapturedSerpUrlByTab ??= {};
pageData.previousUrl = existingPageData?.pageUrl || tabData.tabOpenInitiators[tabId]?.url || '';
setTimeout(async () => {
  if (pageData.isValidSite) {
    await diagnosticsReporter.addReportsBulk([{
      loadTime: new Date().getTime(),
      previousUrl: pageData.previousUrl,
      pageUrl: pageData.pageUrl,
      clickId: pageData.clickId || undefined,
      trt: tabData.transitions[tabId]?.[url]?.trt,
      trq: tabData.transitions[tabId]?.[url]?.trq
    }]);
  }
  await this.clearData(tabId, url);
}, 100);
await pageDataStore.setData(tabId, pageData);
await this.onActivated();

createFrameHeaderRule(domain) {
  return {
    id: DNR_RULE_ID,
    priority: 1,
    condition: {
      requestDomains: [domain],
      resourceTypes: ['sub_frame']
    },
    action: {
      type: 'modifyHeaders',
      responseHeaders: [{
        header: 'X-Frame-Options',
        operation: 'remove'
      }, {
        header: 'Frame-Options',
        operation: 'remove'
      }, {
        header: 'Content-Security-Policy',
        operation: 'remove'
      }, {
        header: 'Content-Security-Policy-Report-Only',
        operation: 'remove'
      }]
    }
  };
}

async render(url, localeParams = {}, timeoutMs = 25000) {
  if (!this.isSupported()) return null;
  const domain = new URL(url).hostname;
  const localizedUrl = this.applyLocaleParams(url, localeParams);
  try {
    await this.toggleDNRRule(domain, true);
    await this.toggleContentScript(domain, true);
    await this.ensureOffscreenDocument();
    const result = await chrome.runtime.sendMessage({
      target: 'offscreen',
      type: 'RENDER_SERP_IN_IFRAME',
      data: {
        url: localizedUrl,
        timeout: timeoutMs
      }
    });
    if (result?.success) {
      return {
        ...result.data,
        engine: 'google'
      };
    }
    remoteLogger.logError(new Error(result?.error || 'Unknown extraction error'), 'SerpRenderer.render');
    return null;
  } catch (error) {
    remoteLogger.logError(error, 'SerpRenderer.render');
    return null;
  } finally {
    await this.toggleContentScript(domain, false).catch(() => {});
    await this.toggleDNRRule(domain, false).catch(() => {});
  }
}