// ==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

// ==UserScript==
// @name         AR15 - Bypass Sovrn Links
// @namespace    local
// @version      2.0
// @description  Bypass Sovrn redirects on AR15.com
// @match        https://www.ar15.com/*
// @match        https://ar15.com/*
// @grant        none
// ==/UserScript==

(function () {
   'use strict';

   function unwrap(link) {
       if (!link || !link.href) return null;

       try {
           const url = new URL(link.href);

           // Only process Sovrn links
           if (
               url.hostname !== 'sovrn.co' &&
               !url.hostname.endsWith('.sovrn.co')
           ) {
               return null;
           }

           // Sovrn stores the real destination in "u"
           const destination = url.searchParams.get('u');

           if (!destination) return null;

           const realURL = new URL(destination);

           if (
               realURL.protocol !== 'http:' &&
               realURL.protocol !== 'https:'
           ) {
               return null;
           }

           // Replace Sovrn URL with real destination
           link.href = realURL.href;

           return realURL.href;

       } catch (err) {
           return null;
       }
   }


   // Fix as soon as pointer reaches a link
   document.addEventListener('pointerover', function (e) {
       const link = e.target.closest?.('a[href]');
       if (link) unwrap(link);
   }, true);


   // Also fix during mouse movement
   document.addEventListener('mousemove', function (e) {
       const link = e.target.closest?.('a[href]');
       if (link) unwrap(link);
   }, true);


   // Make sure it's fixed before mouse button goes down
   document.addEventListener('mousedown', function (e) {
       const link = e.target.closest?.('a[href]');
       if (link) unwrap(link);
   }, true);


   // FINAL SAFETY:
   // Intercept click if Sovrn somehow rewrites it again
   document.addEventListener('click', function (e) {

       const link = e.target.closest?.('a[href]');
       if (!link) return;

       const destination = unwrap(link);

       // Only intervene if this was actually a Sovrn link
       if (!destination) return;

       e.preventDefault();
       e.stopPropagation();
       e.stopImmediatePropagation();

       if (
           e.ctrlKey ||
           e.metaKey ||
           e.shiftKey ||
           e.button === 1
       ) {
           window.open(destination, '_blank');
       } else {
           window.location.assign(destination);
       }

   }, true);

})();

// ==UserScript==
// @name         AR15 - Add GMass No-Track to Posted Links
// @namespace    local
// @version      2.0
// @description  Adds gmasstrack=false to URLs pasted into AR15 posts
// @match        https://www.ar15.com/*
// @match        https://ar15.com/*
// @grant        none
// @run-at       document-idle
// ==/UserScript==

(function () {
   'use strict';

   function addNoTrack(text) {

       // Only process something that looks like a URL
       if (!/^https?:\/\//i.test(text.trim())) {
           return text;
       }

       try {
           const url = new URL(text.trim());

           // Don't modify AR15 links
           if (
               url.hostname === 'ar15.com' ||
               url.hostname.endsWith('.ar15.com')
           ) {
               return text;
           }

           // Add or replace parameter
           url.searchParams.set('gmasstrack', 'false');

           return url.href;

       } catch (e) {
           return text;
       }
   }


   document.addEventListener('paste', function(e) {

       const target = e.target;

       if (!target) return;

       // Only operate inside editable fields
       const editable = target.closest(
           'textarea, input[type="text"], [contenteditable="true"]'
       );

       if (!editable) return;

       const clipboard =
           e.clipboardData?.getData('text/plain');

       if (!clipboard) return;

       const modified = addNoTrack(clipboard);

       // Not a URL or nothing changed
       if (modified === clipboard) return;


       // STOP AR15 FROM HANDLING THE ORIGINAL PASTE
       e.preventDefault();
       e.stopPropagation();
       e.stopImmediatePropagation();


       // -----------------------------------------
       // NORMAL TEXTAREA
       // -----------------------------------------

       if (
           editable.tagName === 'TEXTAREA' ||
           editable.tagName === 'INPUT'
       ) {

           const start = editable.selectionStart;
           const end = editable.selectionEnd;

           editable.setRangeText(
               modified,
               start,
               end,
               'end'
           );

           editable.dispatchEvent(
               new Event('input', {
                   bubbles: true
               })
           );

           return;
       }


       // -----------------------------------------
       // RICH-TEXT / CONTENTEDITABLE
       // -----------------------------------------

       if (editable.isContentEditable) {

           const selection = window.getSelection();

           if (!selection || !selection.rangeCount)
               return;

           const range = selection.getRangeAt(0);

           range.deleteContents();

           const textNode =
               document.createTextNode(modified);

           range.insertNode(textNode);

           // Move cursor to end
           range.setStartAfter(textNode);
           range.setEndAfter(textNode);

           selection.removeAllRanges();
           selection.addRange(range);

           // Tell AR15 editor contents changed
           editable.dispatchEvent(
               new Event('input', {
                   bubbles: true
               })
           );
       }

   }, true);

})();

||sovrn.co/^$urlskip=-blocked ?u
@@||sovrn.co/^$urlskip=-blocked ?u

https://www.eff.org/deeplinks/2025/01/online-behavioral-ads-fuel-surveillance-industry-heres-how