scriptlets.js

'use strict';

/// remove-dom-node.js
/// alias rdn.js
/// world ISOLATED
/// dependency run-at.fn
/// dependency safe-self.fn
//  example.com##+js(rdn, .ads, /text/)
function removeDOMElement(
    selector = '',
	string = '',
	...varargs
) {
    const safe = safeSelf();
    const logPrefix = safe.makeLogPrefix('removeDOMNode', ...Array.from(arguments), ...varargs);
	const extraArgs = safe.parseVarargs(varargs);
	const pattern = safe.patternToRegex(string);
	if ( selector === '' ) { return; }
	if ( string === '' ) { string === '/.+/' }
	const stop = (takeRecord = true) => {
        if ( takeRecord ) {
            handleMutations(observer.takeRecords());
        }
        observer.disconnect();
        if ( safe.logLevel > 1 ) {
            safe.uboLog(logPrefix, 'Quitting');
        }
    };
    let sedCount = extraArgs.sedCount || 0;
    const handleNode = node => { 
		const nodes = document.querySelectorAll(selector);
		for ( const elem of nodes ) {
				  if ( pattern.test(elem.outerHTML) ) {
				       elem.outerHTML= '';
				  }
		}	
		safe.uboLog(logPrefix, `${selector} node with matching ${string} string removed from the DOM`);
		return sedCount === 0 || (sedCount -= 1) !== 0;
    };
    const handleMutations = mutations => {
        for ( const mutation of mutations ) {
            for ( const node of mutation.addedNodes ) {
                if ( handleNode(node) ) { continue; }
                stop(false); return;
            }
        }
    };
    const observer = new MutationObserver(handleMutations);
    observer.observe(document, { childList: true, subtree: true });
    if ( document.documentElement ) {
        const treeWalker = document.createTreeWalker(
            document.documentElement,
            NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT
        );
        let count = 0;
        for (;;) {
            const node = treeWalker.nextNode();
            count += 1;
            if ( node === null ) { break; }
            if ( handleNode(node) ) { continue; }
            stop(); break;
        }
        safe.uboLog(logPrefix, `${count} nodes present before installing mutation observer`);
    }
	if ( extraArgs.loop ) { return; }
    runAt(( ) => {
        const quit = extraArgs.quit || 0;
        if ( quit !== 0 ) {
            setTimeout(( ) => { stop(); }, quit);
        } else {
            stop();
        }
    }, 'interactive');
}

/// remove-style-property.js
/// alias rsp.js
/// world ISOLATED
/// dependency run-at.fn
/// dependency safe-self.fn
//  example.com##+js(rsp, [selector], /prop/)
function removeStyleProperty(
    selector = '',
	property = '',
	...varargs
) {
    if ( property === '' || selector === '' ) { return; }
	const safe = safeSelf();
    const logPrefix = safe.makeLogPrefix('removeStyleProperty', ...Array.from(arguments), ...varargs);
	const extraArgs = safe.parseVarargs(varargs);
	const prop = safe.patternToRegex(property);
	const stop = (takeRecord = true) => {
	        if ( takeRecord ) {
	            handleMutations(observer.takeRecords());
	        }
	        observer.disconnect();
	        if ( safe.logLevel > 1 ) {
	            safe.uboLog(logPrefix, 'Quitting');
	        }
	    };
	    let sedCount = extraArgs.sedCount || 0;
	    const handleNode = node => { 
			const nodes = document.querySelectorAll(selector);
			try { 
			for ( const elem of nodes ) {
					   if ( elem ) {
						    const value = elem.getAttribute('style').replace(prop, '');
						    elem.setAttribute('style', value);
					   }
			}
			} catch { }
			safe.uboLog(logPrefix, `style ${prop} property present in ${selector} removed from the DOM`);
			return sedCount === 0 || (sedCount -= 1) !== 0;
	    };
	    const handleMutations = mutations => {
	        for ( const mutation of mutations ) {
	            for ( const node of mutation.addedNodes ) {
	                if ( handleNode(node) ) { continue; }
	                stop(false); return;
	            }
	        }
	    };
	    const observer = new MutationObserver(handleMutations);
	    observer.observe(document, { 
			childList: true, 
			subtree: true, 
			attributes: true, 
			attributeFilter: ['style'] 
		});
	    if ( document.documentElement ) {
	        const treeWalker = document.createTreeWalker(
	            document.documentElement,
	            NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT
	        );
	        let count = 0;
	        for (;;) {
	            const node = treeWalker.nextNode();
	            count += 1;
	            if ( node === null ) { break; }
	            if ( handleNode(node) ) { continue; }
	            stop(); break;
	        }
	        safe.uboLog(logPrefix, `${count} nodes present before installing mutation observer`);
	    }
		  if ( extraArgs.loop ) { return; }
	    runAt(( ) => {
	        const quit = extraArgs.quit || 0;
	        if ( quit !== 0 ) {
	            setTimeout(( ) => { stop(); }, quit);
	        } else {
	            stop();
	        }
	    }, 'interactive');
}

