Universal Content Blocker

A comprehensive content blocker that removes ads, trackers, and unwanted content using filter lists and host files
Wrap lines
// ==UserScript==
// @name         Universal Content Blocker
// @namespace    https://github.com/your-username/universal-content-blocker
// @version      1.0.0
// @description  A comprehensive content blocker that removes ads, trackers, and unwanted content using filter lists and host files
// @author       Jack Zhang
// @license      MIT
// @match        *://*/*
// @grant        GM_xmlhttpRequest
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_addStyle
// @connect      easylist.to
// @connect      adguardteam.github.io
// @connect      raw.githubusercontent.com
// @connect      *
// @run-at       document-start
// @homepage     https://github.com/your-username/universal-content-blocker
// @supportURL   https://github.com/your-username/universal-content-blocker/issues
// ==/UserScript==

/* 
Universal Content Blocker - A powerful userscript to block unwanted content
MIT License - https://opensource.org/licenses/MIT
*/

(function() {
    'use strict';

    // Host Blocker Implementation
    class HostBlocker {
        constructor() {
            this.blockedHosts = new Set();
            this.lastUpdate = 0;
        }

        async loadHostFile(url) {
            try {
                const response = await this.fetchHostFile(url);
                this.parseHostFile(response);
                this.lastUpdate = Date.now();
                return true;
            } catch (error) {
                console.error('Failed to load host file:', error);
                return false;
            }
        }

        fetchHostFile(url) {
            return new Promise((resolve, reject) => {
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: url,
                    onload: function(response) {
                        if (response.status === 200) {
                            resolve(response.responseText);
                        } else {
                            reject(new Error(`HTTP ${response.status}`));
                        }
                    },
                    onerror: reject
                });
            });
        }

        parseHostFile(content) {
            const lines = content.split('\n');
            
            for (const line of lines) {
                if (line.startsWith('#') || !line.trim()) continue;

                const parts = line.trim().split(/\s+/);
                if (parts.length >= 2) {
                    const domain = parts[1].toLowerCase();
                    this.blockedHosts.add(domain);

                    if (!domain.startsWith('www.')) {
                        this.blockedHosts.add(`www.${domain}`);
                    }
                }
            }
        }

        shouldBlockDomain(url) {
            try {
                const hostname = new URL(url).hostname.toLowerCase();
                
                if (this.blockedHosts.has(hostname)) return true;

                return Array.from(this.blockedHosts).some(blockedHost => 
                    hostname.endsWith(`.${blockedHost}`)
                );
            } catch (error) {
                console.error('Error parsing URL:', error);
                return false;
            }
        }

        addBlockedHost(domain) {
            domain = domain.toLowerCase();
            this.blockedHosts.add(domain);
            
            if (!domain.startsWith('www.')) {
                this.blockedHosts.add(`www.${domain}`);
            }
        }

        removeBlockedHost(domain) {
            domain = domain.toLowerCase();
            this.blockedHosts.delete(domain);
            this.blockedHosts.delete(`www.${domain}`);
        }

        getBlockedHosts() {
            return Array.from(this.blockedHosts);
        }

        clearBlockedHosts() {
            this.blockedHosts.clear();
        }

        exportHostFile() {
            return Array.from(this.blockedHosts)
                .map(host => `0.0.0.0 ${host}`)
                .join('\n');
        }
    }

    // UI Implementation
    class BlockerUI {
        constructor(contentBlocker) {
            this.contentBlocker = contentBlocker;
            this.createUI();
        }

        createUI() {
            const container = document.createElement('div');
            container.id = 'content-blocker-ui';
            container.style.cssText = `
                position: fixed;
                top: 20px;
                right: 20px;
                background: white;
                border: 1px solid #ccc;
                border-radius: 5px;
                padding: 15px;
                z-index: 999999;
                box-shadow: 0 2px 10px rgba(0,0,0,0.1);
                font-family: Arial, sans-serif;
                max-width: 300px;
                display: none;
            `;

            const toggleButton = document.createElement('button');
            toggleButton.textContent = '☰ Content Blocker';
            toggleButton.style.cssText = `
                position: fixed;
                top: 10px;
                right: 10px;
                z-index: 999999;
                padding: 5px 10px;
                background: #4CAF50;
                color: white;
                border: none;
                border-radius: 3px;
                cursor: pointer;
            `;

            toggleButton.addEventListener('click', () => {
                container.style.display = container.style.display === 'none' ? 'block' : 'none';
            });

            const content = this.createContent();
            container.appendChild(content);

            document.body.appendChild(toggleButton);
            document.body.appendChild(container);
        }

        createContent() {
            const content = document.createElement('div');

            const title = document.createElement('h2');
            title.textContent = 'Content Blocker Settings';
            title.style.margin = '0 0 15px 0';

            const stats = document.createElement('div');
            const blockerStats = this.contentBlocker.getStats();
            stats.innerHTML = `
                <p>Blocked items: <span id="blocked-count">${blockerStats.blockedCount}</span></p>
                <p>Active rules: <span id="rules-count">${blockerStats.rulesCount}</span></p>
            `;

            const filterLists = document.createElement('div');
            filterLists.innerHTML = `
                <h3>Filter Lists</h3>
                <div id="filter-lists">
                    ${this.contentBlocker.config.filterLists.map(list => `
                        <div class="filter-list-item">
                            <input type="checkbox" checked>
                            <span>${list}</span>
                        </div>
                    `).join('')}
                </div>
                <button id="add-filter-list">Add Filter List</button>
            `;

            const customRules = document.createElement('div');
            customRules.innerHTML = `
                <h3>Custom Rules</h3>
                <textarea id="custom-rules" rows="4" style="width: 100%">${
                    this.contentBlocker.config.customCssRules.join('\n')
                }</textarea>
                <button id="save-custom-rules">Save Rules</button>
            `;

            const controls = document.createElement('div');
            controls.style.marginTop = '15px';
            controls.innerHTML = `
                <button id="update-lists">Update Lists</button>
                <button id="reset-settings">Reset Settings</button>
            `;

            content.appendChild(title);
            content.appendChild(stats);
            content.appendChild(filterLists);
            content.appendChild(customRules);
            content.appendChild(controls);

            this.addEventListeners(content);

            return content;
        }

        addEventListeners(content) {
            content.querySelector('#add-filter-list').addEventListener('click', () => {
                const url = prompt('Enter filter list URL:');
                if (url) {
                    this.contentBlocker.config.filterLists.push(url);
                    this.contentBlocker.saveConfig();
                    this.contentBlocker.updateFilterLists();
                    this.updateUI();
                }
            });

            content.querySelector('#save-custom-rules').addEventListener('click', () => {
                const rules = content.querySelector('#custom-rules').value.split('\n');
                this.contentBlocker.config.customCssRules = rules;
                this.contentBlocker.saveConfig();
                this.contentBlocker.filterList.applyCosmeticRules();
            });

            content.querySelector('#update-lists').addEventListener('click', () => {
                this.contentBlocker.updateFilterLists();
            });

            content.querySelector('#reset-settings').addEventListener('click', () => {
                if (confirm('Reset all settings to default?')) {
                    this.contentBlocker.config = DEFAULT_CONFIG;
                    this.contentBlocker.saveConfig();
                    this.contentBlocker.init();
                    this.updateUI();
                }
            });
        }

        updateUI() {
            const container = document.getElementById('content-blocker-ui');
            if (!container) return;

            const stats = this.contentBlocker.getStats();
            container.querySelector('#blocked-count').textContent = stats.blockedCount;
            container.querySelector('#rules-count').textContent = stats.rulesCount;

            const filterListsContainer = container.querySelector('#filter-lists');
            filterListsContainer.innerHTML = this.contentBlocker.config.filterLists.map(list => `
                <div class="filter-list-item">
                    <input type="checkbox" checked>
                    <span>${list}</span>
                </div>
            `).join('');

            const customRulesTextarea = container.querySelector('#custom-rules');
            customRulesTextarea.value = this.contentBlocker.config.customCssRules.join('\n');
        }
    }

    // Configuration
    const DEFAULT_CONFIG = {
        filterLists: [
            'https://easylist.to/easylist/easylist.txt',
            'https://easylist.to/easylist/easyprivacy.txt',
            'https://adguardteam.github.io/AdGuardSDNSFilter/Filters/filter.txt'
        ],
        hostFile: 'https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts',
        customCssRules: [
            'div[id^="ad-"]',
            '.banner',
            '[class*="advertisement"]',
            '[id*="sponsor"]'
        ],
        blockedScripts: [
            'analytics.js',
            'ga.js',
            'doubleclick.net',
            'facebook.com/plugins',
            'google-analytics.com'
        ],
        updateInterval: 24 * 60 * 60 * 1000 // 24 hours
    };

    // Core Filter Implementation
    class FilterRule {
        constructor(rule) {
            this.originalRule = rule;
            this.parse(rule);
        }

        parse(rule) {
            rule = rule.split('#')[0].trim();
            if (!rule) return;

            if (rule.startsWith('||')) {
                this.type = 'domain';
                this.pattern = rule.slice(2).replace(/\^/g, '');
            } else if (rule.startsWith('/') && rule.endsWith('/')) {
                this.type = 'regex';
                this.pattern = new RegExp(rule.slice(1, -1));
            } else if (rule.startsWith('##')) {
                this.type = 'cosmetic';
                this.pattern = rule.slice(2);
            } else {
                this.type = 'basic';
                this.pattern = rule;
            }
        }

        matches(url) {
            if (!this.pattern) return false;

            switch (this.type) {
                case 'domain':
                    return url.includes(this.pattern);
                case 'regex':
                    return this.pattern.test(url);
                case 'basic':
                    return url.includes(this.pattern);
                default:
                    return false;
            }
        }
    }

    class FilterList {
        constructor() {
            this.rules = new Set();
            this.cosmeticRules = new Set();
        }

        addRule(rule) {
            if (typeof rule !== 'string' || !rule.trim()) return;
            
            const filterRule = new FilterRule(rule);
            if (filterRule.type === 'cosmetic') {
                this.cosmeticRules.add(filterRule.pattern);
            } else {
                this.rules.add(filterRule);
            }
        }

        shouldBlock(url) {
            for (const rule of this.rules) {
                if (rule.matches(url)) return true;
            }
            return false;
        }

        applyCosmeticRules() {
            if (this.cosmeticRules.size > 0) {
                const cssRules = Array.from(this.cosmeticRules).join(',\n');
                GM_addStyle(`${cssRules} { display: none !important; }`);
            }
        }
    }

    class ContentBlocker {
        constructor() {
            this.filterList = new FilterList();
            this.hostBlocker = new HostBlocker();
            this.config = this.loadConfig();
            this.blockedCount = 0;
            this.init();
        }

        loadConfig() {
            const savedConfig = GM_getValue('blockerConfig');
            return savedConfig ? JSON.parse(savedConfig) : DEFAULT_CONFIG;
        }

        saveConfig() {
            GM_setValue('blockerConfig', JSON.stringify(this.config));
        }

        async init() {
            await this.updateFilterLists();
            await this.updateHostFile();
            this.setupMutationObserver();
            this.blockInitialContent();
            
            // Initialize UI after DOM is ready
            if (document.body) {
                this.ui = new BlockerUI(this);
            } else {
                document.addEventListener('DOMContentLoaded', () => {
                    this.ui = new BlockerUI(this);
                });
            }
            
            // Set up periodic updates
            setInterval(() => {
                this.updateFilterLists();
                this.updateHostFile();
            }, this.config.updateInterval);
        }

        async updateFilterLists() {
            for (const url of this.config.filterLists) {
                try {
                    const response = await this.fetchFilterList(url);
                    const rules = response.split('\n');
                    for (const rule of rules) {
                        this.filterList.addRule(rule);
                    }
                } catch (error) {
                    console.error(`Failed to fetch filter list from ${url}:`, error);
                }
            }
            this.filterList.applyCosmeticRules();
            if (this.ui) this.ui.updateUI();
        }

        async updateHostFile() {
            if (this.config.hostFile) {
                await this.hostBlocker.loadHostFile(this.config.hostFile);
            }
        }

        fetchFilterList(url) {
            return new Promise((resolve, reject) => {
                GM_xmlhttpRequest({
                    method: 'GET',
                    url: url,
                    onload: function(response) {
                        if (response.status === 200) {
                            resolve(response.responseText);
                        } else {
                            reject(new Error(`HTTP ${response.status}`));
                        }
                    },
                    onerror: reject
                });
            });
        }

        setupMutationObserver() {
            const observer = new MutationObserver((mutations) => {
                for (const mutation of mutations) {
                    if (mutation.type === 'childList') {
                        this.processNewNodes(mutation.addedNodes);
                    }
                }
            });

            if (document.body) {
                observer.observe(document.body, {
                    childList: true,
                    subtree: true
                });
            } else {
                document.addEventListener('DOMContentLoaded', () => {
                    observer.observe(document.body, {
                        childList: true,
                        subtree: true
                    });
                });
            }
        }

        processNewNodes(nodes) {
            nodes.forEach(node => {
                if (node.nodeType === Node.ELEMENT_NODE) {
                    this.blockScripts(node);
                    this.blockIframes(node);
                    this.blockImages(node);
                }
            });
        }

        blockInitialContent() {
            if (document.body) {
                this.blockScripts(document);
                this.blockIframes(document);
                this.blockImages(document);
            }
        }

        shouldBlock(url) {
            return this.filterList.shouldBlock(url) || this.hostBlocker.shouldBlockDomain(url);
        }

        blockScripts(root) {
            const scripts = root.getElementsByTagName('script');
            for (const script of scripts) {
                const src = script.src;
                if (src && this.shouldBlock(src)) {
                    script.remove();
                    this.blockedCount++;
                }
            }
        }

        blockIframes(root) {
            const iframes = root.getElementsByTagName('iframe');
            for (const iframe of iframes) {
                const src = iframe.src;
                if (src && this.shouldBlock(src)) {
                    iframe.remove();
                    this.blockedCount++;
                }
            }
        }

        blockImages(root) {
            const images = root.getElementsByTagName('img');
            for (const img of images) {
                const src = img.src;
                if (src && this.shouldBlock(src)) {
                    img.remove();
                    this.blockedCount++;
                }
            }
        }

        getStats() {
            return {
                blockedCount: this.blockedCount,
                rulesCount: this.filterList.rules.size + this.filterList.cosmeticRules.size + this.hostBlocker.blockedHosts.size
            };
        }
    }

    // Initialize the content blocker
    const blocker = new ContentBlocker();
})();
欢迎访问Greasy Fork镜像
