// ==UserScript==
// @name         Remove VigLink, AvantLink, and Sovrn Redirects
// @namespace    https://tampermonkey.net/
// @version      2.0
// @description  Replace VigLink, AvantLink, and Sovrn affiliate redirect links with their direct destination URLs
// @match        *://*/*
// @run-at       document-end
// @grant        none
// ==/UserScript==

(function () {
   'use strict';

   /*
    * Redirect networks to remove.
    *
    * Matching is restricted to the actual domain or one of its subdomains.
    * Example:
    *   redirect.viglink.com     -> matches
    *   viglink.com              -> matches
    *   viglink.com.evilsite.com -> does NOT match
    */
   const REDIRECT_DOMAINS = [
       'viglink.com',
       'avantlink.com',
       'sovrn.com',
       'sovrn.co'
   ];

   /*
    * Common query-string parameters used to hold the real destination URL.
    */
   const PARAM_CANDIDATES = new Set([
       'url',
       'u',
       'dest',
       'destination',
       'to',
       'afsrc',
       'redir',
       'redirect',
       'redirecturl',
       'target',
       'r'
   ]);

   /*
    * Set to true if you want rewritten links displayed in the browser console.
    */
   const DEBUG = false;

   function log(...args) {
       if (DEBUG) {
           console.log('[Affiliate Redirect Remover]', ...args);
       }
   }

   /*
    * Strictly determine whether a hostname belongs to one of the
    * redirect networks.
    */
   function isRedirectDomain(hostname) {
       if (!hostname) return false;

       const host = hostname.toLowerCase().replace(/\.$/, '');

       return REDIRECT_DOMAINS.some(domain =>
           host === domain || host.endsWith('.' + domain)
       );
   }

   /*
    * Only permit normal HTTP/HTTPS destination URLs.
    */
   function isValidHttpUrl(value) {
       if (!value || typeof value !== 'string') {
           return false;
       }

       try {
           const parsed = new URL(value);
           return parsed.protocol === 'http:' || parsed.protocol === 'https:';
       } catch {
           return false;
       }
   }

   /*
    * URLSearchParams already performs one level of decoding.
    *
    * Only decode again when the current value is NOT already a valid URL.
    * This prevents legitimate encoded characters inside the destination URL
    * from being unnecessarily decoded.
    */
   function normalizeDestination(value) {
       if (!value) return null;

       let candidate = value.trim();

       if (isValidHttpUrl(candidate)) {
           return candidate;
       }

       for (let i = 0; i < 2; i++) {
           try {
               const decoded = decodeURIComponent(candidate);

               if (decoded === candidate) {
                   break;
               }

               candidate = decoded;

               if (isValidHttpUrl(candidate)) {
                   return candidate;
               }
           } catch {
               break;
           }
       }

       return null;
   }

   /*
    * Extract the real destination URL from one redirect wrapper.
    */
   function extractDestination(href) {
       try {
           const parsed = new URL(href);

           if (!isRedirectDomain(parsed.hostname)) {
               return null;
           }

           /*
            * Parameter matching is case-insensitive.
            */
           for (const [key, value] of parsed.searchParams.entries()) {
               if (!PARAM_CANDIDATES.has(key.toLowerCase())) {
                   continue;
               }

               const destination = normalizeDestination(value);

               if (destination) {
                   return destination;
               }
           }

           return null;

       } catch (error) {
           log('Unable to parse URL:', href, error);
           return null;
       }
   }

   /*
    * Unwrap multiple redirect layers if one affiliate redirect points
    * through another supported affiliate redirect.
    *
    * The depth limit prevents malformed links from creating a loop.
    */
   function unwrapRedirect(href, maxDepth = 5) {
       let current = href;
       let changed = false;
       const seen = new Set();

       for (let depth = 0; depth < maxDepth; depth++) {

           if (seen.has(current)) {
               break;
           }

           seen.add(current);

           const destination = extractDestination(current);

           if (!destination || destination === current) {
               break;
           }

           current = destination;
           changed = true;
       }

       return changed ? current : null;
   }

   /*
    * Rewrite an individual link.
    */
   function fixLink(link) {
       if (!(link instanceof HTMLAnchorElement)) {
           return;
       }

       const href = link.href;

       if (!href) {
           return;
       }

       const directUrl = unwrapRedirect(href);

       if (directUrl && directUrl !== href) {
           log('Rewriting:', href, '->', directUrl);
           link.href = directUrl;
       }
   }

   /*
    * Scan all links currently present on the page.
    */
   function scan(root = document) {
       if (!root?.querySelectorAll) {
           return;
       }

       root.querySelectorAll('a[href]').forEach(fixLink);
   }

   /*
    * Initial page scan.
    */
   scan();

   /*
    * Catch links immediately before the user interacts with them.
    *
    * This provides another layer of protection against sites that rewrite
    * links shortly before a click.
    */
   function fixClickedLink(event) {
       const target = event.target;

       if (!(target instanceof Element)) {
           return;
       }

       const link = target.closest('a[href]');

       if (link) {
           fixLink(link);
       }
   }

   document.addEventListener('pointerdown', fixClickedLink, true);
   document.addEventListener('click', fixClickedLink, true);

   /*
    * Watch for:
    *
    * 1. New links added dynamically.
    * 2. Existing links whose href attribute is changed after page load.
    */
   const observer = new MutationObserver(mutations => {

       for (const mutation of mutations) {

           if (
               mutation.type === 'attributes' &&
               mutation.target instanceof HTMLAnchorElement
           ) {
               fixLink(mutation.target);
               continue;
           }

           if (mutation.type === 'childList') {

               for (const node of mutation.addedNodes) {

                   if (!(node instanceof Element)) {
                       continue;
                   }

                   if (node instanceof HTMLAnchorElement) {
                       fixLink(node);
                   }

                   scan(node);
               }
           }
       }
   });

   observer.observe(document.documentElement, {
       childList: true,
       subtree: true,
       attributes: true,
       attributeFilter: ['href']
   });

})();

brave://settings/shields/filters

ar15.com##+js(user-sovrn-direct.js)

sovrn-direct