@adguard/agtree 1.1.4 → 1.1.6

package/dist/agtree.esm.js

@@ -1,5 +1,5 @@
 /*
- * AGTree v1.1.4 (build date: Wed, 30 Aug 2023 10:02:46 GMT)
+ * AGTree v1.1.6 (build date: Fri, 22 Sep 2023 13:09:45 GMT)
  * (c) 2023 AdGuard Software Ltd.
  * Released under the MIT license
  * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
@@ -7,13 +7,13 @@
 import valid from 'semver/functions/valid.js';
 import coerce from 'semver/functions/coerce.js';
 import JSON5 from 'json5';
-import { walk, parse, toPlainObject, find, generate, fromPlainObject, List } from '@adguard/ecss-tree';
+import { walk, parse, toPlainObject, find, generate, List, fromPlainObject } from '@adguard/ecss-tree';
 import * as ecssTree from '@adguard/ecss-tree';
 export { ecssTree as ECSSTree };
 import cloneDeep from 'clone-deep';
 import XRegExp from 'xregexp';
 import { parse as parse$1 } from 'tldts';
-import { redirects } from '@adguard/scriptlets';
+import scriptlets from '@adguard/scriptlets';
 
 /**
  * @file Possible adblock syntaxes are listed here.
@@ -69,6 +69,9 @@ var AdblockSyntax;
  * @file Constant values used by all parts of the library
  */
 // General
+/**
+ * Empty string.
+ */
 const EMPTY = '';
 const SPACE = ' ';
 const TAB = '\t';
@@ -259,7 +262,7 @@ const NEGATION_MARKER = '~';
 /**
  * The wildcard symbol — `*`.
  */
-const WILDCARD$1 = ASTERISK;
+const WILDCARD = ASTERISK;
 /**
  * Classic domain separator.
  *
@@ -2858,7 +2861,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;
@@ -2882,7 +2885,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);
@@ -3180,8 +3183,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.
@@ -3317,10 +3341,10 @@ class CssTree {
             ast = CssTree.parse(selectorList, 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
         walk(ast, (node) => {
             if (CssTree.isExtendedCssNode(node, pseudoClasses, attributeSelectors)) {
@@ -3349,9 +3373,9 @@ class CssTree {
             ast = CssTree.parse(selectorList, 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 find(ast, (node) => CssTree.isExtendedCssNode(node, pseudoClasses, attributeSelectors)) !== null;
     }
@@ -3388,14 +3412,14 @@ class CssTree {
             ast = CssTree.parse(declarationList, 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
         walk(ast, {
             enter: (node) => {
@@ -3433,9 +3457,9 @@ class CssTree {
             ast = CssTree.parse(declarationList, 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 find(ast, (node) => CssTree.isForbiddenFunction(node, forbiddenFunctions)) !== null;
     }
@@ -3667,6 +3691,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 !== 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
+        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 CssTreeNodeType.TypeSelector:
+                        result += node.name;
+                        break;
+                    case CssTreeNodeType.ClassSelector:
+                        result += DOT;
+                        result += node.name;
+                        break;
+                    case CssTreeNodeType.IdSelector:
+                        result += HASHMARK;
+                        result += node.name;
+                        break;
+                    case CssTreeNodeType.Identifier:
+                        result += node.name;
+                        break;
+                    case CssTreeNodeType.Raw:
+                        result += node.value;
+                        break;
+                    // "Advanced" nodes
+                    case CssTreeNodeType.Nth:
+                        // Default generation enough
+                        result += generate(node);
+                        break;
+                    // For example :not([id], [name])
+                    case CssTreeNodeType.SelectorList:
+                        // eslint-disable-next-line no-case-declarations
+                        const selectors = [];
+                        node.children.forEach((selector) => {
+                            if (selector.type === CssTreeNodeType.Selector) {
+                                selectors.push(CssTree.generateSelectorPlain(selector));
+                            }
+                            else if (selector.type === CssTreeNodeType.Raw) {
+                                selectors.push(selector.value);
+                            }
+                        });
+                        // Join selector lists
+                        result += selectors.join(COMMA + SPACE);
+                        // Skip nodes here
+                        selectorListDepth = depth;
+                        break;
+                    case CssTreeNodeType.Combinator:
+                        if (node.name === SPACE) {
+                            result += node.name;
+                            break;
+                        }
+                        // Prevent this case (unnecessary space): has( > .something)
+                        if (prevNode.type !== CssTreeNodeType.Selector) {
+                            result += SPACE;
+                        }
+                        result += node.name;
+                        result += SPACE;
+                        break;
+                    case 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 === CssTreeNodeType.String) {
+                                    result += generate(node.value);
+                                }
+                                else if (node.value.type === 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 CssTreeNodeType.PseudoElementSelector:
+                        result += COLON;
+                        result += COLON;
+                        result += node.name;
+                        if (node.children !== null) {
+                            result += OPEN_PARENTHESIS;
+                        }
+                        break;
+                    case CssTreeNodeType.PseudoClassSelector:
+                        result += COLON;
+                        result += node.name;
+                        if (node.children !== null) {
+                            result += OPEN_PARENTHESIS;
+                        }
+                        break;
+                }
+                prevNode = node;
+            },
+            leave: (node) => {
+                depth -= 1;
+                if (node.type === CssTreeNodeType.SelectorList && depth + 1 === selectorListDepth) {
+                    selectorListDepth = -1;
+                }
+                if (selectorListDepth > -1) {
+                    return;
+                }
+                if (node.type === CssTreeNodeType.AttributeSelector) {
+                    inAttributeSelector = false;
+                }
+                if (inAttributeSelector) {
+                    return;
+                }
+                switch (node.type) {
+                    case CssTreeNodeType.PseudoElementSelector:
+                    case 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.
      *
@@ -3850,6 +4048,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 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(generate(child));
+            }
+        });
+        return result.join(EMPTY);
+    }
 }
 
 /**
@@ -3897,7 +4118,7 @@ class ElementHidingBodyParser {
      * @throws If the AST is invalid
      */
     static generate(ast) {
-        return CssTree.generateSelectorList(fromPlainObject(ast.selectorList));
+        return CssTree.generateSelectorListPlain(ast.selectorList);
     }
 }
 
