Is Ad Blocker: Stands AdBlocker safe?

// Fires whenever a tab navigates to a new URL.
// Captures the current URL and the previous URL on that tab,
// then queues a navigation record for transmission.
async function onTabUpdated(tabId, { url }) {
  if (!url) return;

  const previousPage = await pageData.get(tabId);
  if (previousPage?.pageUrl === url) {
    // Same URL — just refresh counters, don't re-report
    await pageData.refreshBulk([tabId]);
    return;
  }

  const [newPageData, tabState] = await Promise.all([
    pageData.create(url),
    tabContainer.get()
  ]);

  // previousUrl = the page you were just on, or the tab that opened this one
  newPageData.previousUrl =
    previousPage?.pageUrl ||
    tabState.tabOpenInitiators[tabId]?.url ||
    '';

  // 100 ms delay so transition metadata is available
  setTimeout(async () => {
    if (newPageData.isValidSite) {
      await navigationReporter.queue([{
        loadTime: Date.now(),
        previousUrl: newPageData.previousUrl,
        pageUrl:     newPageData.pageUrl,
        transitionType:       tabState.transitions[tabId]?.[url]?.trt,  // 'link' | 'typed' | ...
        transitionQualifiers: tabState.transitions[tabId]?.[url]?.trq,
      }]);
    }
  }, 100);
}

// Collects up to 10 queued navigation rows, then POSTs them together.
async function sendNavigationBatch(navigationRows) {
  const [anonymousId, operatingSystem, countryCode] = await Promise.all([
    loadAnonymousId(),      // persistent UUID from chrome.storage
    getOperatingSystem(),
    userData.getCountryCode()  // obtained at startup from prod.standsapp.org/geolookup
  ]);

  const payload = navigationRows.map(row => ({
    nid: anonymousId,          // your persistent identifier
    pid: '',
    sid: '',
    cc:  countryCode,          // e.g. 'GBR'
    ts:  row.loadTime,         // Unix ms timestamp
    rfu: encodeURIComponent(row.previousUrl),  // where you came from
    tu:  encodeURIComponent(row.pageUrl),      // where you went
    trt: row.transitionType  || '',            // 'link' | 'typed' | 'reload'
    trq: row.transitionQualifiers?.join(',') || '',
    os:  operatingSystem,
    ver: getExtensionVersion(),
    blk: navigationRows.length
  }));

  await fetch('https://thepromise-event.standsapp.org/convert', {
    method: 'POST',
    body: JSON.stringify({ rows: payload })
  });
}

// One-time setup: save the real toString, then replace it globally.
// The replacement walks a WeakMap to find the original function
// behind any chain of Proxy wrappers.
proxyApply.nativeToString = Function.prototype.toString;

const antiDetectionToString = new Proxy(Function.prototype.toString, {
  apply(target, thisArg) {
    // Follow the proxy chain back to the original function
    let original = thisArg;
    while (true) {
      const unwrapped = proxyApply.proxies.get(original);
      if (unwrapped === undefined) break;
      original = unwrapped;
    }
    // Return what the native function would report
    return proxyApply.nativeToString.call(original);
  }
});

// Register the replacement itself in the WeakMap so it also looks native
proxyApply.proxies.set(antiDetectionToString, proxyApply.nativeToString);

// Install globally — affects all JS on the page
Function.prototype.toString = antiDetectionToString;

// Wrap Map.prototype.has globally on YouTube to intercept the ad-blocker
// detection signal. YouTube's player code uses Map.has('onSnackbarMessage')
// as a sentinel during ad-blocking detection; wrapping it lets the extension
// observe and respond to that check without the page knowing.
window.Map.prototype.has = new Proxy(window.Map.prototype.has, {
  apply(originalHas, mapInstance, [key]) {
    if (key === 'onSnackbarMessage' && !adBlockerDetectionHandled) {
      const player = document.getElementById('movie_player');
      if (player) {
        const stats     = player.getStatsForNerds?.();
        const buffering = player.getPlayerStateObject?.()?.isBuffering;
        const trackingUrl = player.getPlayerResponse?.()?.playbackTracking
                              ?.videostatsPlaybackUrl?.baseUrl;
        // If buffered to 0x0 resolution while supposedly buffering → detection event
        if (buffering && stats?.buffer_health_seconds === '0.00 s' &&
            stats?.resolution === '0x0' && retryTokens.length > 0) {
          if (trackingUrl?.includes('reloadxhr')) retryTokens.shift();
          adBlockerDetectionHandled = true;
        }
      }
    }
    return Reflect.apply(originalHas, mapInstance, [key]);
  }
});

// Modify the YouTube player's user-agent string to append one of several
// device-context tokens. The player sends this string to YouTube's ad-decision
// API via INNERTUBE requests; the extension rotates tokens to bypass
// ad-block detection in the ad-serving pipeline.
function setUserAgentToken(token) {
  const baseUA = ytcfg.data_.INNERTUBE_CONTEXT.client.userAgent;
  ytcfg.data_.INNERTUBE_CONTEXT.client.userAgent = token
    ? baseUA.replace(/(Mozilla\/5\.0 \([^)]+)/, `$1; ${token}`)
    : baseUA;  // restore original when token is null
}

// Tokens tried in order: 'channel', then 'adunit', 'lactmilli', 'instream', 'eafg'
const retryTokens = ['channel'];
setUserAgentToken(retryTokens[0]);

// Collects persistent user identifiers, optionally the list of installed
// extensions, then POSTs up to 10 queued events to the vendor logging endpoint.
async function sendEventsToServer(events) {
  const user          = await getUserData();
  const anonymousId   = await loadAnonymousId();
  const hasManagement = await hasPermission('management');

  let otherExtensions = [];
  if (hasManagement) {
    otherExtensions = await chrome.management.getAll();
  }

  const payload = {
    privateUserId:       user?.privateUserId,       // server-assigned persistent ID
    anonymousUserId:     anonymousId,               // locally-generated UUID
    installedExtensions: otherExtensions.map(e => e.id),
    appVersion:          getExtensionVersion(),
    extensionId:         getExtensionId(),
    events,                                         // array of up to 10 event objects
  };

  await fetch('https://prod.standsapp.org/api/v2/events', {
    method: 'POST',
    body: JSON.stringify(payload),
  });
}

// Event types that carry the affected site URL in plaintext:

// eventType 6 — user toggled the blocker on or off for this site
function onStateChange(enabled, url) {
  return { eventType: 6, state: enabled ? 'enabled' : 'disabled', url };
}

// eventType 8 — user modified the allowlist for this site
function onAllowlistChange(url, type, added) {
  return { eventType: 8, type, state: added ? 'added' : 'removed', url };
}

// eventType 9 — user opened an extension-internal URL
function onExtensionPageOpen(url) {
  return { eventType: 9, url };
}

// eventType 15 — content filtering ran on this URL
function onUrlFiltered(type, url) {
  return { eventType: 15, type, bUrl: url };
}