@adguard/agtree 1.1.5 → 1.1.7

package/dist/agtree.cjs

@@ -1,5 +1,5 @@
 /*
- * AGTree v1.1.5 (build date: Tue, 05 Sep 2023 15:10:53 GMT)
+ * AGTree v1.1.7 (build date: Tue, 07 Nov 2023 14:17:46 GMT)
  * (c) 2023 AdGuard Software Ltd.
  * Released under the MIT license
  * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
@@ -281,7 +281,7 @@ const NEGATION_MARKER = '~';
 /**
  * The wildcard symbol — `*`.
  */
-const WILDCARD$1 = ASTERISK;
+const WILDCARD = ASTERISK;
 /**
  * Classic domain separator.
  *
@@ -2880,7 +2880,7 @@ class ModifierParser {
         const modifierEnd = Math.max(StringUtils.skipWSBack(raw) + 1, modifierNameStart);
         // Modifier name can't be empty
         if (modifierNameStart === modifierEnd) {
-            throw new AdblockSyntaxError('Modifier name can\'t be empty', locRange(loc, 0, raw.length));
+            throw new AdblockSyntaxError('Modifier name cannot be empty', locRange(loc, 0, raw.length));
         }
         let modifier;
         let value;
@@ -2904,7 +2904,7 @@ class ModifierParser {
             };
             // Value can't be empty
             if (assignmentIndex + 1 === modifierEnd) {
-                throw new AdblockSyntaxError('Modifier value can\'t be empty', locRange(loc, 0, raw.length));
+                throw new AdblockSyntaxError('Modifier value cannot be empty', locRange(loc, 0, raw.length));
             }
             // Skip whitespace after the assignment operator
             const valueStart = StringUtils.skipWS(raw, assignmentIndex + MODIFIER_ASSIGN_OPERATOR.length);
@@ -3202,8 +3202,29 @@ const FORBIDDEN_CSS_FUNCTIONS = new Set([
     'url',
 ]);
 
+/**
+ * @file Clone related utilities
+ *
+ * We should keep clone related functions in this file. Thus, we just provide
+ * a simple interface for cloning values, we use it across the AGTree project,
+ * and the implementation "under the hood" can be improved later, if needed.
+ */
+/**
+ * Clones an input value to avoid side effects. Use it only in justified cases,
+ * because it can impact performance negatively.
+ *
+ * @param value Value to clone
+ * @returns Cloned value
+ */
+function clone(value) {
+    // TODO: Replace cloneDeep with a more efficient implementation
+    return cloneDeep(value);
+}
+
 /**
  * @file Additional / helper functions for ECSSTree / CSSTree.
+ *
+ * @note There are no tests for some functions, but during the AGTree optimization we remove them anyway.
  */
 /**
  * Common CSSTree parsing options.
@@ -3339,10 +3360,10 @@ class CssTree {
             ast = CssTree.parse(selectorList, exports.CssTreeParserContext.selectorList);
         }
         else {
-            ast = cloneDeep(selectorList);
+            ast = clone(selectorList);
         }
         const nodes = [];
-        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ecssTree.walk(ast, (node) => {
             if (CssTree.isExtendedCssNode(node, pseudoClasses, attributeSelectors)) {
@@ -3371,9 +3392,9 @@ class CssTree {
             ast = CssTree.parse(selectorList, exports.CssTreeParserContext.selectorList);
         }
         else {
-            ast = cloneDeep(selectorList);
+            ast = selectorList;
         }
-        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return ecssTree.find(ast, (node) => CssTree.isExtendedCssNode(node, pseudoClasses, attributeSelectors)) !== null;
     }
@@ -3410,14 +3431,14 @@ class CssTree {
             ast = CssTree.parse(declarationList, exports.CssTreeParserContext.declarationList);
         }
         else {
-            ast = cloneDeep(declarationList);
+            ast = clone(declarationList);
         }
         const nodes = [];
         // While walking the AST we should skip the nested functions,
         // for example skip url()s in cross-fade(url(), url()), since
         // cross-fade() itself is already a forbidden function
         let inForbiddenFunction = false;
-        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ecssTree.walk(ast, {
             enter: (node) => {
@@ -3455,9 +3476,9 @@ class CssTree {
             ast = CssTree.parse(declarationList, exports.CssTreeParserContext.declarationList);
         }
         else {
-            ast = cloneDeep(declarationList);
+            ast = clone(declarationList);
         }
-        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return ecssTree.find(ast, (node) => CssTree.isForbiddenFunction(node, forbiddenFunctions)) !== null;
     }
@@ -3689,6 +3710,180 @@ class CssTree {
         });
         return result.trim();
     }
+    /**
+     * Generates string representation of the selector list.
+     *
+     * @param ast SelectorList AST
+     * @returns String representation of the selector list
+     */
+    static generateSelectorListPlain(ast) {
+        const result = [];
+        if (!ast.children || ast.children.length === 0) {
+            throw new Error('Selector list cannot be empty');
+        }
+        ast.children.forEach((selector, index, nodeList) => {
+            if (selector.type !== exports.CssTreeNodeType.Selector) {
+                throw new Error(`Unexpected node type: ${selector.type}`);
+            }
+            result.push(this.generateSelectorPlain(selector));
+            // If there is a next node, add a comma and a space after the selector
+            if (nodeList[index + 1]) {
+                result.push(COMMA, SPACE);
+            }
+        });
+        return result.join(EMPTY);
+    }
+    /**
+     * Selector generation based on CSSTree's AST. This is necessary because CSSTree
+     * only adds spaces in some edge cases.
+     *
+     * @param ast CSS Tree AST
+     * @returns CSS selector as string
+     */
+    static generateSelectorPlain(ast) {
+        let result = EMPTY;
+        let inAttributeSelector = false;
+        let depth = 0;
+        let selectorListDepth = -1;
+        let prevNode = ast;
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ecssTree.walk(ast, {
+            // TODO: Need to improve CSSTree types, until then we need to use any type here
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            enter: (node) => {
+                depth += 1;
+                // Skip attribute selector / selector list children
+                if (inAttributeSelector || selectorListDepth > -1) {
+                    return;
+                }
+                switch (node.type) {
+                    // "Trivial" nodes
+                    case exports.CssTreeNodeType.TypeSelector:
+                        result += node.name;
+                        break;
+                    case exports.CssTreeNodeType.ClassSelector:
+                        result += DOT;
+                        result += node.name;
+                        break;
+                    case exports.CssTreeNodeType.IdSelector:
+                        result += HASHMARK;
+                        result += node.name;
+                        break;
+                    case exports.CssTreeNodeType.Identifier:
+                        result += node.name;
+                        break;
+                    case exports.CssTreeNodeType.Raw:
+                        result += node.value;
+                        break;
+                    // "Advanced" nodes
+                    case exports.CssTreeNodeType.Nth:
+                        // Default generation enough
+                        result += ecssTree.generate(node);
+                        break;
+                    // For example :not([id], [name])
+                    case exports.CssTreeNodeType.SelectorList:
+                        // eslint-disable-next-line no-case-declarations
+                        const selectors = [];
+                        node.children.forEach((selector) => {
+                            if (selector.type === exports.CssTreeNodeType.Selector) {
+                                selectors.push(CssTree.generateSelectorPlain(selector));
+                            }
+                            else if (selector.type === exports.CssTreeNodeType.Raw) {
+                                selectors.push(selector.value);
+                            }
+                        });
+                        // Join selector lists
+                        result += selectors.join(COMMA + SPACE);
+                        // Skip nodes here
+                        selectorListDepth = depth;
+                        break;
+                    case exports.CssTreeNodeType.Combinator:
+                        if (node.name === SPACE) {
+                            result += node.name;
+                            break;
+                        }
+                        // Prevent this case (unnecessary space): has( > .something)
+                        if (prevNode.type !== exports.CssTreeNodeType.Selector) {
+                            result += SPACE;
+                        }
+                        result += node.name;
+                        result += SPACE;
+                        break;
+                    case exports.CssTreeNodeType.AttributeSelector:
+                        result += OPEN_SQUARE_BRACKET;
+                        // Identifier name
+                        if (node.name) {
+                            result += node.name.name;
+                        }
+                        // Matcher operator, eg =
+                        if (node.matcher) {
+                            result += node.matcher;
+                            // Value can be String, Identifier or null
+                            if (node.value !== null) {
+                                // String node
+                                if (node.value.type === exports.CssTreeNodeType.String) {
+                                    result += ecssTree.generate(node.value);
+                                }
+                                else if (node.value.type === exports.CssTreeNodeType.Identifier) {
+                                    // Identifier node
+                                    result += node.value.name;
+                                }
+                            }
+                        }
+                        // Flags
+                        if (node.flags) {
+                            // Space before flags
+                            result += SPACE;
+                            result += node.flags;
+                        }
+                        result += CLOSE_SQUARE_BRACKET;
+                        inAttributeSelector = true;
+                        break;
+                    case exports.CssTreeNodeType.PseudoElementSelector:
+                        result += COLON;
+                        result += COLON;
+                        result += node.name;
+                        if (node.children !== null) {
+                            result += OPEN_PARENTHESIS;
+                        }
+                        break;
+                    case exports.CssTreeNodeType.PseudoClassSelector:
+                        result += COLON;
+                        result += node.name;
+                        if (node.children !== null) {
+                            result += OPEN_PARENTHESIS;
+                        }
+                        break;
+                }
+                prevNode = node;
+            },
+            leave: (node) => {
+                depth -= 1;
+                if (node.type === exports.CssTreeNodeType.SelectorList && depth + 1 === selectorListDepth) {
+                    selectorListDepth = -1;
+                }
+                if (selectorListDepth > -1) {
+                    return;
+                }
+                if (node.type === exports.CssTreeNodeType.AttributeSelector) {
+                    inAttributeSelector = false;
+                }
+                if (inAttributeSelector) {
+                    return;
+                }
+                switch (node.type) {
+                    case exports.CssTreeNodeType.PseudoElementSelector:
+                    case exports.CssTreeNodeType.PseudoClassSelector:
+                        if (node.children) {
+                            result += CLOSE_PARENTHESIS;
+                        }
+                        break;
+                }
+            },
+        });
+        return result.trim();
+    }
     /**
      * Block generation based on CSSTree's AST. This is necessary because CSSTree only adds spaces in some edge cases.
      *
@@ -3872,6 +4067,29 @@ class CssTree {
         });
         return result;
     }
+    /**
+     * Helper function to generate a raw string from a function selector's children
+     *
+     * @param node Function node
+     * @returns Generated function value
+     * @example `responseheader(name)` -> `name`
+     */
+    static generateFunctionPlainValue(node) {
+        const result = [];
+        node.children?.forEach((child) => {
+            switch (child.type) {
+                case exports.CssTreeNodeType.Raw:
+                    result.push(child.value);
+                    break;
+                default:
+                    // Fallback to CSSTree's default generate function
+                    // TODO: Need to improve CSSTree types, until then we need to use any type here
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    result.push(ecssTree.generate(child));
+            }
+        });
+        return result.join(EMPTY);
+    }
 }
 
 /**
@@ -3919,7 +4137,7 @@ class ElementHidingBodyParser {
      * @throws If the AST is invalid
      */
     static generate(ast) {
-        return CssTree.generateSelectorList(ecssTree.fromPlainObject(ast.selectorList));
+        return CssTree.generateSelectorListPlain(ast.selectorList);
     }
 }
 
