@adguard/agtree 1.1.5 → 1.1.6

package/dist/agtree.cjs

@@ -1,5 +1,5 @@
 /*
- * AGTree v1.1.5 (build date: Tue, 05 Sep 2023 15:10:53 GMT)
+ * AGTree v1.1.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
@@ -281,7 +281,7 @@ const NEGATION_MARKER = '~';
 /**
  * The wildcard symbol — `*`.
  */
-const WILDCARD$1 = ASTERISK;
+const WILDCARD = ASTERISK;
 /**
  * Classic domain separator.
  *
@@ -2880,7 +2880,7 @@ class ModifierParser {
         const modifierEnd = Math.max(StringUtils.skipWSBack(raw) + 1, modifierNameStart);
         // Modifier name can't be empty
         if (modifierNameStart === modifierEnd) {
-            throw new AdblockSyntaxError('Modifier name can\'t be empty', locRange(loc, 0, raw.length));
+            throw new AdblockSyntaxError('Modifier name cannot be empty', locRange(loc, 0, raw.length));
         }
         let modifier;
         let value;
@@ -2904,7 +2904,7 @@ class ModifierParser {
             };
             // Value can't be empty
             if (assignmentIndex + 1 === modifierEnd) {
-                throw new AdblockSyntaxError('Modifier value can\'t be empty', locRange(loc, 0, raw.length));
+                throw new AdblockSyntaxError('Modifier value cannot be empty', locRange(loc, 0, raw.length));
             }
             // Skip whitespace after the assignment operator
             const valueStart = StringUtils.skipWS(raw, assignmentIndex + MODIFIER_ASSIGN_OPERATOR.length);
@@ -3202,8 +3202,29 @@ const FORBIDDEN_CSS_FUNCTIONS = new Set([
     'url',
 ]);
 
+/**
+ * @file Clone related utilities
+ *
+ * We should keep clone related functions in this file. Thus, we just provide
+ * a simple interface for cloning values, we use it across the AGTree project,
+ * and the implementation "under the hood" can be improved later, if needed.
+ */
+/**
+ * Clones an input value to avoid side effects. Use it only in justified cases,
+ * because it can impact performance negatively.
+ *
+ * @param value Value to clone
+ * @returns Cloned value
+ */
+function clone(value) {
+    // TODO: Replace cloneDeep with a more efficient implementation
+    return cloneDeep(value);
+}
+
 /**
  * @file Additional / helper functions for ECSSTree / CSSTree.
+ *
+ * @note There are no tests for some functions, but during the AGTree optimization we remove them anyway.
  */
 /**
  * Common CSSTree parsing options.
@@ -3339,10 +3360,10 @@ class CssTree {
             ast = CssTree.parse(selectorList, exports.CssTreeParserContext.selectorList);
         }
         else {
-            ast = cloneDeep(selectorList);
+            ast = clone(selectorList);
         }
         const nodes = [];
-        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ecssTree.walk(ast, (node) => {
             if (CssTree.isExtendedCssNode(node, pseudoClasses, attributeSelectors)) {
@@ -3371,9 +3392,9 @@ class CssTree {
             ast = CssTree.parse(selectorList, exports.CssTreeParserContext.selectorList);
         }
         else {
-            ast = cloneDeep(selectorList);
+            ast = selectorList;
         }
-        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return ecssTree.find(ast, (node) => CssTree.isExtendedCssNode(node, pseudoClasses, attributeSelectors)) !== null;
     }
@@ -3410,14 +3431,14 @@ class CssTree {
             ast = CssTree.parse(declarationList, exports.CssTreeParserContext.declarationList);
         }
         else {
-            ast = cloneDeep(declarationList);
+            ast = clone(declarationList);
         }
         const nodes = [];
         // While walking the AST we should skip the nested functions,
         // for example skip url()s in cross-fade(url(), url()), since
         // cross-fade() itself is already a forbidden function
         let inForbiddenFunction = false;
-        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ecssTree.walk(ast, {
             enter: (node) => {
@@ -3455,9 +3476,9 @@ class CssTree {
             ast = CssTree.parse(declarationList, exports.CssTreeParserContext.declarationList);
         }
         else {
-            ast = cloneDeep(declarationList);
+            ast = clone(declarationList);
         }
-        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         return ecssTree.find(ast, (node) => CssTree.isForbiddenFunction(node, forbiddenFunctions)) !== null;
     }
@@ -3689,6 +3710,180 @@ class CssTree {
         });
         return result.trim();
     }
+    /**
+     * Generates string representation of the selector list.
+     *
+     * @param ast SelectorList AST
+     * @returns String representation of the selector list
+     */
+    static generateSelectorListPlain(ast) {
+        const result = [];
+        if (!ast.children || ast.children.length === 0) {
+            throw new Error('Selector list cannot be empty');
+        }
+        ast.children.forEach((selector, index, nodeList) => {
+            if (selector.type !== exports.CssTreeNodeType.Selector) {
+                throw new Error(`Unexpected node type: ${selector.type}`);
+            }
+            result.push(this.generateSelectorPlain(selector));
+            // If there is a next node, add a comma and a space after the selector
+            if (nodeList[index + 1]) {
+                result.push(COMMA, SPACE);
+            }
+        });
+        return result.join(EMPTY);
+    }
+    /**
+     * Selector generation based on CSSTree's AST. This is necessary because CSSTree
+     * only adds spaces in some edge cases.
+     *
+     * @param ast CSS Tree AST
+     * @returns CSS selector as string
+     */
+    static generateSelectorPlain(ast) {
+        let result = EMPTY;
+        let inAttributeSelector = false;
+        let depth = 0;
+        let selectorListDepth = -1;
+        let prevNode = ast;
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ecssTree.walk(ast, {
+            // TODO: Need to improve CSSTree types, until then we need to use any type here
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            enter: (node) => {
+                depth += 1;
+                // Skip attribute selector / selector list children
+                if (inAttributeSelector || selectorListDepth > -1) {
+                    return;
+                }
+                switch (node.type) {
+                    // "Trivial" nodes
+                    case exports.CssTreeNodeType.TypeSelector:
+                        result += node.name;
+                        break;
+                    case exports.CssTreeNodeType.ClassSelector:
+                        result += DOT;
+                        result += node.name;
+                        break;
+                    case exports.CssTreeNodeType.IdSelector:
+                        result += HASHMARK;
+                        result += node.name;
+                        break;
+                    case exports.CssTreeNodeType.Identifier:
+                        result += node.name;
+                        break;
+                    case exports.CssTreeNodeType.Raw:
+                        result += node.value;
+                        break;
+                    // "Advanced" nodes
+                    case exports.CssTreeNodeType.Nth:
+                        // Default generation enough
+                        result += ecssTree.generate(node);
+                        break;
+                    // For example :not([id], [name])
+                    case exports.CssTreeNodeType.SelectorList:
+                        // eslint-disable-next-line no-case-declarations
+                        const selectors = [];
+                        node.children.forEach((selector) => {
+                            if (selector.type === exports.CssTreeNodeType.Selector) {
+                                selectors.push(CssTree.generateSelectorPlain(selector));
+                            }
+                            else if (selector.type === exports.CssTreeNodeType.Raw) {
+                                selectors.push(selector.value);
+                            }
+                        });
+                        // Join selector lists
+                        result += selectors.join(COMMA + SPACE);
+                        // Skip nodes here
+                        selectorListDepth = depth;
+                        break;
+                    case exports.CssTreeNodeType.Combinator:
+                        if (node.name === SPACE) {
+                            result += node.name;
+                            break;
+                        }
+                        // Prevent this case (unnecessary space): has( > .something)
+                        if (prevNode.type !== exports.CssTreeNodeType.Selector) {
+                            result += SPACE;
+                        }
+                        result += node.name;
+                        result += SPACE;
+                        break;
+                    case exports.CssTreeNodeType.AttributeSelector:
+                        result += OPEN_SQUARE_BRACKET;
+                        // Identifier name
+                        if (node.name) {
+                            result += node.name.name;
+                        }
+                        // Matcher operator, eg =
+                        if (node.matcher) {
+                            result += node.matcher;
+                            // Value can be String, Identifier or null
+                            if (node.value !== null) {
+                                // String node
+                                if (node.value.type === exports.CssTreeNodeType.String) {
+                                    result += ecssTree.generate(node.value);
+                                }
+                                else if (node.value.type === exports.CssTreeNodeType.Identifier) {
+                                    // Identifier node
+                                    result += node.value.name;
+                                }
+                            }
+                        }
+                        // Flags
+                        if (node.flags) {
+                            // Space before flags
+                            result += SPACE;
+                            result += node.flags;
+                        }
+                        result += CLOSE_SQUARE_BRACKET;
+                        inAttributeSelector = true;
+                        break;
+                    case exports.CssTreeNodeType.PseudoElementSelector:
+                        result += COLON;
+                        result += COLON;
+                        result += node.name;
+                        if (node.children !== null) {
+                            result += OPEN_PARENTHESIS;
+                        }
+                        break;
+                    case exports.CssTreeNodeType.PseudoClassSelector:
+                        result += COLON;
+                        result += node.name;
+                        if (node.children !== null) {
+                            result += OPEN_PARENTHESIS;
+                        }
+                        break;
+                }
+                prevNode = node;
+            },
+            leave: (node) => {
+                depth -= 1;
+                if (node.type === exports.CssTreeNodeType.SelectorList && depth + 1 === selectorListDepth) {
+                    selectorListDepth = -1;
+                }
+                if (selectorListDepth > -1) {
+                    return;
+                }
+                if (node.type === exports.CssTreeNodeType.AttributeSelector) {
+                    inAttributeSelector = false;
+                }
+                if (inAttributeSelector) {
+                    return;
+                }
+                switch (node.type) {
+                    case exports.CssTreeNodeType.PseudoElementSelector:
+                    case exports.CssTreeNodeType.PseudoClassSelector:
+                        if (node.children) {
+                            result += CLOSE_PARENTHESIS;
+                        }
+                        break;
+                }
+            },
+        });
+        return result.trim();
+    }
     /**
      * Block generation based on CSSTree's AST. This is necessary because CSSTree only adds spaces in some edge cases.
      *
@@ -3872,6 +4067,29 @@ class CssTree {
         });
         return result;
     }
+    /**
+     * Helper function to generate a raw string from a function selector's children
+     *
+     * @param node Function node
+     * @returns Generated function value
+     * @example `responseheader(name)` -> `name`
+     */
+    static generateFunctionPlainValue(node) {
+        const result = [];
+        node.children?.forEach((child) => {
+            switch (child.type) {
+                case exports.CssTreeNodeType.Raw:
+                    result.push(child.value);
+                    break;
+                default:
+                    // Fallback to CSSTree's default generate function
+                    // TODO: Need to improve CSSTree types, until then we need to use any type here
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    result.push(ecssTree.generate(child));
+            }
+        });
+        return result.join(EMPTY);
+    }
 }
 
 /**
@@ -3919,7 +4137,7 @@ class ElementHidingBodyParser {
      * @throws If the AST is invalid
      */
     static generate(ast) {
-        return CssTree.generateSelectorList(ecssTree.fromPlainObject(ast.selectorList));
+        return CssTree.generateSelectorListPlain(ast.selectorList);
     }
 }
 
