AdsBlock.user.js

(function () {
    'use strict';

    class AdConfig {

        static STYLE_ID = 'ads_block';

        static SELECTORS = [
            '#diep-io_728x90_2',
            '#diep-io_300x250',
            '#diep-io_300x250.active',
            '.aa-unit.active'
        ];

        static BLOCK_KEYWORDS = [
            'doubleclick.net',
            'googlesyndication',
            'securepubads',
            'pagead',
            'adservice',
            'adserver',
            'adsystem',
            'adnxs',
            'adform',
            'amazon-ads',
            'ads',
            'adsrvr',
            'amp4ads',
            'casalemedia',
            'taboola',
            'outbrain',
            'rubiconproject'
        ];

        static AMP_MARKERS = [
            'i-amphtml-inabox',
            'i-amphtml-singledoc',
            'i-amphtml-standalone',
            'amp4ads',
            'i-amphtml-iframed'
        ];
    }

    class StyleManager {

        static inject() {

            if (document.getElementById(AdConfig.STYLE_ID)) return;

            const style = document.createElement('style');
            style.id = AdConfig.STYLE_ID;

            style.textContent = `
                ${AdConfig.SELECTORS.join(',')} {
                    display:none !important;
                    visibility:hidden !important;
                    opacity:0 !important;
                    pointer-events:none !important;
                }
            `;

            (document.head || document.documentElement).appendChild(style);
        }
    }

    class AdDetector {

        static isAdNode(node) {
            if (!node || node.nodeType !== 1) return false;
            const id = node.id || '';

            if (id.startsWith('diep-io_728x90') || id.startsWith('diep-io_300x250')) return true;
            if (node.matches?.(AdConfig.SELECTORS.join(','))) return true;
            if (node.querySelector?.(AdConfig.SELECTORS.join(','))) return true;

            return false;
        }

        static remove(node) {
            if (!node) return false;
            if (this.isAdNode(node)) {
                node.remove?.() || node.parentNode?.removeChild(node);
                return true;
            }

            return false;
        }
    }

    class DOMInterceptor {

        static patchDOM() {
            this.patch('appendChild');
            this.patch('insertBefore');
            this.patch('replaceChild');
        }

        static patch(method) {

            const original = Node.prototype[method];

            Node.prototype[method] = function (...args) {
                const node = args[0];
                if (AdDetector.isAdNode(node)) return node;
                return original.apply(this, args);
            };
        }

        static patchAttributes() {

            const original = Element.prototype.setAttribute;

            Element.prototype.setAttribute = function (name, value) {

                if (name === 'id') {
                    if (value.startsWith('diep-io_728x90') || value.startsWith('diep-io_300x250')) return;
                }

                if (name === 'class') {
                    const classes = value.split(/\s+/);
                    if (classes.includes('aa-unit') && classes.includes('active')) {
                        this.remove?.();
                        return;
                    }
                }

                return original.call(this, name, value);
            };
        }
    }

    class DOMWatcher {

        static start() {

            const observer = new MutationObserver(mutations => {

                for (const mutation of mutations) {
                    for (const node of mutation.addedNodes) {
                        if (AdDetector.remove(node)) continue;
                        node.querySelectorAll?.(AdConfig.SELECTORS.join(',')).forEach(n => AdDetector.remove(n));
                    }
                }
            });

            observer.observe(
                document.documentElement,
                { childList: true, subtree: true }
            );
        }
    }

    class NetworkBlocker {

        static isAMP() {
            const cls = document.documentElement.className;
            return AdConfig.AMP_MARKERS.some(marker => cls.includes(marker));
        }

        static isBlocked(url) {
            if (!url) return false;
            const s = String(url).toLowerCase();
            return AdConfig.BLOCK_KEYWORDS.some(k => s.includes(k));
        }

        static patchFetch() {

            const originalFetch = window.fetch;

            window.fetch = function (resource, init) {

                const url = resource?.url || resource;

                if (NetworkBlocker.isAMP() && NetworkBlocker.isBlocked(url)) {
                    return Promise.resolve(new Response('', { status: 204 }));
                }

                return originalFetch.apply(this, arguments);
            };
        }

        static patchXHR() {

            const originalOpen = XMLHttpRequest.prototype.open;
            const originalSend = XMLHttpRequest.prototype.send;

            XMLHttpRequest.prototype.open = function (method, url) {
                if (NetworkBlocker.isAMP() && NetworkBlocker.isBlocked(url)) this.blocked = true;
                return originalOpen.apply(this, arguments);
            };

            XMLHttpRequest.prototype.send = function () {

                if (this.blocked) {
                    this.abort();
                    return;
                }

                return originalSend.apply(this, arguments);
            };
        }

        static patchIframe() {

            const proto = HTMLIFrameElement?.prototype;
            if (!proto) return;

            const original = proto.setAttribute;

            proto.setAttribute = function (name, value) {
                if ((name === 'src' || name === 'srcdoc') && NetworkBlocker.isBlocked(value)) return;
                return original.call(this, name, value);
            };
        }

        static init() {
            this.patchFetch();
            this.patchXHR();
            this.patchIframe();
        }
    }

    class AdBlocker {

        static init() {
            StyleManager.inject();
            DOMInterceptor.patchDOM();
            DOMInterceptor.patchAttributes();
            DOMWatcher.start();
            NetworkBlocker.init();
        }
    }

    AdBlocker.init();

})();