Fix ESLint indentation warnings (#3800)

* Fix ESLint indentation warnings

* Undo code reformatting within parentheses

* Add exception for logical expressions

* Update array expression rule

* Disable rule for reProceduralOperator assignment

* Fix indentation in static-filtering-parser.js

platform/nodejs/eslintrc.json

@@ -9,7 +9,21 @@
         "sourceType": "module"
     },
     "rules": {
-        "indent": [ "warn", 4 ],
+        "indent": [
+          "warn",
+          4,
+          {
+            "ArrayExpression": "first",
+            "CallExpression": { "arguments": "first" },
+            "MemberExpression": "off",
+            "ObjectExpression": "off",
+            "ignoreComments": true,
+            "ignoredNodes": [
+              "AssignmentExpression:has(Literal)",
+              "LogicalExpression"
+            ]
+          }
+        ],
         "getter-return": "off",
         "no-control-regex": "off",
         "no-empty": [ "error", { "allowEmptyCatch": true } ],

platform/nodejs/index.js

@@ -166,7 +166,7 @@ function reset() {
 // module.exports. Once all included files are written like ES modules, using
 // export statements, this should no longer be necessary.
 if (typeof module !== 'undefined' && typeof exports !== 'undefined') {
-  module.exports = exports;
+    module.exports = exports;
 }
 
 export {

src/js/static-filtering-parser.js

@@ -1312,7 +1312,7 @@ Parser.prototype.SelectorCompiler = class {
         this.rePseudoElement = /:(?::?after|:?before|:-?[a-z][a-z-]*[a-z])$/;
         this.reProceduralOperator = new RegExp([
             '^(?:',
-                Array.from(parser.proceduralOperatorTokens.keys()).join('|'),
+            Array.from(parser.proceduralOperatorTokens.keys()).join('|'),
             ')\\('
         ].join(''));
         this.reEatBackslashes = /\\([()])/g;
@@ -2183,30 +2183,30 @@ Parser.prototype.OPTNotSupported = OPTNotSupported;
 
 const netOptionTokenDescriptors = new Map([
     [ '1p', OPTToken1p | OPTCanNegate ],
-        [ 'first-party', OPTToken1p | OPTCanNegate ],
+    /* synonym */ [ 'first-party', OPTToken1p | OPTCanNegate ],
     [ 'strict1p', OPTToken1pStrict ],
     [ '3p', OPTToken3p | OPTCanNegate ],
-        [ 'third-party', OPTToken3p | OPTCanNegate ],
+    /* synonym */ [ 'third-party', OPTToken3p | OPTCanNegate ],
     [ 'strict3p', OPTToken3pStrict ],
     [ 'all', OPTTokenAll | OPTNetworkType | OPTNonCspableType ],
     [ 'badfilter', OPTTokenBadfilter ],
     [ 'cname', OPTTokenCname | OPTAllowOnly | OPTModifierType ],
     [ 'csp', OPTTokenCsp | OPTMustAssign | OPTAllowMayAssign | OPTModifierType ],
     [ 'css', OPTTokenCss | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
-        [ 'stylesheet', OPTTokenCss | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
+    /* synonym */ [ 'stylesheet', OPTTokenCss | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
     [ 'denyallow', OPTTokenDenyAllow | OPTMustAssign | OPTDomainList | OPTNeedDomainOpt | OPTNonCspableType ],
     [ 'doc', OPTTokenDoc | OPTNetworkType | OPTCanNegate | OPTModifiableType | OPTRedirectableType ],
-        [ 'document', OPTTokenDoc | OPTNetworkType | OPTCanNegate | OPTModifiableType | OPTRedirectableType ],
+    /* synonym */ [ 'document', OPTTokenDoc | OPTNetworkType | OPTCanNegate | OPTModifiableType | OPTRedirectableType ],
     [ 'domain', OPTTokenDomain | OPTMustAssign | OPTDomainList ],
     [ 'ehide', OPTTokenEhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
-        [ 'elemhide', OPTTokenEhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
+    /* synonym */ [ 'elemhide', OPTTokenEhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
     [ 'empty', OPTTokenEmpty | OPTBlockOnly | OPTModifierType ],
     [ 'frame', OPTTokenFrame | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType ],
-        [ 'subdocument', OPTTokenFrame | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType ],
+    /* synonym */ [ 'subdocument', OPTTokenFrame | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType ],
     [ 'font', OPTTokenFont | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTNonCspableType ],
     [ 'genericblock', OPTTokenGenericblock | OPTNotSupported ],
     [ 'ghide', OPTTokenGhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
-        [ 'generichide', OPTTokenGhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
+    /* synonym */ [ 'generichide', OPTTokenGhide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
     [ 'header', OPTTokenHeader | OPTMustAssign | OPTAllowMayAssign | OPTNonCspableType | OPTNonRedirectableType ],
     [ 'image', OPTTokenImage | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
     [ 'important', OPTTokenImportant | OPTBlockOnly ],
@@ -2217,22 +2217,22 @@ const netOptionTokenDescriptors = new Map([
     [ 'mp4', OPTTokenMp4 | OPTNetworkType | OPTBlockOnly |  OPTModifierType ],
     [ '_', OPTTokenNoop ],
     [ 'object', OPTTokenObject | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
-        [ 'object-subrequest', OPTTokenObject | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
+    /* synonym */ [ 'object-subrequest', OPTTokenObject | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
     [ 'other', OPTTokenOther | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
     [ 'ping', OPTTokenPing | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTNonCspableType | OPTNonRedirectableType ],
-        [ 'beacon', OPTTokenPing | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTNonCspableType | OPTNonRedirectableType ],
+    /* synonym */ [ 'beacon', OPTTokenPing | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTNonCspableType | OPTNonRedirectableType ],
     [ 'popunder', OPTTokenPopunder | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
     [ 'popup', OPTTokenPopup | OPTNonNetworkType | OPTCanNegate | OPTNonCspableType | OPTNonRedirectableType ],
     [ 'queryprune', OPTTokenQueryprune | OPTMayAssign | OPTModifierType | OPTNonCspableType | OPTNonRedirectableType ],
-        [ 'removeparam', OPTTokenQueryprune | OPTMayAssign | OPTModifierType | OPTNonCspableType | OPTNonRedirectableType ],
+    /* synonym */ [ 'removeparam', OPTTokenQueryprune | OPTMayAssign | OPTModifierType | OPTNonCspableType | OPTNonRedirectableType ],
     [ 'redirect', OPTTokenRedirect | OPTMustAssign | OPTAllowMayAssign | OPTModifierType ],
-        [ 'rewrite', OPTTokenRedirect | OPTMustAssign | OPTAllowMayAssign | OPTModifierType ],
+    /* synonym */ [ 'rewrite', OPTTokenRedirect | OPTMustAssign | OPTAllowMayAssign | OPTModifierType ],
     [ 'redirect-rule', OPTTokenRedirectRule | OPTMustAssign | OPTAllowMayAssign | OPTModifierType | OPTNonCspableType ],
     [ 'script', OPTTokenScript | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
     [ 'shide', OPTTokenShide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
-        [ 'specifichide', OPTTokenShide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
+    /* synonym */ [ 'specifichide', OPTTokenShide | OPTNonNetworkType | OPTNonCspableType | OPTNonRedirectableType ],
     [ 'xhr', OPTTokenXhr | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
-        [ 'xmlhttprequest', OPTTokenXhr | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
+    /* synonym */ [ 'xmlhttprequest', OPTTokenXhr | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTRedirectableType | OPTNonCspableType ],
     [ 'webrtc', OPTTokenWebrtc | OPTNotSupported ],
     [ 'websocket', OPTTokenWebsocket | OPTCanNegate | OPTNetworkType | OPTModifiableType | OPTNonCspableType | OPTNonRedirectableType ],
 ]);
@@ -2242,30 +2242,30 @@ Parser.prototype.netOptionTokenDescriptors =
 
 Parser.netOptionTokenIds = new Map([
     [ '1p', OPTToken1p ],
-        [ 'first-party', OPTToken1p ],
+    /* synonym */ [ 'first-party', OPTToken1p ],
     [ 'strict1p', OPTToken1pStrict ],
     [ '3p', OPTToken3p ],
-        [ 'third-party', OPTToken3p ],
+    /* synonym */ [ 'third-party', OPTToken3p ],
     [ 'strict3p', OPTToken3pStrict ],
     [ 'all', OPTTokenAll ],
     [ 'badfilter', OPTTokenBadfilter ],
     [ 'cname', OPTTokenCname ],
     [ 'csp', OPTTokenCsp ],
     [ 'css', OPTTokenCss ],
-        [ 'stylesheet', OPTTokenCss ],
+    /* synonym */ [ 'stylesheet', OPTTokenCss ],
     [ 'denyallow', OPTTokenDenyAllow ],
     [ 'doc', OPTTokenDoc ],
-        [ 'document', OPTTokenDoc ],
+    /* synonym */ [ 'document', OPTTokenDoc ],
     [ 'domain', OPTTokenDomain ],
     [ 'ehide', OPTTokenEhide ],
-        [ 'elemhide', OPTTokenEhide ],
+    /* synonym */ [ 'elemhide', OPTTokenEhide ],
     [ 'empty', OPTTokenEmpty ],
     [ 'frame', OPTTokenFrame ],
-        [ 'subdocument', OPTTokenFrame ],
+    /* synonym */ [ 'subdocument', OPTTokenFrame ],
     [ 'font', OPTTokenFont ],
     [ 'genericblock', OPTTokenGenericblock ],
     [ 'ghide', OPTTokenGhide ],
-        [ 'generichide', OPTTokenGhide ],
+    /* synonym */ [ 'generichide', OPTTokenGhide ],
     [ 'header', OPTTokenHeader ],
     [ 'image', OPTTokenImage ],
     [ 'important', OPTTokenImportant ],
@@ -2276,22 +2276,22 @@ Parser.netOptionTokenIds = new Map([
     [ 'mp4', OPTTokenMp4 ],
     [ '_', OPTTokenNoop ],
     [ 'object', OPTTokenObject ],
-        [ 'object-subrequest', OPTTokenObject ],
+    /* synonym */ [ 'object-subrequest', OPTTokenObject ],
     [ 'other', OPTTokenOther ],
     [ 'ping', OPTTokenPing ],
-        [ 'beacon', OPTTokenPing ],
+    /* synonym */ [ 'beacon', OPTTokenPing ],
     [ 'popunder', OPTTokenPopunder ],
     [ 'popup', OPTTokenPopup ],
     [ 'queryprune', OPTTokenQueryprune ],
-        [ 'removeparam', OPTTokenQueryprune ],
+    /* synonym */ [ 'removeparam', OPTTokenQueryprune ],
     [ 'redirect', OPTTokenRedirect ],
-        [ 'rewrite', OPTTokenRedirect ],
+    /* synonym */ [ 'rewrite', OPTTokenRedirect ],
     [ 'redirect-rule', OPTTokenRedirectRule ],
     [ 'script', OPTTokenScript ],
     [ 'shide', OPTTokenShide ],
-        [ 'specifichide', OPTTokenShide ],
+    /* synonym */ [ 'specifichide', OPTTokenShide ],
     [ 'xhr', OPTTokenXhr ],
-        [ 'xmlhttprequest', OPTTokenXhr ],
+    /* synonym */ [ 'xmlhttprequest', OPTTokenXhr ],
     [ 'webrtc', OPTTokenWebrtc ],
     [ 'websocket', OPTTokenWebsocket ],
 ]);
@@ -2806,81 +2806,81 @@ Parser.regexUtils = Parser.prototype.regexUtils = (( ) => {
 
     const toTokenizableStr = node => {
         switch ( node.type ) {
-            case 1: /* T_SEQUENCE, 'Sequence' */ {
+        case 1: /* T_SEQUENCE, 'Sequence' */ {
-                let s = '';
+            let s = '';
-                for ( let i = 0; i < node.val.length; i++ ) {
+            for ( let i = 0; i < node.val.length; i++ ) {
-                    s += toTokenizableStr(node.val[i]);
+                s += toTokenizableStr(node.val[i]);
+            }
+            return s;
+        }
+        case 2: /* T_ALTERNATION, 'Alternation' */
+        case 8: /* T_CHARGROUP, 'CharacterGroup' */ {
+            let firstChar = 0;
+            let lastChar = 0;
+            for ( let i = 0; i < node.val.length; i++ ) {
+                const s = toTokenizableStr(node.val[i]);
+                if ( firstChar === 0 && firstCharCodeClass(s) === 1 ) {
+                    firstChar = 1;
                 }
-                return s;
+                if ( lastChar === 0 && lastCharCodeClass(s) === 1 ) {
-            }
+                    lastChar = 1;
-            case 2: /* T_ALTERNATION, 'Alternation' */
-            case 8: /* T_CHARGROUP, 'CharacterGroup' */ {
-                let firstChar = 0;
-                let lastChar = 0;
-                for ( let i = 0; i < node.val.length; i++ ) {
-                    const s = toTokenizableStr(node.val[i]);
-                    if ( firstChar === 0 && firstCharCodeClass(s) === 1 ) {
-                        firstChar = 1;
-                    }
-                    if ( lastChar === 0 && lastCharCodeClass(s) === 1 ) {
-                        lastChar = 1;
-                    }
-                    if ( firstChar === 1 && lastChar === 1 ) { break; }
                 }
-                return String.fromCharCode(firstChar, lastChar);
+                if ( firstChar === 1 && lastChar === 1 ) { break; }
             }
-            case 4: /* T_GROUP, 'Group' */ {
+            return String.fromCharCode(firstChar, lastChar);
-                if ( node.flags.NegativeLookAhead === 1 ) { return '\x01'; }
+        }
-                if ( node.flags.NegativeLookBehind === 1 ) { return '\x01'; }
+        case 4: /* T_GROUP, 'Group' */ {
-                return toTokenizableStr(node.val);
+            if ( node.flags.NegativeLookAhead === 1 ) { return '\x01'; }
-            }
+            if ( node.flags.NegativeLookBehind === 1 ) { return '\x01'; }
-            case 16: /* T_QUANTIFIER, 'Quantifier' */ {
+            return toTokenizableStr(node.val);
-                const s = toTokenizableStr(node.val);
+        }
-                const first = firstCharCodeClass(s);
+        case 16: /* T_QUANTIFIER, 'Quantifier' */ {
-                const last = lastCharCodeClass(s);
+            const s = toTokenizableStr(node.val);
-                if ( node.flags.min === 0 && first === 0 && last === 0 ) {
+            const first = firstCharCodeClass(s);
-                    return '';
+            const last = lastCharCodeClass(s);
-                }
+            if ( node.flags.min === 0 && first === 0 && last === 0 ) {
-                return String.fromCharCode(first, last);
-            }
-            case 64: /* T_HEXCHAR, 'HexChar' */ {
-                return String.fromCharCode(parseInt(node.val.slice(1), 16));
-            }
-            case 128: /* T_SPECIAL, 'Special' */ {
-                const flags = node.flags;
-                if (
-                    flags.EndCharGroup === 1 || // dangling `]`
-                    flags.EndGroup === 1 ||     // dangling `)`
-                    flags.EndRepeats === 1      // dangling `}`
-                ) {
-                    throw new Error('Unmatched bracket');
-                }
-                return flags.MatchEnd === 1 ||
-                       flags.MatchStart === 1 ||
-                       flags.MatchWordBoundary === 1
-                    ? '\x00'
-                    : '\x01';
-            }
-            case 256: /* T_CHARS, 'Characters' */ {
-                for ( let i = 0; i < node.val.length; i++ ) {
-                    if ( firstCharCodeClass(node.val[i]) === 1 ) {
-                        return '\x01';
-                    }
-                }
-                return '\x00';
-            }
-            // Ranges are assumed to always involve token-related characters.
-            case 512: /* T_CHARRANGE, 'CharacterRange' */ {
-                return '\x01';
-            }
-            case 1024: /* T_STRING, 'String' */ {
-                return node.val;
-            }
-            case 2048: /* T_COMMENT, 'Comment' */ {
                 return '';
             }
-            default:
+            return String.fromCharCode(first, last);
-                break;
+        }
+        case 64: /* T_HEXCHAR, 'HexChar' */ {
+            return String.fromCharCode(parseInt(node.val.slice(1), 16));
+        }
+        case 128: /* T_SPECIAL, 'Special' */ {
+            const flags = node.flags;
+            if (
+                flags.EndCharGroup === 1 || // dangling `]`
+                flags.EndGroup === 1 ||     // dangling `)`
+                flags.EndRepeats === 1      // dangling `}`
+            ) {
+                throw new Error('Unmatched bracket');
+            }
+            return flags.MatchEnd === 1 ||
+                   flags.MatchStart === 1 ||
+                   flags.MatchWordBoundary === 1
+                ? '\x00'
+                : '\x01';
+        }
+        case 256: /* T_CHARS, 'Characters' */ {
+            for ( let i = 0; i < node.val.length; i++ ) {
+                if ( firstCharCodeClass(node.val[i]) === 1 ) {
+                    return '\x01';
+                }
+            }
+            return '\x00';
+        }
+        // Ranges are assumed to always involve token-related characters.
+        case 512: /* T_CHARRANGE, 'CharacterRange' */ {
+            return '\x01';
+        }
+        case 1024: /* T_STRING, 'String' */ {
+            return node.val;
+        }
+        case 2048: /* T_COMMENT, 'Comment' */ {
+            return '';
+        }
+        default:
+            break;
         }
         return '\x01';
     };