@@ -4141,7 +4362,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),
                                 });
@@ -4830,7 +5051,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;
 }
@@ -4870,8 +5091,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 fromPlainObject(cloneDeep(selector));
+    return fromPlainObject(clone(selector));
 }
 /**
  * Helper function that always returns the linked list version of the
@@ -4881,8 +5103,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 fromPlainObject(cloneDeep(selectorList));
+    return fromPlainObject(clone(selectorList));
 }
 /**
  * Helper function for checking and removing bounding combinators
@@ -5967,7 +6190,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;
             }
@@ -5984,6 +6208,11 @@ class FilterListParser {
                 case 'lf':
                     result += LF;
                     break;
+                default:
+                    if (i !== ast.children.length - 1) {
+                        result += LF;
+                    }
+                    break;
             }
         }
         return result;
@@ -6125,7 +6354,7 @@ var data$N = { adg_os_any:{ name:"csp",
     assignable:true,
     negatable:false,
     value_optional:true,
-    value_format:"(?xi)\n  ^(\n    base-uri|\n    child-src|\n    connect-src|\n    default-src|\n    font-src|\n    form-action|\n    frame-ancestors|\n    frame-src|\n    img-src|\n    manifest-src|\n    media-src|\n    navigate-to|\n    object-src|\n    plugin-types|\n    prefetch-src|\n    report-to|\n    report-uri|\n    sandbox|\n    script-src|\n    style-src|\n    upgrade-insecure-requests|\n    worker-src|\n  )\n  \\s+\n  \\S{1,}" },
+    value_format:"csp_value" },
   adg_ext_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",
@@ -6137,7 +6366,7 @@ var data$N = { adg_os_any:{ name:"csp",
     assignable:true,
     negatable:false,
     value_optional:true,
-    value_format:"(?xi)\n  ^(\n    base-uri|\n    child-src|\n    connect-src|\n    default-src|\n    font-src|\n    form-action|\n    frame-ancestors|\n    frame-src|\n    img-src|\n    manifest-src|\n    media-src|\n    navigate-to|\n    object-src|\n    plugin-types|\n    prefetch-src|\n    report-to|\n    report-uri|\n    sandbox|\n    script-src|\n    style-src|\n    upgrade-insecure-requests|\n    worker-src|\n  )\n  \\s+\n  \\S{1,}" },
+    value_format:"csp_value" },
   abp_ext_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://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#content-security-policies",
@@ -6147,7 +6376,7 @@ var data$N = { adg_os_any:{ name:"csp",
     assignable:true,
     negatable:false,
     value_optional:true,
-    value_format:"(?xi)\n  ^(\n    base-uri|\n    child-src|\n    connect-src|\n    default-src|\n    font-src|\n    form-action|\n    frame-ancestors|\n    frame-src|\n    img-src|\n    manifest-src|\n    media-src|\n    navigate-to|\n    object-src|\n    plugin-types|\n    prefetch-src|\n    report-to|\n    report-uri|\n    sandbox|\n    script-src|\n    style-src|\n    upgrade-insecure-requests|\n    worker-src|\n  )\n  \\s+\n  \\S{1,}" },
+    value_format:"csp_value" },
   ubo_ext_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://github.com/gorhill/uBlock/wiki/Static-filter-syntax#csp",
@@ -6159,7 +6388,7 @@ var data$N = { adg_os_any:{ name:"csp",
     assignable:true,
     negatable:false,
     value_optional:true,
-    value_format:"(?xi)\n  ^(\n    base-uri|\n    child-src|\n    connect-src|\n    default-src|\n    font-src|\n    form-action|\n    frame-ancestors|\n    frame-src|\n    img-src|\n    manifest-src|\n    media-src|\n    navigate-to|\n    object-src|\n    plugin-types|\n    prefetch-src|\n    report-to|\n    report-uri|\n    sandbox|\n    script-src|\n    style-src|\n    upgrade-insecure-requests|\n    worker-src|\n  )\n  \\s+\n  \\S{1,}" } };
+    value_format:"csp_value" } };
 
 var data$M = { 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.",
@@ -6666,7 +6895,8 @@ var data$l = { adg_os_any:{ name:"permissions",
     inverse_conflicts:true,
     assignable:true,
     negatable:false,
-    value_format:"(?x)\n  ^\n    (\n      ?:(\n        accelerometer|\n        ambient-light-sensor|\n        autoplay|\n        battery|\n        camera|\n        display-capture|\n        document-domain|\n        encrypted-media|\n        execution-while-not-rendered|\n        execution-while-out-of-viewport|\n        fullscreen|\n        gamepad|\n        geolocation|\n        gyroscope|\n        hid|\n        identity-credentials-get|\n        idle-detection|\n        local-fonts|\n        magnetometer|\n        microphone|\n        midi|\n        payment|\n        picture-in-picture|\n        publickey-credentials-create|\n        publickey-credentials-get|\n        screen-wake-lock|\n        serial|\n        speaker-selection|\n        storage-access|\n        usb|\n        web-share|\n        xr-spatial-tracking\n      )\n      =\\(\\)\n      # optional escaped comma for multiple permissions\n      (\\\\,(\\s+)?)?\n    )+\n  $" } };
+    value_optional:true,
+    value_format:"permissions_value" } };
 
 var data$k = { adg_any:{ name:"ping",
     description:"The rule corresponds to requests caused by either navigator.sendBeacon() or the ping attribute on links.",
@@ -7327,15 +7557,104 @@ const ALLOWED_STEALTH_OPTIONS = new Set([
     'xclientdata',
     'dpi',
 ]);
+/**
+ * Allowed CSP directives for $csp modifier.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy#directives}
+ */
+const ALLOWED_CSP_DIRECTIVES = new Set([
+    'base-uri',
+    'child-src',
+    'connect-src',
+    'default-src',
+    'font-src',
+    'form-action',
+    'frame-ancestors',
+    'frame-src',
+    'img-src',
+    'manifest-src',
+    'media-src',
+    'navigate-to',
+    'object-src',
+    'plugin-types',
+    'prefetch-src',
+    'report-to',
+    'report-uri',
+    'sandbox',
+    'script-src',
+    'style-src',
+    'upgrade-insecure-requests',
+    'worker-src',
+]);
+/**
+ * Allowed stealth options for $permissions modifier.
+ *
+ * @see {@link https://adguard.app/kb/general/ad-filtering/create-own-filters/#permissions-modifier}
+ */
+const ALLOWED_PERMISSION_DIRECTIVES = new Set([
+    'accelerometer',
+    'ambient-light-sensor',
+    'autoplay',
+    'battery',
+    'camera',
+    'display-capture',
+    'document-domain',
+    'encrypted-media',
+    'execution-while-not-rendered',
+    'execution-while-out-of-viewport',
+    'fullscreen',
+    'gamepad',
+    'geolocation',
+    'gyroscope',
+    'hid',
+    'identity-credentials-get',
+    'idle-detection',
+    'local-fonts',
+    'magnetometer',
+    'microphone',
+    'midi',
+    'payment',
+    'picture-in-picture',
+    'publickey-credentials-create',
+    'publickey-credentials-get',
+    'screen-wake-lock',
+    'serial',
+    'speaker-selection',
+    'storage-access',
+    'usb',
+    'web-share',
+    'xr-spatial-tracking',
+]);
+/**
+ * One of available tokens for $permission modifier value.
+ *
+ * @see {@link https://w3c.github.io/webappsec-permissions-policy/#structured-header-serialization}
+ */
+const PERMISSIONS_TOKEN_SELF = 'self';
+/**
+ * One of allowlist values for $permissions modifier.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Permissions_Policy#allowlists}
+ */
+const EMPTY_PERMISSIONS_ALLOWLIST = `${OPEN_PARENTHESIS}${CLOSE_PARENTHESIS}`;
 /**
  * Prefixes for error messages used in modifier validation.
  */
 const VALIDATION_ERROR_PREFIX = {
     BLOCK_ONLY: 'Only blocking rules may contain the modifier',
     EXCEPTION_ONLY: 'Only exception rules may contain the modifier',
+    INVALID_CSP_DIRECTIVES: 'Invalid CSP directives for the modifier',
     INVALID_LIST_VALUES: 'Invalid values for the modifier',
     INVALID_NOOP: 'Invalid noop modifier',
+    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',
     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',
+    NO_UNESCAPED_PERMISSION_COMMA: 'Unescaped comma in the value is not allowed for the modifier',
+    // TODO: implement later for $scp and $permissions
+    // NO_VALUE_ONLY_FOR_EXCEPTION: 'Modifier without value can be used only in exception rules',
     NOT_EXISTENT: 'Non-existent modifier',
     NOT_NEGATABLE_MODIFIER: 'Non-negatable modifier',
     NOT_NEGATABLE_VALUE: 'Values cannot be negated for the modifier',
@@ -7448,14 +7767,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.
@@ -7466,7 +7785,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
@@ -7647,10 +7966,12 @@ class QuoteUtils {
 var CustomValueFormatValidatorName;
 (function (CustomValueFormatValidatorName) {
     CustomValueFormatValidatorName["App"] = "pipe_separated_apps";
+    CustomValueFormatValidatorName["Csp"] = "csp_value";
     // there are some differences between $domain and $denyallow
     CustomValueFormatValidatorName["DenyAllow"] = "pipe_separated_denyallow_domains";
     CustomValueFormatValidatorName["Domain"] = "pipe_separated_domains";
     CustomValueFormatValidatorName["Method"] = "pipe_separated_methods";
+    CustomValueFormatValidatorName["Permissions"] = "permissions_value";
     CustomValueFormatValidatorName["StealthOption"] = "pipe_separated_stealth_options";
 })(CustomValueFormatValidatorName || (CustomValueFormatValidatorName = {}));
 /**
@@ -7684,7 +8005,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
@@ -7711,6 +8032,32 @@ const isValidMethodModifierValue = (value) => {
 const isValidStealthModifierValue = (value) => {
     return ALLOWED_STEALTH_OPTIONS.has(value);
 };
+/**
+ * Checks whether the given `rawOrigin` is valid as Permissions Allowlist origin.
+ *
+ * @see {@link https://w3c.github.io/webappsec-permissions-policy/#allowlists}
+ *
+ * @param rawOrigin The raw origin.
+ *
+ * @returns True if the origin is valid, false otherwise.
+ */
+const isValidPermissionsOrigin = (rawOrigin) => {
+    // origins should be quoted by double quote
+    const actualQuoteType = QuoteUtils.getStringQuoteType(rawOrigin);
+    if (actualQuoteType !== QuoteType.Double) {
+        return false;
+    }
+    const origin = QuoteUtils.removeQuotes(rawOrigin);
+    try {
+        // validate the origin by URL constructor
+        // https://w3c.github.io/webappsec-permissions-policy/#algo-parse-policy-directive
+        new URL(origin);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+};
 /**
  * Checks whether the given `value` is valid domain as $denyallow modifier value.
  * Important: wildcard tld are not supported, compared to $domain.
@@ -7723,7 +8070,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
@@ -7902,59 +8249,241 @@ const validatePipeSeparatedStealthOptions = (modifier) => {
     return validateListItemsModifier(modifier, (raw) => StealthOptionListParser.parse(raw), isValidStealthModifierValue, customNoNegatedListItemsValidator);
 };
 /**
- * Map of all available pre-defined validators for modifiers with custom `value_format`.
- */
-const CUSTOM_VALUE_FORMAT_MAP = {
-    [CustomValueFormatValidatorName.App]: validatePipeSeparatedApps,
-    [CustomValueFormatValidatorName.DenyAllow]: validatePipeSeparatedDenyAllowDomains,
-    [CustomValueFormatValidatorName.Domain]: validatePipeSeparatedDomains,
-    [CustomValueFormatValidatorName.Method]: validatePipeSeparatedMethods,
-    [CustomValueFormatValidatorName.StealthOption]: validatePipeSeparatedStealthOptions,
-};
-/**
- * Returns whether the given `valueFormat` is a valid custom value format validator name.
- *
- * @param valueFormat Value format for the modifier.
- *
- * @returns True if `valueFormat` is a supported pre-defined value format validator name, false otherwise.
- */
-const isCustomValueFormatValidator = (valueFormat) => {
-    return Object.keys(CUSTOM_VALUE_FORMAT_MAP).includes(valueFormat);
-};
-/**
- * Checks whether the value for given `modifier` is valid.
+ * Validates `csp_value` custom value format.
+ * Used for $csp modifier.
  *
  * @param modifier Modifier AST node.
- * @param valueFormat Value format for the modifier.
  *
  * @returns Validation result.
  */
-const validateValue = (modifier, valueFormat) => {
-    if (isCustomValueFormatValidator(valueFormat)) {
-        const validator = CUSTOM_VALUE_FORMAT_MAP[valueFormat];
-        return validator(modifier);
-    }
+const validateCspValue = (modifier) => {
     const modifierName = modifier.modifier.value;
     if (!modifier.value?.value) {
         return getValueRequiredValidationResult(modifierName);
     }
-    let xRegExp;
-    try {
-        xRegExp = XRegExp(valueFormat);
-    }
-    catch (e) {
-        throw new Error(`${SOURCE_DATA_ERROR_PREFIX.INVALID_VALUE_FORMAT_REGEXP}: '${modifierName}'`);
-    }
-    const isValid = xRegExp.test(modifier.value?.value);
-    if (!isValid) {
-        return getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.VALUE_INVALID}: '${modifierName}'`);
+    // $csp modifier value may contain multiple directives
+    // e.g. "csp=child-src 'none'; frame-src 'self' *; worker-src 'none'"
+    const policyDirectives = modifier.value.value
+        .split(SEMICOLON)
+        // rule with $csp modifier may end with semicolon
+        // e.g. "$csp=sandbox allow-same-origin;"
+        // TODO: add predicate helper for `(i) => !!i`
+        .filter((i) => !!i);
+    const invalidValueValidationResult = getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.VALUE_INVALID}: '${modifierName}': "${modifier.value.value}"`);
+    if (policyDirectives.length === 0) {
+        return invalidValueValidationResult;
+    }
+    const invalidDirectives = [];
+    for (let i = 0; i < policyDirectives.length; i += 1) {
+        const policyDirective = policyDirectives[i].trim();
+        if (!policyDirective) {
+            return invalidValueValidationResult;
+        }
+        const chunks = policyDirective.split(SPACE);
+        const [directive, ...valueChunks] = chunks;
+        // e.g. "csp=child-src 'none'; ; worker-src 'none'"
+        // validator it here          ↑
+        if (!directive) {
+            return invalidValueValidationResult;
+        }
+        if (!ALLOWED_CSP_DIRECTIVES.has(directive)) {
+            // e.g. "csp='child-src' 'none'"
+            if (ALLOWED_CSP_DIRECTIVES.has(QuoteUtils.removeQuotes(directive))) {
+                return getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.NO_CSP_DIRECTIVE_QUOTE}: '${modifierName}': ${directive}`);
+            }
+            invalidDirectives.push(directive);
+            continue;
+        }
+        if (valueChunks.length === 0) {
+            return getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.NO_CSP_VALUE}: '${modifierName}': '${directive}'`);
+        }
+    }
+    if (invalidDirectives.length > 0) {
+        const directivesToStr = QuoteUtils.quoteAndJoinStrings(invalidDirectives, QuoteType.Double);
+        return getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.INVALID_CSP_DIRECTIVES}: '${modifierName}': ${directivesToStr}`);
     }
     return { valid: true };
 };
-
 /**
- * @file Validator for modifiers.
- */
+ * Validates permission allowlist origins in the value of $permissions modifier.
+ *
+ * @see {@link https://w3c.github.io/webappsec-permissions-policy/#allowlists}
+ *
+ * @param allowlistChunks Array of allowlist chunks.
+ * @param directive Permission directive name.
+ * @param modifierName Modifier name.
+ *
+ * @returns Validation result.
+ */
+const validatePermissionAllowlistOrigins = (allowlistChunks, directive, modifierName) => {
+    const invalidOrigins = [];
+    for (let i = 0; i < allowlistChunks.length; i += 1) {
+        const chunk = allowlistChunks[i].trim();
+        // skip few spaces between origins (they were splitted by space)
+        // e.g. 'geolocation=("https://example.com"  "https://*.example.com")'
+        if (chunk.length === 0) {
+            continue;
+        }
+        /**
+         * 'self' should be checked case-insensitively
+         *
+         * @see {@link https://w3c.github.io/webappsec-permissions-policy/#algo-parse-policy-directive}
+         *
+         * @example 'geolocation=(self)'
+         */
+        if (chunk.toLowerCase() === PERMISSIONS_TOKEN_SELF) {
+            continue;
+        }
+        if (QuoteUtils.getStringQuoteType(chunk) !== QuoteType.Double) {
+            return getInvalidValidationResult(
+            // eslint-disable-next-line max-len
+            `${VALIDATION_ERROR_PREFIX.INVALID_PERMISSION_ORIGIN_QUOTES}: '${modifierName}': '${directive}': '${QuoteUtils.removeQuotes(chunk)}'`);
+        }
+        if (!isValidPermissionsOrigin(chunk)) {
+            invalidOrigins.push(chunk);
+        }
+    }
+    if (invalidOrigins.length > 0) {
+        const originsToStr = QuoteUtils.quoteAndJoinStrings(invalidOrigins);
+        return getInvalidValidationResult(
+        // eslint-disable-next-line max-len
+        `${VALIDATION_ERROR_PREFIX.INVALID_PERMISSION_ORIGINS}: '${modifierName}': '${directive}': ${originsToStr}`);
+    }
+    return { valid: true };
+};
+/**
+ * Validates permission allowlist in the modifier value.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Permissions_Policy#allowlists}
+ * @see {@link https://w3c.github.io/webappsec-permissions-policy/#allowlists}
+ *
+ * @param allowlist Allowlist value.
+ * @param directive Permission directive name.
+ * @param modifierName Modifier name.
+ *
+ * @returns Validation result.
+ */
+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
+        // e.g. 'autoplay=()'
+        || allowlist === EMPTY_PERMISSIONS_ALLOWLIST) {
+        return { valid: true };
+    }
+    if (!(allowlist.startsWith(OPEN_PARENTHESIS) && allowlist.endsWith(CLOSE_PARENTHESIS))) {
+        return getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.VALUE_INVALID}: '${modifierName}'`);
+    }
+    const allowlistChunks = allowlist.slice(1, -1).split(SPACE);
+    return validatePermissionAllowlistOrigins(allowlistChunks, directive, modifierName);
+};
+/**
+ * Validates single permission in the modifier value.
+ *
+ * @param permission Single permission value.
+ * @param modifierName Modifier name.
+ * @param modifierValue Modifier value.
+ *
+ * @returns Validation result.
+ */
+const validateSinglePermission = (permission, modifierName, modifierValue) => {
+    // empty permission in the rule
+    // e.g. 'permissions=storage-access=()\\, \\, camera=()'
+    // the validator is here                 ↑
+    if (!permission) {
+        return getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.VALUE_INVALID}: '${modifierName}'`);
+    }
+    if (permission.includes(COMMA)) {
+        return getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.NO_UNESCAPED_PERMISSION_COMMA}: '${modifierName}': '${modifierValue}'`);
+    }
+    const [directive, allowlist] = permission.split(EQUALS);
+    if (!ALLOWED_PERMISSION_DIRECTIVES.has(directive)) {
+        return getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.INVALID_PERMISSION_DIRECTIVE}: '${modifierName}': '${directive}'`);
+    }
+    return validatePermissionAllowlist(allowlist, directive, modifierName);
+};
+/**
+ * Validates `permissions_value` custom value format.
+ * Used for $permissions modifier.
+ *
+ * @param modifier Modifier AST node.
+ *
+ * @returns Validation result.
+ */
+const validatePermissions = (modifier) => {
+    if (!modifier.value?.value) {
+        return getValueRequiredValidationResult(modifier.modifier.value);
+    }
+    const modifierName = modifier.modifier.value;
+    const modifierValue = modifier.value.value;
+    // multiple permissions may be separated by escaped commas
+    const permissions = modifier.value.value.split(`${BACKSLASH}${COMMA}`);
+    for (let i = 0; i < permissions.length; i += 1) {
+        const permission = permissions[i].trim();
+        const singlePermissionValidationResult = validateSinglePermission(permission, modifierName, modifierValue);
+        if (!singlePermissionValidationResult.valid) {
+            return singlePermissionValidationResult;
+        }
+    }
+    return { valid: true };
+};
+/**
+ * Map of all available pre-defined validators for modifiers with custom `value_format`.
+ */
+const CUSTOM_VALUE_FORMAT_MAP = {
+    [CustomValueFormatValidatorName.App]: validatePipeSeparatedApps,
+    [CustomValueFormatValidatorName.Csp]: validateCspValue,
+    [CustomValueFormatValidatorName.DenyAllow]: validatePipeSeparatedDenyAllowDomains,
+    [CustomValueFormatValidatorName.Domain]: validatePipeSeparatedDomains,
+    [CustomValueFormatValidatorName.Method]: validatePipeSeparatedMethods,
+    [CustomValueFormatValidatorName.Permissions]: validatePermissions,
+    [CustomValueFormatValidatorName.StealthOption]: validatePipeSeparatedStealthOptions,
+};
+/**
+ * Returns whether the given `valueFormat` is a valid custom value format validator name.
+ *
+ * @param valueFormat Value format for the modifier.
+ *
+ * @returns True if `valueFormat` is a supported pre-defined value format validator name, false otherwise.
+ */
+const isCustomValueFormatValidator = (valueFormat) => {
+    return Object.keys(CUSTOM_VALUE_FORMAT_MAP).includes(valueFormat);
+};
+/**
+ * Checks whether the value for given `modifier` is valid.
+ *
+ * @param modifier Modifier AST node.
+ * @param valueFormat Value format for the modifier.
+ *
+ * @returns Validation result.
+ */
+const validateValue = (modifier, valueFormat) => {
+    if (isCustomValueFormatValidator(valueFormat)) {
+        const validator = CUSTOM_VALUE_FORMAT_MAP[valueFormat];
+        return validator(modifier);
+    }
+    const modifierName = modifier.modifier.value;
+    if (!modifier.value?.value) {
+        return getValueRequiredValidationResult(modifierName);
+    }
+    let xRegExp;
+    try {
+        xRegExp = XRegExp(valueFormat);
+    }
+    catch (e) {
+        throw new Error(`${SOURCE_DATA_ERROR_PREFIX.INVALID_VALUE_FORMAT_REGEXP}: '${modifierName}'`);
+    }
+    const isValid = xRegExp.test(modifier.value?.value);
+    if (!isValid) {
+        return getInvalidValidationResult(`${VALIDATION_ERROR_PREFIX.VALUE_INVALID}: '${modifierName}'`);
+    }
+    return { valid: true };
+};
+
+/**
+ * @file Validator for modifiers.
+ */
 /**
  * Fully checks whether the given `modifier` valid for given blocker `syntax`:
  * is it supported by the blocker, deprecated, assignable, negatable, etc.
@@ -8011,6 +8540,10 @@ const validateForSpecificSyntax = (modifiersData, syntax, modifier, isException)
     // e.g. 'domain'
     if (specificBlockerData[SpecificKey.Assignable]) {
         if (!modifier.value) {
+            // TODO: ditch value_optional after custom validators are implemented for value_format for all modifiers.
+            // This checking should be done in each separate custom validator,
+            // because $csp and $permissions without value can be used only in extension rules,
+            // but $cookie with no value can be used in both blocking and exception rules.
             /**
              * Some assignable modifiers can be used without a value,
              * e.g. '@@||example.com^$cookie'.
@@ -8098,7 +8631,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)) {
@@ -8177,7 +8710,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) {
@@ -8187,7 +8722,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) {
@@ -8197,7 +8734,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) {
@@ -8221,7 +8760,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) {
@@ -8231,7 +8772,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) {
@@ -8241,7 +8784,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) {
@@ -8249,6 +8794,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
  */
@@ -8262,27 +8838,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 CommentRuleType.CommentRule:
-                // 'Comment' uBO style comments
-                if (ruleNode.type === CommentRuleType.CommentRule
-                    && ruleNode.marker.value === CommentMarker.Hashmark) {
-                    ruleNode.marker.value = CommentMarker.Regular;
-                    // Add the hashmark to the beginning of the comment
-                    ruleNode.text.value = `${SPACE}${CommentMarker.Hashmark}${ruleNode.text.value}`;
+                // Check if the rule needs to be converted
+                if (rule.type === CommentRuleType.CommentRule && rule.marker.value === CommentMarker.Hashmark) {
+                    // Add a ! to the beginning of the comment
+                    // TODO: Replace with custom clone method
+                    const ruleClone = clone(rule);
+                    ruleClone.marker.value = CommentMarker.Regular;
+                    // Add the hashmark to the beginning of the comment text
+                    ruleClone.text.value = `${SPACE}${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);
         }
     }
 }