@@ -4163,7 +4381,7 @@ class CssInjectionBodyParser {
                             if (mediaQueryList || declarationList || remove) {
                                 throw new AdblockSyntaxError(
                                 // eslint-disable-next-line max-len
-                                'Invalid selector, regular selector elements can\'t be used after special pseudo-classes', {
+                                'Invalid selector, regular selector elements cannot be used after special pseudo-classes', {
                                     start: node.loc?.start ?? loc,
                                     end: shiftLoc(loc, raw.length),
                                 });
@@ -4852,7 +5070,7 @@ function createModifierListNode(modifiers = []) {
     const result = {
         type: 'ModifierList',
         // We need to clone the modifiers to avoid side effects
-        children: cloneDeep(modifiers),
+        children: modifiers.length ? clone(modifiers) : [],
     };
     return result;
 }
@@ -4892,8 +5110,9 @@ function hasUboModifierIndicator(rawSelectorList) {
  * @returns Linked list based selector
  */
 function convertSelectorToLinkedList(selector) {
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return ecssTree.fromPlainObject(cloneDeep(selector));
+    return ecssTree.fromPlainObject(clone(selector));
 }
 /**
  * Helper function that always returns the linked list version of the
@@ -4903,8 +5122,9 @@ function convertSelectorToLinkedList(selector) {
  * @returns Linked list based selector list
  */
 function convertSelectorListToLinkedList(selectorList) {
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return ecssTree.fromPlainObject(cloneDeep(selectorList));
+    return ecssTree.fromPlainObject(clone(selectorList));
 }
 /**
  * Helper function for checking and removing bounding combinators
@@ -5989,7 +6209,8 @@ class FilterListParser {
      */
     static generate(ast, preferRaw = false) {
         let result = EMPTY;
-        for (const rule of ast.children) {
+        for (let i = 0; i < ast.children.length; i += 1) {
+            const rule = ast.children[i];
             if (preferRaw && rule.raws?.text) {
                 result += rule.raws.text;
             }
@@ -6006,6 +6227,11 @@ class FilterListParser {
                 case 'lf':
                     result += LF;
                     break;
+                default:
+                    if (i !== ast.children.length - 1) {
+                        result += LF;
+                    }
+                    break;
             }
         }
         return result;
@@ -7560,14 +7786,14 @@ const getSpecificBlockerData = (modifiersData, blockerPrefix, modifierName) => {
  * @example
  * `example.*` — matches with any TLD, e.g. `example.org`, `example.com`, etc.
  */
-const WILDCARD_TLD = DOT + WILDCARD$1;
+const WILDCARD_TLD = DOT + WILDCARD;
 /**
  * Marker for a wildcard subdomain — `*.`.
  *
  * @example
  * `*.example.org` — matches with any subdomain, e.g. `foo.example.org` or `bar.example.org`
  */
-const WILDCARD_SUBDOMAIN = WILDCARD$1 + DOT;
+const WILDCARD_SUBDOMAIN = WILDCARD + DOT;
 class DomainUtils {
     /**
      * Check if the input is a valid domain or hostname.
@@ -7578,7 +7804,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
@@ -7798,7 +8024,7 @@ const isValidAppNameChunk = (chunk) => {
 const isValidAppModifierValue = (value) => {
     // $app modifier does not support wildcard tld
     // https://adguard.app/kb/general/ad-filtering/create-own-filters/#app-modifier
-    if (value.includes(WILDCARD$1)) {
+    if (value.includes(WILDCARD)) {
         return false;
     }
     return value
@@ -7863,7 +8089,7 @@ const isValidDenyAllowModifierValue = (value) => {
     // $denyallow modifier does not support wildcard tld
     // https://adguard.app/kb/general/ad-filtering/create-own-filters/#denyallow-modifier
     // but here we are simply checking whether the value contains wildcard `*`, not ends with `.*`
-    if (value.includes(WILDCARD$1)) {
+    if (value.includes(WILDCARD)) {
         return false;
     }
     // TODO: add cache for domains validation
@@ -8160,7 +8386,7 @@ const validatePermissionAllowlist = (allowlist, directive, modifierName) => {
     // `*` is one of available permissions tokens
     // e.g. 'fullscreen=*'
     // https://w3c.github.io/webappsec-permissions-policy/#structured-header-serialization
-    if (allowlist === WILDCARD$1
+    if (allowlist === WILDCARD
         // e.g. 'autoplay=()'
         || allowlist === EMPTY_PERMISSIONS_ALLOWLIST) {
         return { valid: true };
@@ -8424,7 +8650,7 @@ class ModifierValidator {
      * @returns Result of modifier validation.
      */
     validate = (syntax, rawModifier, isException = false) => {
-        const modifier = cloneDeep(rawModifier);
+        const modifier = clone(rawModifier);
         // special case: handle noop modifier which may be used as multiple underscores (not just one)
         // https://adguard.com/kb/general/ad-filtering/create-own-filters/#noop-modifier
         if (modifier.modifier.value.startsWith(UNDERSCORE)) {
@@ -8503,7 +8729,9 @@ class ConverterBase {
      * Converts some data to AdGuard format
      *
      * @param data Data to convert
-     * @returns Converted data
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the data is invalid or incompatible
      */
     static convertToAdg(data) {
@@ -8513,7 +8741,9 @@ class ConverterBase {
      * Converts some data to Adblock Plus format
      *
      * @param data Data to convert
-     * @returns Converted data
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the data is invalid or incompatible
      */
     static convertToAbp(data) {
@@ -8523,7 +8753,9 @@ class ConverterBase {
      * Converts some data to uBlock Origin format
      *
      * @param data Data to convert
-     * @returns Converted data
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the data is invalid or incompatible
      */
     static convertToUbo(data) {
@@ -8547,7 +8779,9 @@ class RuleConverterBase extends ConverterBase {
      * Converts an adblock filtering rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
@@ -8557,7 +8791,9 @@ class RuleConverterBase extends ConverterBase {
      * Converts an adblock filtering rule to Adblock Plus format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAbp(rule) {
@@ -8567,7 +8803,9 @@ class RuleConverterBase extends ConverterBase {
      * Converts an adblock filtering rule to uBlock Origin format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToUbo(rule) {
@@ -8575,6 +8813,37 @@ class RuleConverterBase extends ConverterBase {
     }
 }
 
+/**
+ * @file Conversion result interface and helper functions
+ */
+/**
+ * Helper function to create a generic conversion result.
+ *
+ * @param result Conversion result
+ * @param isConverted Indicates whether the input item was converted
+ * @template T Type of the item to convert
+ * @template U Type of the conversion result (defaults to `T`, but can be `T[]` as well)
+ * @returns Generic conversion result
+ */
+// eslint-disable-next-line max-len
+function createConversionResult(result, isConverted) {
+    return {
+        result,
+        isConverted,
+    };
+}
+/**
+ * Helper function to create a node conversion result.
+ *
+ * @param nodes Array of nodes
+ * @param isConverted Indicates whether the input item was converted
+ * @template T Type of the node (extends `Node`)
+ * @returns Node conversion result
+ */
+function createNodeConversionResult(nodes, isConverted) {
+    return createConversionResult(nodes, isConverted);
+}
+
 /**
  * @file Comment rule converter
  */
@@ -8588,27 +8857,30 @@ class CommentRuleConverter extends RuleConverterBase {
      * Converts a comment rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
         // TODO: Add support for other comment types, if needed
         // Main task is # -> ! conversion
-        switch (ruleNode.type) {
+        switch (rule.type) {
             case exports.CommentRuleType.CommentRule:
-                // 'Comment' uBO style comments
-                if (ruleNode.type === exports.CommentRuleType.CommentRule
-                    && ruleNode.marker.value === exports.CommentMarker.Hashmark) {
-                    ruleNode.marker.value = exports.CommentMarker.Regular;
-                    // Add the hashmark to the beginning of the comment
-                    ruleNode.text.value = `${SPACE}${exports.CommentMarker.Hashmark}${ruleNode.text.value}`;
+                // Check if the rule needs to be converted
+                if (rule.type === exports.CommentRuleType.CommentRule && rule.marker.value === exports.CommentMarker.Hashmark) {
+                    // Add a ! to the beginning of the comment
+                    // TODO: Replace with custom clone method
+                    const ruleClone = clone(rule);
+                    ruleClone.marker.value = exports.CommentMarker.Regular;
+                    // Add the hashmark to the beginning of the comment text
+                    ruleClone.text.value = `${SPACE}${exports.CommentMarker.Hashmark}${ruleClone.text.value}`;
+                    return createNodeConversionResult([ruleClone], true);
                 }
-                return [ruleNode];
+                return createNodeConversionResult([rule], false);
             // Leave any other comment rule as is
             default:
-                return [ruleNode];
+                return createNodeConversionResult([rule], false);
         }
     }
 }
@@ -8778,6 +9050,58 @@ class RegExpUtils {
     }
 }
 
+/**
+ * @file Custom clone functions for AST nodes, this is probably the most efficient way to clone AST nodes.
+ * @todo Maybe move them to parser classes as 'clone' methods
+ */
+/**
+ * Clones a scriptlet rule node.
+ *
+ * @param node Node to clone
+ * @returns Cloned node
+ */
+function cloneScriptletRuleNode(node) {
+    return {
+        type: node.type,
+        children: node.children.map((child) => ({ ...child })),
+    };
+}
+/**
+ * Clones a domain list node.
+ *
+ * @param node Node to clone
+ * @returns Cloned node
+ */
+function cloneDomainListNode(node) {
+    return {
+        type: node.type,
+        separator: node.separator,
+        children: node.children.map((domain) => ({ ...domain })),
+    };
+}
+/**
+ * Clones a modifier list node.
+ *
+ * @param node Node to clone
+ * @returns Cloned node
+ */
+function cloneModifierListNode(node) {
+    return {
+        type: node.type,
+        children: node.children.map((modifier) => {
+            const res = {
+                type: modifier.type,
+                exception: modifier.exception,
+                modifier: { ...modifier.modifier },
+            };
+            if (modifier.value) {
+                res.value = { ...modifier.value };
+            }
+            return res;
+        }),
+    };
+}
+
 /**
  * @file HTML filtering rule converter
  */
@@ -8790,16 +9114,22 @@ class RegExpUtils {
  *
  * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#html-filtering-rules}
  */
-const ADGUARD_HTML_DEFAULT_MAX_LENGTH = 8192;
-const ADGUARD_HTML_CONVERSION_MAX_LENGTH = ADGUARD_HTML_DEFAULT_MAX_LENGTH * 32;
+const ADG_HTML_DEFAULT_MAX_LENGTH = 8192;
+const ADG_HTML_CONVERSION_MAX_LENGTH = ADG_HTML_DEFAULT_MAX_LENGTH * 32;
 const NOT_SPECIFIED = -1;
-const CONTAINS$1 = 'contains';
-const HAS_TEXT$1 = 'has-text';
-const MAX_LENGTH = 'max-length';
-const MIN_LENGTH = 'min-length';
-const MIN_TEXT_LENGTH = 'min-text-length';
-const TAG_CONTENT = 'tag-content';
-const WILDCARD = 'wildcard';
+var PseudoClasses$1;
+(function (PseudoClasses) {
+    PseudoClasses["Contains"] = "contains";
+    PseudoClasses["HasText"] = "has-text";
+    PseudoClasses["MinTextLength"] = "min-text-length";
+})(PseudoClasses$1 || (PseudoClasses$1 = {}));
+var AttributeSelectors;
+(function (AttributeSelectors) {
+    AttributeSelectors["MaxLength"] = "max-length";
+    AttributeSelectors["MinLength"] = "min-length";
+    AttributeSelectors["TagContent"] = "tag-content";
+    AttributeSelectors["Wildcard"] = "wildcard";
+})(AttributeSelectors || (AttributeSelectors = {}));
 /**
  * HTML filtering rule converter class
  *
@@ -8822,16 +9152,23 @@ class HtmlRuleConverter extends RuleConverterBase {
      * ```
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
+        // Ignore AdGuard rules
+        if (rule.syntax === exports.AdblockSyntax.Adg) {
+            return createNodeConversionResult([rule], false);
+        }
+        if (rule.syntax === exports.AdblockSyntax.Abp) {
+            throw new RuleConversionError('Invalid rule, ABP does not support HTML filtering rules');
+        }
         // Prepare the conversion result
         const conversionResult = [];
         // Iterate over selector list
-        for (const selector of ruleNode.body.body.children) {
+        for (const selector of rule.body.body.children) {
             // Check selector, just in case
             if (selector.type !== exports.CssTreeNodeType.Selector) {
                 throw new RuleConversionError(`Expected selector, got '${selector.type}'`);
@@ -8858,24 +9195,24 @@ class HtmlRuleConverter extends RuleConverterBase {
                             throw new RuleConversionError('Tag selector should be the first child, if present');
                         }
                         // Simply store the tag selector
-                        convertedSelector.children.push(cloneDeep(node));
+                        convertedSelector.children.push(clone(node));
                         break;
                     case exports.CssTreeNodeType.AttributeSelector:
                         // Check if the attribute selector is a special AdGuard attribute
                         switch (node.name.name) {
-                            case MIN_LENGTH:
+                            case AttributeSelectors.MinLength:
                                 minLength = CssTree.parseAttributeSelectorValueAsNumber(node);
                                 break;
-                            case MAX_LENGTH:
+                            case AttributeSelectors.MaxLength:
                                 maxLength = CssTree.parseAttributeSelectorValueAsNumber(node);
                                 break;
-                            case TAG_CONTENT:
-                            case WILDCARD:
+                            case AttributeSelectors.TagContent:
+                            case AttributeSelectors.Wildcard:
                                 CssTree.assertAttributeSelectorHasStringValue(node);
-                                convertedSelector.children.push(cloneDeep(node));
+                                convertedSelector.children.push(clone(node));
                                 break;
                             default:
-                                convertedSelector.children.push(cloneDeep(node));
+                                convertedSelector.children.push(clone(node));
                         }
                         break;
                     case exports.CssTreeNodeType.PseudoClassSelector:
@@ -8889,18 +9226,18 @@ class HtmlRuleConverter extends RuleConverterBase {
                         }
                         // Process the pseudo class based on its name
                         switch (node.name) {
-                            case HAS_TEXT$1:
-                            case CONTAINS$1:
+                            case PseudoClasses$1.HasText:
+                            case PseudoClasses$1.Contains:
                                 // Check if the argument is a RegExp
                                 if (RegExpUtils.isRegexPattern(arg.value)) {
                                     // TODO: Add some support for RegExp patterns later
                                     // Need to find a way to convert some RegExp patterns to glob patterns
                                     throw new RuleConversionError('Conversion of RegExp patterns is not yet supported');
                                 }
-                                convertedSelector.children.push(CssTree.createAttributeSelectorNode(TAG_CONTENT, arg.value));
+                                convertedSelector.children.push(CssTree.createAttributeSelectorNode(AttributeSelectors.TagContent, arg.value));
                                 break;
                             // https://github.com/gorhill/uBlock/wiki/Procedural-cosmetic-filters#subjectmin-text-lengthn
-                            case MIN_TEXT_LENGTH:
+                            case PseudoClasses$1.MinTextLength:
                                 minLength = CssTree.parsePseudoClassArgumentAsNumber(node);
                                 break;
                             default:
@@ -8912,10 +9249,10 @@ class HtmlRuleConverter extends RuleConverterBase {
                 }
             }
             if (minLength !== NOT_SPECIFIED) {
-                convertedSelector.children.push(CssTree.createAttributeSelectorNode(MIN_LENGTH, String(minLength)));
+                convertedSelector.children.push(CssTree.createAttributeSelectorNode(AttributeSelectors.MinLength, String(minLength)));
             }
-            convertedSelector.children.push(CssTree.createAttributeSelectorNode(MAX_LENGTH, String(maxLength === NOT_SPECIFIED
-                ? ADGUARD_HTML_CONVERSION_MAX_LENGTH
+            convertedSelector.children.push(CssTree.createAttributeSelectorNode(AttributeSelectors.MaxLength, String(maxLength === NOT_SPECIFIED
+                ? ADG_HTML_CONVERSION_MAX_LENGTH
                 : maxLength)));
             // Create the converted rule
             conversionResult.push({
@@ -8925,7 +9262,7 @@ class HtmlRuleConverter extends RuleConverterBase {
                 // Convert the separator based on the exception status
                 separator: {
                     type: 'Value',
-                    value: ruleNode.exception
+                    value: rule.exception
                         ? exports.CosmeticRuleSeparator.AdgHtmlFilteringException
                         : exports.CosmeticRuleSeparator.AdgHtmlFiltering,
                 },
@@ -8940,11 +9277,11 @@ class HtmlRuleConverter extends RuleConverterBase {
                             }],
                     },
                 },
-                exception: ruleNode.exception,
-                domains: ruleNode.domains,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
             });
         }
-        return conversionResult;
+        return createNodeConversionResult(conversionResult, true);
     }
 }
 
@@ -8965,96 +9302,38 @@ function getScriptletName(scriptletNode) {
     return scriptletNode.children[0].value;
 }
 /**
- * Set name of the scriptlet
+ * Set name of the scriptlet.
+ * Modifies input `scriptletNode` if needed.
  *
  * @param scriptletNode Scriptlet node to set name of
  * @param name Name to set
- * @returns Scriptlet node with the specified name
- * @throws If the scriptlet is empty
  */
 function setScriptletName(scriptletNode, name) {
-    if (scriptletNode.children.length === 0) {
-        throw new Error('Empty scriptlet');
+    if (scriptletNode.children.length > 0) {
+        // eslint-disable-next-line no-param-reassign
+        scriptletNode.children[0].value = name;
     }
-    const scriptletNodeClone = cloneDeep(scriptletNode);
-    scriptletNodeClone.children[0].value = name;
-    return scriptletNodeClone;
 }
 /**
  * Set quote type of the scriptlet parameters
  *
  * @param scriptletNode Scriptlet node to set quote type of
  * @param quoteType Preferred quote type
- * @returns Scriptlet node with the specified quote type
  */
 function setScriptletQuoteType(scriptletNode, quoteType) {
-    if (scriptletNode.children.length === 0) {
-        throw new Error('Empty scriptlet');
-    }
-    const scriptletNodeClone = cloneDeep(scriptletNode);
-    for (let i = 0; i < scriptletNodeClone.children.length; i += 1) {
-        scriptletNodeClone.children[i].value = QuoteUtils.setStringQuoteType(scriptletNodeClone.children[i].value, quoteType);
-    }
-    return scriptletNodeClone;
-}
-
-/**
- * @file Scriptlet conversions from ABP and uBO to ADG
- */
-const ABP_SCRIPTLET_PREFIX = 'abp-';
-const UBO_SCRIPTLET_PREFIX = 'ubo-';
-/**
- * Helper class for converting scriptlets from ABP and uBO to ADG
- */
-class AdgScriptletConverter {
-    /**
-     * Helper function to convert scriptlets to ADG. We implement the core
-     * logic here to avoid code duplication.
-     *
-     * @param scriptletNode Scriptlet parameter list node to convert
-     * @param prefix Prefix to add to the scriptlet name
-     * @returns Converted scriptlet parameter list node
-     */
-    static convertToAdg(scriptletNode, prefix) {
-        // Remove possible quotes just to make it easier to work with the scriptlet name
-        const scriptletName = QuoteUtils.setStringQuoteType(getScriptletName(scriptletNode), exports.QuoteType.None);
-        // Clone the node to avoid any side effects
-        let result = cloneDeep(scriptletNode);
-        // Only add prefix if it's not already there
-        if (!scriptletName.startsWith(prefix)) {
-            result = setScriptletName(scriptletNode, `${prefix}${scriptletName}`);
+    if (scriptletNode.children.length > 0) {
+        for (let i = 0; i < scriptletNode.children.length; i += 1) {
+            // eslint-disable-next-line no-param-reassign
+            scriptletNode.children[i].value = QuoteUtils.setStringQuoteType(scriptletNode.children[i].value, quoteType);
         }
-        // ADG scriptlet parameters should be quoted, and single quoted are preferred
-        result = setScriptletQuoteType(result, exports.QuoteType.Single);
-        return result;
     }
-    /**
-     * Converts an ABP snippet node to ADG scriptlet node, if possible.
-     *
-     * @param scriptletNode Scriptlet node to convert
-     * @returns Converted scriptlet node
-     * @throws If the scriptlet isn't supported by ADG or is invalid
-     * @see {@link https://help.adblockplus.org/hc/en-us/articles/1500002338501#snippets-ref}
-     */
-    static convertFromAbp = (scriptletNode) => {
-        return AdgScriptletConverter.convertToAdg(scriptletNode, ABP_SCRIPTLET_PREFIX);
-    };
-    /**
-     * Convert a uBO scriptlet node to ADG scriptlet node, if possible.
-     *
-     * @param scriptletNode Scriptlet node to convert
-     * @returns Converted scriptlet node
-     * @throws If the scriptlet isn't supported by ADG or is invalid
-     * @see {@link https://github.com/gorhill/uBlock/wiki/Resources-Library#available-general-purpose-scriptlets}
-     */
-    static convertFromUbo = (scriptletNode) => {
-        return AdgScriptletConverter.convertToAdg(scriptletNode, UBO_SCRIPTLET_PREFIX);
-    };
 }
 
 /**
  * @file Scriptlet injection rule converter
  */
+const ABP_SCRIPTLET_PREFIX = 'abp-';
+const UBO_SCRIPTLET_PREFIX = 'ubo-';
 /**
  * Scriptlet injection rule converter class
  *
@@ -9065,38 +9344,91 @@ class ScriptletRuleConverter extends RuleConverterBase {
      * Converts a scriptlet injection rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
+        // Ignore AdGuard rules
+        if (rule.syntax === exports.AdblockSyntax.Adg) {
+            return createNodeConversionResult([rule], false);
+        }
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
+        convertedSeparator = rule.exception
+            ? exports.CosmeticRuleSeparator.AdgJsInjectionException
+            : exports.CosmeticRuleSeparator.AdgJsInjection;
         const convertedScriptlets = [];
-        for (const scriptlet of ruleNode.body.children) {
-            if (ruleNode.syntax === exports.AdblockSyntax.Abp) {
-                convertedScriptlets.push(AdgScriptletConverter.convertFromAbp(scriptlet));
-            }
-            else if (ruleNode.syntax === exports.AdblockSyntax.Ubo) {
-                convertedScriptlets.push(AdgScriptletConverter.convertFromUbo(scriptlet));
+        for (const scriptlet of rule.body.children) {
+            // Clone the node to avoid any side effects
+            const scriptletClone = cloneScriptletRuleNode(scriptlet);
+            // Remove possible quotes just to make it easier to work with the scriptlet name
+            const scriptletName = QuoteUtils.setStringQuoteType(getScriptletName(scriptletClone), exports.QuoteType.None);
+            // Add prefix if it's not already there
+            let prefix;
+            switch (rule.syntax) {
+                case exports.AdblockSyntax.Abp:
+                    prefix = ABP_SCRIPTLET_PREFIX;
+                    break;
+                case exports.AdblockSyntax.Ubo:
+                    prefix = UBO_SCRIPTLET_PREFIX;
+                    break;
+                default:
+                    prefix = EMPTY;
             }
-            else if (ruleNode.syntax === exports.AdblockSyntax.Adg) {
-                convertedScriptlets.push(scriptlet);
+            if (!scriptletName.startsWith(prefix)) {
+                setScriptletName(scriptletClone, `${prefix}${scriptletName}`);
             }
+            // ADG scriptlet parameters should be quoted, and single quoted are preferred
+            setScriptletQuoteType(scriptletClone, exports.QuoteType.Single);
+            convertedScriptlets.push(scriptletClone);
         }
-        ruleNode.separator.value = ruleNode.exception
-            ? exports.CosmeticRuleSeparator.AdgJsInjectionException
-            : exports.CosmeticRuleSeparator.AdgJsInjection;
-        // ADG doesn't support multiple scriptlets in one rule, so we should split them
-        return convertedScriptlets.map((scriptlet) => {
-            return {
-                ...ruleNode,
+        return createNodeConversionResult(convertedScriptlets.map((scriptlet) => {
+            const res = {
+                category: rule.category,
+                type: rule.type,
                 syntax: exports.AdblockSyntax.Adg,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: convertedSeparator,
+                },
                 body: {
-                    ...ruleNode.body,
+                    type: rule.body.type,
                     children: [scriptlet],
                 },
             };
-        });
+            if (rule.modifiers) {
+                res.modifiers = cloneModifierListNode(rule.modifiers);
+            }
+            return res;
+        }), true);
+    }
+}
+
+/**
+ * A very simple map extension that allows to store multiple values for the same key
+ * by storing them in an array.
+ *
+ * @todo Add more methods if needed
+ */
+class MultiValueMap extends Map {
+    /**
+     * Adds a value to the map. If the key already exists, the value will be appended to the existing array,
+     * otherwise a new array will be created for the key.
+     *
+     * @param key Key to add
+     * @param values Value(s) to add
+     */
+    add(key, ...values) {
+        let currentValues = super.get(key);
+        if (isUndefined(currentValues)) {
+            currentValues = [];
+            super.set(key, values);
+        }
+        currentValues.push(...values);
     }
 }
 
@@ -9122,69 +9454,115 @@ class AdgCosmeticRuleModifierConverter {
      * Converts a uBO cosmetic rule modifier list to ADG, if possible.
      *
      * @param modifierList Cosmetic rule modifier list node to convert
-     * @returns Converted cosmetic rule modifier list node
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the modifier list cannot be converted
      * @see {@link https://github.com/gorhill/uBlock/wiki/Procedural-cosmetic-filters#cosmetic-filter-operators}
      */
-    static convertFromUbo = (modifierList) => {
-        const convertedModifierList = createModifierListNode();
-        for (const modifier of modifierList.children) {
-            let modifierValue;
-            switch (modifier.modifier.value) {
-                case UBO_MATCHES_PATH_OPERATOR:
-                    // :matches-path() should have a value
-                    if (!modifier.value) {
-                        throw new RuleConversionError('Missing value for :matches-path(...)');
-                    }
-                    modifierValue = RegExpUtils.isRegexPattern(modifier.value.value)
-                        ? StringUtils.escapeCharacters(modifier.value.value, SPECIAL_MODIFIER_REGEX_CHARS)
-                        : modifier.value.value;
-                    // Convert uBO's `:matches-path(...)` operator to ADG's `$path=...` modifier
-                    convertedModifierList.children.push(createModifierNode(ADG_PATH_MODIFIER, 
-                    // We should negate the regexp if the modifier is an exception
-                    modifier.exception
-                        // eslint-disable-next-line max-len
-                        ? `${REGEX_MARKER}${RegExpUtils.negateRegexPattern(RegExpUtils.patternToRegexp(modifierValue))}${REGEX_MARKER}`
-                        : modifierValue));
-                    break;
-                default:
-                    // Leave the modifier as-is
-                    convertedModifierList.children.push(modifier);
+    static convertFromUbo(modifierList) {
+        const conversionMap = new MultiValueMap();
+        modifierList.children.forEach((modifier, index) => {
+            // :matches-path
+            if (modifier.modifier.value === UBO_MATCHES_PATH_OPERATOR) {
+                if (!modifier.value) {
+                    throw new RuleConversionError(`'${UBO_MATCHES_PATH_OPERATOR}' operator requires a value`);
+                }
+                const value = RegExpUtils.isRegexPattern(modifier.value.value)
+                    ? StringUtils.escapeCharacters(modifier.value.value, SPECIAL_MODIFIER_REGEX_CHARS)
+                    : modifier.value.value;
+                // Convert uBO's `:matches-path(...)` operator to ADG's `$path=...` modifier
+                conversionMap.add(index, createModifierNode(ADG_PATH_MODIFIER, 
+                // We should negate the regexp if the modifier is an exception
+                modifier.exception
+                    // eslint-disable-next-line max-len
+                    ? `${REGEX_MARKER}${RegExpUtils.negateRegexPattern(RegExpUtils.patternToRegexp(value))}${REGEX_MARKER}`
+                    : value));
             }
-        }
-        return convertedModifierList;
-    };
+        });
+        // Check if we have any converted modifiers
+        if (conversionMap.size) {
+            const modifierListClone = clone(modifierList);
+            // Replace the original modifiers with the converted ones
+            modifierListClone.children = modifierListClone.children.map((modifier, index) => {
+                const convertedModifier = conversionMap.get(index);
+                return convertedModifier ?? modifier;
+            }).flat();
+            return createConversionResult(modifierListClone, true);
+        }
+        // Otherwise, just return the original modifier list
+        return createConversionResult(modifierList, false);
+    }
 }
 
-// Constants for pseudo-classes (please keep them sorted alphabetically)
-const ABP_CONTAINS = '-abp-contains';
-const ABP_HAS = '-abp-has';
-const CONTAINS = 'contains';
-const HAS = 'has';
-const HAS_TEXT = 'has-text';
-const MATCHES_CSS = 'matches-css';
-const MATCHES_CSS_AFTER = 'matches-css-after';
-const MATCHES_CSS_BEFORE = 'matches-css-before';
-const NOT = 'not';
-// Constants for pseudo-elements (please keep them sorted alphabetically)
-const AFTER = 'after';
-const BEFORE = 'before';
+var PseudoClasses;
+(function (PseudoClasses) {
+    PseudoClasses["AbpContains"] = "-abp-contains";
+    PseudoClasses["AbpHas"] = "-abp-has";
+    PseudoClasses["Contains"] = "contains";
+    PseudoClasses["Has"] = "has";
+    PseudoClasses["HasText"] = "has-text";
+    PseudoClasses["MatchesCss"] = "matches-css";
+    PseudoClasses["MatchesCssAfter"] = "matches-css-after";
+    PseudoClasses["MatchesCssBefore"] = "matches-css-before";
+    PseudoClasses["Not"] = "not";
+})(PseudoClasses || (PseudoClasses = {}));
+var PseudoElements;
+(function (PseudoElements) {
+    PseudoElements["After"] = "after";
+    PseudoElements["Before"] = "before";
+})(PseudoElements || (PseudoElements = {}));
+const PSEUDO_ELEMENT_NAMES = new Set([
+    PseudoElements.After,
+    PseudoElements.Before,
+]);
+const LEGACY_MATCHES_CSS_NAMES = new Set([
+    PseudoClasses.MatchesCssAfter,
+    PseudoClasses.MatchesCssBefore,
+]);
+const LEGACY_EXT_CSS_INDICATOR_PSEUDO_NAMES = new Set([
+    PseudoClasses.Not,
+    PseudoClasses.MatchesCssBefore,
+    PseudoClasses.MatchesCssAfter,
+]);
+const CSS_CONVERSION_INDICATOR_PSEUDO_NAMES = new Set([
+    PseudoClasses.AbpContains,
+    PseudoClasses.AbpHas,
+    PseudoClasses.HasText,
+]);
 /**
  * Converts some pseudo-classes to pseudo-elements. For example:
  * - `:before` → `::before`
  *
  * @param selectorList Selector list to convert
- * @returns Converted selector list
+ * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+ * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+ * If the node was not converted, the result will contain the original node with the same object reference
  */
 function convertToPseudoElements(selectorList) {
-    // Prepare conversion result
-    const selectorListClone = cloneDeep(selectorList);
+    // Check conversion indications before doing any heavy work
+    const hasIndicator = ecssTree.find(
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    selectorList, (node) => node.type === exports.CssTreeNodeType.PseudoClassSelector && PSEUDO_ELEMENT_NAMES.has(node.name));
+    if (!hasIndicator) {
+        return createConversionResult(selectorList, false);
+    }
+    // Make a clone of the selector list to avoid modifying the original one,
+    // then convert & return the cloned version
+    const selectorListClone = clone(selectorList);
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ecssTree.walk(selectorListClone, {
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         leave: (node) => {
             if (node.type === exports.CssTreeNodeType.PseudoClassSelector) {
-                // :after  → ::after
-                // :before → ::before
-                if (node.name === AFTER || node.name === BEFORE) {
+                // If the pseudo-class is `:before` or `:after`, then we should
+                // convert the node type to pseudo-element:
+                //  :after  → ::after
+                //  :before → ::before
+                if (PSEUDO_ELEMENT_NAMES.has(node.name)) {
                     Object.assign(node, {
                         ...node,
                         type: exports.CssTreeNodeType.PseudoElementSelector,
@@ -9193,7 +9571,7 @@ function convertToPseudoElements(selectorList) {
             }
         },
     });
-    return selectorListClone;
+    return createConversionResult(selectorListClone, true);
 }
 /**
  * Converts legacy Extended CSS `matches-css-before` and `matches-css-after`
@@ -9202,33 +9580,36 @@ function convertToPseudoElements(selectorList) {
  * - `:matches-css-after(...)`  → `:matches-css(after, ...)`
  *
  * @param node Node to convert
+ * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+ * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+ * If the node was not converted, the result will contain the original node with the same object reference
  * @throws If the node is invalid
  */
 function convertLegacyMatchesCss(node) {
-    const nodeClone = cloneDeep(node);
-    if (nodeClone.type === exports.CssTreeNodeType.PseudoClassSelector
-        && [MATCHES_CSS_BEFORE, MATCHES_CSS_AFTER].includes(nodeClone.name)) {
-        if (!nodeClone.children || nodeClone.children.size < 1) {
-            throw new Error(`Invalid ${nodeClone.name} pseudo-class: missing argument`);
-        }
-        // Remove the 'matches-css-' prefix to get the direction
-        const direction = nodeClone.name.substring(MATCHES_CSS.length + 1);
-        // Rename the pseudo-class
-        nodeClone.name = MATCHES_CSS;
-        // Add the direction to the first raw argument
-        const arg = nodeClone.children.first;
-        // Check argument
-        if (!arg) {
-            throw new Error(`Invalid ${nodeClone.name} pseudo-class: argument shouldn't be null`);
-        }
-        if (arg.type !== exports.CssTreeNodeType.Raw) {
-            throw new Error(`Invalid ${nodeClone.name} pseudo-class: unexpected argument type`);
-        }
-        // Add the direction as the first argument
-        arg.value = `${direction},${arg.value}`;
-        // Replace the original node with the converted one
-        Object.assign(node, nodeClone);
-    }
+    // Check conversion indications before doing any heavy work
+    if (node.type !== exports.CssTreeNodeType.PseudoClassSelector || !LEGACY_MATCHES_CSS_NAMES.has(node.name)) {
+        return createConversionResult(node, false);
+    }
+    const nodeClone = clone(node);
+    if (!nodeClone.children || nodeClone.children.length < 1) {
+        throw new Error(`Invalid ${node.name} pseudo-class: missing argument`);
+    }
+    // Rename the pseudo-class
+    nodeClone.name = PseudoClasses.MatchesCss;
+    // Remove the 'matches-css-' prefix to get the direction
+    const direction = node.name.substring(PseudoClasses.MatchesCss.length + 1);
+    // Add the direction to the first raw argument
+    const arg = nodeClone.children[0];
+    // Check argument
+    if (!arg) {
+        throw new Error(`Invalid ${node.name} pseudo-class: argument shouldn't be null`);
+    }
+    if (arg.type !== exports.CssTreeNodeType.Raw) {
+        throw new Error(`Invalid ${node.name} pseudo-class: unexpected argument type`);
+    }
+    // Add the direction as the first argument
+    arg.value = `${direction},${arg.value}`;
+    return createConversionResult(nodeClone, true);
 }
 /**
  * Converts legacy Extended CSS selectors to the modern Extended CSS syntax.
@@ -9238,16 +9619,40 @@ function convertLegacyMatchesCss(node) {
  * - `[-ext-matches-css-before=...]` → `:matches-css(before, ...)`
  *
  * @param selectorList Selector list AST to convert
- * @returns Converted selector list
+ * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+ * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+ * If the node was not converted, the result will contain the original node with the same object reference
  */
 function convertFromLegacyExtendedCss(selectorList) {
-    // Prepare conversion result
-    const selectorListClone = cloneDeep(selectorList);
+    // Check conversion indications before doing any heavy work
+    const hasIndicator = ecssTree.find(
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    selectorList, (node) => {
+        if (node.type === exports.CssTreeNodeType.PseudoClassSelector) {
+            return LEGACY_EXT_CSS_INDICATOR_PSEUDO_NAMES.has(node.name);
+        }
+        if (node.type === exports.CssTreeNodeType.AttributeSelector) {
+            return node.name.name.startsWith(LEGACY_EXT_CSS_ATTRIBUTE_PREFIX);
+        }
+        return false;
+    });
+    if (!hasIndicator) {
+        return createConversionResult(selectorList, false);
+    }
+    const selectorListClone = clone(selectorList);
+    // TODO: Need to improve CSSTree types, until then we need to use any type here
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ecssTree.walk(selectorListClone, {
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         leave: (node) => {
             // :matches-css-before(arg) → :matches-css(before,arg)
             // :matches-css-after(arg)  → :matches-css(after,arg)
-            convertLegacyMatchesCss(node);
+            const convertedLegacyExtCss = convertLegacyMatchesCss(node);
+            if (convertedLegacyExtCss.isConverted) {
+                Object.assign(node, convertedLegacyExtCss.result);
+            }
             // [-ext-name=...]   → :name(...)
             // [-ext-name='...'] → :name(...)
             // [-ext-name="..."] → :name(...)
@@ -9261,7 +9666,7 @@ function convertFromLegacyExtendedCss(selectorList) {
                 // Remove the '-ext-' prefix to get the pseudo-class name
                 const name = node.name.name.substring(LEGACY_EXT_CSS_ATTRIBUTE_PREFIX.length);
                 // Prepare the children list for the pseudo-class node
-                const children = new ecssTree.List();
+                const children = [];
                 // TODO: Change String node to Raw node to drop the quotes.
                 // The structure of the node is the same, just the type
                 // is different and generate() will generate the quotes
@@ -9274,7 +9679,7 @@ function convertFromLegacyExtendedCss(selectorList) {
                 // For example, if the input is [-ext-has="> .selector"], then
                 // we need to parse "> .selector" as a selector instead of string
                 // it as a raw value
-                if ([HAS, NOT].includes(name)) {
+                if ([PseudoClasses.Has, PseudoClasses.Not].includes(name)) {
                     // Get the value of the attribute selector
                     const { value } = node;
                     // If the value is an identifier, then simply push it to the
@@ -9284,10 +9689,12 @@ function convertFromLegacyExtendedCss(selectorList) {
                     }
                     else if (value.type === exports.CssTreeNodeType.String) {
                         // Parse the value as a selector
-                        const parsedChildren = CssTree.parse(value.value, exports.CssTreeParserContext.selectorList);
+                        const parsedChildren = CssTree.parsePlain(value.value, exports.CssTreeParserContext.selectorList);
                         // Don't forget convert the parsed AST again, because
                         // it was a raw string before
-                        children.push(convertFromLegacyExtendedCss(parsedChildren));
+                        const convertedChildren = convertFromLegacyExtendedCss(parsedChildren);
+                        // Push the converted children to the list
+                        children.push(convertedChildren.result);
                     }
                 }
                 else {
@@ -9314,14 +9721,12 @@ function convertFromLegacyExtendedCss(selectorList) {
                     children,
                 };
                 // Handle this case: [-ext-matches-css-before=...] → :matches-css(before,...)
-                convertLegacyMatchesCss(pseudoNode);
-                // Convert attribute selector to pseudo-class selector, but
-                // keep the reference to the original node
-                Object.assign(node, pseudoNode);
+                const convertedPseudoNode = convertLegacyMatchesCss(pseudoNode);
+                Object.assign(node, convertedPseudoNode.isConverted ? convertedPseudoNode.result : pseudoNode);
             }
         },
     });
-    return selectorListClone;
+    return createConversionResult(selectorListClone, true);
 }
 /**
  * CSS selector converter
@@ -9333,32 +9738,51 @@ class CssSelectorConverter extends ConverterBase {
      * Converts Extended CSS elements to AdGuard-compatible ones
      *
      * @param selectorList Selector list to convert
-     * @returns Converted selector list
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the rule is invalid or incompatible
      */
     static convertToAdg(selectorList) {
         // First, convert
         //  - legacy Extended CSS selectors to the modern Extended CSS syntax and
         //  - some pseudo-classes to pseudo-elements
-        const selectorListClone = convertToPseudoElements(convertFromLegacyExtendedCss(cloneDeep(selectorList)));
+        const legacyExtCssConverted = convertFromLegacyExtendedCss(selectorList);
+        const pseudoElementsConverted = convertToPseudoElements(legacyExtCssConverted.result);
+        const hasIndicator = legacyExtCssConverted.isConverted || pseudoElementsConverted.isConverted || ecssTree.find(
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        selectorList, 
+        // eslint-disable-next-line max-len
+        (node) => node.type === exports.CssTreeNodeType.PseudoClassSelector && CSS_CONVERSION_INDICATOR_PSEUDO_NAMES.has(node.name));
+        if (!hasIndicator) {
+            return createConversionResult(selectorList, false);
+        }
+        const selectorListClone = legacyExtCssConverted.isConverted || pseudoElementsConverted.isConverted
+            ? pseudoElementsConverted.result
+            : clone(selectorList);
         // Then, convert some Extended CSS pseudo-classes to AdGuard-compatible ones
+        // TODO: Need to improve CSSTree types, until then we need to use any type here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         ecssTree.walk(selectorListClone, {
+            // TODO: Need to improve CSSTree types, until then we need to use any type here
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             leave: (node) => {
                 if (node.type === exports.CssTreeNodeType.PseudoClassSelector) {
                     // :-abp-contains(...) → :contains(...)
                     // :has-text(...)      → :contains(...)
-                    if (node.name === ABP_CONTAINS || node.name === HAS_TEXT) {
-                        CssTree.renamePseudoClass(node, CONTAINS);
+                    if (node.name === PseudoClasses.AbpContains || node.name === PseudoClasses.HasText) {
+                        CssTree.renamePseudoClass(node, PseudoClasses.Contains);
                     }
                     // :-abp-has(...) → :has(...)
-                    if (node.name === ABP_HAS) {
-                        CssTree.renamePseudoClass(node, HAS);
+                    if (node.name === PseudoClasses.AbpHas) {
+                        CssTree.renamePseudoClass(node, PseudoClasses.Has);
                     }
                     // TODO: check uBO's `:others()` and `:watch-attr()` pseudo-classes
                 }
             },
         });
-        return selectorListClone;
+        return createConversionResult(selectorListClone, true);
     }
 }
 
@@ -9375,27 +9799,39 @@ class CssInjectionRuleConverter extends RuleConverterBase {
      * Converts a CSS injection rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
         // Change the separator if the rule contains ExtendedCSS selectors
-        if (CssTree.hasAnySelectorExtendedCssNode(ruleNode.body.selectorList) || ruleNode.body.remove) {
-            ruleNode.separator.value = ruleNode.exception
+        if (CssTree.hasAnySelectorExtendedCssNode(rule.body.selectorList) || rule.body.remove) {
+            convertedSeparator = rule.exception
                 ? exports.CosmeticRuleSeparator.AdgExtendedCssInjectionException
                 : exports.CosmeticRuleSeparator.AdgExtendedCssInjection;
         }
         else {
-            ruleNode.separator.value = ruleNode.exception
+            convertedSeparator = rule.exception
                 ? exports.CosmeticRuleSeparator.AdgCssInjectionException
                 : exports.CosmeticRuleSeparator.AdgCssInjection;
         }
-        // Convert CSS selector list
-        Object.assign(ruleNode.body.selectorList, CssSelectorConverter.convertToAdg(ecssTree.fromPlainObject(ruleNode.body.selectorList)));
-        ruleNode.syntax = exports.AdblockSyntax.Adg;
-        return [ruleNode];
+        const convertedSelectorList = CssSelectorConverter.convertToAdg(rule.body.selectorList);
+        // Check if the rule needs to be converted
+        if (!(rule.syntax === exports.AdblockSyntax.Common || rule.syntax === exports.AdblockSyntax.Adg)
+            || separator !== convertedSeparator
+            || convertedSelectorList.isConverted) {
+            // TODO: Replace with custom clone method
+            const ruleClone = clone(rule);
+            ruleClone.syntax = exports.AdblockSyntax.Adg;
+            ruleClone.separator.value = convertedSeparator;
+            ruleClone.body.selectorList = convertedSelectorList.result;
+            return createNodeConversionResult([ruleClone], true);
+        }
+        // Otherwise, return the original rule
+        return createNodeConversionResult([rule], false);
     }
 }
 
@@ -9412,27 +9848,39 @@ class ElementHidingRuleConverter extends RuleConverterBase {
      * Converts an element hiding rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
         // Change the separator if the rule contains ExtendedCSS selectors
-        if (CssTree.hasAnySelectorExtendedCssNode(ruleNode.body.selectorList)) {
-            ruleNode.separator.value = ruleNode.exception
+        if (CssTree.hasAnySelectorExtendedCssNode(rule.body.selectorList)) {
+            convertedSeparator = rule.exception
                 ? exports.CosmeticRuleSeparator.ExtendedElementHidingException
                 : exports.CosmeticRuleSeparator.ExtendedElementHiding;
         }
         else {
-            ruleNode.separator.value = ruleNode.exception
+            convertedSeparator = rule.exception
                 ? exports.CosmeticRuleSeparator.ElementHidingException
                 : exports.CosmeticRuleSeparator.ElementHiding;
         }
-        // Convert CSS selector list
-        Object.assign(ruleNode.body.selectorList, CssSelectorConverter.convertToAdg(ecssTree.fromPlainObject(ruleNode.body.selectorList)));
-        ruleNode.syntax = exports.AdblockSyntax.Adg;
-        return [ruleNode];
+        const convertedSelectorList = CssSelectorConverter.convertToAdg(rule.body.selectorList);
+        // Check if the rule needs to be converted
+        if (!(rule.syntax === exports.AdblockSyntax.Common || rule.syntax === exports.AdblockSyntax.Adg)
+            || separator !== convertedSeparator
+            || convertedSelectorList.isConverted) {
+            // TODO: Replace with custom clone method
+            const ruleClone = clone(rule);
+            ruleClone.syntax = exports.AdblockSyntax.Adg;
+            ruleClone.separator.value = convertedSeparator;
+            ruleClone.body.selectorList = convertedSelectorList.result;
+            return createNodeConversionResult([ruleClone], true);
+        }
+        // Otherwise, return the original rule
+        return createNodeConversionResult([rule], false);
     }
 }
 
@@ -9460,7 +9908,7 @@ function createNetworkRuleNode(pattern, modifiers = undefined, exception = false
         },
     };
     if (!isUndefined(modifiers)) {
-        result.modifiers = cloneDeep(modifiers);
+        result.modifiers = clone(modifiers);
     }
     return result;
 }
@@ -9480,32 +9928,37 @@ class HeaderRemovalRuleConverter extends RuleConverterBase {
      * Converts a header removal rule to AdGuard syntax, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
+     * @example
+     * If the input rule is:
+     * ```adblock
+     * example.com##^responseheader(header-name)
+     * ```
+     * The output will be:
+     * ```adblock
+     * ||example.com^$removeheader=header-name
+     * ```
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
         // TODO: Add support for ABP syntax once it starts supporting header removal rules
-        // Check the input rule
-        if (ruleNode.category !== exports.RuleCategory.Cosmetic
-            || ruleNode.type !== exports.CosmeticRuleType.HtmlFilteringRule
-            || ruleNode.body.body.type !== exports.CssTreeNodeType.Function
-            || ruleNode.body.body.name !== UBO_RESPONSEHEADER_MARKER) {
-            throw new RuleConversionError('Not a response header rule');
+        // Leave the rule as is if it's not a header removal rule
+        if (rule.category !== exports.RuleCategory.Cosmetic
+            || rule.type !== exports.CosmeticRuleType.HtmlFilteringRule
+            || rule.body.body.type !== exports.CssTreeNodeType.Function
+            || rule.body.body.name !== UBO_RESPONSEHEADER_MARKER) {
+            return createNodeConversionResult([rule], false);
         }
         // Prepare network rule pattern
-        let pattern = EMPTY;
-        if (ruleNode.domains.children.length === 1) {
+        const pattern = [];
+        if (rule.domains.children.length === 1) {
             // If the rule has only one domain, we can use a simple network rule pattern:
             // ||single-domain-from-the-rule^
-            pattern = [
-                ADBLOCK_URL_START,
-                ruleNode.domains.children[0].value,
-                ADBLOCK_URL_SEPARATOR,
-            ].join(EMPTY);
+            pattern.push(ADBLOCK_URL_START, rule.domains.children[0].value, ADBLOCK_URL_SEPARATOR);
         }
-        else if (ruleNode.domains.children.length > 1) {
+        else if (rule.domains.children.length > 1) {
             // TODO: Add support for multiple domains, for example:
             // example.com,example.org,example.net##^responseheader(header-name)
             // We should consider allowing $domain with $removeheader modifier,
@@ -9515,13 +9968,13 @@ class HeaderRemovalRuleConverter extends RuleConverterBase {
         }
         // Prepare network rule modifiers
         const modifiers = createModifierListNode();
-        modifiers.children.push(createModifierNode(ADG_REMOVEHEADER_MODIFIER, CssTree.generateFunctionValue(ecssTree.fromPlainObject(ruleNode.body.body))));
+        modifiers.children.push(createModifierNode(ADG_REMOVEHEADER_MODIFIER, CssTree.generateFunctionPlainValue(rule.body.body)));
         // Construct the network rule
-        return [
-            createNetworkRuleNode(pattern, modifiers, 
+        return createNodeConversionResult([
+            createNetworkRuleNode(pattern.join(EMPTY), modifiers, 
             // Copy the exception flag
-            ruleNode.exception, exports.AdblockSyntax.Adg),
-        ];
+            rule.exception, exports.AdblockSyntax.Adg),
+        ], true);
     }
 }
 
@@ -9538,48 +9991,69 @@ class CosmeticRuleConverter extends RuleConverterBase {
      * Converts a cosmetic rule to AdGuard syntax, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
-        // Convert cosmetic rule modifiers
-        if (ruleNode.modifiers) {
-            if (ruleNode.syntax === exports.AdblockSyntax.Ubo) {
-                // uBO doesn't support this rule:
-                // example.com##+js(set-constant.js, foo, bar):matches-path(/baz)
-                if (ruleNode.type === exports.CosmeticRuleType.ScriptletInjectionRule) {
-                    throw new RuleConversionError('uBO scriptlet injection rules don\'t support cosmetic rule modifiers');
-                }
-                ruleNode.modifiers = AdgCosmeticRuleModifierConverter.convertFromUbo(ruleNode.modifiers);
-            }
-            else if (ruleNode.syntax === exports.AdblockSyntax.Abp) {
-                // TODO: Implement once ABP starts supporting cosmetic rule modifiers
-                throw new RuleConversionError('ABP don\'t support cosmetic rule modifiers');
-            }
-        }
+        let subconverterResult;
         // Convert cosmetic rule based on its type
-        switch (ruleNode.type) {
+        switch (rule.type) {
             case exports.CosmeticRuleType.ElementHidingRule:
-                return ElementHidingRuleConverter.convertToAdg(ruleNode);
+                subconverterResult = ElementHidingRuleConverter.convertToAdg(rule);
+                break;
             case exports.CosmeticRuleType.ScriptletInjectionRule:
-                return ScriptletRuleConverter.convertToAdg(ruleNode);
+                subconverterResult = ScriptletRuleConverter.convertToAdg(rule);
+                break;
             case exports.CosmeticRuleType.CssInjectionRule:
-                return CssInjectionRuleConverter.convertToAdg(ruleNode);
+                subconverterResult = CssInjectionRuleConverter.convertToAdg(rule);
+                break;
             case exports.CosmeticRuleType.HtmlFilteringRule:
                 // Handle special case: uBO response header filtering rule
-                if (ruleNode.body.body.type === exports.CssTreeNodeType.Function
-                    && ruleNode.body.body.name === UBO_RESPONSEHEADER_MARKER) {
-                    return HeaderRemovalRuleConverter.convertToAdg(ruleNode);
+                if (rule.body.body.type === exports.CssTreeNodeType.Function
+                    && rule.body.body.name === UBO_RESPONSEHEADER_MARKER) {
+                    subconverterResult = HeaderRemovalRuleConverter.convertToAdg(rule);
                 }
-                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 exports.CosmeticRuleType.JsInjectionRule:
-                return [ruleNode];
+                subconverterResult = createNodeConversionResult([rule], false);
+                break;
             default:
                 throw new RuleConversionError('Unsupported cosmetic rule type');
         }
+        let convertedModifiers;
+        // Convert cosmetic rule modifiers, if any
+        if (rule.modifiers) {
+            if (rule.syntax === exports.AdblockSyntax.Ubo) {
+                // uBO doesn't support this rule:
+                // example.com##+js(set-constant.js, foo, bar):matches-path(/baz)
+                if (rule.type === exports.CosmeticRuleType.ScriptletInjectionRule) {
+                    throw new RuleConversionError('uBO scriptlet injection rules don\'t support cosmetic rule modifiers');
+                }
+                convertedModifiers = AdgCosmeticRuleModifierConverter.convertFromUbo(rule.modifiers);
+            }
+            else if (rule.syntax === exports.AdblockSyntax.Abp) {
+                // TODO: Implement once ABP starts supporting cosmetic rule modifiers
+                throw new RuleConversionError('ABP don\'t support cosmetic rule modifiers');
+            }
+        }
+        if ((subconverterResult.result.length > 1 || subconverterResult.isConverted)
+            || (convertedModifiers && convertedModifiers.isConverted)) {
+            // Add modifier list to the subconverter result rules
+            subconverterResult.result.forEach((subconverterRule) => {
+                if (convertedModifiers && subconverterRule.category === exports.RuleCategory.Cosmetic) {
+                    // eslint-disable-next-line no-param-reassign
+                    subconverterRule.modifiers = convertedModifiers.result;
+                }
+            });
+            return subconverterResult;
+        }
+        return createNodeConversionResult([rule], false);
     }
 }
 
@@ -9651,17 +10125,16 @@ class NetworkRuleModifierListConverter extends ConverterBase {
      * Converts a network rule modifier list to AdGuard format, if possible.
      *
      * @param modifierList Network rule modifier list node to convert
-     * @returns Converted modifier list node
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
      * @throws If the conversion is not possible
      */
     static convertToAdg(modifierList) {
-        // Clone the provided AST node to avoid side effects
-        const modifierListNode = cloneDeep(modifierList);
-        const convertedModifierList = createModifierListNode();
-        // We should merge $csp modifiers into one
-        const cspValues = [];
-        modifierListNode.children.forEach((modifierNode) => {
-            // Handle regular modifiers conversion and $csp modifiers collection
+        const conversionMap = new MultiValueMap();
+        // Special case: $csp modifier
+        let cspCount = 0;
+        modifierList.children.forEach((modifierNode, index) => {
             const modifierConversions = ADG_CONVERSION_MAP.get(modifierNode.modifier.value);
             if (modifierConversions) {
                 for (const modifierConversion of modifierConversions) {
@@ -9674,17 +10147,14 @@ class NetworkRuleModifierListConverter extends ConverterBase {
                     const value = modifierConversion.value
                         ? modifierConversion.value(modifierNode.value?.value)
                         : modifierNode.value?.value;
-                    if (name === CSP_MODIFIER && value) {
-                        // Special case: collect $csp values
-                        cspValues.push(value);
+                    // Check if the name or the value is different from the original modifier
+                    // If so, add the converted modifier to the list
+                    if (name !== modifierNode.modifier.value || value !== modifierNode.value?.value) {
+                        conversionMap.add(index, createModifierNode(name, value, exception));
                     }
-                    else {
-                        // Regular case: collect the converted modifiers, if the modifier list
-                        // not already contains the same modifier
-                        const existingModifier = convertedModifierList.children.find((m) => m.modifier.value === name && m.exception === exception && m.value?.value === value);
-                        if (!existingModifier) {
-                            convertedModifierList.children.push(createModifierNode(name, value, exception));
-                        }
+                    // Special case: $csp modifier
+                    if (name === CSP_MODIFIER) {
+                        cspCount += 1;
                     }
                 }
                 return;
@@ -9707,26 +10177,52 @@ class NetworkRuleModifierListConverter extends ConverterBase {
                 // Try to convert the redirect resource name to ADG format
                 // This function returns undefined if the resource name is unknown
                 const convertedRedirectResource = redirects.convertRedirectNameToAdg(redirectResource);
-                convertedModifierList.children.push(createModifierNode(modifierName, 
-                // If the redirect resource name is unknown, fall back to the original one
-                // Later, the validator will throw an error if the resource name is invalid
-                convertedRedirectResource || redirectResource, modifierNode.exception));
-                return;
-            }
-            // In all other cases, just copy the modifier as is, if the modifier list
-            // not already contains the same modifier
-            const existingModifier = convertedModifierList.children.find((m) => m.modifier.value === modifierNode.modifier.value
-                && m.exception === modifierNode.exception
-                && m.value?.value === modifierNode.value?.value);
-            if (!existingModifier) {
-                convertedModifierList.children.push(modifierNode);
+                // Check if the modifier name or the redirect resource name is different from the original modifier
+                // If so, add the converted modifier to the list
+                if (modifierName !== modifierNode.modifier.value
+                    || (convertedRedirectResource !== undefined && convertedRedirectResource !== redirectResource)) {
+                    conversionMap.add(index, createModifierNode(modifierName, 
+                    // If the redirect resource name is unknown, fall back to the original one
+                    // Later, the validator will throw an error if the resource name is invalid
+                    convertedRedirectResource || redirectResource, modifierNode.exception));
+                }
             }
         });
-        // Merge $csp modifiers into one, then add it to the converted modifier list
-        if (cspValues.length > 0) {
-            convertedModifierList.children.push(createModifierNode(CSP_MODIFIER, cspValues.join(CSP_SEPARATOR)));
+        // Prepare the result if there are any converted modifiers or $csp modifiers
+        if (conversionMap.size || cspCount) {
+            const modifierListClone = cloneModifierListNode(modifierList);
+            // Replace the original modifiers with the converted ones
+            // One modifier may be replaced with multiple modifiers, so we need to flatten the array
+            modifierListClone.children = modifierListClone.children.map((modifierNode, index) => {
+                const conversionRecord = conversionMap.get(index);
+                if (conversionRecord) {
+                    return conversionRecord;
+                }
+                return modifierNode;
+            }).flat();
+            // Special case: $csp modifier: merge multiple $csp modifiers into one
+            // and put it at the end of the modifier list
+            if (cspCount) {
+                const cspValues = [];
+                modifierListClone.children = modifierListClone.children.filter((modifierNode) => {
+                    if (modifierNode.modifier.value === CSP_MODIFIER) {
+                        if (!modifierNode.value?.value) {
+                            throw new RuleConversionError('$csp modifier value is missing');
+                        }
+                        cspValues.push(modifierNode.value?.value);
+                        return false;
+                    }
+                    return true;
+                });
+                modifierListClone.children.push(createModifierNode(CSP_MODIFIER, cspValues.join(CSP_SEPARATOR)));
+            }
+            // Before returning the result, remove duplicated modifiers
+            modifierListClone.children = modifierListClone.children.filter((modifierNode, index, self) => self.findIndex((m) => m.modifier.value === modifierNode.modifier.value
+                && m.exception === modifierNode.exception
+                && m.value?.value === modifierNode.value?.value) === index);
+            return createConversionResult(modifierListClone, true);
         }
-        return convertedModifierList;
+        return createConversionResult(modifierList, false);
     }
 }
 
@@ -9743,17 +10239,35 @@ class NetworkRuleConverter extends RuleConverterBase {
      * Converts a network rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
-        // Convert modifiers
-        if (ruleNode.modifiers) {
-            Object.assign(ruleNode.modifiers, NetworkRuleModifierListConverter.convertToAdg(ruleNode.modifiers));
+        if (rule.modifiers) {
+            const modifiers = NetworkRuleModifierListConverter.convertToAdg(rule.modifiers);
+            // If the object reference is different, it means that the modifiers were converted
+            // In this case, we should clone the entire rule and replace the modifiers with the converted ones
+            if (modifiers.isConverted) {
+                return {
+                    result: [{
+                            category: exports.RuleCategory.Network,
+                            type: 'NetworkRule',
+                            syntax: rule.syntax,
+                            exception: rule.exception,
+                            pattern: {
+                                type: 'Value',
+                                value: rule.pattern.value,
+                            },
+                            modifiers: modifiers.result,
+                        }],
+                    isConverted: true,
+                };
+            }
         }
-        return [ruleNode];
+        // If the modifiers were not converted, return the original rule
+        return createNodeConversionResult([rule], false);
     }
 }
 
@@ -9774,48 +10288,27 @@ class RuleConverter extends RuleConverterBase {
      * Converts an adblock filtering rule to AdGuard format, if possible.
      *
      * @param rule Rule node to convert
-     * @returns Array of converted rule nodes
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
      * @throws If the rule is invalid or cannot be converted
      */
     static convertToAdg(rule) {
-        // Clone the provided AST node to avoid side effects
-        const ruleNode = cloneDeep(rule);
         // Delegate conversion to the corresponding sub-converter
         // based on the rule category
-        switch (ruleNode.category) {
+        switch (rule.category) {
             case exports.RuleCategory.Comment:
-                return CommentRuleConverter.convertToAdg(ruleNode);
+                return CommentRuleConverter.convertToAdg(rule);
             case exports.RuleCategory.Cosmetic:
-                return CosmeticRuleConverter.convertToAdg(ruleNode);
+                return CosmeticRuleConverter.convertToAdg(rule);
             case exports.RuleCategory.Network:
-                return NetworkRuleConverter.convertToAdg(ruleNode);
+                return NetworkRuleConverter.convertToAdg(rule);
             default:
-                throw new RuleConversionError(`Unknown rule category: ${ruleNode.category}`);
+                throw new RuleConversionError(`Unknown rule category: ${rule.category}`);
         }
     }
 }
 
-/**
- * @file Utility functions for working with filter list nodes
- */
-/**
- * Creates a filter list node
- *
- * @param rules Rules to put in the list (optional, defaults to an empty list)
- * @returns Filter list node
- */
-function createFilterListNode(rules = []) {
-    const result = {
-        type: 'FilterList',
-        children: [],
-    };
-    // We need to clone the rules to avoid side effects
-    if (rules.length > 0) {
-        result.children = cloneDeep(rules);
-    }
-    return result;
-}
-
 /**
  * @file Adblock filter list converter
  */
@@ -9834,18 +10327,133 @@ class FilterListConverter extends ConverterBase {
      * Converts an adblock filter list to AdGuard format, if possible.
      *
      * @param filterListNode Filter list node to convert
-     * @returns Converted filter list node
-     * @throws If the filter list is invalid or cannot be converted
+     * @param tolerant Indicates whether the converter should be tolerant to invalid rules. If enabled and a rule is
+     * invalid, it will be left as is. If disabled and a rule is invalid, the whole filter list will be failed.
+     * Defaults to `true`.
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
+     * @throws If the filter list is invalid or cannot be converted (if the tolerant mode is disabled)
+     */
+    static convertToAdg(filterListNode, tolerant = true) {
+        // Prepare a map to store the converted rules by their index in the filter list
+        const conversionMap = new MultiValueMap();
+        // Iterate over the filtering rules and convert them one by one, then add them to the result (one conversion may
+        // result in multiple rules)
+        for (let i = 0; i < filterListNode.children.length; i += 1) {
+            try {
+                const convertedRules = RuleConverter.convertToAdg(filterListNode.children[i]);
+                // Add the converted rules to the map if they were converted
+                if (convertedRules.isConverted) {
+                    conversionMap.add(i, ...convertedRules.result);
+                }
+            }
+            catch (error) {
+                // If the tolerant mode is disabled, we should throw an error, this will fail the whole filter list
+                // conversion.
+                // Otherwise, we just ignore the error and leave the rule as is
+                if (!tolerant) {
+                    throw error;
+                }
+            }
+        }
+        // If the conversion map is empty, it means that no rules were converted, so we can return the original filter
+        // list
+        if (conversionMap.size === 0) {
+            return createConversionResult(filterListNode, false);
+        }
+        // Otherwise, create a new filter list node with the converted rules
+        const convertedFilterList = {
+            type: 'FilterList',
+            children: [],
+        };
+        // Iterate over the original rules again and add them to the converted filter list, replacing the converted
+        // rules with the new ones at the specified indexes
+        for (let i = 0; i < filterListNode.children.length; i += 1) {
+            const rules = conversionMap.get(i);
+            if (rules) {
+                convertedFilterList.children.push(...rules);
+            }
+            else {
+                // We clone the unconverted rules to avoid mutating the original filter list if we return the converted
+                // one
+                convertedFilterList.children.push(clone(filterListNode.children[i]));
+            }
+        }
+        return createConversionResult(convertedFilterList, true);
+    }
+}
+
+/**
+ * @file Filter list converter for raw filter lists
+ *
+ * Technically, this is a wrapper around `FilterListConverter` that works with nodes instead of strings.
+ */
+/**
+ * Adblock filter list converter class.
+ *
+ * You can use this class to convert string-based filter lists, since most of the converters work with nodes.
+ * This class just provides an extra layer on top of the {@link FilterListConverter} and calls the parser/serializer
+ * before/after the conversion internally.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class RawFilterListConverter extends ConverterBase {
+    /**
+     * Converts an adblock filter list text to AdGuard format, if possible.
+     *
+     * @param rawFilterList Raw filter list text to convert
+     * @param tolerant Indicates whether the converter should be tolerant to invalid rules. If enabled and a rule is
+     * invalid, it will be left as is. If disabled and a rule is invalid, the whole filter list will be failed.
+     * Defaults to `true`.
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the array of converted filter list text, and its `isConverted` flag indicates whether the original rule was
+     * converted. If the rule was not converted, the original filter list text will be returned
+     * @throws If the filter list is invalid or cannot be converted (if the tolerant mode is disabled)
      */
-    static convertToAdg(filterListNode) {
-        const result = createFilterListNode();
-        // Iterate over the filtering rules and convert them one by one,
-        // then add them to the result (one conversion may result in multiple rules)
-        for (const ruleNode of filterListNode.children) {
-            const convertedRules = RuleConverter.convertToAdg(ruleNode);
-            result.children.push(...convertedRules);
+    static convertToAdg(rawFilterList, tolerant = true) {
+        const conversionResult = FilterListConverter.convertToAdg(FilterListParser.parse(rawFilterList, tolerant), tolerant);
+        // If the filter list was not converted, return the original text
+        if (!conversionResult.isConverted) {
+            return createConversionResult(rawFilterList, false);
         }
-        return result;
+        // Otherwise, serialize the filter list and return the result
+        return createConversionResult(FilterListParser.generate(conversionResult.result), true);
+    }
+}
+
+/**
+ * @file Rule converter for raw rules
+ *
+ * Technically, this is a wrapper around `RuleConverter` that works with nodes instead of strings.
+ */
+/**
+ * Adblock filtering rule converter class.
+ *
+ * You can use this class to convert string-based adblock rules, since most of the converters work with nodes.
+ * This class just provides an extra layer on top of the {@link RuleConverter} and calls the parser/serializer
+ * before/after the conversion internally.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class RawRuleConverter extends ConverterBase {
+    /**
+     * Converts an adblock filtering rule to AdGuard format, if possible.
+     *
+     * @param rawRule Raw rule text to convert
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the array of converted rule texts, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the original rule text will be returned
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rawRule) {
+        const conversionResult = RuleConverter.convertToAdg(RuleParser.parse(rawRule));
+        // If the rule was not converted, return the original rule text
+        if (!conversionResult.isConverted) {
+            return createConversionResult([rawRule], false);
+        }
+        // Otherwise, serialize the converted rule nodes
+        return createConversionResult(conversionResult.result.map(RuleParser.generate), true);
     }
 }
 
@@ -9927,7 +10535,7 @@ class LogicalExpressionUtils {
     }
 }
 
-const version$1 = "1.1.5";
+const version$1 = "1.1.6";
 
 /**
  * @file AGTree version
@@ -9988,6 +10596,8 @@ exports.PREPROCESSOR_MARKER = PREPROCESSOR_MARKER;
 exports.ParameterListParser = ParameterListParser;
 exports.PreProcessorCommentRuleParser = PreProcessorCommentRuleParser;
 exports.QuoteUtils = QuoteUtils;
+exports.RawFilterListConverter = RawFilterListConverter;
+exports.RawRuleConverter = RawRuleConverter;
 exports.RegExpUtils = RegExpUtils;
 exports.RuleConversionError = RuleConversionError;
 exports.RuleConverter = RuleConverter;