/// insertClass.js
/// alias isc.js
/// world ISOLATED
/// dependency run-at.fn
/// dependency safe-self.fn
//  example.com##+js(isc, class, [selector])
function insertClass(
    needle = '',
	selector = '',
	...varargs
) {
    const safe = safeSelf();
    const logPrefix = safe.makeLogPrefix('insertClass', ...Array.from(arguments));
	const extraArgs = safe.parseVarargs(varargs);
	if ( needle === '' ) { return; }
	const needles = needle.split(/\s*\|\s*/);
	if ( selector === '' ) { selector = '.' + needles.map(a => CSS.escape(a)).join(',.'); }
	const stop = (takeRecord = true) => {
        if ( takeRecord ) {
            handleMutations(observer.takeRecords());
        }
        observer.disconnect();
        if ( safe.logLevel > 1 ) {
            safe.uboLog(logPrefix, 'Quitting');
        }
    };
    let sedCount = extraArgs.sedCount || 0;
    const handleNode = node => { 
		const nodes = document.querySelectorAll(selector);
		try {
			for ( const elem of nodes ) {
			      if ( !elem.classList.contains(...needles) ) { 
			           elem.classList.add(...needles);
			      }	
			}
		} catch { }	
		safe.uboLog(logPrefix, `${needles} added to the ${selector} in the DOM`);
		return sedCount === 0 || (sedCount -= 1) !== 0;
    };
    const handleMutations = mutations => {
        for ( const mutation of mutations ) {
            for ( const node of mutation.addedNodes ) {
                if ( handleNode(node) ) { continue; }
                stop(false); return;
            }
        }
    };
    const observer = new MutationObserver(handleMutations);
    observer.observe(document, { childList: true, subtree: true });
    if ( document.documentElement ) {
        const treeWalker = document.createTreeWalker(
            document.documentElement,
            NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT
        );
        let count = 0;
        for (;;) {
            const node = treeWalker.nextNode();
            count += 1;
            if ( node === null ) { break; }
            if ( handleNode(node) ) { continue; }
            stop(); break;
        }
        safe.uboLog(logPrefix, `${count} nodes present before installing mutation observer`);
    }
	if ( extraArgs.loop ) { return; }
    runAt(( ) => {
        const quit = extraArgs.quit || 0;
        if ( quit !== 0 ) {
            setTimeout(( ) => { stop(); }, quit);
        } else {
            stop();
        }
    }, 'interactive');
}

/// replace-class.js
/// alias rpc.js
/// world ISOLATED
/// dependency run-at.fn
// example.com##+js(rpc, [selector], oldclass, newclass)
function replaceClass(
	selector = '',
	oldclass = '',
	newclass = ''
) {
	if ( selector === '' || oldclass === '' || newclass === '' ) { return; }
	const replaceclass = ( ) => {
	  const nodes = document.querySelectorAll(selector);
	  try {
		for ( const node of nodes ) {
		      if ( node.classList.contains(oldclass) ) {	
			   node.classList.replace(oldclass, newclass);
		      }	      
		}
	  } catch { }
	};
	let observer, timer;
    	const onDomChanged = mutations => {
        if ( timer !== undefined ) { return; }
        let shouldWork = false;
        for ( const mutation of mutations ) {
            if ( mutation.addedNodes.length === 0 ) { continue; }
            for ( const node of mutation.addedNodes ) {
                if ( node.nodeType !== 1 ) { continue; }
                shouldWork = true;
                break;
            }
            if ( shouldWork ) { break; }
        }
        if ( shouldWork === false ) { return; }
        timer = self.requestAnimationFrame(( ) => {
            timer = undefined;
            replaceclass();
        });
        };
        const start = ( ) => {
        if ( replaceclass() === false ) { return; }
        observer = new MutationObserver(onDomChanged);
        observer.observe(document.body, {
            subtree: true,
            childList: true,
        });
        };
        runAt(( ) => { start(); }, 'interactive');
}