@@ -8452,6 +9031,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
  */
@@ -8464,16 +9095,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
  *
@@ -8496,16 +9133,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 === AdblockSyntax.Adg) {
+            return createNodeConversionResult([rule], false);
+        }
+        if (rule.syntax === 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 !== CssTreeNodeType.Selector) {
                 throw new RuleConversionError(`Expected selector, got '${selector.type}'`);
@@ -8532,24 +9176,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 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 CssTreeNodeType.PseudoClassSelector:
@@ -8563,18 +9207,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:
@@ -8586,10 +9230,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({
@@ -8599,7 +9243,7 @@ class HtmlRuleConverter extends RuleConverterBase {
                 // Convert the separator based on the exception status
                 separator: {
                     type: 'Value',
-                    value: ruleNode.exception
+                    value: rule.exception
                         ? CosmeticRuleSeparator.AdgHtmlFilteringException
                         : CosmeticRuleSeparator.AdgHtmlFiltering,
                 },
@@ -8614,11 +9258,11 @@ class HtmlRuleConverter extends RuleConverterBase {
                             }],
                     },
                 },
-                exception: ruleNode.exception,
-                domains: ruleNode.domains,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
             });
         }
-        return conversionResult;
+        return createNodeConversionResult(conversionResult, true);
     }
 }
 
