@browserless.io/browserless 2.20.2 → 2.21.1

package/extensions/ublock/js/static-filtering-parser.js

@@ -172,6 +172,7 @@ export const NODE_TYPE_NET_OPTION_NAME_IMAGE        = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_IMPORTANT    = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_INLINEFONT   = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_INLINESCRIPT = iota++;
+export const NODE_TYPE_NET_OPTION_NAME_IPADDRESS    = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_MATCHCASE    = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_MEDIA        = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_METHOD       = iota++;
@@ -190,11 +191,13 @@ export const NODE_TYPE_NET_OPTION_NAME_REPLACE      = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_SCRIPT       = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_SHIDE        = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_TO           = iota++;
+export const NODE_TYPE_NET_OPTION_NAME_URLSKIP      = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_URLTRANSFORM = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_XHR          = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_WEBRTC       = iota++;
 export const NODE_TYPE_NET_OPTION_NAME_WEBSOCKET    = iota++;
 export const NODE_TYPE_NET_OPTION_ASSIGN            = iota++;
+export const NODE_TYPE_NET_OPTION_QUOTE             = iota++;
 export const NODE_TYPE_NET_OPTION_VALUE             = iota++;
 export const NODE_TYPE_OPTION_VALUE_DOMAIN_LIST     = iota++;
 export const NODE_TYPE_OPTION_VALUE_DOMAIN_RAW      = iota++;
