☰

Dynamic Include Sites Script (Protocol-Independent)

Run on default & user-defined sites using wildcard patterns (ignores protocols), with full management features.

This script should not be not be installed directly. It is a library for other scripts to include with the meta directive // @require https://update.greatest.deepsurf.us/scripts/526770/1596962/Dynamic%20Include%20Sites%20Script%20%28Protocol-Independent%29.js 

  1. // ==UserScript==
  2. // @name         Site Filter (Protocol-Independent)
  3. // @namespace    http://tampermonkey.net/
  4. // @version      2.7
  5. // @description  Manage allowed sites dynamically and reference this in other scripts.
  6. // @author       blvdmd
  7. // @match        *://*/*
  8. // @noframes
  9. // @grant        GM_getValue
  10. // @grant        GM_setValue
  11. // @grant        GM_registerMenuCommand
  12. // @grant        GM_download
  13. // @run-at       document-start
  14. // ==/UserScript==
  15.  
  16. (function () {
  17.     'use strict';
  18.  
  19.      // Exit if the script is running in an iframe or embedded context
  20.      if (window.self !== window.top) {
  21.         return; // Stop execution for embedded pages
  22.     }
  23.  
  24.     const USE_EMOJI_FOR_STATUS = true; // Configurable flag to use emoji for true/false status
  25.     const SHOW_STATUS_ONLY_IF_TRUE = true; // Configurable flag to show status only if any value is true
  26.  
  27.     // ✅ Wait for `SCRIPT_STORAGE_KEY` to be set
  28.     function waitForScriptStorageKey(maxWait = 1000) {
  29.         return new Promise(resolve => {
  30.             const startTime = Date.now();
  31.             const interval = setInterval(() => {
  32.                 if (typeof window.SCRIPT_STORAGE_KEY !== 'undefined') {
  33.                     clearInterval(interval);
  34.                     resolve(window.SCRIPT_STORAGE_KEY);
  35.                 } else if (Date.now() - startTime > maxWait) {
  36.                     clearInterval(interval);
  37.                     console.error("🚨 SCRIPT_STORAGE_KEY is not set! Make sure your script sets it **before** @require.");
  38.                     resolve(null);
  39.                 }
  40.             }, 50);
  41.         });
  42.     }
  43.  
  44.     (async function initialize() {
  45.         async function waitForDocumentReady() {
  46.             if (document.readyState === "complete") return;
  47.             return new Promise(resolve => {
  48.                 window.addEventListener("load", resolve, { once: true });
  49.             });
  50.         }
  51.         // ✅ Wait for the script storage key
  52.         const key = await waitForScriptStorageKey();
  53.         if (!key) return;
  54.  
  55.         // ✅ Ensure the document is fully loaded before setting `shouldRunOnThisSite`
  56.         await waitForDocumentReady();
  57.  
  58.         const STORAGE_KEY = `additionalSites_${key}`;
  59.  
  60.         function getDefaultList() {
  61.             return typeof window.GET_DEFAULT_LIST === "function" ? window.GET_DEFAULT_LIST() : [];
  62.         }
  63.  
  64.         function normalizeUrl(url) {
  65.             if (typeof url !== 'string') {
  66.                 url = String(url);
  67.             }
  68.             return url.replace(/^https?:\/\//, '');
  69.         }
  70.  
  71.         let additionalSites = GM_getValue(STORAGE_KEY, []);
  72.  
  73.         let mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(item => {
  74.             if (typeof item === 'string') {
  75.                 return { pattern: normalizeUrl(item), preProcessingRequired: false, postProcessingRequired: false };
  76.             }
  77.             return { ...item, pattern: normalizeUrl(item.pattern) };
  78.         });
  79.  
  80.         GM_registerMenuCommand("➕ Add Current Site to Include List", addCurrentSiteMenu);
  81.         GM_registerMenuCommand("📜 View Included Sites", viewIncludedSites);
  82.         GM_registerMenuCommand("🗑️ Delete Specific Entries", deleteEntries);
  83.         GM_registerMenuCommand("✏️ Edit an Entry", editEntry);
  84.         GM_registerMenuCommand("🚨 Clear All Entries", clearAllEntries);
  85.         GM_registerMenuCommand("📤 Export Site List as JSON", exportAdditionalSites);
  86.         GM_registerMenuCommand("📥 Import Site List from JSON", importAdditionalSites);
  87.  
  88.         async function shouldRunOnThisSite() {
  89.             const currentFullPath = normalizeUrl(`${window.top.location.href}`);
  90.             return mergedSites.some(item => wildcardToRegex(normalizeUrl(item.pattern)).test(currentFullPath));
  91.         }
  92.  
  93.         function wildcardToRegex(pattern) {
  94.             return new RegExp("^" + pattern
  95.                     .replace(/[-[\]{}()+^$|#\s]/g, '\\$&')
  96.                     .replace(/\./g, '\\.')
  97.                     .replace(/\?/g, '\\?')
  98.                     .replace(/\*/g, '.*')
  99.                 + "$");
  100.         }
  101.  
  102.         function addCurrentSiteMenu() {
  103.             const currentHost = window.top.location.hostname; // Use window.top to get the top-level hostname
  104.             const currentPath = window.top.location.pathname; // Use window.top to get the top-level pathname
  105.             const domainParts = currentHost.split('.');
  106.             const baseDomain = domainParts.length > 2 ? domainParts.slice(-2).join('.') : domainParts.join('.');
  107.             const secondLevelDomain = domainParts.length > 2 ? domainParts.slice(-2, -1)[0] : domainParts[0];
  108.         
  109.             const options = [
  110.                 { name: `Preferred Domain Match (*${secondLevelDomain}.*)`, pattern: `*${secondLevelDomain}.*` },
  111.                 { name: `Base Hostname (*.${baseDomain}*)`, pattern: `*.${baseDomain}*` },
  112.                 { name: `Base Domain (*.${secondLevelDomain}.*)`, pattern: `*.${secondLevelDomain}.*` },
  113.                 { name: `Host Contains (*${secondLevelDomain}*)`, pattern: `*${secondLevelDomain}*` },
  114.                 { name: `Exact Path (${currentHost}${currentPath})`, pattern: normalizeUrl(`${window.top.location.href}`) },
  115.                 { name: "Custom Wildcard Pattern", pattern: normalizeUrl(`${window.top.location.href}`) }
  116.             ];
  117.  
  118.             const userChoice = prompt(
  119.                 "Select an option to add the site:\n" +
  120.                 options.map((opt, index) => `${index + 1}. ${opt.name}`).join("\n") +
  121.                 "\nEnter a number or cancel."
  122.             );
  123.  
  124.             if (!userChoice) return;
  125.             const selectedIndex = parseInt(userChoice, 10) - 1;
  126.             if (selectedIndex >= 0 && selectedIndex < options.length) {
  127.                 let pattern = normalizeUrl(options[selectedIndex].pattern);
  128.                 if (options[selectedIndex].name === "Custom Wildcard Pattern") {
  129.                     pattern = normalizeUrl(prompt("Edit custom wildcard pattern:", pattern));
  130.                     if (!pattern.trim()) return alert("Invalid pattern. Operation canceled.");
  131.                 }
  132.  
  133.                 const preProcessingRequired = prompt("Is pre-processing required? (y/n)", "n").toLowerCase() === 'y';
  134.                 const postProcessingRequired = prompt("Is post-processing required? (y/n)", "n").toLowerCase() === 'y';
  135.                 const onDemandFloatingButtonRequired = prompt("Is on-demand floating button required? (y/n)", "n").toLowerCase() === 'y';
  136.                 const backgroundChangeObserverRequired = prompt("Is background change observer required? (y/n)", "n").toLowerCase() === 'y';
  137.  
  138.                 const entry = { 
  139.                     pattern, 
  140.                     preProcessingRequired, 
  141.                     postProcessingRequired, 
  142.                     onDemandFloatingButtonRequired, 
  143.                     backgroundChangeObserverRequired 
  144.                 };
  145.                 
  146.                 if (!additionalSites.some(item => item.pattern === pattern)) {
  147.                     additionalSites.push(entry);
  148.                     GM_setValue(STORAGE_KEY, additionalSites);
  149.                     mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(item => {
  150.                         if (typeof item === 'string') {
  151.                             return { 
  152.                                 pattern: normalizeUrl(item), 
  153.                                 preProcessingRequired: false, 
  154.                                 postProcessingRequired: false, 
  155.                                 onDemandFloatingButtonRequired: false, 
  156.                                 backgroundChangeObserverRequired: false 
  157.                             };
  158.                         }
  159.                         return { 
  160.                             ...item, 
  161.                             pattern: normalizeUrl(item.pattern),
  162.                             onDemandFloatingButtonRequired: item.onDemandFloatingButtonRequired || false,
  163.                             backgroundChangeObserverRequired: item.backgroundChangeObserverRequired || false
  164.                         };
  165.                     });
  166.                     alert(`✅ Added site with pattern: ${pattern}`);
  167.                 } else {
  168.                     alert(`⚠️ Pattern "${pattern}" is already in the list.`);
  169.                 }
  170.             }
  171.         }
  172.  
  173.         function viewIncludedSites() {
  174.             const siteList = additionalSites.map(item => {
  175.                 const status = formatStatus(item.preProcessingRequired, item.postProcessingRequired, item.onDemandFloatingButtonRequired, item.backgroundChangeObserverRequired);
  176.                 return `${item.pattern}${status ? ` (${status})` : ''}`;
  177.             }).join("\n");
  178.             alert(`🔍 Included Sites:\n${siteList || "No sites added yet."}`);
  179.         }
  180.  
  181.         function deleteEntries() {
  182.             if (additionalSites.length === 0) return alert("⚠️ No user-defined entries to delete.");
  183.             const userChoice = prompt("Select entries to delete (comma-separated numbers):\n" +
  184.                 additionalSites.map((item, index) => `${index + 1}. ${item.pattern}`).join("\n"));
  185.             if (!userChoice) return;
  186.             const indicesToRemove = userChoice.split(',').map(num => parseInt(num.trim(), 10) - 1);
  187.             additionalSites = additionalSites.filter((_, index) => !indicesToRemove.includes(index));
  188.             GM_setValue(STORAGE_KEY, additionalSites);
  189.             mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(item => {
  190.                 if (typeof item === 'string') {
  191.                     return { pattern: normalizeUrl(item), preProcessingRequired: false, postProcessingRequired: false };
  192.                 }
  193.                 return { ...item, pattern: normalizeUrl(item.pattern) };
  194.             });
  195.             alert("✅ Selected entries have been deleted.");
  196.         }
  197.  
  198.         function editEntry() {
  199.             if (additionalSites.length === 0) return alert("⚠️ No user-defined entries to edit.");
  200.             const userChoice = prompt("Select an entry to edit:\n" +
  201.                 additionalSites.map((item, index) => {
  202.                     const status = formatStatus(item.preProcessingRequired, item.postProcessingRequired, item.onDemandFloatingButtonRequired, item.backgroundChangeObserverRequired);
  203.                     return `${index + 1}. ${item.pattern}${status ? ` (${status})` : ''}`;
  204.                 }).join("\n"));
  205.             if (!userChoice) return;
  206.             const selectedIndex = parseInt(userChoice, 10) - 1;
  207.             if (selectedIndex < 0 || selectedIndex >= additionalSites.length) return alert("❌ Invalid selection.");
  208.             const entry = additionalSites[selectedIndex];
  209.             const newPattern = normalizeUrl(prompt("Edit the pattern:", entry.pattern));
  210.             if (!newPattern || !newPattern.trim()) return;
  211.         
  212.             const preProcessingRequired = prompt("Is pre-processing required? (y/n)", entry.preProcessingRequired ? "y" : "n").toLowerCase() === 'y';
  213.             const postProcessingRequired = prompt("Is post-processing required? (y/n)", entry.postProcessingRequired ? "y" : "n").toLowerCase() === 'y';
  214.             const onDemandFloatingButtonRequired = prompt("Is on-demand floating button required? (y/n)", entry.onDemandFloatingButtonRequired ? "y" : "n").toLowerCase() === 'y';
  215.             const backgroundChangeObserverRequired = prompt("Is background change observer required? (y/n)", entry.backgroundChangeObserverRequired ? "y" : "n").toLowerCase() === 'y';
  216.         
  217.             entry.pattern = newPattern.trim();
  218.             entry.preProcessingRequired = preProcessingRequired;
  219.             entry.postProcessingRequired = postProcessingRequired;
  220.             entry.onDemandFloatingButtonRequired = onDemandFloatingButtonRequired;
  221.             entry.backgroundChangeObserverRequired = backgroundChangeObserverRequired;
  222.             GM_setValue(STORAGE_KEY, additionalSites);
  223.             mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(item => {
  224.                 if (typeof item === 'string') {
  225.                     return { 
  226.                         pattern: normalizeUrl(item), 
  227.                         preProcessingRequired: false, 
  228.                         postProcessingRequired: false, 
  229.                         onDemandFloatingButtonRequired: false, 
  230.                         backgroundChangeObserverRequired: false 
  231.                     };
  232.                 }
  233.                 return { 
  234.                     ...item, 
  235.                     pattern: normalizeUrl(item.pattern),
  236.                     onDemandFloatingButtonRequired: item.onDemandFloatingButtonRequired || false,
  237.                     backgroundChangeObserverRequired: item.backgroundChangeObserverRequired || false
  238.                 };
  239.             });
  240.             alert("✅ Entry updated.");
  241.         }
  242.  
  243.         function clearAllEntries() {
  244.             if (additionalSites.length === 0) return alert("⚠️ No user-defined entries to clear.");
  245.             if (confirm(`🚨 You have ${additionalSites.length} entries. Clear all?`)) {
  246.                 additionalSites = [];
  247.                 GM_setValue(STORAGE_KEY, additionalSites);
  248.                 mergedSites = [...getDefaultList()].map(item => {
  249.                     if (typeof item === 'string') {
  250.                         return { pattern: normalizeUrl(item), preProcessingRequired: false, postProcessingRequired: false };
  251.                     }
  252.                     return { ...item, pattern: normalizeUrl(item.pattern) };
  253.                 });
  254.                 alert("✅ All user-defined entries cleared.");
  255.             }
  256.         }
  257.  
  258.         // function exportAdditionalSites() {
  259.         //     GM_download("data:text/json;charset=utf-8," + encodeURIComponent(JSON.stringify(additionalSites, null, 2)), "additionalSites_backup.json");
  260.         //     alert("📤 Additional sites exported as JSON.");
  261.         // }
  262.  
  263.         function exportAdditionalSites() {
  264.             const data = JSON.stringify(additionalSites, null, 2);
  265.             const blob = new Blob([data], { type: 'application/json' });
  266.             const url = URL.createObjectURL(blob);
  267.             const a = document.createElement('a');
  268.             a.href = url;
  269.             a.download = 'additionalSites_backup.json';
  270.             document.body.appendChild(a);
  271.             a.click();
  272.             document.body.removeChild(a);
  273.             URL.revokeObjectURL(url);
  274.             alert("📤 Additional sites exported as JSON.");
  275.         }
  276.  
  277.         // function importAdditionalSites() {
  278.         //     const input = document.createElement("input");
  279.         //     input.type = "file";
  280.         //     input.accept = ".json";
  281.         //     input.onchange = event => {
  282.         //         const reader = new FileReader();
  283.         //         reader.onload = e => {
  284.         //             additionalSites = JSON.parse(e.target.result);
  285.         //             GM_setValue(STORAGE_KEY, additionalSites);
  286.         //             mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(item => {
  287.         //                 if (typeof item === 'string') {
  288.         //                     return { pattern: normalizeUrl(item), preProcessingRequired: false, postProcessingRequired: false };
  289.         //                 }
  290.         //                 return { ...item, pattern: normalizeUrl(item.pattern) };
  291.         //             });
  292.         //             alert("📥 Sites imported successfully.");
  293.         //         };
  294.         //         reader.readAsText(event.target.files[0]);
  295.         //     };
  296.         //     input.click();
  297.         // }
  298.  
  299.         function importAdditionalSites() {
  300.             const input = document.createElement('input');
  301.             input.type = 'file';
  302.             input.accept = '.json';
  303.             input.style.display = 'none';
  304.             input.onchange = event => {
  305.                 const reader = new FileReader();
  306.                 reader.onload = e => {
  307.                     try {
  308.                         const importedData = JSON.parse(e.target.result);
  309.                         if (Array.isArray(importedData)) {
  310.                             additionalSites = importedData.map(item => {
  311.                                 if (typeof item === 'string') {
  312.                                     return normalizeUrl(item);
  313.                                 } else if (typeof item === 'object' && item.pattern) {
  314.                                     return { ...item, pattern: normalizeUrl(item.pattern) };
  315.                                 }
  316.                                 throw new Error('Invalid data format');
  317.                             });
  318.                             GM_setValue(STORAGE_KEY, additionalSites);
  319.                             mergedSites = [...new Set([...getDefaultList(), ...additionalSites])].map(item => {
  320.                                 if (typeof item === 'string') {
  321.                                     return normalizeUrl(item);
  322.                                 }
  323.                                 return { ...item, pattern: normalizeUrl(item.pattern) };
  324.                             });
  325.                             alert('📥 Sites imported successfully.');
  326.                         } else {
  327.                             throw new Error('Invalid data format');
  328.                         }
  329.                     } catch (error) {
  330.                         alert('❌ Failed to import sites: ' + error.message);
  331.                     }
  332.                 };
  333.                 reader.readAsText(event.target.files[0]);
  334.             };
  335.             document.body.appendChild(input);
  336.             input.click();
  337.             document.body.removeChild(input);
  338.         }
  339.  
  340.         function formatStatus(preProcessingRequired, postProcessingRequired, onDemandFloatingButtonRequired, backgroundChangeObserverRequired) {
  341.             if (SHOW_STATUS_ONLY_IF_TRUE && !preProcessingRequired && !postProcessingRequired && !onDemandFloatingButtonRequired && !backgroundChangeObserverRequired) {
  342.                 return '';
  343.             }
  344.             const preStatus = USE_EMOJI_FOR_STATUS ? (preProcessingRequired ? '✅' : '✖️') : (preProcessingRequired ? 'true' : 'false');
  345.             const postStatus = USE_EMOJI_FOR_STATUS ? (postProcessingRequired ? '✅' : '✖️') : (postProcessingRequired ? 'true' : 'false');
  346.             const floatingButtonStatus = USE_EMOJI_FOR_STATUS ? (onDemandFloatingButtonRequired ? '✅' : '✖️') : (onDemandFloatingButtonRequired ? 'true' : 'false');
  347.             const backgroundObserverStatus = USE_EMOJI_FOR_STATUS ? (backgroundChangeObserverRequired ? '✅' : '✖️') : (backgroundChangeObserverRequired ? 'true' : 'false');
  348.             return `Pre: ${preStatus}, Post: ${postStatus}, Floating Button: ${floatingButtonStatus}, Background Observer: ${backgroundObserverStatus}`;
  349.         }
  350.  
  351.         window.shouldRunOnThisSite = shouldRunOnThisSite;
  352.         window.isPreProcessingRequired = function() {
  353.             const currentFullPath = normalizeUrl(`${window.top.location.href}`);
  354.             const entry = mergedSites.find(item => wildcardToRegex(normalizeUrl(item.pattern)).test(currentFullPath));
  355.             return entry ? entry.preProcessingRequired : false;
  356.         };
  357.         window.isPostProcessingRequired = function() {
  358.             const currentFullPath = normalizeUrl(`${window.top.location.href}`);
  359.             const entry = mergedSites.find(item => wildcardToRegex(normalizeUrl(item.pattern)).test(currentFullPath));
  360.             return entry ? entry.postProcessingRequired : false;
  361.         };
  362.         // Expose isOnDemandFloatingButtonRequired
  363.         window.isOnDemandFloatingButtonRequired = function() {
  364.             const currentFullPath = normalizeUrl(`${window.top.location.href}`);
  365.             const entry = mergedSites.find(item => wildcardToRegex(normalizeUrl(item.pattern)).test(currentFullPath));
  366.             return entry ? entry.onDemandFloatingButtonRequired : false;
  367.         };
  368.  
  369.         // Expose isBackgroundChangeObserverRequired
  370.         window.isBackgroundChangeObserverRequired = function() {
  371.             const currentFullPath = normalizeUrl(`${window.top.location.href}`);
  372.             const entry = mergedSites.find(item => wildcardToRegex(normalizeUrl(item.pattern)).test(currentFullPath));
  373.             return entry ? entry.backgroundChangeObserverRequired : false;
  374.         };
  375.     })();
  376. })();
  377.  
  378. //To use this in another script use @require
  379.  
  380. // // @run-at       document-end
  381. // // ==/UserScript==
  382.  
  383. // window.SCRIPT_STORAGE_KEY = "magnetLinkHashChecker"; // UNIQUE STORAGE KEY
  384.  
  385.  
  386. // window.GET_DEFAULT_LIST = function() {
  387. //      return [
  388. //         { pattern: "*1337x.*", preProcessingRequired: false, postProcessingRequired: false, onDemandFloatingButtonRequired: false, backgroundChangeObserverRequired: false },
  389. //         { pattern: "*yts.*", preProcessingRequired: true, postProcessingRequired: true, onDemandFloatingButtonRequired: false, backgroundChangeObserverRequired: false },
  390. //         { pattern: "*torrentgalaxy.*", preProcessingRequired: false, postProcessingRequired: true, onDemandFloatingButtonRequired: false, backgroundChangeObserverRequired: false },
  391. //         { pattern: "*bitsearch.*", preProcessingRequired: false, postProcessingRequired: false, onDemandFloatingButtonRequired: false, backgroundChangeObserverRequired: false },
  392. //         { pattern: "*thepiratebay.*", preProcessingRequired: false, postProcessingRequired: false, onDemandFloatingButtonRequired: false, backgroundChangeObserverRequired: false },
  393. //         { pattern: "*ext.*", preProcessingRequired: false, postProcessingRequired: false, onDemandFloatingButtonRequired: false, backgroundChangeObserverRequired: false }
  394. //     ];
  395. // };
  396.  
  397.  
  398. // (async function () {
  399. //     'use strict';
  400.  
  401. //     // ✅ Wait until `shouldRunOnThisSite` is available
  402. //     while (typeof shouldRunOnThisSite === 'undefined') {
  403. //         await new Promise(resolve => setTimeout(resolve, 50));
  404. //     }
  405.  
  406. //     if (!(await shouldRunOnThisSite())) return;
  407. //     //alert("running");
  408.  
  409. //     console.log("Pre-Customization enabled for this site: " + isPreProcessingRequired() );
  410. //     console.log("Post-Customization enabled for this site: " + isPostProcessingRequired() );
  411.  
  412. //     const OFFCLOUD_CACHE_API_URL = 'https://offcloud.com/api/cache';