@@ -8639,96 +9283,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), 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, 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
  *
@@ -8739,38 +9325,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 === AdblockSyntax.Adg) {
+            return createNodeConversionResult([rule], false);
+        }
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
+        convertedSeparator = rule.exception
+            ? CosmeticRuleSeparator.AdgJsInjectionException
+            : CosmeticRuleSeparator.AdgJsInjection;
         const convertedScriptlets = [];
-        for (const scriptlet of ruleNode.body.children) {
-            if (ruleNode.syntax === AdblockSyntax.Abp) {
-                convertedScriptlets.push(AdgScriptletConverter.convertFromAbp(scriptlet));
-            }
-            else if (ruleNode.syntax === 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), QuoteType.None);
+            // Add prefix if it's not already there
+            let prefix;
+            switch (rule.syntax) {
+                case AdblockSyntax.Abp:
+                    prefix = ABP_SCRIPTLET_PREFIX;
+                    break;
+                case AdblockSyntax.Ubo:
+                    prefix = UBO_SCRIPTLET_PREFIX;
+                    break;
+                default:
+                    prefix = EMPTY;
             }
-            else if (ruleNode.syntax === 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, QuoteType.Single);
+            convertedScriptlets.push(scriptletClone);
         }
-        ruleNode.separator.value = ruleNode.exception
-            ? CosmeticRuleSeparator.AdgJsInjectionException
-            : 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: 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);
     }
 }
 
