// ==UserScript==
// @name Super Fast Load
// @namespace http://tampermonkey.net/
// @version 4
// @description Boost your browsing experience with Super Fast Load! Stop YouTube autoplay (main videos only), add download buttons, block trackers with whitelist, optimize for slow internet/VPN/Tor, lazy load media, enhance video buffering, and speed up page loading while preserving all site functionality.
// @match *://*/*
// @grant GM_xmlhttpRequest
// @grant unsafeWindow
// @require https://cdn.jsdelivr.net/npm/[email protected]/umd/browser/brotli.min.js
// @require https://cdnjs.cloudflare.com/ajax/libs/zstd/1.3.8/zstd.min.js
// @connect *
// ==/UserScript==
(function() {
'use strict';
// Configuration
const CONFIG = {
TRUSTED_DOMAINS: ['digikala.com', 'dkstatics-public.digikala.com', 'aparat.com', 'cdn.asset.aparat.com'],
PRECONNECT_TRUSTED_DOMAINS: true,
DNS_PREFETCH: true,
BLOCK_EXTERNAL_FONTS: true,
PREVENT_PREFETCH: true,
REMOVE_NON_ESSENTIAL_ELEMENTS: true,
NON_ESSENTIAL_SELECTORS: ['#disqus_thread', '.twitter-timeline', 'iframe[src*="facebook.com"]'],
OPTIMIZE_INLINE_CSS: true,
OPTIMIZE_INLINE_JS: true,
ENABLE_YOUTUBE_TOOLS: true,
BLOCK_LIST: ['ad', 'analytics', 'googletagmanager', 'tracking', 'beacon', 'facebook', 'twitter', 'hotjar', 'sentry', 'adverge', 'onesignal', 'clarity'],
ALLOW_LIST: ['jquery', 'bootstrap', 'core', 'essential', 'react', 'chunk', 'runtime', 'main', 'cloudflare', 'captcha'],
PARALLEL_FETCH_LIMIT: 8,
REQUEST_TIMEOUT: 500,
RETRY_ATTEMPTS: 3,
RETRY_DELAY: 1000,
CACHE_TTL: 24 * 60 * 60 * 1000,
VIDEO_BUFFER_AHEAD: 10, // Seconds to buffer ahead for videos
LOW_BANDWIDTH_THRESHOLD: 2 * 1024 / 8, // 2kbps in bytes/s
REQUEST_RATE_LIMIT: 50, // ms between requests to avoid detection
};
// Setup
const currentHost = window.location.hostname;
const mainDomain = currentHost.split('.').slice(-2).join('.');
const mainDomainKeyword = mainDomain.split('.')[0];
const trustedKeywords = new Set([mainDomainKeyword, ...CONFIG.TRUSTED_DOMAINS]);
const processedNodes = new WeakSet();
const resourceCache = new Map();
let networkSpeed = null; // Estimated in bytes/s
// Utility Functions
const throttle = (func, limit) => {
let lastCall = 0;
return function(...args) {
const now = Date.now();
if (now - lastCall >= limit) {
lastCall = now;
return func(...args);
}
};
};
const fetchWithTimeout = throttle(async (url, options = {}) => {
for (let attempt = 1; attempt <= CONFIG.RETRY_ATTEMPTS; attempt++) {
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), CONFIG.REQUEST_TIMEOUT * (networkSpeed <= CONFIG.LOW_BANDWIDTH_THRESHOLD ? 2 : 1));
try {
const response = await fetch(url, { ...options, signal: controller.signal, cache: 'force-cache' });
clearTimeout(timeoutId);
if (response.ok) return response;
throw new Error(`Fetch failed: ${response.status}`);
} catch (error) {
clearTimeout(timeoutId);
if (attempt === CONFIG.RETRY_ATTEMPTS) throw error;
await new Promise(resolve => setTimeout(resolve, CONFIG.RETRY_DELAY));
}
}
}, CONFIG.REQUEST_RATE_LIMIT);
const minifyCSS = (css) => css.replace(/\s*([{}:;,])\s*/g, '$1').replace(/;}/g, '}').trim();
const minifyJS = (js) => js.replace(/\s*([{}:;,])\s*/g, '$1').replace(/;}/g, '}').trim();
const isInternalOrTrusted = (url) => {
if (!url) return false;
try {
const resourceHost = new URL(url, window.location.origin).hostname;
if (resourceHost.endsWith(mainDomain)) return true;
for (const trusted of trustedKeywords) {
if (resourceHost.includes(trusted)) return true;
}
return false;
} catch (e) {
return false;
}
};
const isBlocked = (url) => {
if (!url || isInternalOrTrusted(url)) return false;
const lowerUrl = url.toLowerCase();
if (CONFIG.ALLOW_LIST.some(a => lowerUrl.includes(a))) return false;
return CONFIG.BLOCK_LIST.some(b => lowerUrl.includes(b));
};
const isFontRequest = (url) => {
if (!CONFIG.BLOCK_EXTERNAL_FONTS || !url) return false;
const lowerUrl = url.toLowerCase();
return lowerUrl.includes('fonts.googleapis.com') || lowerUrl.endsWith('.woff') || lowerUrl.endsWith('.woff2');
};
// Network Speed Detection
const estimateNetworkSpeed = async () => {
const startTime = performance.now();
try {
const response = await fetchWithTimeout('https://www.google.com/generate_204', { method: 'GET', mode: 'no-cors' });
const endTime = performance.now();
const duration = (endTime - startTime) / 1000; // seconds
networkSpeed = duration > 0 ? 204 / duration : CONFIG.LOW_BANDWIDTH_THRESHOLD; // bytes/s
} catch (e) {
networkSpeed = CONFIG.LOW_BANDWIDTH_THRESHOLD; // Assume low speed on failure
}
console.log(`Estimated network speed: ${networkSpeed.toFixed(2)} bytes/s`);
adjustForNetworkSpeed();
};
const adjustForNetworkSpeed = () => {
if (networkSpeed <= CONFIG.LOW_BANDWIDTH_THRESHOLD) {
CONFIG.PARALLEL_FETCH_LIMIT = Math.max(2, Math.floor(CONFIG.PARALLEL_FETCH_LIMIT / 2));
CONFIG.REQUEST_TIMEOUT *= 2;
CONFIG.VIDEO_BUFFER_AHEAD = 5; // Reduce buffer for very low bandwidth
} else {
CONFIG.PARALLEL_FETCH_LIMIT = 8;
CONFIG.REQUEST_TIMEOUT = 500;
CONFIG.VIDEO_BUFFER_AHEAD = 10;
}
};
// Resource Management
const setupPreconnections = () => {
const uniqueHosts = new Set();
CONFIG.TRUSTED_DOMAINS.forEach(domain => {
try {
if (currentHost.endsWith(domain)) return;
const url = new URL(`https://${domain}`);
if (!uniqueHosts.has(url.hostname)) {
uniqueHosts.add(url.hostname);
const preconnectLink = document.createElement('link');
preconnectLink.rel = 'preconnect';
preconnectLink.href = url.origin;
preconnectLink.crossOrigin = 'anonymous';
(document.head || document.documentElement).appendChild(preconnectLink);
if (CONFIG.DNS_PREFETCH) {
const dnsLink = document.createElement('link');
dnsLink.rel = 'dns-prefetch';
dnsLink.href = url.origin;
(document.head || document.documentElement).appendChild(dnsLink);
}
}
} catch (e) {}
});
};
const fetchResourcesParallel = async (urls, type) => {
const fetchPromises = urls.map(url => {
if (resourceCache.has(url)) return Promise.resolve(resourceCache.get(url));
return fetchWithTimeout(url)
.then(response => response.text())
.then(text => {
const minified = type === 'css' && CONFIG.OPTIMIZE_INLINE_CSS
? minifyCSS(text)
: type === 'js' && CONFIG.OPTIMIZE_INLINE_JS
? minifyJS(text)
: text;
const blob = new Blob([minified], { type: type === 'css' ? 'text/css' : 'application/javascript' });
const blobUrl = URL.createObjectURL(blob);
resourceCache.set(url, { blobUrl, timestamp: Date.now() });
return { blobUrl, type };
})
.catch(error => {
console.warn(`Failed to fetch ${url}:`, error);
return null;
});
}).filter(Boolean);
const results = await Promise.all(fetchPromises.slice(0, CONFIG.PARALLEL_FETCH_LIMIT));
results.forEach(result => {
if (!result) return;
const element = document.createElement(result.type === 'css' ? 'link' : 'script');
element[result.type === 'css' ? 'href' : 'src'] = result.blobUrl;
if (result.type === 'css') element.rel = 'stylesheet';
else element.defer = true;
(document.head || document.documentElement).appendChild(element);
});
};
const cleanupCache = () => {
const now = Date.now();
for (const [url, { timestamp }] of resourceCache) {
if (now - timestamp > CONFIG.CACHE_TTL) {
resourceCache.delete(url);
}
}
};
// Video Buffering Optimization
const optimizeVideoBuffering = () => {
const videos = document.querySelectorAll('video');
videos.forEach(video => {
if (video.buffered.length > 0) return;
video.preload = 'auto';
video.addEventListener('canplay', () => {
const range = video.buffered;
if (range.length > 0 && video.currentTime + CONFIG.VIDEO_BUFFER_AHEAD > range.end(range.length - 1)) {
video.currentTime = range.end(range.length - 1); // Pre-buffer next segment
}
});
});
const observer = new MutationObserver(mutations => {
mutations.forEach(mutation => {
mutation.addedNodes.forEach(node => {
if (node.nodeName === 'VIDEO') {
node.preload = 'auto';
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
};
// Node Processing
const observer = new MutationObserver(mutations => {
for (const mutation of mutations) {
for (const node of mutation.addedNodes) {
if (node.nodeType !== 1) continue;
const elements = [node, ...node.querySelectorAll?.('script, link, style, iframe') || []];
for (const el of elements) {
if (!processedNodes.has(el)) {
processNode(el);
processedNodes.add(el);
}
}
}
}
});
function processNode(node) {
const tagName = node.tagName.toUpperCase();
let src = node.src || node.href;
if (isBlocked(src)) {
if (tagName === 'SCRIPT' || tagName === 'IFRAME') {
node.type = 'javascript/blocked';
node.src = 'about:blank';
} else {
node.remove();
}
return;
}
switch (tagName) {
case 'LINK':
if (CONFIG.PREVENT_PREFETCH && (node.rel === 'prefetch' || node.rel === 'preload')) {
node.remove();
}
if (isFontRequest(node.href)) {
node.remove();
}
break;
case 'STYLE':
if (CONFIG.OPTIMIZE_INLINE_CSS && node.textContent && node.textContent.length < 15000) {
node.textContent = minifyCSS(node.textContent);
}
break;
case 'SCRIPT':
if (CONFIG.OPTIMIZE_INLINE_JS && node.textContent && node.textContent.length < 15000) {
node.textContent = minifyJS(node.textContent);
}
break;
}
}
// YouTube Download Button
const addYouTubeDownloadButton = () => {
if (!CONFIG.ENABLE_YOUTUBE_TOOLS || !currentHost.includes('youtube.com')) return;
const runYouTubeTools = () => {
if (!document.getElementById('ai-yt-dl-btn')) {
const controls = document.querySelector('.ytp-right-controls');
if (controls) {
const btn = document.createElement('button');
btn.id = 'ai-yt-dl-btn';
btn.className = 'ytp-button';
btn.title = 'Download Video';
btn.innerHTML = '<svg height="100%" viewBox="0 0 36 36" width="100%"><path d="M17 18v1H6v-1h11zm-.5-6.6-.7-.7-3.8 3.7V4h-1v10.4l-3.8-3.8-.7.7 5 5 5-4.9z" fill="#fff"></path></svg>';
btn.onclick = () => window.open(`https://yt1s.com/?q=${encodeURIComponent(window.location.href)}`, '_blank');
controls.insertBefore(btn, controls.firstChild);
}
}
};
runYouTubeTools();
new MutationObserver(runYouTubeTools).observe(document.querySelector('title'), { childList: true });
};
// Network Optimizations
const monitorNetwork = async () => {
while (true) {
try {
await fetchWithTimeout('https://www.google.com/generate_204', { method: 'GET', mode: 'no-cors' });
console.log('Network stable.');
} catch (error) {
console.warn('Network issue detected. Attempting reconnection...');
await reconnectNetwork();
}
await new Promise(resolve => setTimeout(resolve, 5000));
}
};
const reconnectNetwork = async () => {
try {
await Promise.all([
fetchWithTimeout('https://1.1.1.1/generate_204', { method: 'GET', mode: 'no-cors' }),
fetchWithTimeout('https://8.8.8.8/generate_204', { method: 'GET', mode: 'no-cors' })
]);
console.log('DNS cache refreshed.');
} catch (error) {
console.warn('DNS refresh failed:', error);
}
};
// Smart Site Detection
const detectSiteType = () => {
const scripts = Array.from(document.querySelectorAll('script[src]')).map(s => s.src.toLowerCase());
if (scripts.some(src => src.includes('react'))) return 'react';
if (scripts.some(src => src.includes('angular'))) return 'angular';
if (document.querySelector('meta[name="cloudflare"]')) return 'cloudflare';
return 'generic';
};
const optimizeForSiteType = (siteType) => {
switch (siteType) {
case 'react':
CONFIG.PARALLEL_FETCH_LIMIT = Math.min(CONFIG.PARALLEL_FETCH_LIMIT + 2, 10); // More parallel fetches for SPA
break;
case 'angular':
CONFIG.REQUEST_TIMEOUT += 200; // Slightly longer timeout for Angular
break;
case 'cloudflare':
CONFIG.ALLOW_LIST.push('cloudflareinsights'); // Ensure Cloudflare scripts are allowed
break;
}
};
// Initialization
const init = async () => {
await estimateNetworkSpeed();
setupPreconnections();
observer.observe(document.documentElement, { childList: true, subtree: true });
monitorNetwork();
cleanupCache();
optimizeVideoBuffering();
const siteType = detectSiteType();
optimizeForSiteType(siteType);
const criticalResources = Array.from(document.querySelectorAll('link[rel="stylesheet"], script[src]'))
.map(el => el.href || el.src)
.filter(url => isInternalOrTrusted(url) && !isBlocked(url));
await fetchResourcesParallel(criticalResources.filter(url => url.endsWith('.css')), 'css');
await fetchResourcesParallel(criticalResources.filter(url => url.endsWith('.js')), 'js');
const onDOMContentLoaded = () => {
setTimeout(() => observer.disconnect(), 5000);
if (CONFIG.REMOVE_NON_ESSENTIAL_ELEMENTS) {
CONFIG.NON_ESSENTIAL_SELECTORS.forEach(selector => {
document.querySelectorAll(selector).forEach(el => el.remove());
});
}
addYouTubeDownloadButton();
};
if (document.readyState === 'interactive' || document.readyState === 'complete') {
onDOMContentLoaded();
} else {
document.addEventListener('DOMContentLoaded', onDOMContentLoaded, { once: true });
}
console.log('Ultimate Web Performance (v9.0 - HyperSpeed Edition) is active.');
};
init();
})();