@@ -4163,7 +4381,7 @@ class CssInjectionBodyParser {
                             if (mediaQueryList || declarationList || remove) {
                                 throw new AdblockSyntaxError(
                                 // eslint-disable-next-line max-len
-                                'Invalid selector, regular selector elements can\'t be used after special pseudo-classes', {
+                                'Invalid selector, regular selector elements cannot be used after special pseudo-classes', {
                                     start: node.loc?.start ?? loc,
                                     end: shiftLoc(loc, raw.length),
                                 });
@@ -4852,7 +5070,7 @@ function createModifierListNode(modifiers = []) {
     const result = {
         type: 'ModifierList',
         // We need to clone the modifiers to avoid side effects
-        children: cloneDeep(modifiers),
+        children: modifiers.length ? clone(modifiers) : [],
     };
     return result;
 }
@@ -4892,8 +5110,9 @@ function hasUboModifierIndicator(rawSelectorList) {
  * @returns Linked list based selector
  */
 function convertSelectorToLinkedList(selector) {
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return ecssTree.fromPlainObject(cloneDeep(selector));
+    return ecssTree.fromPlainObject(clone(selector));
 }
 /**
  * Helper function that always returns the linked list version of the
@@ -4903,8 +5122,9 @@ function convertSelectorToLinkedList(selector) {
  * @returns Linked list based selector list
  */
 function convertSelectorListToLinkedList(selectorList) {
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return ecssTree.fromPlainObject(cloneDeep(selectorList));
+    return ecssTree.fromPlainObject(clone(selectorList));
 }
 /**
  * Helper function for checking and removing bounding combinators
@@ -5989,7 +6209,8 @@ class FilterListParser {
      */
     static generate(ast, preferRaw = false) {
         let result = EMPTY;
-        for (const rule of ast.children) {
+        for (let i = 0; i < ast.children.length; i += 1) {
+            const rule = ast.children[i];
             if (preferRaw && rule.raws?.text) {
                 result += rule.raws.text;
             }
@@ -6006,6 +6227,11 @@ class FilterListParser {
                 case 'lf':
                     result += LF;
                     break;
+                default:
+                    if (i !== ast.children.length - 1) {
+                        result += LF;
+                    }
+                    break;
             }
         }
         return result;
@@ -6055,7 +6281,7 @@ class RuleConversionError extends Error {
     }
 }
 
-var data$T = { adg_os_any:{ name:"all",
+var data$U = { adg_os_any:{ name:"all",
     description:"$all modifier is made of $document, $popup, and all content-type modifiers combined.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#all-modifier",
     negatable:false,
@@ -6081,14 +6307,14 @@ var data$T = { adg_os_any:{ name:"all",
     negatable:false,
     block_only:false } };
 
-var data$S = { adg_os_any:{ name:"app",
+var data$T = { adg_os_any:{ name:"app",
     description:"The `$app` modifier lets you narrow the rule coverage down to a specific application or a list of applications.\nThe modifier's behavior and syntax perfectly match the corresponding basic rules `$app` modifier.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#app-modifier",
     assignable:true,
     negatable:false,
     value_format:"pipe_separated_apps" } };
 
-var data$R = { adg_os_any:{ name:"badfilter",
+var data$S = { adg_os_any:{ name:"badfilter",
     description:"The rules with the `$badfilter` modifier disable other basic rules to which they refer. It means that\nthe text of the disabled rule should match the text of the `$badfilter` rule (without the `$badfilter` modifier).",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#badfilter-modifier",
     negatable:false },
@@ -6109,19 +6335,19 @@ var data$R = { adg_os_any:{ name:"badfilter",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#badfilter",
     negatable:false } };
 
-var data$Q = { ubo_ext_any:{ name:"cname",
+var data$R = { ubo_ext_any:{ name:"cname",
     description:"When used in an exception filter,\nit will bypass blocking CNAME uncloaked requests for the current (specified) document.",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#cname",
     negatable:false,
     exception_only:true } };
 
-var data$P = { adg_os_any:{ name:"content",
+var data$Q = { adg_os_any:{ name:"content",
     description:"Disables HTML filtering and `$replace` rules on the pages that match the rule.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#content-modifier",
     negatable:false,
     exception_only:true } };
 
-var data$O = { adg_os_any:{ name:"cookie",
+var data$P = { adg_os_any:{ name:"cookie",
     description:"The `$cookie` modifier completely changes rule behavior.\nInstead of blocking a request, this modifier makes us suppress or modify the Cookie and Set-Cookie headers.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#cookie-modifier",
     assignable:true,
@@ -6136,7 +6362,7 @@ var data$O = { adg_os_any:{ name:"cookie",
     value_optional:true,
     value_format:"^([^;=\\s]*?)((?:;(maxAge=\\d+;?)?|(sameSite=(lax|none|strict);?)?){1,3})(?<!;)$" } };
 
-var data$N = { adg_os_any:{ name:"csp",
+var data$O = { adg_os_any:{ name:"csp",
     description:"This modifier completely changes the rule behavior.\nIf it is applied to a rule, it will not block the matching request.\nThe response headers are going to be modified instead.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#csp-modifier",
     conflicts:[ "domain",
@@ -6183,7 +6409,7 @@ var data$N = { adg_os_any:{ name:"csp",
     value_optional:true,
     value_format:"csp_value" } };
 
-var data$M = { adg_os_any:{ name:"denyallow",
+var data$N = { adg_os_any:{ name:"denyallow",
     description:"The `$denyallow` modifier allows to avoid creating additional rules\nwhen it is needed to disable a certain rule for specific domains.\n`$denyallow` matches only target domains and not referrer domains.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#denyallow-modifier",
     conflicts:[ "to" ],
@@ -6219,7 +6445,7 @@ var data$M = { adg_os_any:{ name:"denyallow",
     negatable:false,
     value_format:"pipe_separated_denyallow_domains" } };
 
-var data$L = { adg_os_any:{ name:"document",
+var data$M = { adg_os_any:{ name:"document",
     description:"The rule corresponds to the main frame document requests,\ni.e. HTML documents that are loaded in the browser tab.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#document-modifier",
     negatable:false },
@@ -6245,7 +6471,7 @@ var data$L = { adg_os_any:{ name:"document",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#document",
     negatable:false } };
 
-var data$K = { adg_any:{ name:"domain",
+var data$L = { adg_any:{ name:"domain",
     aliases:[ "from" ],
     description:"The `$domain` modifier limits the rule application area to a list of domains and their subdomains.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#domain-modifier",
@@ -6266,7 +6492,7 @@ var data$K = { adg_any:{ name:"domain",
     negatable:false,
     value_format:"pipe_separated_domains" } };
 
-var data$J = { adg_any:{ name:"elemhide",
+var data$K = { adg_any:{ name:"elemhide",
     aliases:[ "ehide" ],
     description:"Disables any cosmetic rules on the pages matching the rule.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#elemhide-modifier",
@@ -6285,7 +6511,7 @@ var data$J = { adg_any:{ name:"elemhide",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#elemhide-1",
     description:"Disables any cosmetic rules on the pages matching the rule." } };
 
-var data$I = { adg_os_any:{ name:"empty",
+var data$J = { adg_os_any:{ name:"empty",
     description:"This modifier is deprecated in favor of the $redirect modifier.\nRules with `$empty` are still supported and being converted into `$redirect=nooptext` now\nbut the support shall be removed in the future.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#empty-modifier",
     deprecated:true,
@@ -6302,7 +6528,7 @@ var data$I = { adg_os_any:{ name:"empty",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#empty",
     negatable:false } };
 
-var data$H = { adg_any:{ name:"first-party",
+var data$I = { adg_any:{ name:"first-party",
     aliases:[ "1p",
       "~third-party" ],
     description:"A restriction of first-party requests. Equal to `~third-party`.",
@@ -6315,7 +6541,7 @@ var data$H = { adg_any:{ name:"first-party",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#1p",
     negatable:false } };
 
-var data$G = { adg_os_any:{ name:"extension",
+var data$H = { adg_os_any:{ name:"extension",
     description:"Disables all userscripts on the pages matching this rule.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#extension-modifier",
     conflicts:[ "domain",
@@ -6331,7 +6557,7 @@ var data$G = { adg_os_any:{ name:"extension",
     inverse_conflicts:true,
     exception_only:true } };
 
-var data$F = { adg_any:{ name:"font",
+var data$G = { adg_any:{ name:"font",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#font-modifier",
     description:"The rule corresponds to requests for fonts, e.g. `.woff` filename extension." },
   abp_any:{ name:"font",
@@ -6341,7 +6567,7 @@ var data$F = { adg_any:{ name:"font",
     docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#options",
     description:"The rule corresponds to requests for fonts, e.g. `.woff` filename extension." } };
 
-var data$E = { adg_os_any:{ name:"genericblock",
+var data$F = { adg_os_any:{ name:"genericblock",
     description:"Disables generic basic rules on pages that correspond to exception rule.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#genericblock-modifier",
     conflicts:[ "domain",
@@ -6397,7 +6623,7 @@ var data$E = { adg_os_any:{ name:"genericblock",
     negatable:false,
     exception_only:true } };
 
-var data$D = { adg_any:{ name:"generichide",
+var data$E = { adg_any:{ name:"generichide",
     aliases:[ "ghide" ],
     description:"Disables all generic cosmetic rules.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#generichide-modifier",
@@ -6429,7 +6655,7 @@ var data$D = { adg_any:{ name:"generichide",
     negatable:false,
     exception_only:true } };
 
-var data$C = { adg_os_any:{ name:"header",
+var data$D = { adg_os_any:{ name:"header",
     description:"The `$header` modifier allows matching the HTTP response\nhaving a specific header with (optionally) a specific value.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#header-modifier",
     assignable:true,
@@ -6445,7 +6671,7 @@ var data$C = { adg_os_any:{ name:"header",
     assignable:true,
     value_format:"(?xi)\n  ^\n    # header name\n    [\\w-]+\n    (\n      :\n      # header value: string or regexp\n      (\\w+|\\/.+\\/)\n    )?" } };
 
-var data$B = { adg_os_any:{ name:"hls",
+var data$C = { adg_os_any:{ name:"hls",
     description:"The `$hls` rules modify the response of a matching request.\nThey are intended as a convenient way to remove segments from HLS playlists (RFC 8216).",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#hls-modifier",
     version_added:"CoreLibs 1.10",
@@ -6461,7 +6687,7 @@ var data$B = { adg_os_any:{ name:"hls",
     value_optional:true,
     value_format:"(?xi)\n  (\n    # string pattern\n    \\w+\n    # or regexp pattern\n    |\n    # TODO: improve regexp pattern to invalidate unescaped `/`, `$`, and `,`\n    \\/.+\\/\n      # options\n      ([ti]*)?\n  )" } };
 
-var data$A = { adg_any:{ name:"image",
+var data$B = { adg_any:{ name:"image",
     description:"The rule corresponds to images requests.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#image-modifier" },
   abp_any:{ name:"image",
@@ -6471,7 +6697,7 @@ var data$A = { adg_any:{ name:"image",
     description:"The rule corresponds to images requests.",
     docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#options" } };
 
-var data$z = { adg_any:{ name:"important",
+var data$A = { adg_any:{ name:"important",
     description:"The `$important` modifier applied to a rule increases its priority\nover any other rule without `$important` modifier. Even over basic exception rules.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#important-modifier",
     negatable:false },
@@ -6480,7 +6706,7 @@ var data$z = { adg_any:{ name:"important",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#important",
     negatable:false } };
 
-var data$y = { adg_os_any:{ name:"inline-font",
+var data$z = { adg_os_any:{ name:"inline-font",
     description:"The `$inline-font` modifier is a sort of a shortcut for $csp modifier with specific value.\nE.g. `||example.org^$inline-font` is converting into:\n```adblock\n||example.org^$csp=font-src 'self' 'unsafe-eval' http: https: data: blob: mediastream: filesystem:\n```",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#inline-font-modifier" },
   adg_ext_any:{ name:"inline-font",
@@ -6490,7 +6716,7 @@ var data$y = { adg_os_any:{ name:"inline-font",
     description:"The `$inline-font` modifier is a sort of a shortcut for $csp modifier with specific value.\nE.g. `||example.org^$inline-font` is converting into:\n```adblock\n||example.org^$csp=font-src 'self' 'unsafe-eval' http: https: data: blob: mediastream: filesystem:\n```",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#inline-font" } };
 
-var data$x = { adg_os_any:{ name:"inline-script",
+var data$y = { adg_os_any:{ name:"inline-script",
     description:"The `$inline-script` modifier is a sort of a shortcut for $csp modifier with specific value.\nE.g. `||example.org^$inline-script` is converting into:\n```adblock\n||example.org^$csp=script-src 'self' 'unsafe-eval' http: https: data: blob: mediastream: filesystem:\n```",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#inline-script-modifier" },
   adg_ext_any:{ name:"inline-script",
@@ -6500,7 +6726,7 @@ var data$x = { adg_os_any:{ name:"inline-script",
     description:"The `$inline-script` modifier is a sort of a shortcut for $csp modifier with specific value.\nE.g. `||example.org^$inline-script` is converting into:\n```adblock\n||example.org^$csp=script-src 'self' 'unsafe-eval' http: https: data: blob: mediastream: filesystem:\n```",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#inline-script" } };
 
-var data$w = { adg_os_any:{ name:"jsinject",
+var data$x = { adg_os_any:{ name:"jsinject",
     description:"Forbids adding of javascript code to the page.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#jsinject-modifier",
     conflicts:[ "domain",
@@ -6559,7 +6785,7 @@ var data$w = { adg_os_any:{ name:"jsinject",
     negatable:false,
     exception_only:true } };
 
-var data$v = { adg_os_any:{ name:"jsonprune",
+var data$w = { adg_os_any:{ name:"jsonprune",
     description:"The `$jsonprune` rules modify the response to a matching request\nby removing JSON items that match a modified JSONPath expression.\nThey do not modify responses which are not valid JSON documents.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#jsonprune-modifier",
     assignable:true,
@@ -6567,7 +6793,7 @@ var data$v = { adg_os_any:{ name:"jsonprune",
     value_optional:true,
     value_format:"(?xi)\n  ^\n    # the expression always starts with a dollar sign (for root)\n    # which should be escaped\n    \\\\\n    \\$\n    \\.?\n    # TODO: improve the expression to invalidate unescaped `$` and `,`\n    .+\n  $" } };
 
-var data$u = { adg_any:{ name:"match-case",
+var data$v = { adg_any:{ name:"match-case",
     description:"This modifier defines a rule which applies only to addresses that match the case.\nDefault rules are case-insensitive.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#match-case-modifier" },
   abp_any:{ name:"match-case",
@@ -6577,7 +6803,7 @@ var data$u = { adg_any:{ name:"match-case",
     description:"This modifier defines a rule which applies only to addresses that match the case.\nDefault rules are case-insensitive.",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#match-case" } };
 
-var data$t = { adg_any:{ name:"media",
+var data$u = { adg_any:{ name:"media",
     description:"A restriction of third-party and own requests.\nA third-party request is a request from a different domain.\nFor example, a request to `example.org` from `domain.com` is a third-party request.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#media-modifier" },
   abp_any:{ name:"media",
@@ -6587,7 +6813,7 @@ var data$t = { adg_any:{ name:"media",
     description:"A restriction of third-party and own requests.\nA third-party request is a request from a different domain.\nFor example, a request to `example.org` from `domain.com` is a third-party request.",
     docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#options" } };
 
-var data$s = { adg_os_any:{ name:"method",
+var data$t = { adg_os_any:{ name:"method",
     description:"This modifier limits the rule scope to requests that use the specified set of HTTP methods.\nNegated methods are allowed.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#method-modifier",
     negatable:false,
@@ -6606,7 +6832,7 @@ var data$s = { adg_os_any:{ name:"method",
     assignable:true,
     value_format:"pipe_separated_methods" } };
 
-var data$r = { adg_os_any:{ name:"mp4",
+var data$s = { adg_os_any:{ name:"mp4",
     description:"As a response to blocked request AdGuard returns a short video placeholder.\nRules with `$mp4` are still supported and being converted into `$redirect=noopmp4-1s` now\nbut the support shall be removed in the future.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#mp4-modifier",
     deprecated:true,
@@ -6623,7 +6849,7 @@ var data$r = { adg_os_any:{ name:"mp4",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#mp4",
     negatable:false } };
 
-var data$q = { adg_os_any:{ name:"network",
+var data$r = { adg_os_any:{ name:"network",
     description:"This is basically a Firewall-kind of rules allowing to fully block\nor unblock access to a specified remote address.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#network-modifier",
     conflicts:[ "app",
@@ -6631,7 +6857,7 @@ var data$q = { adg_os_any:{ name:"network",
     inverse_conflicts:true,
     negatable:false } };
 
-var data$p = { adg_os_any:{ name:"_",
+var data$q = { adg_os_any:{ name:"_",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#noop-modifier",
     description:"The noop modifier does nothing and can be used solely to increase rules' readability.\nIt consists of a sequence of underscore characters (_) of any length\nand can appear in a rule as many times as needed.",
     negatable:false },
@@ -6652,13 +6878,13 @@ var data$p = { adg_os_any:{ name:"_",
     description:"The noop modifier does nothing and can be used solely to increase rules' readability.\nIt consists of a sequence of underscore characters (_) of any length\nand can appear in a rule as many times as needed.",
     negatable:false } };
 
-var data$o = { adg_any:{ name:"object-subrequest",
+var data$p = { adg_any:{ name:"object-subrequest",
     description:"The `$object-subrequest` modifier is removed and is no longer supported.\nRules with it are considered as invalid.\nThe rule corresponds to requests by browser plugins (it is usually Flash).",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#object-subrequest-modifier",
     removed:true,
     removal_message:"The `$object-subrequest` modifier is removed and is no longer supported.\nRules with it are considered as invalid." } };
 
-var data$n = { adg_any:{ name:"object",
+var data$o = { adg_any:{ name:"object",
     description:"The rule corresponds to browser plugins resources, e.g. Java or Flash",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#object-modifier" },
   abp_any:{ name:"object",
@@ -6668,7 +6894,7 @@ var data$n = { adg_any:{ name:"object",
     description:"The rule corresponds to browser plugins resources, e.g. Java or Flash.",
     docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" } };
 
-var data$m = { adg_any:{ name:"other",
+var data$n = { adg_any:{ name:"other",
     description:"The rule applies to requests for which the type has not been determined\nor does not match the types listed above.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#other-modifier" },
   abp_any:{ name:"other",
@@ -6678,7 +6904,7 @@ var data$m = { adg_any:{ name:"other",
     description:"The rule applies to requests for which the type has not been determined\nor does not match the types listed above.",
     docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" } };
 
-var data$l = { adg_os_any:{ name:"permissions",
+var data$m = { adg_os_any:{ name:"permissions",
     description:"For the requests matching a `$permissions` rule, ad blocker strengthens response's feature policy\nby adding additional feature policy equal to the `$permissions` modifier contents.\n`$permissions` rules are applied independently from any other rule type.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#permissions-modifier",
     version_added:"CoreLibs 1.11",
@@ -6691,7 +6917,7 @@ var data$l = { adg_os_any:{ name:"permissions",
     value_optional:true,
     value_format:"permissions_value" } };
 
-var data$k = { adg_any:{ name:"ping",
+var data$l = { adg_any:{ name:"ping",
     description:"The rule corresponds to requests caused by either navigator.sendBeacon() or the ping attribute on links.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#ping-modifier" },
   abp_any:{ name:"ping",
@@ -6701,13 +6927,13 @@ var data$k = { adg_any:{ name:"ping",
     description:"The rule corresponds to requests caused by either navigator.sendBeacon() or the ping attribute on links.",
     docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" } };
 
-var data$j = { ubo_ext_any:{ name:"popunder",
+var data$k = { ubo_ext_any:{ name:"popunder",
     description:"To block \"popunders\" windows/tabs where the original page redirects to an advertisement\nand the desired content loads in the newly created one.\nTo be used in the same manner as the popup filter option, except that it will block popunders.",
     docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#popunder",
     negatable:false,
     block_only:true } };
 
-var data$i = { adg_any:{ name:"popup",
+var data$j = { adg_any:{ name:"popup",
     description:"Pages opened in a new tab or window.\nNote: Filters will not block pop-ups by default, only if the `$popup`  type option is specified.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#popup-modifier",
     negatable:false },
@@ -6720,7 +6946,7 @@ var data$i = { adg_any:{ name:"popup",
     docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options",
     negatable:false } };
 
-var data$h = { adg_os_any:{ name:"redirect-rule",
+var data$i = { adg_os_any:{ name:"redirect-rule",
     description:"This is basically an alias to `$redirect`\nsince it has the same \"redirection\" values and the logic is almost similar.\nThe difference is that `$redirect-rule` is applied only in the case\nwhen the target request is blocked by a different basic rule.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#redirect-rule-modifier",
     conflicts:[ "domain",
@@ -6811,7 +7037,7 @@ var data$h = { adg_os_any:{ name:"redirect-rule",
     negatable:false,
     value_format:"(?x)\n  ^(\n    1x1\\.gif|\n    2x2\\.png|\n    3x2\\.png|\n    32x32\\.png|\n    noop\\.css|\n    noop\\.html|\n    noopframe|\n    noop\\.js|\n    noop\\.txt|\n    noop-0\\.1s\\.mp3|\n    noop-0\\.5s\\.mp3|\n    noop-1s\\.mp4|\n    none|\n    click2load\\.html|\n    addthis_widget\\.js|\n    amazon_ads\\.js|\n    amazon_apstag\\.js|\n    monkeybroker\\.js|\n    doubleclick_instream_ad_status|\n    google-analytics_ga\\.js|\n    google-analytics_analytics\\.js|\n    google-analytics_inpage_linkid\\.js|\n    google-analytics_cx_api\\.js|\n    google-ima\\.js|\n    googletagservices_gpt\\.js|\n    googletagmanager_gtm\\.js|\n    googlesyndication_adsbygoogle\\.js|\n    scorecardresearch_beacon\\.js|\n    outbrain-widget\\.js|\n    hd-main\\.js\n  )\n  (:[0-9]+)?$" } };
 
-var data$g = { adg_os_any:{ name:"redirect",
+var data$h = { adg_os_any:{ name:"redirect",
     description:"Used to redirect web requests to a local \"resource\".",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#redirect-modifier",
     assignable:true,
@@ -6839,6 +7065,17 @@ var data$g = { adg_os_any:{ name:"redirect",
     negatable:false,
     value_format:"(?x)\n  # ABP resources always starts with the `abp-resource:` prefix\n  ^abp-resource:\n  # Possible resource names\n  (\n    blank-text|\n    blank-css|\n    blank-js|\n    blank-html|\n    blank-mp3|\n    1x1-transparent-gif|\n    2x2-transparent-png|\n    3x2-transparent-png|\n    32x32-transparent-png\n  )$" } };
 
+var data$g = { adg_os_any:{ name:"referrerpolicy",
+    description:"This modifier allows overriding of a page's referrer policy.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#referrerpolicy-modifier",
+    conflicts:[ "document",
+      "subdocument" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"referrerpolicy_value" } };
+
 var data$f = { adg_os_any:{ name:"removeheader",
     description:"Rules with the `$removeheader` modifier are intended to remove headers from HTTP requests and responses.",
     docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#removeheader-modifier",
@@ -7148,46 +7385,47 @@ var data = { adg_any:{ name:"xmlhttprequest",
 // @ts-nocheck
 // Please keep imports and exports in alphabetical order
 const rawModifiersData = {
-    all: data$T,
-    app: data$S,
-    badfilter: data$R,
-    cname: data$Q,
-    content: data$P,
-    cookie: data$O,
-    csp: data$N,
-    denyallow: data$M,
-    document: data$L,
-    domain: data$K,
-    elemhide: data$J,
-    empty: data$I,
-    firstParty: data$H,
-    extension: data$G,
-    font: data$F,
-    genericblock: data$E,
-    generichide: data$D,
-    header: data$C,
-    hls: data$B,
-    image: data$A,
-    important: data$z,
-    inlineFont: data$y,
-    inlineScript: data$x,
-    jsinject: data$w,
-    jsonprune: data$v,
-    matchCase: data$u,
-    media: data$t,
-    method: data$s,
-    mp4: data$r,
-    network: data$q,
-    noop: data$p,
-    objectSubrequest: data$o,
-    object: data$n,
-    other: data$m,
-    permissions: data$l,
-    ping: data$k,
-    popunder: data$j,
-    popup: data$i,
-    redirectRule: data$h,
-    redirect: data$g,
+    all: data$U,
+    app: data$T,
+    badfilter: data$S,
+    cname: data$R,
+    content: data$Q,
+    cookie: data$P,
+    csp: data$O,
+    denyallow: data$N,
+    document: data$M,
+    domain: data$L,
+    elemhide: data$K,
+    empty: data$J,
+    firstParty: data$I,
+    extension: data$H,
+    font: data$G,
+    genericblock: data$F,
+    generichide: data$E,
+    header: data$D,
+    hls: data$C,
+    image: data$B,
+    important: data$A,
+    inlineFont: data$z,
+    inlineScript: data$y,
+    jsinject: data$x,
+    jsonprune: data$w,
+    matchCase: data$v,
+    media: data$u,
+    method: data$t,
+    mp4: data$s,
+    network: data$r,
+    noop: data$q,
+    objectSubrequest: data$p,
+    object: data$o,
+    other: data$n,
+    permissions: data$m,
+    ping: data$l,
+    popunder: data$k,
+    popup: data$j,
+    redirectRule: data$i,
+    redirect: data$h,
+    referrerpolicy: data$g,
     removeheader: data$f,
     removeparam: data$e,
     replace: data$d,
@@ -7380,7 +7618,7 @@ const ALLOWED_CSP_DIRECTIVES = new Set([
     'worker-src',
 ]);
 /**
- * Allowed stealth options for $permissions modifier.
+ * Allowed directives for $permissions modifier.
  *
  * @see {@link https://adguard.app/kb/general/ad-filtering/create-own-filters/#permissions-modifier}
  */
@@ -7430,6 +7668,21 @@ const PERMISSIONS_TOKEN_SELF = 'self';
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Permissions_Policy#allowlists}
  */
 const EMPTY_PERMISSIONS_ALLOWLIST = `${OPEN_PARENTHESIS}${CLOSE_PARENTHESIS}`;
+/**
+ * Allowed directives for $referrerpolicy modifier.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy}
+ */
+const REFERRER_POLICY_DIRECTIVES = new Set([
+    'no-referrer',
+    'no-referrer-when-downgrade',
+    'origin',
+    'origin-when-cross-origin',
+    'same-origin',
+    'strict-origin',
+    'strict-origin-when-cross-origin',
+    'unsafe-url',
+]);
 /**
  * Prefixes for error messages used in modifier validation.
  */
@@ -7442,6 +7695,7 @@ const VALIDATION_ERROR_PREFIX = {
     INVALID_PERMISSION_DIRECTIVE: 'Invalid Permissions-Policy directive for the modifier',
     INVALID_PERMISSION_ORIGINS: 'Origins in the value is invalid for the modifier and the directive',
     INVALID_PERMISSION_ORIGIN_QUOTES: 'Double quotes should be used for origins in the value of the modifier',
+    INVALID_REFERRER_POLICY_DIRECTIVE: 'Invalid Referrer-Policy directive for the modifier',
     MIXED_NEGATIONS: 'Simultaneous usage of negated and not negated values is forbidden for the modifier',
     NO_CSP_VALUE: 'No CSP value for the modifier and the directive',
     NO_CSP_DIRECTIVE_QUOTE: 'CSP directives should no be quoted for the modifier',
@@ -7560,14 +7814,14 @@ const getSpecificBlockerData = (modifiersData, blockerPrefix, modifierName) => {
  * @example
  * `example.*` — matches with any TLD, e.g. `example.org`, `example.com`, etc.
  */
-const WILDCARD_TLD = DOT + WILDCARD$1;
+const WILDCARD_TLD = DOT + WILDCARD;
 /**
  * Marker for a wildcard subdomain — `*.`.
  *
  * @example
  * `*.example.org` — matches with any subdomain, e.g. `foo.example.org` or `bar.example.org`
  */
-const WILDCARD_SUBDOMAIN = WILDCARD$1 + DOT;
+const WILDCARD_SUBDOMAIN = WILDCARD + DOT;
 class DomainUtils {
     /**
      * Check if the input is a valid domain or hostname.
@@ -7578,7 +7832,7 @@ class DomainUtils {
     static isValidDomainOrHostname(domain) {
         let domainToCheck = domain;
         // Wildcard-only domain, typically a generic rule
-        if (domainToCheck === WILDCARD$1) {
+        if (domainToCheck === WILDCARD) {
             return true;
         }
         // https://adguard.com/kb/general/ad-filtering/create-own-filters/#wildcard-for-tld
@@ -7765,6 +8019,7 @@ var CustomValueFormatValidatorName;
     CustomValueFormatValidatorName["Domain"] = "pipe_separated_domains";
     CustomValueFormatValidatorName["Method"] = "pipe_separated_methods";
     CustomValueFormatValidatorName["Permissions"] = "permissions_value";
+    CustomValueFormatValidatorName["ReferrerPolicy"] = "referrerpolicy_value";
     CustomValueFormatValidatorName["StealthOption"] = "pipe_separated_stealth_options";
 })(CustomValueFormatValidatorName || (CustomValueFormatValidatorName = {}));
 /**
@@ -7798,7 +8053,7 @@ const isValidAppNameChunk = (chunk) => {
 const isValidAppModifierValue = (value) => {
     // $app modifier does not support wildcard tld
     // https://adguard.app/kb/general/ad-filtering/create-own-filters/#app-modifier
-    if (value.includes(WILDCARD$1)) {
+    if (value.includes(WILDCARD)) {
         return false;
     }
     return value
@@ -7863,7 +8118,7 @@ const isValidDenyAllowModifierValue = (value) => {
     // $denyallow modifier does not support wildcard tld
     // https://adguard.app/kb/general/ad-filtering/create-own-filters/#denyallow-modifier
     // but here we are simply checking whether the value contains wildcard `*`, not ends with `.*`
-    if (value.includes(WILDCARD$1)) {
+    if (value.includes(WILDCARD)) {
         return false;
     }
     // TODO: add cache for domains validation
@@ -8160,7 +8415,7 @@ const validatePermissionAllowlist = (allowlist, directive, modifierName) => {
     // `*` is one of available permissions tokens
     // e.g. 'fullscreen=*'
     // https://w3c.github.io/webappsec-permissions-policy/#structured-header-serialization
-    if (allowlist === WILDCARD$1
+    if (allowlist === WILDCARD
         // e.g. 'autoplay=()'
         || allowlist === EMPTY_PERMISSIONS_ALLOWLIST) {
         return { valid: true };
@@ -8221,6 +8476,26 @@ const validatePermissions = (modifier) => {
     }
     return { valid: true };
 };
+/**
+ * Validates `referrerpolicy_value` custom value format.
+ * Used for $referrerpolicy modifier.
+ *
+ * @param modifier Modifier AST node.
+ *
+ * @returns Validation result.
+ */
+const validateReferrerPolicy = (modifier) => {
+    if (!modifier.value?.value) {
+        return getValueRequiredValidationResult(modifier.modifier.value);
+    }
+    const modifierName = modifier.modifier.value;
+    const modifierValue = modifier.value.value;
+    if (!REFERRER_POLICY_DIRECTIVES.has(modifierValue)) {
+        // eslint-disable-next-line max-len
+        return getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.INVALID_REFERRER_POLICY_DIRECTIVE}: '${modifierName}': '${modifierValue}'`);
+    }
+    return { valid: true };
+};
 /**
  * Map of all available pre-defined validators for modifiers with custom `value_format`.
  */
@@ -8231,6 +8506,7 @@ const CUSTOM_VALUE_FORMAT_MAP = {
     [CustomValueFormatValidatorName.Domain]: validatePipeSeparatedDomains,
     [CustomValueFormatValidatorName.Method]: validatePipeSeparatedMethods,
     [CustomValueFormatValidatorName.Permissions]: validatePermissions,
+    [CustomValueFormatValidatorName.ReferrerPolicy]: validateReferrerPolicy,
     [CustomValueFormatValidatorName.StealthOption]: validatePipeSeparatedStealthOptions,
 };
 /**
@@ -8424,7 +8700,7 @@ class ModifierValidator {
      * @returns Result of modifier validation.
      */
     validate = (syntax, rawModifier, isException = false) => {
-        const modifier = cloneDeep(rawModifier);
+        const modifier = clone(rawModifier);
         // special case: handle noop modifier which may be used as multiple underscores (not just one)
         // https://adguard.com/kb/general/ad-filtering/create-own-filters/#noop-modifier
         if (modifier.modifier.value.startsWith(UNDERSCORE)) {
@@ -8503,7 +8779,9 @@ class ConverterBase {
      * Converts some data to AdGuard format
      *
      * @param data Data to convert
-     * @returns Converted data
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the data is invalid or incompatible
      */
     static convertToAdg(data) {
@@ -8513,7 +8791,9 @@ class ConverterBase {
      * Converts some data to Adblock Plus format
      *
      * @param data Data to convert
-     * @returns Converted data
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the data is invalid or incompatible
      */
     static convertToAbp(data) {
@@ -8523,7 +8803,9 @@ class ConverterBase {
      * Converts some data to uBlock Origin format
      *
      * @param data Data to convert
-     * @returns Converted data
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the data is invalid or incompatible
      */
     static convertToUbo(data) {
@@ -8547,7 +8829,9 @@ class RuleConverterBase extends ConverterBase {
      * Converts an adblock filtering rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
@@ -8557,7 +8841,9 @@ class RuleConverterBase extends ConverterBase {
      * Converts an adblock filtering rule to Adblock Plus format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAbp(rule) {
@@ -8567,7 +8853,9 @@ class RuleConverterBase extends ConverterBase {
      * Converts an adblock filtering rule to uBlock Origin format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToUbo(rule) {
@@ -8575,6 +8863,37 @@ class RuleConverterBase extends ConverterBase {
     }
 }
 
+/**
+ * @file Conversion result interface and helper functions
+ */
+/**
+ * Helper function to create a generic conversion result.
+ *
+ * @param result Conversion result
+ * @param isConverted Indicates whether the input item was converted
+ * @template T Type of the item to convert
+ * @template U Type of the conversion result (defaults to `T`, but can be `T[]` as well)
+ * @returns Generic conversion result
+ */
+// eslint-disable-next-line max-len
+function createConversionResult(result, isConverted) {
+    return {
+        result,
+        isConverted,
+    };
+}
+/**
+ * Helper function to create a node conversion result.
+ *
+ * @param nodes Array of nodes
+ * @param isConverted Indicates whether the input item was converted
+ * @template T Type of the node (extends `Node`)
+ * @returns Node conversion result
+ */
+function createNodeConversionResult(nodes, isConverted) {
+    return createConversionResult(nodes, isConverted);
+}
+
 /**
  * @file Comment rule converter
  */
@@ -8588,27 +8907,30 @@ class CommentRuleConverter extends RuleConverterBase {
      * Converts a comment rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
         // TODO: Add support for other comment types, if needed
         // Main task is # -> ! conversion
-        switch (ruleNode.type) {
+        switch (rule.type) {
             case exports.CommentRuleType.CommentRule:
-                // 'Comment' uBO style comments
-                if (ruleNode.type === exports.CommentRuleType.CommentRule
-                    && ruleNode.marker.value === exports.CommentMarker.Hashmark) {
-                    ruleNode.marker.value = exports.CommentMarker.Regular;
-                    // Add the hashmark to the beginning of the comment
-                    ruleNode.text.value = `${SPACE}${exports.CommentMarker.Hashmark}${ruleNode.text.value}`;
+                // Check if the rule needs to be converted
+                if (rule.type === exports.CommentRuleType.CommentRule && rule.marker.value === exports.CommentMarker.Hashmark) {
+                    // Add a ! to the beginning of the comment
+                    // TODO: Replace with custom clone method
+                    const ruleClone = clone(rule);
+                    ruleClone.marker.value = exports.CommentMarker.Regular;
+                    // Add the hashmark to the beginning of the comment text
+                    ruleClone.text.value = `${SPACE}${exports.CommentMarker.Hashmark}${ruleClone.text.value}`;
+                    return createNodeConversionResult([ruleClone], true);
                 }
-                return [ruleNode];
+                return createNodeConversionResult([rule], false);
             // Leave any other comment rule as is
             default:
-                return [ruleNode];
+                return createNodeConversionResult([rule], false);
         }
     }
 }
@@ -8778,6 +9100,58 @@ class RegExpUtils {
     }
 }
 
+/**
+ * @file Custom clone functions for AST nodes, this is probably the most efficient way to clone AST nodes.
+ * @todo Maybe move them to parser classes as 'clone' methods
+ */
+/**
+ * Clones a scriptlet rule node.
+ *
+ * @param node Node to clone
+ * @returns Cloned node
+ */
+function cloneScriptletRuleNode(node) {
+    return {
+        type: node.type,
+        children: node.children.map((child) => ({ ...child })),
+    };
+}
+/**
+ * Clones a domain list node.
+ *
+ * @param node Node to clone
+ * @returns Cloned node
+ */
+function cloneDomainListNode(node) {
+    return {
+        type: node.type,
+        separator: node.separator,
+        children: node.children.map((domain) => ({ ...domain })),
+    };
+}
+/**
+ * Clones a modifier list node.
+ *
+ * @param node Node to clone
+ * @returns Cloned node
+ */
+function cloneModifierListNode(node) {
+    return {
+        type: node.type,
+        children: node.children.map((modifier) => {
+            const res = {
+                type: modifier.type,
+                exception: modifier.exception,
+                modifier: { ...modifier.modifier },
+            };
+            if (modifier.value) {
+                res.value = { ...modifier.value };
+            }
+            return res;
+        }),
+    };
+}
+
 /**
  * @file HTML filtering rule converter
  */
@@ -8790,16 +9164,22 @@ class RegExpUtils {
  *
  * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#html-filtering-rules}
  */
-const ADGUARD_HTML_DEFAULT_MAX_LENGTH = 8192;
-const ADGUARD_HTML_CONVERSION_MAX_LENGTH = ADGUARD_HTML_DEFAULT_MAX_LENGTH * 32;
+const ADG_HTML_DEFAULT_MAX_LENGTH = 8192;
+const ADG_HTML_CONVERSION_MAX_LENGTH = ADG_HTML_DEFAULT_MAX_LENGTH * 32;
 const NOT_SPECIFIED = -1;
-const CONTAINS$1 = 'contains';
-const HAS_TEXT$1 = 'has-text';
-const MAX_LENGTH = 'max-length';
-const MIN_LENGTH = 'min-length';
-const MIN_TEXT_LENGTH = 'min-text-length';
-const TAG_CONTENT = 'tag-content';
-const WILDCARD = 'wildcard';
+var PseudoClasses$1;
+(function (PseudoClasses) {
+    PseudoClasses["Contains"] = "contains";
+    PseudoClasses["HasText"] = "has-text";
+    PseudoClasses["MinTextLength"] = "min-text-length";
+})(PseudoClasses$1 || (PseudoClasses$1 = {}));
+var AttributeSelectors;
+(function (AttributeSelectors) {
+    AttributeSelectors["MaxLength"] = "max-length";
+    AttributeSelectors["MinLength"] = "min-length";
+    AttributeSelectors["TagContent"] = "tag-content";
+    AttributeSelectors["Wildcard"] = "wildcard";
+})(AttributeSelectors || (AttributeSelectors = {}));
 /**
  * HTML filtering rule converter class
  *
@@ -8822,16 +9202,23 @@ class HtmlRuleConverter extends RuleConverterBase {
      * ```
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
+        // Ignore AdGuard rules
+        if (rule.syntax === exports.AdblockSyntax.Adg) {
+            return createNodeConversionResult([rule], false);
+        }
+        if (rule.syntax === exports.AdblockSyntax.Abp) {
+            throw new RuleConversionError('Invalid rule, ABP does not support HTML filtering rules');
+        }
         // Prepare the conversion result
         const conversionResult = [];
         // Iterate over selector list
-        for (const selector of ruleNode.body.body.children) {
+        for (const selector of rule.body.body.children) {
             // Check selector, just in case
             if (selector.type !== exports.CssTreeNodeType.Selector) {
                 throw new RuleConversionError(`Expected selector, got '${selector.type}'`);
@@ -8858,24 +9245,24 @@ class HtmlRuleConverter extends RuleConverterBase {
                             throw new RuleConversionError('Tag selector should be the first child, if present');
                         }
                         // Simply store the tag selector
-                        convertedSelector.children.push(cloneDeep(node));
+                        convertedSelector.children.push(clone(node));
                         break;
                     case exports.CssTreeNodeType.AttributeSelector:
                         // Check if the attribute selector is a special AdGuard attribute
                         switch (node.name.name) {
-                            case MIN_LENGTH:
+                            case AttributeSelectors.MinLength:
                                 minLength = CssTree.parseAttributeSelectorValueAsNumber(node);
                                 break;
-                            case MAX_LENGTH:
+                            case AttributeSelectors.MaxLength:
                                 maxLength = CssTree.parseAttributeSelectorValueAsNumber(node);
                                 break;
-                            case TAG_CONTENT:
-                            case WILDCARD:
+                            case AttributeSelectors.TagContent:
+                            case AttributeSelectors.Wildcard:
                                 CssTree.assertAttributeSelectorHasStringValue(node);
-                                convertedSelector.children.push(cloneDeep(node));
+                                convertedSelector.children.push(clone(node));
                                 break;
                             default:
-                                convertedSelector.children.push(cloneDeep(node));
+                                convertedSelector.children.push(clone(node));
                         }
                         break;
                     case exports.CssTreeNodeType.PseudoClassSelector:
@@ -8889,18 +9276,18 @@ class HtmlRuleConverter extends RuleConverterBase {
                         }
                         // Process the pseudo class based on its name
                         switch (node.name) {
-                            case HAS_TEXT$1:
-                            case CONTAINS$1:
+                            case PseudoClasses$1.HasText:
+                            case PseudoClasses$1.Contains:
                                 // Check if the argument is a RegExp
                                 if (RegExpUtils.isRegexPattern(arg.value)) {
                                     // TODO: Add some support for RegExp patterns later
                                     // Need to find a way to convert some RegExp patterns to glob patterns
                                     throw new RuleConversionError('Conversion of RegExp patterns is not yet supported');
                                 }
-                                convertedSelector.children.push(CssTree.createAttributeSelectorNode(TAG_CONTENT, arg.value));
+                                convertedSelector.children.push(CssTree.createAttributeSelectorNode(AttributeSelectors.TagContent, arg.value));
                                 break;
                             // https://github.com/gorhill/uBlock/wiki/Procedural-cosmetic-filters#subjectmin-text-lengthn
-                            case MIN_TEXT_LENGTH:
+                            case PseudoClasses$1.MinTextLength:
                                 minLength = CssTree.parsePseudoClassArgumentAsNumber(node);
                                 break;
                             default:
@@ -8912,10 +9299,10 @@ class HtmlRuleConverter extends RuleConverterBase {
                 }
             }
             if (minLength !== NOT_SPECIFIED) {
-                convertedSelector.children.push(CssTree.createAttributeSelectorNode(MIN_LENGTH, String(minLength)));
+                convertedSelector.children.push(CssTree.createAttributeSelectorNode(AttributeSelectors.MinLength, String(minLength)));
             }
-            convertedSelector.children.push(CssTree.createAttributeSelectorNode(MAX_LENGTH, String(maxLength === NOT_SPECIFIED
-                ? ADGUARD_HTML_CONVERSION_MAX_LENGTH
+            convertedSelector.children.push(CssTree.createAttributeSelectorNode(AttributeSelectors.MaxLength, String(maxLength === NOT_SPECIFIED
+                ? ADG_HTML_CONVERSION_MAX_LENGTH
                 : maxLength)));
             // Create the converted rule
             conversionResult.push({
@@ -8925,7 +9312,7 @@ class HtmlRuleConverter extends RuleConverterBase {
                 // Convert the separator based on the exception status
                 separator: {
                     type: 'Value',
-                    value: ruleNode.exception
+                    value: rule.exception
                         ? exports.CosmeticRuleSeparator.AdgHtmlFilteringException
                         : exports.CosmeticRuleSeparator.AdgHtmlFiltering,
                 },
@@ -8940,11 +9327,11 @@ class HtmlRuleConverter extends RuleConverterBase {
                             }],
                     },
                 },
-                exception: ruleNode.exception,
-                domains: ruleNode.domains,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
             });
         }
-        return conversionResult;
+        return createNodeConversionResult(conversionResult, true);
     }
 }
 
@@ -8965,96 +9352,38 @@ function getScriptletName(scriptletNode) {
     return scriptletNode.children[0].value;
 }
 /**
- * Set name of the scriptlet
+ * Set name of the scriptlet.
+ * Modifies input `scriptletNode` if needed.
  *
  * @param scriptletNode Scriptlet node to set name of
  * @param name Name to set
- * @returns Scriptlet node with the specified name
- * @throws If the scriptlet is empty
  */
 function setScriptletName(scriptletNode, name) {
-    if (scriptletNode.children.length === 0) {
-        throw new Error('Empty scriptlet');
+    if (scriptletNode.children.length > 0) {
+        // eslint-disable-next-line no-param-reassign
+        scriptletNode.children[0].value = name;
     }
-    const scriptletNodeClone = cloneDeep(scriptletNode);
-    scriptletNodeClone.children[0].value = name;
-    return scriptletNodeClone;
 }
 /**
  * Set quote type of the scriptlet parameters
  *
  * @param scriptletNode Scriptlet node to set quote type of
  * @param quoteType Preferred quote type
- * @returns Scriptlet node with the specified quote type
  */
 function setScriptletQuoteType(scriptletNode, quoteType) {
-    if (scriptletNode.children.length === 0) {
-        throw new Error('Empty scriptlet');
-    }
-    const scriptletNodeClone = cloneDeep(scriptletNode);
-    for (let i = 0; i < scriptletNodeClone.children.length; i += 1) {
-        scriptletNodeClone.children[i].value = QuoteUtils.setStringQuoteType(scriptletNodeClone.children[i].value, quoteType);
-    }
-    return scriptletNodeClone;
-}
-
-/**
- * @file Scriptlet conversions from ABP and uBO to ADG
- */
-const ABP_SCRIPTLET_PREFIX = 'abp-';
-const UBO_SCRIPTLET_PREFIX = 'ubo-';
-/**
- * Helper class for converting scriptlets from ABP and uBO to ADG
- */
-class AdgScriptletConverter {
-    /**
-     * Helper function to convert scriptlets to ADG. We implement the core
-     * logic here to avoid code duplication.
-     *
-     * @param scriptletNode Scriptlet parameter list node to convert
-     * @param prefix Prefix to add to the scriptlet name
-     * @returns Converted scriptlet parameter list node
-     */
-    static convertToAdg(scriptletNode, prefix) {
-        // Remove possible quotes just to make it easier to work with the scriptlet name
-        const scriptletName = QuoteUtils.setStringQuoteType(getScriptletName(scriptletNode), exports.QuoteType.None);
-        // Clone the node to avoid any side effects
-        let result = cloneDeep(scriptletNode);
-        // Only add prefix if it's not already there
-        if (!scriptletName.startsWith(prefix)) {
-            result = setScriptletName(scriptletNode, `${prefix}${scriptletName}`);
+    if (scriptletNode.children.length > 0) {
+        for (let i = 0; i < scriptletNode.children.length; i += 1) {
+            // eslint-disable-next-line no-param-reassign
+            scriptletNode.children[i].value = QuoteUtils.setStringQuoteType(scriptletNode.children[i].value, quoteType);
         }
-        // ADG scriptlet parameters should be quoted, and single quoted are preferred
-        result = setScriptletQuoteType(result, exports.QuoteType.Single);
-        return result;
     }
-    /**
-     * Converts an ABP snippet node to ADG scriptlet node, if possible.
-     *
-     * @param scriptletNode Scriptlet node to convert
-     * @returns Converted scriptlet node
-     * @throws If the scriptlet isn't supported by ADG or is invalid
-     * @see {@link https://help.adblockplus.org/hc/en-us/articles/1500002338501#snippets-ref}
-     */
-    static convertFromAbp = (scriptletNode) => {
-        return AdgScriptletConverter.convertToAdg(scriptletNode, ABP_SCRIPTLET_PREFIX);
-    };
-    /**
-     * Convert a uBO scriptlet node to ADG scriptlet node, if possible.
-     *
-     * @param scriptletNode Scriptlet node to convert
-     * @returns Converted scriptlet node
-     * @throws If the scriptlet isn't supported by ADG or is invalid
-     * @see {@link https://github.com/gorhill/uBlock/wiki/Resources-Library#available-general-purpose-scriptlets}
-     */
-    static convertFromUbo = (scriptletNode) => {
-        return AdgScriptletConverter.convertToAdg(scriptletNode, UBO_SCRIPTLET_PREFIX);
-    };
 }
 
 /**
  * @file Scriptlet injection rule converter
  */
+const ABP_SCRIPTLET_PREFIX = 'abp-';
+const UBO_SCRIPTLET_PREFIX = 'ubo-';
 /**
  * Scriptlet injection rule converter class
  *
@@ -9065,38 +9394,91 @@ class ScriptletRuleConverter extends RuleConverterBase {
      * Converts a scriptlet injection rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
+        // Ignore AdGuard rules
+        if (rule.syntax === exports.AdblockSyntax.Adg) {
+            return createNodeConversionResult([rule], false);
+        }
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
+        convertedSeparator = rule.exception
+            ? exports.CosmeticRuleSeparator.AdgJsInjectionException
+            : exports.CosmeticRuleSeparator.AdgJsInjection;
         const convertedScriptlets = [];
-        for (const scriptlet of ruleNode.body.children) {
-            if (ruleNode.syntax === exports.AdblockSyntax.Abp) {
-                convertedScriptlets.push(AdgScriptletConverter.convertFromAbp(scriptlet));
-            }
-            else if (ruleNode.syntax === exports.AdblockSyntax.Ubo) {
-                convertedScriptlets.push(AdgScriptletConverter.convertFromUbo(scriptlet));
+        for (const scriptlet of rule.body.children) {
+            // Clone the node to avoid any side effects
+            const scriptletClone = cloneScriptletRuleNode(scriptlet);
+            // Remove possible quotes just to make it easier to work with the scriptlet name
+            const scriptletName = QuoteUtils.setStringQuoteType(getScriptletName(scriptletClone), exports.QuoteType.None);
+            // Add prefix if it's not already there
+            let prefix;
+            switch (rule.syntax) {
+                case exports.AdblockSyntax.Abp:
+                    prefix = ABP_SCRIPTLET_PREFIX;
+                    break;
+                case exports.AdblockSyntax.Ubo:
+                    prefix = UBO_SCRIPTLET_PREFIX;
+                    break;
+                default:
+                    prefix = EMPTY;
             }
-            else if (ruleNode.syntax === exports.AdblockSyntax.Adg) {
-                convertedScriptlets.push(scriptlet);
+            if (!scriptletName.startsWith(prefix)) {
+                setScriptletName(scriptletClone, `${prefix}${scriptletName}`);
             }
+            // ADG scriptlet parameters should be quoted, and single quoted are preferred
+            setScriptletQuoteType(scriptletClone, exports.QuoteType.Single);
+            convertedScriptlets.push(scriptletClone);
         }
-        ruleNode.separator.value = ruleNode.exception
-            ? exports.CosmeticRuleSeparator.AdgJsInjectionException
-            : exports.CosmeticRuleSeparator.AdgJsInjection;
-        // ADG doesn't support multiple scriptlets in one rule, so we should split them
-        return convertedScriptlets.map((scriptlet) => {
-            return {
-                ...ruleNode,
+        return createNodeConversionResult(convertedScriptlets.map((scriptlet) => {
+            const res = {
+                category: rule.category,
+                type: rule.type,
                 syntax: exports.AdblockSyntax.Adg,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: convertedSeparator,
+                },
                 body: {
-                    ...ruleNode.body,
+                    type: rule.body.type,
                     children: [scriptlet],
                 },
             };
-        });
+            if (rule.modifiers) {
+                res.modifiers = cloneModifierListNode(rule.modifiers);
+            }
+            return res;
+        }), true);
+    }
+}
+
+/**
+ * A very simple map extension that allows to store multiple values for the same key
+ * by storing them in an array.
+ *
+ * @todo Add more methods if needed
+ */
+class MultiValueMap extends Map {
+    /**
+     * Adds a value to the map. If the key already exists, the value will be appended to the existing array,
+     * otherwise a new array will be created for the key.
+     *
+     * @param key Key to add
+     * @param values Value(s) to add
+     */
+    add(key, ...values) {
+        let currentValues = super.get(key);
+        if (isUndefined(currentValues)) {
+            currentValues = [];
+            super.set(key, values);
+        }
+        currentValues.push(...values);
     }
 }
 
@@ -9122,69 +9504,115 @@ class AdgCosmeticRuleModifierConverter {
      * Converts a uBO cosmetic rule modifier list to ADG, if possible.
      *
      * @param modifierList Cosmetic rule modifier list node to convert
-     * @returns Converted cosmetic rule modifier list node
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the modifier list cannot be converted
      * @see {@link https://github.com/gorhill/uBlock/wiki/Procedural-cosmetic-filters#cosmetic-filter-operators}
      */
-    static convertFromUbo = (modifierList) => {
-        const convertedModifierList = createModifierListNode();
-        for (const modifier of modifierList.children) {
-            let modifierValue;
-            switch (modifier.modifier.value) {
-                case UBO_MATCHES_PATH_OPERATOR:
-                    // :matches-path() should have a value
-                    if (!modifier.value) {
-                        throw new RuleConversionError('Missing value for :matches-path(...)');
-                    }
-                    modifierValue = RegExpUtils.isRegexPattern(modifier.value.value)
-                        ? StringUtils.escapeCharacters(modifier.value.value, SPECIAL_MODIFIER_REGEX_CHARS)
-                        : modifier.value.value;
-                    // Convert uBO's `:matches-path(...)` operator to ADG's `$path=...` modifier
-                    convertedModifierList.children.push(createModifierNode(ADG_PATH_MODIFIER, 
-                    // We should negate the regexp if the modifier is an exception
-                    modifier.exception
-                        // eslint-disable-next-line max-len
-                        ? `${REGEX_MARKER}${RegExpUtils.negateRegexPattern(RegExpUtils.patternToRegexp(modifierValue))}${REGEX_MARKER}`
-                        : modifierValue));
-                    break;
-                default:
-                    // Leave the modifier as-is
-                    convertedModifierList.children.push(modifier);
+    static convertFromUbo(modifierList) {
+        const conversionMap = new MultiValueMap();
+        modifierList.children.forEach((modifier, index) => {
+            // :matches-path
+            if (modifier.modifier.value === UBO_MATCHES_PATH_OPERATOR) {
+                if (!modifier.value) {
+                    throw new RuleConversionError(`'${UBO_MATCHES_PATH_OPERATOR}' operator requires a value`);
+                }
+                const value = RegExpUtils.isRegexPattern(modifier.value.value)
+                    ? StringUtils.escapeCharacters(modifier.value.value, SPECIAL_MODIFIER_REGEX_CHARS)
+                    : modifier.value.value;
+                // Convert uBO's `:matches-path(...)` operator to ADG's `$path=...` modifier
+                conversionMap.add(index, createModifierNode(ADG_PATH_MODIFIER, 
+                // We should negate the regexp if the modifier is an exception
+                modifier.exception
+                    // eslint-disable-next-line max-len
+                    ? `${REGEX_MARKER}${RegExpUtils.negateRegexPattern(RegExpUtils.patternToRegexp(value))}${REGEX_MARKER}`
+                    : value));
             }
-        }
-        return convertedModifierList;
-    };
+        });
+        // Check if we have any converted modifiers
+        if (conversionMap.size) {
+            const modifierListClone = clone(modifierList);
+            // Replace the original modifiers with the converted ones
+            modifierListClone.children = modifierListClone.children.map((modifier, index) => {
+                const convertedModifier = conversionMap.get(index);
+                return convertedModifier ?? modifier;
+            }).flat();
+            return createConversionResult(modifierListClone, true);
+        }
+        // Otherwise, just return the original modifier list
+        return createConversionResult(modifierList, false);
+    }
 }
 
-// Constants for pseudo-classes (please keep them sorted alphabetically)
-const ABP_CONTAINS = '-abp-contains';
-const ABP_HAS = '-abp-has';
-const CONTAINS = 'contains';
-const HAS = 'has';
-const HAS_TEXT = 'has-text';
-const MATCHES_CSS = 'matches-css';
-const MATCHES_CSS_AFTER = 'matches-css-after';
-const MATCHES_CSS_BEFORE = 'matches-css-before';
-const NOT = 'not';
-// Constants for pseudo-elements (please keep them sorted alphabetically)
-const AFTER = 'after';
-const BEFORE = 'before';
+var PseudoClasses;
+(function (PseudoClasses) {
+    PseudoClasses["AbpContains"] = "-abp-contains";
+    PseudoClasses["AbpHas"] = "-abp-has";
+    PseudoClasses["Contains"] = "contains";
+    PseudoClasses["Has"] = "has";
+    PseudoClasses["HasText"] = "has-text";
+    PseudoClasses["MatchesCss"] = "matches-css";
+    PseudoClasses["MatchesCssAfter"] = "matches-css-after";
+    PseudoClasses["MatchesCssBefore"] = "matches-css-before";
+    PseudoClasses["Not"] = "not";
+})(PseudoClasses || (PseudoClasses = {}));
+var PseudoElements;
+(function (PseudoElements) {
+    PseudoElements["After"] = "after";
+    PseudoElements["Before"] = "before";
+})(PseudoElements || (PseudoElements = {}));
+const PSEUDO_ELEMENT_NAMES = new Set([
+    PseudoElements.After,
+    PseudoElements.Before,
+]);
+const LEGACY_MATCHES_CSS_NAMES = new Set([
+    PseudoClasses.MatchesCssAfter,
+    PseudoClasses.MatchesCssBefore,
+]);
+const LEGACY_EXT_CSS_INDICATOR_PSEUDO_NAMES = new Set([
+    PseudoClasses.Not,
+    PseudoClasses.MatchesCssBefore,
+    PseudoClasses.MatchesCssAfter,
+]);
+const CSS_CONVERSION_INDICATOR_PSEUDO_NAMES = new Set([
+    PseudoClasses.AbpContains,
+    PseudoClasses.AbpHas,
+    PseudoClasses.HasText,
+]);
 /**
  * Converts some pseudo-classes to pseudo-elements. For example:
  * - `:before` → `::before`
  *
  * @param selectorList Selector list to convert
- * @returns Converted selector list
+ * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+ * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+ * If the node was not converted, the result will contain the original node with the same object reference
  */
 function convertToPseudoElements(selectorList) {
-    // Prepare conversion result
-    const selectorListClone = cloneDeep(selectorList);
+    // Check conversion indications before doing any heavy work
+    const hasIndicator = ecssTree.find(
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    selectorList, (node) => node.type === exports.CssTreeNodeType.PseudoClassSelector && PSEUDO_ELEMENT_NAMES.has(node.name));
+    if (!hasIndicator) {
+        return createConversionResult(selectorList, false);
+    }
+    // Make a clone of the selector list to avoid modifying the original one,
+    // then convert & return the cloned version
+    const selectorListClone = clone(selectorList);
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ecssTree.walk(selectorListClone, {
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         leave: (node) => {
             if (node.type === exports.CssTreeNodeType.PseudoClassSelector) {
-                // :after  → ::after
-                // :before → ::before
-                if (node.name === AFTER || node.name === BEFORE) {
+                // If the pseudo-class is `:before` or `:after`, then we should
+                // convert the node type to pseudo-element:
+                //  :after  → ::after
+                //  :before → ::before
+                if (PSEUDO_ELEMENT_NAMES.has(node.name)) {
                     Object.assign(node, {
                         ...node,
                         type: exports.CssTreeNodeType.PseudoElementSelector,
@@ -9193,7 +9621,7 @@ function convertToPseudoElements(selectorList) {
             }
         },
     });
-    return selectorListClone;
+    return createConversionResult(selectorListClone, true);
 }
 /**
  * Converts legacy Extended CSS `matches-css-before` and `matches-css-after`
@@ -9202,33 +9630,36 @@ function convertToPseudoElements(selectorList) {
  * - `:matches-css-after(...)`  → `:matches-css(after, ...)`
  *
  * @param node Node to convert
+ * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+ * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+ * If the node was not converted, the result will contain the original node with the same object reference
  * @throws If the node is invalid
  */
 function convertLegacyMatchesCss(node) {
-    const nodeClone = cloneDeep(node);
-    if (nodeClone.type === exports.CssTreeNodeType.PseudoClassSelector
-        && [MATCHES_CSS_BEFORE, MATCHES_CSS_AFTER].includes(nodeClone.name)) {
-        if (!nodeClone.children || nodeClone.children.size < 1) {
-            throw new Error(`Invalid ${nodeClone.name} pseudo-class: missing argument`);
-        }
-        // Remove the 'matches-css-' prefix to get the direction
-        const direction = nodeClone.name.substring(MATCHES_CSS.length + 1);
-        // Rename the pseudo-class
-        nodeClone.name = MATCHES_CSS;
-        // Add the direction to the first raw argument
-        const arg = nodeClone.children.first;
-        // Check argument
-        if (!arg) {
-            throw new Error(`Invalid ${nodeClone.name} pseudo-class: argument shouldn't be null`);
-        }
-        if (arg.type !== exports.CssTreeNodeType.Raw) {
-            throw new Error(`Invalid ${nodeClone.name} pseudo-class: unexpected argument type`);
-        }
-        // Add the direction as the first argument
-        arg.value = `${direction},${arg.value}`;
-        // Replace the original node with the converted one
-        Object.assign(node, nodeClone);
-    }
+    // Check conversion indications before doing any heavy work
+    if (node.type !== exports.CssTreeNodeType.PseudoClassSelector || !LEGACY_MATCHES_CSS_NAMES.has(node.name)) {
+        return createConversionResult(node, false);
+    }
+    const nodeClone = clone(node);
+    if (!nodeClone.children || nodeClone.children.length < 1) {
+        throw new Error(`Invalid ${node.name} pseudo-class: missing argument`);
+    }
+    // Rename the pseudo-class
+    nodeClone.name = PseudoClasses.MatchesCss;
+    // Remove the 'matches-css-' prefix to get the direction
+    const direction = node.name.substring(PseudoClasses.MatchesCss.length + 1);
+    // Add the direction to the first raw argument
+    const arg = nodeClone.children[0];
+    // Check argument
+    if (!arg) {
+        throw new Error(`Invalid ${node.name} pseudo-class: argument shouldn't be null`);
+    }
+    if (arg.type !== exports.CssTreeNodeType.Raw) {
+        throw new Error(`Invalid ${node.name} pseudo-class: unexpected argument type`);
+    }
+    // Add the direction as the first argument
+    arg.value = `${direction},${arg.value}`;
+    return createConversionResult(nodeClone, true);
 }
 /**
  * Converts legacy Extended CSS selectors to the modern Extended CSS syntax.
@@ -9238,16 +9669,40 @@ function convertLegacyMatchesCss(node) {
  * - `[-ext-matches-css-before=...]` → `:matches-css(before, ...)`
  *
  * @param selectorList Selector list AST to convert
- * @returns Converted selector list
+ * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+ * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+ * If the node was not converted, the result will contain the original node with the same object reference
  */
 function convertFromLegacyExtendedCss(selectorList) {
-    // Prepare conversion result
-    const selectorListClone = cloneDeep(selectorList);
+    // Check conversion indications before doing any heavy work
+    const hasIndicator = ecssTree.find(
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    selectorList, (node) => {
+        if (node.type === exports.CssTreeNodeType.PseudoClassSelector) {
+            return LEGACY_EXT_CSS_INDICATOR_PSEUDO_NAMES.has(node.name);
+        }
+        if (node.type === exports.CssTreeNodeType.AttributeSelector) {
+            return node.name.name.startsWith(LEGACY_EXT_CSS_ATTRIBUTE_PREFIX);
+        }
+        return false;
+    });
+    if (!hasIndicator) {
+        return createConversionResult(selectorList, false);
+    }
+    const selectorListClone = clone(selectorList);
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ecssTree.walk(selectorListClone, {
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         leave: (node) => {
             // :matches-css-before(arg) → :matches-css(before,arg)
             // :matches-css-after(arg)  → :matches-css(after,arg)
-            convertLegacyMatchesCss(node);
+            const convertedLegacyExtCss = convertLegacyMatchesCss(node);
+            if (convertedLegacyExtCss.isConverted) {
+                Object.assign(node, convertedLegacyExtCss.result);
+            }
             // [-ext-name=...]   → :name(...)
             // [-ext-name='...'] → :name(...)
             // [-ext-name="..."] → :name(...)
@@ -9261,7 +9716,7 @@ function convertFromLegacyExtendedCss(selectorList) {
                 // Remove the '-ext-' prefix to get the pseudo-class name
                 const name = node.name.name.substring(LEGACY_EXT_CSS_ATTRIBUTE_PREFIX.length);
                 // Prepare the children list for the pseudo-class node
-                const children = new ecssTree.List();
+                const children = [];
                 // TODO: Change String node to Raw node to drop the quotes.
                 // The structure of the node is the same, just the type
                 // is different and generate() will generate the quotes
@@ -9274,7 +9729,7 @@ function convertFromLegacyExtendedCss(selectorList) {
                 // For example, if the input is [-ext-has="> .selector"], then
                 // we need to parse "> .selector" as a selector instead of string
                 // it as a raw value
-                if ([HAS, NOT].includes(name)) {
+                if ([PseudoClasses.Has, PseudoClasses.Not].includes(name)) {
                     // Get the value of the attribute selector
                     const { value } = node;
                     // If the value is an identifier, then simply push it to the
@@ -9284,10 +9739,12 @@ function convertFromLegacyExtendedCss(selectorList) {
                     }
                     else if (value.type === exports.CssTreeNodeType.String) {
                         // Parse the value as a selector
-                        const parsedChildren = CssTree.parse(value.value, exports.CssTreeParserContext.selectorList);
+                        const parsedChildren = CssTree.parsePlain(value.value, exports.CssTreeParserContext.selectorList);
                         // Don't forget convert the parsed AST again, because
                         // it was a raw string before
-                        children.push(convertFromLegacyExtendedCss(parsedChildren));
+                        const convertedChildren = convertFromLegacyExtendedCss(parsedChildren);
+                        // Push the converted children to the list
+                        children.push(convertedChildren.result);
                     }
                 }
                 else {
@@ -9314,14 +9771,12 @@ function convertFromLegacyExtendedCss(selectorList) {
                     children,
                 };
                 // Handle this case: [-ext-matches-css-before=...] → :matches-css(before,...)
-                convertLegacyMatchesCss(pseudoNode);
-                // Convert attribute selector to pseudo-class selector, but
-                // keep the reference to the original node
-                Object.assign(node, pseudoNode);
+                const convertedPseudoNode = convertLegacyMatchesCss(pseudoNode);
+                Object.assign(node, convertedPseudoNode.isConverted ? convertedPseudoNode.result : pseudoNode);
             }
         },
     });
-    return selectorListClone;
+    return createConversionResult(selectorListClone, true);
 }
 /**
  * CSS selector converter
@@ -9333,32 +9788,51 @@ class CssSelectorConverter extends ConverterBase {
      * Converts Extended CSS elements to AdGuard-compatible ones
      *
      * @param selectorList Selector list to convert
-     * @returns Converted selector list
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the rule is invalid or incompatible
      */
     static convertToAdg(selectorList) {
         // First, convert
         //  - legacy Extended CSS selectors to the modern Extended CSS syntax and
         //  - some pseudo-classes to pseudo-elements
-        const selectorListClone = convertToPseudoElements(convertFromLegacyExtendedCss(cloneDeep(selectorList)));
+        const legacyExtCssConverted = convertFromLegacyExtendedCss(selectorList);
+        const pseudoElementsConverted = convertToPseudoElements(legacyExtCssConverted.result);
+        const hasIndicator = legacyExtCssConverted.isConverted || pseudoElementsConverted.isConverted || ecssTree.find(
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        selectorList, 
+        // eslint-disable-next-line max-len
+        (node) => node.type === exports.CssTreeNodeType.PseudoClassSelector && CSS_CONVERSION_INDICATOR_PSEUDO_NAMES.has(node.name));
+        if (!hasIndicator) {
+            return createConversionResult(selectorList, false);
+        }
+        const selectorListClone = legacyExtCssConverted.isConverted || pseudoElementsConverted.isConverted
+            ? pseudoElementsConverted.result
+            : clone(selectorList);
         // Then, convert some Extended CSS pseudo-classes to AdGuard-compatible ones
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ecssTree.walk(selectorListClone, {
+            // TODO: Need to improve CSSTree types, until then we need to use any type here
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             leave: (node) => {
                 if (node.type === exports.CssTreeNodeType.PseudoClassSelector) {
                     // :-abp-contains(...) → :contains(...)
                     // :has-text(...)      → :contains(...)
-                    if (node.name === ABP_CONTAINS || node.name === HAS_TEXT) {
-                        CssTree.renamePseudoClass(node, CONTAINS);
+                    if (node.name === PseudoClasses.AbpContains || node.name === PseudoClasses.HasText) {
+                        CssTree.renamePseudoClass(node, PseudoClasses.Contains);
                     }
                     // :-abp-has(...) → :has(...)
-                    if (node.name === ABP_HAS) {
-                        CssTree.renamePseudoClass(node, HAS);
+                    if (node.name === PseudoClasses.AbpHas) {
+                        CssTree.renamePseudoClass(node, PseudoClasses.Has);
                     }
                     // TODO: check uBO's `:others()` and `:watch-attr()` pseudo-classes
                 }
             },
         });
-        return selectorListClone;
+        return createConversionResult(selectorListClone, true);
     }
 }
 
@@ -9375,27 +9849,39 @@ class CssInjectionRuleConverter extends RuleConverterBase {
      * Converts a CSS injection rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
         // Change the separator if the rule contains ExtendedCSS selectors
-        if (CssTree.hasAnySelectorExtendedCssNode(ruleNode.body.selectorList) || ruleNode.body.remove) {
-            ruleNode.separator.value = ruleNode.exception
+        if (CssTree.hasAnySelectorExtendedCssNode(rule.body.selectorList) || rule.body.remove) {
+            convertedSeparator = rule.exception
                 ? exports.CosmeticRuleSeparator.AdgExtendedCssInjectionException
                 : exports.CosmeticRuleSeparator.AdgExtendedCssInjection;
         }
         else {
-            ruleNode.separator.value = ruleNode.exception
+            convertedSeparator = rule.exception
                 ? exports.CosmeticRuleSeparator.AdgCssInjectionException
                 : exports.CosmeticRuleSeparator.AdgCssInjection;
         }
-        // Convert CSS selector list
-        Object.assign(ruleNode.body.selectorList, CssSelectorConverter.convertToAdg(ecssTree.fromPlainObject(ruleNode.body.selectorList)));
-        ruleNode.syntax = exports.AdblockSyntax.Adg;
-        return [ruleNode];
+        const convertedSelectorList = CssSelectorConverter.convertToAdg(rule.body.selectorList);
+        // Check if the rule needs to be converted
+        if (!(rule.syntax === exports.AdblockSyntax.Common || rule.syntax === exports.AdblockSyntax.Adg)
+            || separator !== convertedSeparator
+            || convertedSelectorList.isConverted) {
+            // TODO: Replace with custom clone method
+            const ruleClone = clone(rule);
+            ruleClone.syntax = exports.AdblockSyntax.Adg;
+            ruleClone.separator.value = convertedSeparator;
+            ruleClone.body.selectorList = convertedSelectorList.result;
+            return createNodeConversionResult([ruleClone], true);
+        }
+        // Otherwise, return the original rule
+        return createNodeConversionResult([rule], false);
     }
 }
 
@@ -9412,27 +9898,39 @@ class ElementHidingRuleConverter extends RuleConverterBase {
      * Converts an element hiding rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
         // Change the separator if the rule contains ExtendedCSS selectors
-        if (CssTree.hasAnySelectorExtendedCssNode(ruleNode.body.selectorList)) {
-            ruleNode.separator.value = ruleNode.exception
+        if (CssTree.hasAnySelectorExtendedCssNode(rule.body.selectorList)) {
+            convertedSeparator = rule.exception
                 ? exports.CosmeticRuleSeparator.ExtendedElementHidingException
                 : exports.CosmeticRuleSeparator.ExtendedElementHiding;
         }
         else {
-            ruleNode.separator.value = ruleNode.exception
+            convertedSeparator = rule.exception
                 ? exports.CosmeticRuleSeparator.ElementHidingException
                 : exports.CosmeticRuleSeparator.ElementHiding;
         }
-        // Convert CSS selector list
-        Object.assign(ruleNode.body.selectorList, CssSelectorConverter.convertToAdg(ecssTree.fromPlainObject(ruleNode.body.selectorList)));
-        ruleNode.syntax = exports.AdblockSyntax.Adg;
-        return [ruleNode];
+        const convertedSelectorList = CssSelectorConverter.convertToAdg(rule.body.selectorList);
+        // Check if the rule needs to be converted
+        if (!(rule.syntax === exports.AdblockSyntax.Common || rule.syntax === exports.AdblockSyntax.Adg)
+            || separator !== convertedSeparator
+            || convertedSelectorList.isConverted) {
+            // TODO: Replace with custom clone method
+            const ruleClone = clone(rule);
+            ruleClone.syntax = exports.AdblockSyntax.Adg;
+            ruleClone.separator.value = convertedSeparator;
+            ruleClone.body.selectorList = convertedSelectorList.result;
+            return createNodeConversionResult([ruleClone], true);
+        }
+        // Otherwise, return the original rule
+        return createNodeConversionResult([rule], false);
     }
 }
 
@@ -9460,7 +9958,7 @@ function createNetworkRuleNode(pattern, modifiers = undefined, exception = false
         },
     };
     if (!isUndefined(modifiers)) {
-        result.modifiers = cloneDeep(modifiers);
+        result.modifiers = clone(modifiers);
     }
     return result;
 }
@@ -9480,32 +9978,37 @@ class HeaderRemovalRuleConverter extends RuleConverterBase {
      * Converts a header removal rule to AdGuard syntax, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
+     * @example
+     * If the input rule is:
+     * ```adblock
+     * example.com##^responseheader(header-name)
+     * ```
+     * The output will be:
+     * ```adblock
+     * ||example.com^$removeheader=header-name
+     * ```
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
         // TODO: Add support for ABP syntax once it starts supporting header removal rules
-        // Check the input rule
-        if (ruleNode.category !== exports.RuleCategory.Cosmetic
-            || ruleNode.type !== exports.CosmeticRuleType.HtmlFilteringRule
-            || ruleNode.body.body.type !== exports.CssTreeNodeType.Function
-            || ruleNode.body.body.name !== UBO_RESPONSEHEADER_MARKER) {
-            throw new RuleConversionError('Not a response header rule');
+        // Leave the rule as is if it's not a header removal rule
+        if (rule.category !== exports.RuleCategory.Cosmetic
+            || rule.type !== exports.CosmeticRuleType.HtmlFilteringRule
+            || rule.body.body.type !== exports.CssTreeNodeType.Function
+            || rule.body.body.name !== UBO_RESPONSEHEADER_MARKER) {
+            return createNodeConversionResult([rule], false);
         }
         // Prepare network rule pattern
-        let pattern = EMPTY;
-        if (ruleNode.domains.children.length === 1) {
+        const pattern = [];
+        if (rule.domains.children.length === 1) {
             // If the rule has only one domain, we can use a simple network rule pattern:
             // ||single-domain-from-the-rule^
-            pattern = [
-                ADBLOCK_URL_START,
-                ruleNode.domains.children[0].value,
-                ADBLOCK_URL_SEPARATOR,
-            ].join(EMPTY);
+            pattern.push(ADBLOCK_URL_START, rule.domains.children[0].value, ADBLOCK_URL_SEPARATOR);
         }
-        else if (ruleNode.domains.children.length > 1) {
+        else if (rule.domains.children.length > 1) {
             // TODO: Add support for multiple domains, for example:
             // example.com,example.org,example.net##^responseheader(header-name)
             // We should consider allowing $domain with $removeheader modifier,
@@ -9515,13 +10018,13 @@ class HeaderRemovalRuleConverter extends RuleConverterBase {
         }
         // Prepare network rule modifiers
         const modifiers = createModifierListNode();
-        modifiers.children.push(createModifierNode(ADG_REMOVEHEADER_MODIFIER, CssTree.generateFunctionValue(ecssTree.fromPlainObject(ruleNode.body.body))));
+        modifiers.children.push(createModifierNode(ADG_REMOVEHEADER_MODIFIER, CssTree.generateFunctionPlainValue(rule.body.body)));
         // Construct the network rule
-        return [
-            createNetworkRuleNode(pattern, modifiers, 
+        return createNodeConversionResult([
+            createNetworkRuleNode(pattern.join(EMPTY), modifiers, 
             // Copy the exception flag
-            ruleNode.exception, exports.AdblockSyntax.Adg),
-        ];
+            rule.exception, exports.AdblockSyntax.Adg),
+        ], true);
     }
 }
 
@@ -9538,48 +10041,69 @@ class CosmeticRuleConverter extends RuleConverterBase {
      * Converts a cosmetic rule to AdGuard syntax, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
-        // Convert cosmetic rule modifiers
-        if (ruleNode.modifiers) {
-            if (ruleNode.syntax === exports.AdblockSyntax.Ubo) {
-                // uBO doesn't support this rule:
-                // example.com##+js(set-constant.js, foo, bar):matches-path(/baz)
-                if (ruleNode.type === exports.CosmeticRuleType.ScriptletInjectionRule) {
-                    throw new RuleConversionError('uBO scriptlet injection rules don\'t support cosmetic rule modifiers');
-                }
-                ruleNode.modifiers = AdgCosmeticRuleModifierConverter.convertFromUbo(ruleNode.modifiers);
-            }
-            else if (ruleNode.syntax === exports.AdblockSyntax.Abp) {
-                // TODO: Implement once ABP starts supporting cosmetic rule modifiers
-                throw new RuleConversionError('ABP don\'t support cosmetic rule modifiers');
-            }
-        }
+        let subconverterResult;
         // Convert cosmetic rule based on its type
-        switch (ruleNode.type) {
+        switch (rule.type) {
             case exports.CosmeticRuleType.ElementHidingRule:
-                return ElementHidingRuleConverter.convertToAdg(ruleNode);
+                subconverterResult = ElementHidingRuleConverter.convertToAdg(rule);
+                break;
             case exports.CosmeticRuleType.ScriptletInjectionRule:
-                return ScriptletRuleConverter.convertToAdg(ruleNode);
+                subconverterResult = ScriptletRuleConverter.convertToAdg(rule);
+                break;
             case exports.CosmeticRuleType.CssInjectionRule:
-                return CssInjectionRuleConverter.convertToAdg(ruleNode);
+                subconverterResult = CssInjectionRuleConverter.convertToAdg(rule);
+                break;
             case exports.CosmeticRuleType.HtmlFilteringRule:
                 // Handle special case: uBO response header filtering rule
-                if (ruleNode.body.body.type === exports.CssTreeNodeType.Function
-                    && ruleNode.body.body.name === UBO_RESPONSEHEADER_MARKER) {
-                    return HeaderRemovalRuleConverter.convertToAdg(ruleNode);
+                if (rule.body.body.type === exports.CssTreeNodeType.Function
+                    && rule.body.body.name === UBO_RESPONSEHEADER_MARKER) {
+                    subconverterResult = HeaderRemovalRuleConverter.convertToAdg(rule);
+                }
+                else {
+                    subconverterResult = HtmlRuleConverter.convertToAdg(rule);
                 }
-                return HtmlRuleConverter.convertToAdg(ruleNode);
-            // Note: Currently, only ADG supports JS injection rules
+                break;
+            // Note: Currently, only ADG supports JS injection rules, so we don't need to convert them
             case exports.CosmeticRuleType.JsInjectionRule:
-                return [ruleNode];
+                subconverterResult = createNodeConversionResult([rule], false);
+                break;
             default:
                 throw new RuleConversionError('Unsupported cosmetic rule type');
         }
+        let convertedModifiers;
+        // Convert cosmetic rule modifiers, if any
+        if (rule.modifiers) {
+            if (rule.syntax === exports.AdblockSyntax.Ubo) {
+                // uBO doesn't support this rule:
+                // example.com##+js(set-constant.js, foo, bar):matches-path(/baz)
+                if (rule.type === exports.CosmeticRuleType.ScriptletInjectionRule) {
+                    throw new RuleConversionError('uBO scriptlet injection rules don\'t support cosmetic rule modifiers');
+                }
+                convertedModifiers = AdgCosmeticRuleModifierConverter.convertFromUbo(rule.modifiers);
+            }
+            else if (rule.syntax === exports.AdblockSyntax.Abp) {
+                // TODO: Implement once ABP starts supporting cosmetic rule modifiers
+                throw new RuleConversionError('ABP don\'t support cosmetic rule modifiers');
+            }
+        }
+        if ((subconverterResult.result.length > 1 || subconverterResult.isConverted)
+            || (convertedModifiers && convertedModifiers.isConverted)) {
+            // Add modifier list to the subconverter result rules
+            subconverterResult.result.forEach((subconverterRule) => {
+                if (convertedModifiers && subconverterRule.category === exports.RuleCategory.Cosmetic) {
+                    // eslint-disable-next-line no-param-reassign
+                    subconverterRule.modifiers = convertedModifiers.result;
+                }
+            });
+            return subconverterResult;
+        }
+        return createNodeConversionResult([rule], false);
     }
 }
 
@@ -9651,17 +10175,16 @@ class NetworkRuleModifierListConverter extends ConverterBase {
      * Converts a network rule modifier list to AdGuard format, if possible.
      *
      * @param modifierList Network rule modifier list node to convert
-     * @returns Converted modifier list node
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the conversion is not possible
      */
     static convertToAdg(modifierList) {
-        // Clone the provided AST node to avoid side effects
-        const modifierListNode = cloneDeep(modifierList);
-        const convertedModifierList = createModifierListNode();
-        // We should merge $csp modifiers into one
-        const cspValues = [];
-        modifierListNode.children.forEach((modifierNode) => {
-            // Handle regular modifiers conversion and $csp modifiers collection
+        const conversionMap = new MultiValueMap();
+        // Special case: $csp modifier
+        let cspCount = 0;
+        modifierList.children.forEach((modifierNode, index) => {
             const modifierConversions = ADG_CONVERSION_MAP.get(modifierNode.modifier.value);
             if (modifierConversions) {
                 for (const modifierConversion of modifierConversions) {
@@ -9674,17 +10197,14 @@ class NetworkRuleModifierListConverter extends ConverterBase {
                     const value = modifierConversion.value
                         ? modifierConversion.value(modifierNode.value?.value)
                         : modifierNode.value?.value;
-                    if (name === CSP_MODIFIER && value) {
-                        // Special case: collect $csp values
-                        cspValues.push(value);
+                    // Check if the name or the value is different from the original modifier
+                    // If so, add the converted modifier to the list
+                    if (name !== modifierNode.modifier.value || value !== modifierNode.value?.value) {
+                        conversionMap.add(index, createModifierNode(name, value, exception));
                     }
-                    else {
-                        // Regular case: collect the converted modifiers, if the modifier list
-                        // not already contains the same modifier
-                        const existingModifier = convertedModifierList.children.find((m) => m.modifier.value === name && m.exception === exception && m.value?.value === value);
-                        if (!existingModifier) {
-                            convertedModifierList.children.push(createModifierNode(name, value, exception));
-                        }
+                    // Special case: $csp modifier
+                    if (name === CSP_MODIFIER) {
+                        cspCount += 1;
                     }
                 }
                 return;
@@ -9707,26 +10227,52 @@ class NetworkRuleModifierListConverter extends ConverterBase {
                 // Try to convert the redirect resource name to ADG format
                 // This function returns undefined if the resource name is unknown
                 const convertedRedirectResource = redirects.convertRedirectNameToAdg(redirectResource);
-                convertedModifierList.children.push(createModifierNode(modifierName, 
-                // If the redirect resource name is unknown, fall back to the original one
-                // Later, the validator will throw an error if the resource name is invalid
-                convertedRedirectResource || redirectResource, modifierNode.exception));
-                return;
-            }
-            // In all other cases, just copy the modifier as is, if the modifier list
-            // not already contains the same modifier
-            const existingModifier = convertedModifierList.children.find((m) => m.modifier.value === modifierNode.modifier.value
-                && m.exception === modifierNode.exception
-                && m.value?.value === modifierNode.value?.value);
-            if (!existingModifier) {
-                convertedModifierList.children.push(modifierNode);
+                // Check if the modifier name or the redirect resource name is different from the original modifier
+                // If so, add the converted modifier to the list
+                if (modifierName !== modifierNode.modifier.value
+                    || (convertedRedirectResource !== undefined && convertedRedirectResource !== redirectResource)) {
+                    conversionMap.add(index, createModifierNode(modifierName, 
+                    // If the redirect resource name is unknown, fall back to the original one
+                    // Later, the validator will throw an error if the resource name is invalid
+                    convertedRedirectResource || redirectResource, modifierNode.exception));
+                }
             }
         });
-        // Merge $csp modifiers into one, then add it to the converted modifier list
-        if (cspValues.length > 0) {
-            convertedModifierList.children.push(createModifierNode(CSP_MODIFIER, cspValues.join(CSP_SEPARATOR)));
+        // Prepare the result if there are any converted modifiers or $csp modifiers
+        if (conversionMap.size || cspCount) {
+            const modifierListClone = cloneModifierListNode(modifierList);
+            // Replace the original modifiers with the converted ones
+            // One modifier may be replaced with multiple modifiers, so we need to flatten the array
+            modifierListClone.children = modifierListClone.children.map((modifierNode, index) => {
+                const conversionRecord = conversionMap.get(index);
+                if (conversionRecord) {
+                    return conversionRecord;
+                }
+                return modifierNode;
+            }).flat();
+            // Special case: $csp modifier: merge multiple $csp modifiers into one
+            // and put it at the end of the modifier list
+            if (cspCount) {
+                const cspValues = [];
+                modifierListClone.children = modifierListClone.children.filter((modifierNode) => {
+                    if (modifierNode.modifier.value === CSP_MODIFIER) {
+                        if (!modifierNode.value?.value) {
+                            throw new RuleConversionError('$csp modifier value is missing');
+                        }
+                        cspValues.push(modifierNode.value?.value);
+                        return false;
+                    }
+                    return true;
+                });
+                modifierListClone.children.push(createModifierNode(CSP_MODIFIER, cspValues.join(CSP_SEPARATOR)));
+            }
+            // Before returning the result, remove duplicated modifiers
+            modifierListClone.children = modifierListClone.children.filter((modifierNode, index, self) => self.findIndex((m) => m.modifier.value === modifierNode.modifier.value
+                && m.exception === modifierNode.exception
+                && m.value?.value === modifierNode.value?.value) === index);
+            return createConversionResult(modifierListClone, true);
         }
-        return convertedModifierList;
+        return createConversionResult(modifierList, false);
     }
 }
 
@@ -9743,17 +10289,35 @@ class NetworkRuleConverter extends RuleConverterBase {
      * Converts a network rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
-        // Convert modifiers
-        if (ruleNode.modifiers) {
-            Object.assign(ruleNode.modifiers, NetworkRuleModifierListConverter.convertToAdg(ruleNode.modifiers));
+        if (rule.modifiers) {
+            const modifiers = NetworkRuleModifierListConverter.convertToAdg(rule.modifiers);
+            // If the object reference is different, it means that the modifiers were converted
+            // In this case, we should clone the entire rule and replace the modifiers with the converted ones
+            if (modifiers.isConverted) {
+                return {
+                    result: [{
+                            category: exports.RuleCategory.Network,
+                            type: 'NetworkRule',
+                            syntax: rule.syntax,
+                            exception: rule.exception,
+                            pattern: {
+                                type: 'Value',
+                                value: rule.pattern.value,
+                            },
+                            modifiers: modifiers.result,
+                        }],
+                    isConverted: true,
+                };
+            }
         }
-        return [ruleNode];
+        // If the modifiers were not converted, return the original rule
+        return createNodeConversionResult([rule], false);
     }
 }
 
@@ -9774,48 +10338,27 @@ class RuleConverter extends RuleConverterBase {
      * Converts an adblock filtering rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
         // Delegate conversion to the corresponding sub-converter
         // based on the rule category
-        switch (ruleNode.category) {
+        switch (rule.category) {
             case exports.RuleCategory.Comment:
-                return CommentRuleConverter.convertToAdg(ruleNode);
+                return CommentRuleConverter.convertToAdg(rule);
             case exports.RuleCategory.Cosmetic:
-                return CosmeticRuleConverter.convertToAdg(ruleNode);
+                return CosmeticRuleConverter.convertToAdg(rule);
             case exports.RuleCategory.Network:
-                return NetworkRuleConverter.convertToAdg(ruleNode);
+                return NetworkRuleConverter.convertToAdg(rule);
             default:
-                throw new RuleConversionError(`Unknown rule category: ${ruleNode.category}`);
+                throw new RuleConversionError(`Unknown rule category: ${rule.category}`);
         }
     }
 }
 
-/**
- * @file Utility functions for working with filter list nodes
- */
-/**
- * Creates a filter list node
- *
- * @param rules Rules to put in the list (optional, defaults to an empty list)
- * @returns Filter list node
- */
-function createFilterListNode(rules = []) {
-    const result = {
-        type: 'FilterList',
-        children: [],
-    };
-    // We need to clone the rules to avoid side effects
-    if (rules.length > 0) {
-        result.children = cloneDeep(rules);
-    }
-    return result;
-}
-
 /**
  * @file Adblock filter list converter
  */
@@ -9834,18 +10377,133 @@ class FilterListConverter extends ConverterBase {
      * Converts an adblock filter list to AdGuard format, if possible.
      *
      * @param filterListNode Filter list node to convert
-     * @returns Converted filter list node
-     * @throws If the filter list is invalid or cannot be converted
+     * @param tolerant Indicates whether the converter should be tolerant to invalid rules. If enabled and a rule is
+     * invalid, it will be left as is. If disabled and a rule is invalid, the whole filter list will be failed.
+     * Defaults to `true`.
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
+     * @throws If the filter list is invalid or cannot be converted (if the tolerant mode is disabled)
+     */
+    static convertToAdg(filterListNode, tolerant = true) {
+        // Prepare a map to store the converted rules by their index in the filter list
+        const conversionMap = new MultiValueMap();
+        // Iterate over the filtering rules and convert them one by one, then add them to the result (one conversion may
+        // result in multiple rules)
+        for (let i = 0; i < filterListNode.children.length; i += 1) {
+            try {
+                const convertedRules = RuleConverter.convertToAdg(filterListNode.children[i]);
+                // Add the converted rules to the map if they were converted
+                if (convertedRules.isConverted) {
+                    conversionMap.add(i, ...convertedRules.result);
+                }
+            }
+            catch (error) {
+                // If the tolerant mode is disabled, we should throw an error, this will fail the whole filter list
+                // conversion.
+                // Otherwise, we just ignore the error and leave the rule as is
+                if (!tolerant) {
+                    throw error;
+                }
+            }
+        }
+        // If the conversion map is empty, it means that no rules were converted, so we can return the original filter
+        // list
+        if (conversionMap.size === 0) {
+            return createConversionResult(filterListNode, false);
+        }
+        // Otherwise, create a new filter list node with the converted rules
+        const convertedFilterList = {
+            type: 'FilterList',
+            children: [],
+        };
+        // Iterate over the original rules again and add them to the converted filter list, replacing the converted
+        // rules with the new ones at the specified indexes
+        for (let i = 0; i < filterListNode.children.length; i += 1) {
+            const rules = conversionMap.get(i);
+            if (rules) {
+                convertedFilterList.children.push(...rules);
+            }
+            else {
+                // We clone the unconverted rules to avoid mutating the original filter list if we return the converted
+                // one
+                convertedFilterList.children.push(clone(filterListNode.children[i]));
+            }
+        }
+        return createConversionResult(convertedFilterList, true);
+    }
+}
+
+/**
+ * @file Filter list converter for raw filter lists
+ *
+ * Technically, this is a wrapper around `FilterListConverter` that works with nodes instead of strings.
+ */
+/**
+ * Adblock filter list converter class.
+ *
+ * You can use this class to convert string-based filter lists, since most of the converters work with nodes.
+ * This class just provides an extra layer on top of the {@link FilterListConverter} and calls the parser/serializer
+ * before/after the conversion internally.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class RawFilterListConverter extends ConverterBase {
+    /**
+     * Converts an adblock filter list text to AdGuard format, if possible.
+     *
+     * @param rawFilterList Raw filter list text to convert
+     * @param tolerant Indicates whether the converter should be tolerant to invalid rules. If enabled and a rule is
+     * invalid, it will be left as is. If disabled and a rule is invalid, the whole filter list will be failed.
+     * Defaults to `true`.
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the array of converted filter list text, and its `isConverted` flag indicates whether the original rule was
+     * converted. If the rule was not converted, the original filter list text will be returned
+     * @throws If the filter list is invalid or cannot be converted (if the tolerant mode is disabled)
      */
-    static convertToAdg(filterListNode) {
-        const result = createFilterListNode();
-        // Iterate over the filtering rules and convert them one by one,
-        // then add them to the result (one conversion may result in multiple rules)
-        for (const ruleNode of filterListNode.children) {
-            const convertedRules = RuleConverter.convertToAdg(ruleNode);
-            result.children.push(...convertedRules);
+    static convertToAdg(rawFilterList, tolerant = true) {
+        const conversionResult = FilterListConverter.convertToAdg(FilterListParser.parse(rawFilterList, tolerant), tolerant);
+        // If the filter list was not converted, return the original text
+        if (!conversionResult.isConverted) {
+            return createConversionResult(rawFilterList, false);
         }
-        return result;
+        // Otherwise, serialize the filter list and return the result
+        return createConversionResult(FilterListParser.generate(conversionResult.result), true);
+    }
+}
+
+/**
+ * @file Rule converter for raw rules
+ *
+ * Technically, this is a wrapper around `RuleConverter` that works with nodes instead of strings.
+ */
+/**
+ * Adblock filtering rule converter class.
+ *
+ * You can use this class to convert string-based adblock rules, since most of the converters work with nodes.
+ * This class just provides an extra layer on top of the {@link RuleConverter} and calls the parser/serializer
+ * before/after the conversion internally.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class RawRuleConverter extends ConverterBase {
+    /**
+     * Converts an adblock filtering rule to AdGuard format, if possible.
+     *
+     * @param rawRule Raw rule text to convert
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the array of converted rule texts, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the original rule text will be returned
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rawRule) {
+        const conversionResult = RuleConverter.convertToAdg(RuleParser.parse(rawRule));
+        // If the rule was not converted, return the original rule text
+        if (!conversionResult.isConverted) {
+            return createConversionResult([rawRule], false);
+        }
+        // Otherwise, serialize the converted rule nodes
+        return createConversionResult(conversionResult.result.map(RuleParser.generate), true);
     }
 }
 
@@ -9927,7 +10585,7 @@ class LogicalExpressionUtils {
     }
 }
 
-const version$1 = "1.1.5";
+const version$1 = "1.1.7";
 
 /**
  * @file AGTree version
@@ -9988,6 +10646,8 @@ exports.PREPROCESSOR_MARKER = PREPROCESSOR_MARKER;
 exports.ParameterListParser = ParameterListParser;
 exports.PreProcessorCommentRuleParser = PreProcessorCommentRuleParser;
 exports.QuoteUtils = QuoteUtils;
+exports.RawFilterListConverter = RawFilterListConverter;
+exports.RawRuleConverter = RawRuleConverter;
 exports.RegExpUtils = RegExpUtils;
 exports.RuleConversionError = RuleConversionError;
 exports.RuleConverter = RuleConverter;