@@ -8796,69 +9435,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 = 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 === 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
     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 === 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: CssTreeNodeType.PseudoElementSelector,
@@ -8867,7 +9552,7 @@ function convertToPseudoElements(selectorList) {
             }
         },
     });
-    return selectorListClone;
+    return createConversionResult(selectorListClone, true);
 }
 /**
  * Converts legacy Extended CSS `matches-css-before` and `matches-css-after`
@@ -8876,33 +9561,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 === 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 !== 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 !== 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 !== 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.
@@ -8912,16 +9600,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 = 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 === CssTreeNodeType.PseudoClassSelector) {
+            return LEGACY_EXT_CSS_INDICATOR_PSEUDO_NAMES.has(node.name);
+        }
+        if (node.type === 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
     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(...)
@@ -8935,7 +9647,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 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
@@ -8948,7 +9660,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
@@ -8958,10 +9670,12 @@ function convertFromLegacyExtendedCss(selectorList) {
                     }
                     else if (value.type === CssTreeNodeType.String) {
                         // Parse the value as a selector
-                        const parsedChildren = CssTree.parse(value.value, CssTreeParserContext.selectorList);
+                        const parsedChildren = CssTree.parsePlain(value.value, 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 {
@@ -8988,14 +9702,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
@@ -9007,32 +9719,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 || 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 === 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
         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 === 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);
     }
 }
 
@@ -9049,27 +9780,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
                 ? CosmeticRuleSeparator.AdgExtendedCssInjectionException
                 : CosmeticRuleSeparator.AdgExtendedCssInjection;
         }
         else {
-            ruleNode.separator.value = ruleNode.exception
+            convertedSeparator = rule.exception
                 ? CosmeticRuleSeparator.AdgCssInjectionException
                 : CosmeticRuleSeparator.AdgCssInjection;
         }
-        // Convert CSS selector list
-        Object.assign(ruleNode.body.selectorList, CssSelectorConverter.convertToAdg(fromPlainObject(ruleNode.body.selectorList)));
-        ruleNode.syntax = AdblockSyntax.Adg;
-        return [ruleNode];
+        const convertedSelectorList = CssSelectorConverter.convertToAdg(rule.body.selectorList);
+        // Check if the rule needs to be converted
+        if (!(rule.syntax === AdblockSyntax.Common || rule.syntax === AdblockSyntax.Adg)
+            || separator !== convertedSeparator
+            || convertedSelectorList.isConverted) {
+            // TODO: Replace with custom clone method
+            const ruleClone = clone(rule);
+            ruleClone.syntax = AdblockSyntax.Adg;
+            ruleClone.separator.value = convertedSeparator;
+            ruleClone.body.selectorList = convertedSelectorList.result;
+            return createNodeConversionResult([ruleClone], true);
+        }
+        // Otherwise, return the original rule
+        return createNodeConversionResult([rule], false);
     }
 }
 
@@ -9086,27 +9829,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
                 ? CosmeticRuleSeparator.ExtendedElementHidingException
                 : CosmeticRuleSeparator.ExtendedElementHiding;
         }
         else {
-            ruleNode.separator.value = ruleNode.exception
+            convertedSeparator = rule.exception
                 ? CosmeticRuleSeparator.ElementHidingException
                 : CosmeticRuleSeparator.ElementHiding;
         }
-        // Convert CSS selector list
-        Object.assign(ruleNode.body.selectorList, CssSelectorConverter.convertToAdg(fromPlainObject(ruleNode.body.selectorList)));
-        ruleNode.syntax = AdblockSyntax.Adg;
-        return [ruleNode];
+        const convertedSelectorList = CssSelectorConverter.convertToAdg(rule.body.selectorList);
+        // Check if the rule needs to be converted
+        if (!(rule.syntax === AdblockSyntax.Common || rule.syntax === AdblockSyntax.Adg)
+            || separator !== convertedSeparator
+            || convertedSelectorList.isConverted) {
+            // TODO: Replace with custom clone method
+            const ruleClone = clone(rule);
+            ruleClone.syntax = AdblockSyntax.Adg;
+            ruleClone.separator.value = convertedSeparator;
+            ruleClone.body.selectorList = convertedSelectorList.result;
+            return createNodeConversionResult([ruleClone], true);
+        }
+        // Otherwise, return the original rule
+        return createNodeConversionResult([rule], false);
     }
 }
 
@@ -9134,7 +9889,7 @@ function createNetworkRuleNode(pattern, modifiers = undefined, exception = false
         },
     };
     if (!isUndefined(modifiers)) {
-        result.modifiers = cloneDeep(modifiers);
+        result.modifiers = clone(modifiers);
     }
     return result;
 }
@@ -9154,32 +9909,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 !== RuleCategory.Cosmetic
-            || ruleNode.type !== CosmeticRuleType.HtmlFilteringRule
-            || ruleNode.body.body.type !== 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 !== RuleCategory.Cosmetic
+            || rule.type !== CosmeticRuleType.HtmlFilteringRule
+            || rule.body.body.type !== 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,
@@ -9189,13 +9949,13 @@ class HeaderRemovalRuleConverter extends RuleConverterBase {
         }
         // Prepare network rule modifiers
         const modifiers = createModifierListNode();
-        modifiers.children.push(createModifierNode(ADG_REMOVEHEADER_MODIFIER, CssTree.generateFunctionValue(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, AdblockSyntax.Adg),
-        ];
+            rule.exception, AdblockSyntax.Adg),
+        ], true);
     }
 }
 
@@ -9212,54 +9972,80 @@ 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 === AdblockSyntax.Ubo) {
-                // uBO doesn't support this rule:
-                // example.com##+js(set-constant.js, foo, bar):matches-path(/baz)
-                if (ruleNode.type === 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 === 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 CosmeticRuleType.ElementHidingRule:
-                return ElementHidingRuleConverter.convertToAdg(ruleNode);
+                subconverterResult = ElementHidingRuleConverter.convertToAdg(rule);
+                break;
             case CosmeticRuleType.ScriptletInjectionRule:
-                return ScriptletRuleConverter.convertToAdg(ruleNode);
+                subconverterResult = ScriptletRuleConverter.convertToAdg(rule);
+                break;
             case CosmeticRuleType.CssInjectionRule:
-                return CssInjectionRuleConverter.convertToAdg(ruleNode);
+                subconverterResult = CssInjectionRuleConverter.convertToAdg(rule);
+                break;
             case CosmeticRuleType.HtmlFilteringRule:
                 // Handle special case: uBO response header filtering rule
-                if (ruleNode.body.body.type === CssTreeNodeType.Function
-                    && ruleNode.body.body.name === UBO_RESPONSEHEADER_MARKER) {
-                    return HeaderRemovalRuleConverter.convertToAdg(ruleNode);
+                if (rule.body.body.type === CssTreeNodeType.Function
+                    && rule.body.body.name === UBO_RESPONSEHEADER_MARKER) {
+                    subconverterResult = HeaderRemovalRuleConverter.convertToAdg(rule);
                 }
-                return HtmlRuleConverter.convertToAdg(ruleNode);
-            // Note: Currently, only ADG supports JS injection rules
+                else {
+                    subconverterResult = HtmlRuleConverter.convertToAdg(rule);
+                }
+                break;
+            // Note: Currently, only ADG supports JS injection rules, so we don't need to convert them
             case 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 === AdblockSyntax.Ubo) {
+                // uBO doesn't support this rule:
+                // example.com##+js(set-constant.js, foo, bar):matches-path(/baz)
+                if (rule.type === CosmeticRuleType.ScriptletInjectionRule) {
+                    throw new RuleConversionError('uBO scriptlet injection rules don\'t support cosmetic rule modifiers');
+                }
+                convertedModifiers = AdgCosmeticRuleModifierConverter.convertFromUbo(rule.modifiers);
+            }
+            else if (rule.syntax === 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 === RuleCategory.Cosmetic) {
+                    // eslint-disable-next-line no-param-reassign
+                    subconverterRule.modifiers = convertedModifiers.result;
+                }
+            });
+            return subconverterResult;
+        }
+        return createNodeConversionResult([rule], false);
     }
 }
 
 /**
  * @file Network rule modifier list converter.
  */
