diff options
Diffstat (limited to 'data/extensions/uBlock0@raymondhill.net/js/cosmetic-filtering.js')
| -rw-r--r-- | data/extensions/uBlock0@raymondhill.net/js/cosmetic-filtering.js | 945 |
1 files changed, 945 insertions, 0 deletions
diff --git a/data/extensions/uBlock0@raymondhill.net/js/cosmetic-filtering.js b/data/extensions/uBlock0@raymondhill.net/js/cosmetic-filtering.js new file mode 100644 index 0000000..7cb520a --- /dev/null +++ b/data/extensions/uBlock0@raymondhill.net/js/cosmetic-filtering.js @@ -0,0 +1,945 @@ +/******************************************************************************* + + uBlock Origin - a comprehensive, efficient content blocker + Copyright (C) 2014-present Raymond Hill + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see {http://www.gnu.org/licenses/}. + + Home: https://github.com/gorhill/uBlock +*/ + +/******************************************************************************/ + +import { MRUCache } from './mrucache.js'; +import { StaticExtFilteringHostnameDB } from './static-ext-filtering-db.js'; +import { entityFromHostname } from './uri-utils.js'; +import logger from './logger.js'; +import µb from './background.js'; + +/******************************************************************************/ +/******************************************************************************/ + +const SelectorCacheEntry = class { + constructor() { + this.reset(); + } + + reset() { + this.cosmetic = new Set(); + this.cosmeticHashes = new Set(); + this.disableSurveyor = false; + this.net = new Map(); + this.accessId = SelectorCacheEntry.accessId++; + return this; + } + + dispose() { + this.cosmetic = this.cosmeticHashes = this.net = null; + if ( SelectorCacheEntry.junkyard.length < 25 ) { + SelectorCacheEntry.junkyard.push(this); + } + } + + addCosmetic(details) { + const selectors = details.selectors.join(',\n'); + if ( selectors.length !== 0 ) { + this.cosmetic.add(selectors); + } + for ( const hash of details.hashes ) { + this.cosmeticHashes.add(hash); + } + } + + addNet(selectors) { + if ( typeof selectors === 'string' ) { + this.net.set(selectors, this.accessId); + } else { + this.net.set(selectors.join(',\n'), this.accessId); + } + // Net request-derived selectors: I limit the number of cached + // selectors, as I expect cases where the blocked network requests + // are never the exact same URL. + if ( this.net.size < SelectorCacheEntry.netHighWaterMark ) { return; } + const keys = Array.from(this.net) + .sort((a, b) => b[1] - a[1]) + .slice(SelectorCacheEntry.netLowWaterMark) + .map(a => a[0]); + for ( const key of keys ) { + this.net.delete(key); + } + } + + addNetOne(selector, token) { + this.net.set(selector, token); + } + + add(details) { + this.accessId = SelectorCacheEntry.accessId++; + if ( details.type === 'cosmetic' ) { + this.addCosmetic(details); + } else { + this.addNet(details.selectors); + } + } + + // https://github.com/chrisaljoudi/uBlock/issues/420 + remove(type) { + this.accessId = SelectorCacheEntry.accessId++; + if ( type === undefined || type === 'cosmetic' ) { + this.cosmetic.clear(); + } + if ( type === undefined || type === 'net' ) { + this.net.clear(); + } + } + + retrieveToArray(iterator, out) { + for ( const selector of iterator ) { + out.push(selector); + } + } + + retrieveToSet(iterator, out) { + for ( const selector of iterator ) { + out.add(selector); + } + } + + retrieveNet(out) { + this.accessId = SelectorCacheEntry.accessId++; + if ( this.net.size === 0 ) { return false; } + this.retrieveToArray(this.net.keys(), out); + return true; + } + + retrieveCosmetic(selectors, hashes) { + this.accessId = SelectorCacheEntry.accessId++; + if ( this.cosmetic.size === 0 ) { return false; } + this.retrieveToSet(this.cosmetic, selectors); + this.retrieveToArray(this.cosmeticHashes, hashes); + return true; + } + + static factory() { + const entry = SelectorCacheEntry.junkyard.pop(); + return entry + ? entry.reset() + : new SelectorCacheEntry(); + } +}; + +SelectorCacheEntry.accessId = 1; +SelectorCacheEntry.netLowWaterMark = 20; +SelectorCacheEntry.netHighWaterMark = 30; +SelectorCacheEntry.junkyard = []; + +/******************************************************************************/ +/******************************************************************************/ + +// http://www.cse.yorku.ca/~oz/hash.html#djb2 +// Must mirror content script surveyor's version + +const hashFromStr = (type, s) => { + const len = s.length; + const step = len + 7 >>> 3; + let hash = (type << 5) + type ^ len; + for ( let i = 0; i < len; i += step ) { + hash = (hash << 5) + hash ^ s.charCodeAt(i); + } + return hash & 0xFFFFFF; +}; + +// https://github.com/gorhill/uBlock/issues/1668 +// The key must be literal: unescape escaped CSS before extracting key. +// It's an uncommon case, so it's best to unescape only when needed. + +const keyFromSelector = selector => { + let matches = reSimplestSelector.exec(selector); + if ( matches !== null ) { return matches[0]; } + let key = ''; + matches = rePlainSelector.exec(selector); + if ( matches !== null ) { + key = matches[0]; + } else { + matches = rePlainSelectorEx.exec(selector); + if ( matches === null ) { return; } + key = matches[1] || matches[2]; + } + if ( selector.includes(',') ) { return; } + if ( key.includes('\\') === false ) { return key; } + matches = rePlainSelectorEscaped.exec(selector); + if ( matches === null ) { return; } + key = ''; + const escaped = matches[0]; + let beg = 0; + reEscapeSequence.lastIndex = 0; + for (;;) { + matches = reEscapeSequence.exec(escaped); + if ( matches === null ) { + return key + escaped.slice(beg); + } + key += escaped.slice(beg, matches.index); + beg = reEscapeSequence.lastIndex; + if ( matches[1].length === 1 ) { + key += matches[1]; + } else { + key += String.fromCharCode(parseInt(matches[1], 16)); + } + } +}; + +const reSimplestSelector = /^[#.][\w-]+$/; +const rePlainSelector = /^[#.][\w\\-]+/; +const rePlainSelectorEx = /^[^#.[(]+([#.][\w-]+)|([#.][\w-]+)$/; +const rePlainSelectorEscaped = /^[#.](?:\\[0-9A-Fa-f]+ |\\.|\w|-)+/; +const reEscapeSequence = /\\([0-9A-Fa-f]+ |.)/g; + +/******************************************************************************/ +/******************************************************************************/ + +// Cosmetic filter family tree: +// +// Generic +// Low generic simple: class or id only +// Low generic complex: class or id + extra stuff after +// High generic: +// High-low generic: [alt="..."],[title="..."] +// High-medium generic: [href^="..."] +// High-high generic: everything else +// Specific +// Specific hostname +// Specific entity +// Generic filters can only be enforced once the main document is loaded. +// Specific filers can be enforced before the main document is loaded. + +const CosmeticFilteringEngine = function() { + this.reSimpleHighGeneric = /^(?:[a-z]*\[[^\]]+\]|\S+)$/; + + this.selectorCache = new Map(); + this.selectorCachePruneDelay = 10; // 10 minutes + this.selectorCacheCountMin = 40; + this.selectorCacheCountMax = 50; + this.selectorCacheTimer = vAPI.defer.create(( ) => { + this.pruneSelectorCacheAsync(); + }); + + // specific filters + this.specificFilters = new StaticExtFilteringHostnameDB(); + + // low generic cosmetic filters: map of hash => stringified selector list + this.lowlyGeneric = new Map(); + + // highly generic selectors sets + this.highlyGeneric = Object.create(null); + this.highlyGeneric.simple = { + canonical: 'highGenericHideSimple', + dict: new Set(), + str: '', + mru: new MRUCache(16) + }; + this.highlyGeneric.complex = { + canonical: 'highGenericHideComplex', + dict: new Set(), + str: '', + mru: new MRUCache(16) + }; + this.reset(); +}; + +/******************************************************************************/ + +// Reset all, thus reducing to a minimum memory footprint of the context. + +CosmeticFilteringEngine.prototype.reset = function() { + this.frozen = false; + this.acceptedCount = 0; + this.discardedCount = 0; + this.duplicateBuster = new Set(); + + this.selectorCache.clear(); + this.selectorCacheTimer.off(); + + // hostname, entity-based filters + this.specificFilters.clear(); + + // low generic cosmetic filters + this.lowlyGeneric.clear(); + + // highly generic selectors sets + this.highlyGeneric.simple.dict.clear(); + this.highlyGeneric.simple.str = ''; + this.highlyGeneric.simple.mru.reset(); + this.highlyGeneric.complex.dict.clear(); + this.highlyGeneric.complex.str = ''; + this.highlyGeneric.complex.mru.reset(); + + this.selfieVersion = 2; +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.freeze = function() { + this.duplicateBuster.clear(); + this.specificFilters.collectGarbage(); + + this.highlyGeneric.simple.str = Array.from(this.highlyGeneric.simple.dict).join(',\n'); + this.highlyGeneric.simple.mru.reset(); + this.highlyGeneric.complex.str = Array.from(this.highlyGeneric.complex.dict).join(',\n'); + this.highlyGeneric.complex.mru.reset(); + + this.frozen = true; +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.compile = function(parser, writer) { + if ( parser.hasOptions() === false ) { + this.compileGenericSelector(parser, writer); + return true; + } + + // https://github.com/chrisaljoudi/uBlock/issues/151 + // Negated hostname means the filter applies to all non-negated hostnames + // of same filter OR globally if there is no non-negated hostnames. + let applyGlobally = true; + for ( const { hn, not, bad } of parser.getExtFilterDomainIterator() ) { + if ( bad ) { continue; } + if ( not === false ) { + applyGlobally = false; + } + this.compileSpecificSelector(parser, hn, not, writer); + } + if ( applyGlobally ) { + this.compileGenericSelector(parser, writer); + } + + return true; +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.compileGenericSelector = function(parser, writer) { + if ( parser.isException() ) { + this.compileGenericUnhideSelector(parser, writer); + } else { + this.compileGenericHideSelector(parser, writer); + } +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.compileGenericHideSelector = function( + parser, + writer +) { + const { raw, compiled } = parser.result; + if ( compiled === undefined ) { + const who = writer.properties.get('name') || '?'; + logger.writeOne({ + realm: 'message', + type: 'error', + text: `Invalid generic cosmetic filter in ${who}: ${raw}` + }); + return; + } + + writer.select('COSMETIC_FILTERS:GENERIC'); + + // https://github.com/uBlockOrigin/uBlock-issues/issues/131 + // Support generic procedural filters as per advanced settings. + if ( compiled.charCodeAt(0) === 0x7B /* '{' */ ) { + if ( µb.hiddenSettings.allowGenericProceduralFilters === true ) { + return this.compileSpecificSelector(parser, '', false, writer); + } + const who = writer.properties.get('name') || '?'; + logger.writeOne({ + realm: 'message', + type: 'error', + text: `Invalid generic cosmetic filter in ${who}: ##${raw}` + }); + return; + } + + const key = keyFromSelector(compiled); + if ( key !== undefined ) { + writer.push([ + 0, + hashFromStr(key.charCodeAt(0), key.slice(1)), + compiled, + ]); + return; + } + + // Pass this point, we are dealing with highly-generic cosmetic filters. + // + // For efficiency purpose, we will distinguish between simple and complex + // selectors. + + if ( this.reSimpleHighGeneric.test(compiled) ) { + writer.push([ 4 /* simple */, compiled ]); + } else { + writer.push([ 5 /* complex */, compiled ]); + } +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.compileGenericUnhideSelector = function( + parser, + writer +) { + // Procedural cosmetic filters are acceptable as generic exception filters. + const { raw, compiled } = parser.result; + if ( compiled === undefined ) { + const who = writer.properties.get('name') || '?'; + logger.writeOne({ + realm: 'message', + type: 'error', + text: `Invalid cosmetic filter in ${who}: #@#${raw}` + }); + return; + } + + writer.select('COSMETIC_FILTERS:SPECIFIC'); + + // https://github.com/chrisaljoudi/uBlock/issues/497 + // All generic exception filters are stored as hostname-based filter + // whereas the hostname is the empty string (which matches all + // hostnames). No distinction is made between declarative and + // procedural selectors, since they really exist only to cancel + // out other cosmetic filters. + writer.push([ 8, '', `-${compiled}` ]); +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.compileSpecificSelector = function( + parser, + hostname, + not, + writer +) { + const { raw, compiled, exception } = parser.result; + if ( compiled === undefined ) { + const who = writer.properties.get('name') || '?'; + logger.writeOne({ + realm: 'message', + type: 'error', + text: `Invalid cosmetic filter in ${who}: ##${raw}` + }); + return; + } + + writer.select('COSMETIC_FILTERS:SPECIFIC'); + const prefix = ((exception ? 1 : 0) ^ (not ? 1 : 0)) ? '-' : '+'; + writer.push([ 8, hostname, `${prefix}${compiled}` ]); +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.fromCompiledContent = function(reader, options) { + if ( options.skipCosmetic ) { + this.skipCompiledContent(reader, 'SPECIFIC'); + this.skipCompiledContent(reader, 'GENERIC'); + return; + } + + // Specific cosmetic filter section + reader.select('COSMETIC_FILTERS:SPECIFIC'); + while ( reader.next() ) { + this.acceptedCount += 1; + const fingerprint = reader.fingerprint(); + if ( this.duplicateBuster.has(fingerprint) ) { + this.discardedCount += 1; + continue; + } + this.duplicateBuster.add(fingerprint); + const args = reader.args(); + switch ( args[0] ) { + // hash, example.com, .promoted-tweet + // hash, example.*, .promoted-tweet + // + // https://github.com/uBlockOrigin/uBlock-issues/issues/803 + // Handle specific filters meant to apply everywhere, i.e. selectors + // not to be injected conditionally through the DOM surveyor. + // hash, *, .promoted-tweet + case 8: { + if ( args[1] === '*' && args[2].charCodeAt(0) === 0x2D /* + */ ) { + const selector = args[2].slice(1); + if ( selector.charCodeAt(0) !== 0x7B /* { */ ) { + if ( this.reSimpleHighGeneric.test(selector) ) { + this.highlyGeneric.simple.dict.add(selector); + } else { + this.highlyGeneric.complex.dict.add(selector); + } + break; + } + } + this.specificFilters.store(args[1], args[2]); + break; + } + default: + this.discardedCount += 1; + break; + } + } + + if ( options.skipGenericCosmetic ) { + this.skipCompiledContent(reader, 'GENERIC'); + return; + } + + // Generic cosmetic filter section + reader.select('COSMETIC_FILTERS:GENERIC'); + while ( reader.next() ) { + this.acceptedCount += 1; + const fingerprint = reader.fingerprint(); + if ( this.duplicateBuster.has(fingerprint) ) { + this.discardedCount += 1; + continue; + } + this.duplicateBuster.add(fingerprint); + const args = reader.args(); + switch ( args[0] ) { + // low generic + case 0: { + if ( this.lowlyGeneric.has(args[1]) ) { + const selector = this.lowlyGeneric.get(args[1]); + this.lowlyGeneric.set(args[1], `${selector},\n${args[2]}`); + } else { + this.lowlyGeneric.set(args[1], args[2]); + } + break; + } + // High-high generic hide/simple selectors + // div[id^="allo"] + case 4: + this.highlyGeneric.simple.dict.add(args[1]); + break; + // High-high generic hide/complex selectors + // div[id^="allo"] > span + case 5: + this.highlyGeneric.complex.dict.add(args[1]); + break; + default: + this.discardedCount += 1; + break; + } + } +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.skipCompiledContent = function(reader, sectionId) { + reader.select(`COSMETIC_FILTERS:${sectionId}`); + while ( reader.next() ) { + this.acceptedCount += 1; + this.discardedCount += 1; + } +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.toSelfie = function() { + return { + version: this.selfieVersion, + acceptedCount: this.acceptedCount, + discardedCount: this.discardedCount, + specificFilters: this.specificFilters.toSelfie(), + lowlyGeneric: this.lowlyGeneric, + highSimpleGenericHideDict: this.highlyGeneric.simple.dict, + highSimpleGenericHideStr: this.highlyGeneric.simple.str, + highComplexGenericHideDict: this.highlyGeneric.complex.dict, + highComplexGenericHideStr: this.highlyGeneric.complex.str, + }; +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.fromSelfie = function(selfie) { + if ( selfie.version !== this.selfieVersion ) { + throw new TypeError('Bad selfie'); + } + this.acceptedCount = selfie.acceptedCount; + this.discardedCount = selfie.discardedCount; + this.specificFilters.fromSelfie(selfie.specificFilters); + this.lowlyGeneric = selfie.lowlyGeneric; + this.highlyGeneric.simple.dict = selfie.highSimpleGenericHideDict; + this.highlyGeneric.simple.str = selfie.highSimpleGenericHideStr; + this.highlyGeneric.complex.dict = selfie.highComplexGenericHideDict; + this.highlyGeneric.complex.str = selfie.highComplexGenericHideStr; + this.frozen = true; +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.addToSelectorCache = function(details) { + const hostname = details.hostname; + if ( typeof hostname !== 'string' || hostname === '' ) { return; } + const selectors = details.selectors; + if ( Array.isArray(selectors) === false ) { return; } + let entry = this.selectorCache.get(hostname); + if ( entry === undefined ) { + entry = SelectorCacheEntry.factory(); + this.selectorCache.set(hostname, entry); + if ( this.selectorCache.size > this.selectorCacheCountMax ) { + this.selectorCacheTimer.on({ min: this.selectorCachePruneDelay }); + } + } + entry.add(details); +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.removeFromSelectorCache = function( + targetHostname = '*', + type = undefined +) { + const targetHostnameLength = targetHostname.length; + for ( const [ hostname, item ] of this.selectorCache ) { + if ( targetHostname !== '*' ) { + if ( hostname.endsWith(targetHostname) === false ) { continue; } + if ( hostname.length !== targetHostnameLength ) { + if ( hostname.at(-1) !== '.' ) { continue; } + } + } + item.remove(type); + } +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.pruneSelectorCacheAsync = function() { + if ( this.selectorCache.size <= this.selectorCacheCountMax ) { return; } + const cache = this.selectorCache; + const hostnames = Array.from(cache.keys()) + .sort((a, b) => cache.get(b).accessId - cache.get(a).accessId) + .slice(this.selectorCacheCountMin); + for ( const hn of hostnames ) { + cache.get(hn).dispose(); + cache.delete(hn); + } +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.disableSurveyor = function(details) { + const hostname = details.hostname; + if ( typeof hostname !== 'string' || hostname === '' ) { return; } + const cacheEntry = this.selectorCache.get(hostname); + if ( cacheEntry === undefined ) { return; } + cacheEntry.disableSurveyor = true; +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.cssRuleFromProcedural = function(pfilter) { + if ( pfilter.cssable !== true ) { return; } + const { tasks, action } = pfilter; + let mq, selector; + if ( Array.isArray(tasks) ) { + if ( tasks[0][0] !== 'matches-media' ) { return; } + mq = tasks[0][1]; + if ( tasks.length > 2 ) { return; } + if ( tasks.length === 2 ) { + if ( tasks[1][0] !== 'spath' ) { return; } + selector = tasks[1][1]; + } + } + let style; + if ( Array.isArray(action) ) { + if ( action[0] !== 'style' ) { return; } + selector = selector || pfilter.selector; + style = action[1]; + } + if ( mq === undefined && style === undefined && selector === undefined ) { return; } + if ( mq === undefined ) { + return `${selector}\n{${style}}`; + } + if ( style === undefined ) { + return `@media ${mq} {\n${selector}\n{display:none!important;}\n}`; + } + return `@media ${mq} {\n${selector}\n{${style}}\n}`; +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.retrieveGenericSelectors = function(request) { + if ( this.lowlyGeneric.size === 0 ) { return; } + if ( Array.isArray(request.hashes) === false ) { return; } + if ( request.hashes.length === 0 ) { return; } + + const selectorsSet = new Set(); + const hashes = []; + const safeOnly = request.safeOnly === true; + for ( const hash of request.hashes ) { + const bucket = this.lowlyGeneric.get(hash); + if ( bucket === undefined ) { continue; } + for ( const selector of bucket.split(',\n') ) { + if ( safeOnly && selector === keyFromSelector(selector) ) { continue; } + selectorsSet.add(selector); + } + hashes.push(hash); + } + + // Apply exceptions: it is the responsibility of the caller to provide + // the exceptions to be applied. + const excepted = []; + if ( selectorsSet.size !== 0 && Array.isArray(request.exceptions) ) { + for ( const exception of request.exceptions ) { + if ( selectorsSet.delete(exception) ) { + excepted.push(exception); + } + } + } + + if ( selectorsSet.size === 0 && excepted.length === 0 ) { return; } + + const out = { injectedCSS: '', excepted, }; + const selectors = Array.from(selectorsSet); + + if ( typeof request.hostname === 'string' && request.hostname !== '' ) { + this.addToSelectorCache({ + hostname: request.hostname, + selectors, + hashes, + type: 'cosmetic', + }); + } + + if ( selectors.length === 0 ) { return out; } + + out.injectedCSS = `${selectors.join(',\n')}\n{display:none!important;}`; + vAPI.tabs.insertCSS(request.tabId, { + code: out.injectedCSS, + frameId: request.frameId, + matchAboutBlank: true, + runAt: 'document_start', + }); + + return out; +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.retrieveSpecificSelectors = function( + request, + options +) { + const hostname = request.hostname; + const cacheEntry = this.selectorCache.get(hostname); + + // https://github.com/chrisaljoudi/uBlock/issues/587 + // out.ready will tell the content script the cosmetic filtering engine is + // up and ready. + + // https://github.com/chrisaljoudi/uBlock/issues/497 + // Generic exception filters are to be applied on all pages. + + const out = { + ready: this.frozen, + hostname: hostname, + domain: request.domain, + exceptionFilters: [], + exceptedFilters: [], + proceduralFilters: [], + convertedProceduralFilters: [], + disableSurveyor: this.lowlyGeneric.size === 0, + }; + const injectedCSS = []; + + if ( + options.noSpecificCosmeticFiltering !== true || + options.noGenericCosmeticFiltering !== true + ) { + // Cached cosmetic filters: these are always declarative. + const specificSet = new Set(); + if ( cacheEntry !== undefined ) { + cacheEntry.retrieveCosmetic(specificSet, out.genericCosmeticHashes = []); + if ( cacheEntry.disableSurveyor ) { + out.disableSurveyor = true; + } + } + + const allSet = new Set(); + // Retrieve filters with a non-empty hostname + this.specificFilters.retrieveSpecifics(allSet, hostname); + // Retrieve filters with a entity-based hostname value + const entity = entityFromHostname(hostname, request.domain); + this.specificFilters.retrieveSpecifics(allSet, entity); + // Retrieve filters with a regex-based hostname value + this.specificFilters.retrieveSpecificsByRegex(allSet, hostname, request.url); + // Retrieve filters with an empty hostname + this.specificFilters.retrieveGenerics(allSet); + + // Split filters in different groups + const proceduralSet = new Set(); + const exceptionSet = new Set(); + for ( const s of allSet ) { + const selector = s.slice(1); + if ( s.charCodeAt(0) === 0x2D /* - */ ) { + exceptionSet.add(selector); + } else if ( selector.charCodeAt(0) === 0x7B /* { */ ) { + proceduralSet.add(selector); + } else { + specificSet.add(selector); + } + } + + // Apply exceptions to specific filterset + if ( exceptionSet.size !== 0 ) { + out.exceptionFilters = Array.from(exceptionSet); + for ( const selector of specificSet ) { + if ( exceptionSet.has(selector) === false ) { continue; } + specificSet.delete(selector); + out.exceptedFilters.push(selector); + } + } + + if ( specificSet.size !== 0 ) { + injectedCSS.push( + `${Array.from(specificSet).join(',\n')}\n{display:none!important;}` + ); + } + + // Apply exceptions to procedural filterset. + // Also, some procedural filters are really declarative cosmetic + // filters, so we extract and inject them immediately. + if ( proceduralSet.size !== 0 ) { + for ( const json of proceduralSet ) { + if ( exceptionSet.has(json) ) { + proceduralSet.delete(json); + out.exceptedFilters.push(json); + continue; + } + const pfilter = JSON.parse(json); + if ( exceptionSet.has(pfilter.raw) ) { + proceduralSet.delete(json); + out.exceptedFilters.push(pfilter.raw); + continue; + } + const cssRule = this.cssRuleFromProcedural(pfilter); + if ( cssRule === undefined ) { continue; } + injectedCSS.push(cssRule); + proceduralSet.delete(json); + out.convertedProceduralFilters.push(json); + } + out.proceduralFilters.push(...proceduralSet); + } + + // Highly generic cosmetic filters: sent once along with specific ones. + // A most-recent-used cache is used to skip computing the resulting set + // of high generics for a given set of exceptions. + // The resulting set of high generics is stored as a string, ready to + // be used as-is by the content script. The string is stored + // indirectly in the mru cache: this is to prevent duplication of the + // string in memory, which I have observed occurs when the string is + // stored directly as a value in a Map. + if ( options.noGenericCosmeticFiltering !== true ) { + const exceptionSetHash = out.exceptionFilters.join(); + for ( const key in this.highlyGeneric ) { + const entry = this.highlyGeneric[key]; + let str = entry.mru.lookup(exceptionSetHash); + if ( str === undefined ) { + str = { s: entry.str, excepted: [] }; + let genericSet = entry.dict; + let hit = false; + for ( const exception of exceptionSet ) { + if ( (hit = genericSet.has(exception)) ) { break; } + } + if ( hit ) { + genericSet = new Set(entry.dict); + for ( const exception of exceptionSet ) { + if ( genericSet.delete(exception) ) { + str.excepted.push(exception); + } + } + str.s = Array.from(genericSet).join(',\n'); + } + entry.mru.add(exceptionSetHash, str); + } + if ( str.excepted.length !== 0 ) { + out.exceptedFilters.push(...str.excepted); + } + if ( str.s.length !== 0 ) { + injectedCSS.push(`${str.s}\n{display:none!important;}`); + } + } + } + } + + const details = { + code: '', + frameId: request.frameId, + matchAboutBlank: true, + runAt: 'document_start', + }; + + // Inject all declarative-based filters as a single stylesheet. + if ( injectedCSS.length !== 0 ) { + out.injectedCSS = injectedCSS.join('\n\n'); + details.code = out.injectedCSS; + if ( request.tabId !== undefined && options.dontInject !== true ) { + vAPI.tabs.insertCSS(request.tabId, details); + } + } + + // CSS selectors for collapsible blocked elements + if ( cacheEntry ) { + const networkFilters = []; + if ( cacheEntry.retrieveNet(networkFilters) ) { + details.code = `${networkFilters.join('\n')}\n{display:none!important;}`; + if ( request.tabId !== undefined && options.dontInject !== true ) { + vAPI.tabs.insertCSS(request.tabId, details); + } + } + } + + return out; +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.getFilterCount = function() { + return this.acceptedCount - this.discardedCount; +}; + +/******************************************************************************/ + +CosmeticFilteringEngine.prototype.dump = function() { + const lowlyGenerics = []; + for ( const selectors of this.lowlyGeneric.values() ) { + lowlyGenerics.push(...selectors.split(',\n')); + } + lowlyGenerics.sort(); + const highlyGenerics = Array.from(this.highlyGeneric.simple.dict).sort(); + highlyGenerics.push(...Array.from(this.highlyGeneric.complex.dict).sort()); + return [ + 'Cosmetic Filtering Engine internals:', + `specific: ${this.specificFilters.size}`, + `generic: ${lowlyGenerics.length + highlyGenerics.length}`, + `+ lowly generic: ${lowlyGenerics.length}`, + ...lowlyGenerics.map(a => ` ${a}`), + `+ highly generic: ${highlyGenerics.length}`, + ...highlyGenerics.map(a => ` ${a}`), + ].join('\n'); +}; + +/******************************************************************************/ + +const cosmeticFilteringEngine = new CosmeticFilteringEngine(); + +export default cosmeticFilteringEngine; + +/******************************************************************************/ |