@@ -248,6 +251,7 @@ export const nodeTypeFromOptionName = new Map([
     [ 'important', NODE_TYPE_NET_OPTION_NAME_IMPORTANT ],
     [ 'inline-font', NODE_TYPE_NET_OPTION_NAME_INLINEFONT ],
     [ 'inline-script', NODE_TYPE_NET_OPTION_NAME_INLINESCRIPT ],
+    [ 'ipaddress', NODE_TYPE_NET_OPTION_NAME_IPADDRESS ],
     [ 'match-case', NODE_TYPE_NET_OPTION_NAME_MATCHCASE ],
     [ 'media', NODE_TYPE_NET_OPTION_NAME_MEDIA ],
     [ 'method', NODE_TYPE_NET_OPTION_NAME_METHOD ],
@@ -271,6 +275,7 @@ export const nodeTypeFromOptionName = new Map([
     [ 'shide', NODE_TYPE_NET_OPTION_NAME_SHIDE ],
     /* synonym */ [ 'specifichide', NODE_TYPE_NET_OPTION_NAME_SHIDE ],
     [ 'to', NODE_TYPE_NET_OPTION_NAME_TO ],
+    [ 'urlskip', NODE_TYPE_NET_OPTION_NAME_URLSKIP ],
     [ 'uritransform', NODE_TYPE_NET_OPTION_NAME_URLTRANSFORM ],
     [ 'xhr', NODE_TYPE_NET_OPTION_NAME_XHR ],
     /* synonym */ [ 'xmlhttprequest', NODE_TYPE_NET_OPTION_NAME_XHR ],
@@ -575,6 +580,7 @@ export const preparserIfTokens = new Set([
     'env_mv3',
     'env_safari',
     'cap_html_filtering',
+    'cap_ipaddress',
     'cap_user_stylesheet',
     'false',
     'ext_abp',
@@ -896,7 +902,9 @@ export class AstFilterParser {
         this.reGoodRegexToken = /[^\x01%0-9A-Za-z][%0-9A-Za-z]{7,}|[^\x01%0-9A-Za-z][%0-9A-Za-z]{1,6}[^\x01%0-9A-Za-z]/;
         this.reBadCSP = /(?:^|[;,])\s*report-(?:to|uri)\b/i;
         this.reBadPP = /(?:^|[;,])\s*report-to\b/i;
+        this.reNetOption = /^(~?)([134a-z_-]+)(=?)/;
         this.reNoopOption = /^_+$/;
+        this.netOptionValueParser = new ArgListParser(',');
         this.scriptletArgListParser = new ArgListParser(',');
     }
 
@@ -1398,6 +1406,14 @@ export class AstFilterParser {
                 modifierType = type;
                 unredirectableTypeCount += 1;
                 break;
+            case NODE_TYPE_NET_OPTION_NAME_IPADDRESS: {
+                const value = this.getNetOptionValue(NODE_TYPE_NET_OPTION_NAME_IPADDRESS);
+                if ( /^\/.+\/$/.test(value) ) {
+                    try { void new RegExp(value); }
+                    catch(_) { realBad = true; }
+                }
+                break;
+            }
             case NODE_TYPE_NET_OPTION_NAME_MATCHCASE:
                 realBad = this.isRegexPattern() === false;
                 break;
@@ -1427,6 +1443,7 @@ export class AstFilterParser {
             case NODE_TYPE_NET_OPTION_NAME_REDIRECT:
             case NODE_TYPE_NET_OPTION_NAME_REDIRECTRULE:
             case NODE_TYPE_NET_OPTION_NAME_REPLACE:
+            case NODE_TYPE_NET_OPTION_NAME_URLSKIP:
             case NODE_TYPE_NET_OPTION_NAME_URLTRANSFORM:
                 realBad = isNegated || (isException || hasValue) === false ||
                     modifierType !== 0;
@@ -1505,6 +1522,21 @@ export class AstFilterParser {
             }
             break;
         }
+        case NODE_TYPE_NET_OPTION_NAME_URLSKIP: {
+            realBad = abstractTypeCount || behaviorTypeCount || unredirectableTypeCount;
+            if ( realBad ) { break; }
+            if ( requiresTrustedSource() ) {
+                this.astError = AST_ERROR_UNTRUSTED_SOURCE;
+                realBad = true;
+                break;
+            }
+            const value = this.getNetOptionValue(NODE_TYPE_NET_OPTION_NAME_URLSKIP);
+            if ( value.startsWith('?') === false || value.length < 2 ) {
+                this.astError = AST_ERROR_OPTION_BADVALUE;
+                realBad = true;
+            }
+            break;
+        }
         case NODE_TYPE_NET_OPTION_NAME_URLTRANSFORM: {
             realBad = abstractTypeCount || behaviorTypeCount || unredirectableTypeCount;
             if ( realBad ) { break; }
@@ -1959,16 +1991,17 @@ export class AstFilterParser {
         const head = this.allocHeadNode();
         let prev = head, next = 0;
         let optionBeg = 0, optionEnd = 0;
-        let emptyOption = false, badComma = false;
         while ( optionBeg !== optionsEnd ) {
-            optionEnd = this.endOfNetOption(s, optionBeg);
             next = this.allocTypedNode(
                 NODE_TYPE_NET_OPTION_RAW,
                 parentBeg + optionBeg,
-                parentBeg + optionEnd
+                parentBeg + optionsEnd // open ended
             );
-            emptyOption = optionEnd === optionBeg;
-            this.linkDown(next, this.parseNetOption(next));
+            const { node: down, len: optionLen } = this.parseNetOption(next);
+            // set next's end to down's end
+            optionEnd += optionLen;
+            this.nodes[next+NODE_END_INDEX] = parentBeg + optionEnd;
+            this.linkDown(next, down);
             prev = this.linkRight(prev, next);
             if ( optionEnd === optionsEnd ) { break; }
             optionBeg = optionEnd + 1;
@@ -1977,12 +2010,12 @@ export class AstFilterParser {
                 parentBeg + optionEnd,
                 parentBeg + optionBeg
             );
-            badComma = optionBeg === optionsEnd;
-            prev = this.linkRight(prev, next);
-            if ( emptyOption || badComma ) {
+            if ( optionLen === 0 || optionBeg === optionsEnd ) {
                 this.addNodeFlags(next, NODE_FLAG_ERROR);
                 this.addFlags(AST_FLAG_HAS_ERROR);
             }
+            prev = this.linkRight(prev, next);
+            optionEnd = optionBeg;
         }
         this.linkRight(prev,
             this.allocSentinelNode(NODE_TYPE_NET_OPTION_SENTINEL, parentEnd)
@@ -1990,19 +2023,21 @@ export class AstFilterParser {
         return this.throwHeadNode(head);
     }
 
-    endOfNetOption(s, beg) {
-        const match = this.reNetOptionComma.exec(s.slice(beg));
-        return match !== null ? beg + match.index : s.length;
-    }
-
     parseNetOption(parent) {
         const parentBeg = this.nodes[parent+NODE_BEG_INDEX];
         const s = this.getNodeString(parent);
-        const optionEnd = s.length;
+        const match = this.reNetOption.exec(s) || [];
+        if ( match.length === 0 ) {
+            this.addNodeFlags(parent, NODE_FLAG_ERROR);
+            this.addFlags(AST_FLAG_HAS_ERROR);
+            this.astError = AST_ERROR_OPTION_UNKNOWN;
+            return { node: 0, len: s.length };
+        }
         const head = this.allocHeadNode();
         let prev = head, next = 0;
-        let nameBeg = 0;
-        if ( s.charCodeAt(0) === 0x7E ) {
+        const matchEnd = match && match[0].length || 0;
+        const negated = match[1] === '~';
+        if ( negated ) {
             this.addNodeFlags(parent, NODE_FLAG_IS_NEGATED);
             next = this.allocTypedNode(
                 NODE_TYPE_NET_OPTION_NAME_NOT,
@@ -2010,11 +2045,11 @@ export class AstFilterParser {
                 parentBeg+1
             );
             prev = this.linkRight(prev, next);
-            nameBeg += 1;
         }
-        const equalPos = s.indexOf('=');
-        const nameEnd = equalPos !== -1 ? equalPos : s.length;
-        const name = s.slice(nameBeg, nameEnd);
+        const nameBeg = negated ? 1 : 0;
+        const assigned = match[3] === '=';
+        const nameEnd = matchEnd - (assigned ? 1 : 0);
+        const name = match[2] || '';
         let nodeOptionType = nodeTypeFromOptionName.get(name);
         if ( nodeOptionType === undefined ) {
             nodeOptionType = this.reNoopOption.test(name)
@@ -2037,27 +2072,43 @@ export class AstFilterParser {
             this.addNodeToRegister(nodeOptionType, parent);
         }
         prev = this.linkRight(prev, next);
-        if ( equalPos === -1 ) {
-            return this.throwHeadNode(head);
+        if ( assigned === false ) {
+            return { node: this.throwHeadNode(head), len: matchEnd };
         }
-        const valueBeg = equalPos + 1;
         next = this.allocTypedNode(
             NODE_TYPE_NET_OPTION_ASSIGN,
-            parentBeg + equalPos,
-            parentBeg + valueBeg
+            parentBeg + matchEnd - 1,
+            parentBeg + matchEnd
         );
         prev = this.linkRight(prev, next);
-        if ( (equalPos+1) === optionEnd ) {
-            this.addNodeFlags(parent, NODE_FLAG_ERROR);
-            this.addFlags(AST_FLAG_HAS_ERROR);
-            return this.throwHeadNode(head);
-        }
         this.addNodeFlags(parent, NODE_FLAG_OPTION_HAS_VALUE);
+        const details = this.netOptionValueParser.nextArg(s, matchEnd);
+        if ( details.quoteBeg !== details.argBeg ) {
+            next = this.allocTypedNode(
+                NODE_TYPE_NET_OPTION_QUOTE,
+                parentBeg + details.quoteBeg,
+                parentBeg + details.argBeg
+            );
+            prev = this.linkRight(prev, next);
+        } else {
+            const argEnd = this.endOfNetOption(s, matchEnd);
+            if ( argEnd !== details.argEnd ) {
+                details.argEnd = details.quoteEnd = argEnd;
+            }
+        }
         next = this.allocTypedNode(
             NODE_TYPE_NET_OPTION_VALUE,
-            parentBeg + valueBeg,
-            parentBeg + optionEnd
+            parentBeg + details.argBeg,
+            parentBeg + details.argEnd
         );
+        if ( details.argBeg === details.argEnd ) {
+            this.addNodeFlags(parent, NODE_FLAG_ERROR);
+            this.addFlags(AST_FLAG_HAS_ERROR);
+            this.astError = AST_ERROR_OPTION_BADVALUE;
+        } else if ( details.transform ) {
+            const arg = s.slice(details.argBeg, details.argEnd);
+            this.setNodeTransform(next, this.netOptionValueParser.normalizeArg(arg));
+        }
         switch ( nodeOptionType ) {
         case NODE_TYPE_NET_OPTION_NAME_DENYALLOW:
             this.linkDown(next, this.parseDomainList(next, '|'), 0b00000);
@@ -2069,8 +2120,21 @@ export class AstFilterParser {
         default:
             break;
         }
-        this.linkRight(prev, next);
-        return this.throwHeadNode(head);
+        prev = this.linkRight(prev, next);
+        if ( details.quoteEnd !== details.argEnd ) {
+            next = this.allocTypedNode(
+                NODE_TYPE_NET_OPTION_QUOTE,
+                parentBeg + details.argEnd,
+                parentBeg + details.quoteEnd
+            );
+            this.linkRight(prev, next);
+        }
+        return { node: this.throwHeadNode(head), len: details.quoteEnd };
+    }
+
+    endOfNetOption(s, beg) {
+        const match = this.reNetOptionComma.exec(s.slice(beg));
+        return match !== null ? beg + match.index : s.length;
     }
 
     getNetOptionValue(type) {
@@ -3069,6 +3133,7 @@ export const netOptionTokenDescriptors = new Map([
     [ 'important', { blockOnly: true } ],
     [ 'inline-font', { canNegate: true } ],
     [ 'inline-script', { canNegate: true } ],
+    [ 'ipaddress', { mustAssign: true } ],
     [ 'match-case', { } ],
     [ 'media', { canNegate: true } ],
     [ 'method', { mustAssign: true } ],
@@ -3086,12 +3151,13 @@ export const netOptionTokenDescriptors = new Map([
     /* synonym */ [ 'rewrite', { mustAssign: true } ],
     [ 'redirect-rule', { mustAssign: true } ],
     [ 'removeparam', { } ],
-    [ 'replace', { mustAssign: true } ],
     /* synonym */ [ 'queryprune', { } ],
+    [ 'replace', { mustAssign: true } ],
     [ 'script', { canNegate: true } ],
     [ 'shide', { } ],
     /* synonym */ [ 'specifichide', { } ],
     [ 'to', { mustAssign: true } ],
+    [ 'urlskip', { mustAssign: true } ],
     [ 'uritransform', { mustAssign: true } ],
     [ 'xhr', { canNegate: true } ],
     /* synonym */ [ 'xmlhttprequest', { canNegate: true } ],
@@ -4289,6 +4355,7 @@ export const utils = (( ) => {
         [ 'env_safari', 'safari' ],
         [ 'cap_html_filtering', 'html_filtering' ],
         [ 'cap_user_stylesheet', 'user_stylesheet' ],
+        [ 'cap_ipaddress', 'ipaddress' ],
         [ 'false', 'false' ],
         // Hoping ABP-only list maintainers can at least make use of it to
         // help non-ABP content blockers better deal with filters benefiting
@@ -4323,8 +4390,11 @@ export const utils = (( ) => {
         static evaluateExprToken(token, env = []) {
             const not = token.charCodeAt(0) === 0x21 /* ! */;
             if ( not ) { token = token.slice(1); }
-            const state = preparserTokens.get(token);
-            if ( state === undefined ) { return; }
+            let state = preparserTokens.get(token);
+            if ( state === undefined ) {
+                if ( token.startsWith('cap_') === false ) { return; }
+                state = 'false';
+            }
             return state === 'false' && not || env.includes(state) !== not;
         }