/// append-elem.js
/// alias ape.js
/// dependency run-at.fn
/// world ISOLATED
// example.com##+js(ape, [selector], element, attribute, value)
function appendElem(
	selector = '',
	elem = '',
	attr = '',
	value = '' 
) {
	if ( selector === '' ) { return; }
	const appendNode = ( ) => {
		try {
			const elements = document.querySelectorAll(selector);
			for ( const element of elements ) {
			      const node = document.createElement(elem);
			      node.setAttribute(attr, value);
			      element.append(node);
			}
		} catch { }
	};
	runAt(( ) => { appendNode(); }, 'interactive');
}

/// callfunction.js
/// alias cf.js
/// dependency run-at.fn
// example.com##+js(cf, funcName)
function callFunction(
	funcCall = ''
) {
	      if ( funcCall === '' ) { return; }
	      const funcInvoke = ( ) => { 
			try { 
				self.requestAnimationFrame(funcCall)
			} catch { }
	      };	      
	      runAt(( ) => { funcInvoke(); }, 'idle');
}

/// insert-child-before.js
/// alias icb.js
/// world ISOLATED
/// dependency run-at.fn
// example.com##+js(icb, element, node)
function insertChildBefore( 
	selector = '',
	element = '',
	run = '' 
) {
	if ( selector === '' || element === '' ) { return; }
	let timer;
	const insertelem = () => {
		timer = undefined;
		try {
			const elems = document.querySelectorAll(selector);
			const nodes = document.querySelectorAll(element);
			for (let i = 0; i < elems.length; i++) {
			    elems[i].before(nodes[i]);
			}	
		} catch { }
	};
	const mutationHandler = mutations => {
		if ( timer !== undefined ) { return; }
		let skip = true;
		for ( let i = 0; i < mutations.length && skip; i++ ) {
		    const { type, addedNodes, removedNodes } = mutations[i];
		    if ( type === 'attributes' ) { skip = false; }
		    for ( let j = 0; j < addedNodes.length && skip; j++ ) {
			if ( addedNodes[j].nodeType === 1 ) { skip = false; break; }
		    }
		    for ( let j = 0; j < removedNodes.length && skip; j++ ) {
			if ( removedNodes[j].nodeType === 1 ) { skip = false; break; }
		    }
		}
		if ( skip ) { return; }
		timer = self.requestAnimationFrame(insertelem);
	};
	const start = ( ) => {
		insertelem();
		if ( /\bloop\b/.test(run) === false ) { return; }
		const observer = new MutationObserver(mutationHandler);
		observer.observe(document.documentElement, {
		    childList: true,
		    subtree: true,
		});
	};
	runAt(( ) => { start(); }, /\bcomplete\b/.test(run) ? 'idle' : 'interactive');
}

/// insert-child-after.js
/// alias ica.js
/// world ISOLATED
/// dependency run-at.fn
// example.com##+js(ica, element, node)
function insertChildAfter( 
	selector = '',
	element = '',
	run = '' 
) {
	if ( selector === '' || element === '' ) { return; }
	let timer;
	const insertelem = () => {
		timer = undefined;
		try {
			const elems = document.querySelectorAll(selector);
			const nodes = document.querySelectorAll(element);
			for (let i = 0; i < elems.length; i++) {
			    elems[i].after(nodes[i]);
			}	
		} catch { }
	};
	const mutationHandler = mutations => {
		if ( timer !== undefined ) { return; }
		let skip = true;
		for ( let i = 0; i < mutations.length && skip; i++ ) {
		    const { type, addedNodes, removedNodes } = mutations[i];
		    if ( type === 'attributes' ) { skip = false; }
		    for ( let j = 0; j < addedNodes.length && skip; j++ ) {
			if ( addedNodes[j].nodeType === 1 ) { skip = false; break; }
		    }
		    for ( let j = 0; j < removedNodes.length && skip; j++ ) {
			if ( removedNodes[j].nodeType === 1 ) { skip = false; break; }
		    }
		}
		if ( skip ) { return; }
		timer = self.requestAnimationFrame(insertelem);
	};
	const start = ( ) => {
		insertelem();
		if ( /\bloop\b/.test(run) === false ) { return; }
		const observer = new MutationObserver(mutationHandler);
		observer.observe(document.documentElement, {
		    childList: true,
		    subtree: true,
		});
	};
	runAt(( ) => { start(); }, /\bcomplete\b/.test(run) ? 'idle' : 'interactive');
}