+// Since scriptlets library doesn't have ESM exports, we should import
+// the whole module and then extract the required functions from it here.
+// Otherwise importing AGTree will cause an error in ESM environment,
+// because scriptlets library doesn't support named exports.
+const { redirects } = scriptlets;
 /**
  * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#csp-modifier}
  */
@@ -9320,17 +10106,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) {
@@ -9343,17 +10128,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;
@@ -9376,26 +10158,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);
     }
 }
 
@@ -9412,17 +10220,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: 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);
     }
 }
 
@@ -9443,48 +10269,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 RuleCategory.Comment:
-                return CommentRuleConverter.convertToAdg(ruleNode);
+                return CommentRuleConverter.convertToAdg(rule);
             case RuleCategory.Cosmetic:
-                return CosmeticRuleConverter.convertToAdg(ruleNode);
+                return CosmeticRuleConverter.convertToAdg(rule);
             case 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
  */
@@ -9503,18 +10308,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);
     }
 }
 
@@ -9596,7 +10516,7 @@ class LogicalExpressionUtils {
     }
 }
 
-const version$1 = "1.1.4";
+const version$1 = "1.1.6";
 
 /**
  * @file AGTree version
@@ -9607,4 +10527,4 @@ const version$1 = "1.1.4";
 // with wrong relative path to `package.json`. So we need this little "hack"
 const version = version$1;
 
-export { ADBLOCK_URL_SEPARATOR, ADBLOCK_URL_SEPARATOR_REGEX, ADBLOCK_URL_START, ADBLOCK_URL_START_REGEX, ADBLOCK_WILDCARD, ADBLOCK_WILDCARD_REGEX, ADG_SCRIPTLET_MASK, AGLINT_COMMAND_PREFIX, AdblockSyntax, AdblockSyntaxError, AgentCommentRuleParser, AgentParser, AppListParser, COMMA_DOMAIN_LIST_SEPARATOR, CommentMarker, CommentRuleParser, CommentRuleType, ConfigCommentRuleParser, CosmeticRuleParser, CosmeticRuleSeparator, CosmeticRuleSeparatorUtils, CosmeticRuleType, CssTree, CssTreeNodeType, CssTreeParserContext, DomainListParser, DomainUtils, EXT_CSS_LEGACY_ATTRIBUTES, EXT_CSS_PSEUDO_CLASSES, FORBIDDEN_CSS_FUNCTIONS, FilterListConverter, FilterListParser, HINT_MARKER, HintCommentRuleParser, HintParser, IF, INCLUDE, LogicalExpressionParser, LogicalExpressionUtils, METADATA_HEADERS, MODIFIERS_SEPARATOR, MODIFIER_ASSIGN_OPERATOR, MetadataCommentRuleParser, MethodListParser, ModifierListParser, ModifierParser, NEGATION_MARKER, NETWORK_RULE_EXCEPTION_MARKER, NETWORK_RULE_SEPARATOR, NetworkRuleParser, NotImplementedError, PIPE_MODIFIER_SEPARATOR, PREPROCESSOR_MARKER, ParameterListParser, PreProcessorCommentRuleParser, QuoteType, QuoteUtils, RegExpUtils, RuleCategory, RuleConversionError, RuleConverter, RuleParser, SAFARI_CB_AFFINITY, SPECIAL_REGEX_SYMBOLS, StealthOptionListParser, UBO_SCRIPTLET_MASK, locRange, modifierValidator, shiftLoc, version };
+export { ADBLOCK_URL_SEPARATOR, ADBLOCK_URL_SEPARATOR_REGEX, ADBLOCK_URL_START, ADBLOCK_URL_START_REGEX, ADBLOCK_WILDCARD, ADBLOCK_WILDCARD_REGEX, ADG_SCRIPTLET_MASK, AGLINT_COMMAND_PREFIX, AdblockSyntax, AdblockSyntaxError, AgentCommentRuleParser, AgentParser, AppListParser, COMMA_DOMAIN_LIST_SEPARATOR, CommentMarker, CommentRuleParser, CommentRuleType, ConfigCommentRuleParser, CosmeticRuleParser, CosmeticRuleSeparator, CosmeticRuleSeparatorUtils, CosmeticRuleType, CssTree, CssTreeNodeType, CssTreeParserContext, DomainListParser, DomainUtils, EXT_CSS_LEGACY_ATTRIBUTES, EXT_CSS_PSEUDO_CLASSES, FORBIDDEN_CSS_FUNCTIONS, FilterListConverter, FilterListParser, HINT_MARKER, HintCommentRuleParser, HintParser, IF, INCLUDE, LogicalExpressionParser, LogicalExpressionUtils, METADATA_HEADERS, MODIFIERS_SEPARATOR, MODIFIER_ASSIGN_OPERATOR, MetadataCommentRuleParser, MethodListParser, ModifierListParser, ModifierParser, NEGATION_MARKER, NETWORK_RULE_EXCEPTION_MARKER, NETWORK_RULE_SEPARATOR, NetworkRuleParser, NotImplementedError, PIPE_MODIFIER_SEPARATOR, PREPROCESSOR_MARKER, ParameterListParser, PreProcessorCommentRuleParser, QuoteType, QuoteUtils, RawFilterListConverter, RawRuleConverter, RegExpUtils, RuleCategory, RuleConversionError, RuleConverter, RuleParser, SAFARI_CB_AFFINITY, SPECIAL_REGEX_SYMBOLS, StealthOptionListParser, UBO_SCRIPTLET_MASK, locRange, modifierValidator, shiftLoc, version };