@adguard/agtree 3.4.3 → 4.0.1

package/dist/converter/cosmetic/html.js

@@ -1,25 +1,22 @@
 /*
- * AGTree v3.4.3 (build date: Thu, 11 Dec 2025 13:43:19 GMT)
- * (c) 2025 Adguard Software Ltd.
+ * AGTree v4.0.1 (build date: Thu, 19 Feb 2026 05:13:05 GMT)
+ * (c) 2026 Adguard Software Ltd.
  * Released under the MIT license
  * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
  */
-import { getFormattedTokenName, TokenType } from '@adguard/css-tokenizer';
 import { sprintf } from 'sprintf-js';
 import { CosmeticRuleSeparator, CosmeticRuleType, RuleCategory } from '../../nodes/index.js';
 import { AdblockSyntax } from '../../utils/adblockers.js';
 import { RuleConversionError } from '../../errors/rule-conversion-error.js';
 import { RuleConverterBase } from '../base-interfaces/rule-converter-base.js';
-import { RegExpUtils } from '../../utils/regexp.js';
 import { createNodeConversionResult } from '../base-interfaces/conversion-result.js';
 import { cloneDomainListNode } from '../../ast-utils/clone.js';
-import { CssTokenStream } from '../../parser/css/css-token-stream.js';
-import { UBO_HTML_MASK, EQUALS, EMPTY, ESCAPE_CHARACTER, CSS_PSEUDO_MARKER, CSS_PSEUDO_OPEN, CSS_PSEUDO_CLOSE, OPEN_SQUARE_BRACKET, CLOSE_SQUARE_BRACKET } from '../../utils/constants.js';
-import { StringUtils, DOUBLE_QUOTE_MARKER } from '../../utils/string.js';
-import 'tldts';
-import { QuoteUtils } from '../../utils/quotes.js';
-import 'json5';
-import '../../parser/css/balancing.js';
+import { EMPTY, EQUALS } from '../../utils/constants.js';
+import { RegExpUtils } from '../../utils/regexp.js';
+import { AdgHtmlFilteringBodyParser } from '../../parser/cosmetic/html-filtering-body/adg-html-filtering-body-parser.js';
+import { UboHtmlFilteringBodyParser } from '../../parser/cosmetic/html-filtering-body/ubo-html-filtering-body-parser.js';
+import { AdgHtmlFilteringBodyGenerator } from '../../generator/cosmetic/html-filtering-body/adg-html-filtering-body-generator.js';
+import { UboHtmlFilteringBodyGenerator } from '../../generator/cosmetic/html-filtering-body/ubo-html-filtering-body-generator.js';
 
 /**
  * @file HTML filtering rule converter
@@ -35,152 +32,82 @@ import '../../parser/css/balancing.js';
  */
 const ADG_HTML_DEFAULT_MAX_LENGTH = 8192;
 const ADG_HTML_CONVERSION_MAX_LENGTH = ADG_HTML_DEFAULT_MAX_LENGTH * 32;
-const NOT_SPECIFIED = -1;
-const PseudoClasses = {
-    Contains: 'contains',
+/**
+ * Supported special pseudo-classes from uBlock.
+ *
+ * Note: If new pseudo-classes are added here, ensure to update
+ * the set and logic in the converter methods accordingly.
+ */
+const UboPseudoClasses = {
     HasText: 'has-text',
     MinTextLength: 'min-text-length',
 };
 /**
- * Constructs a pseudo-class string with a specified value for use in CSS selectors.
+ * Supported special attribute selectors from AdGuard.
  *
- * @param pseudo - The pseudo-class name.
- * @param value - The value of the pseudo-class.
- * @returns pseudo-class string, including pseudo-class name, value and delimiters.
+ * Note: If new pseudo-classes are added here, ensure to update
+ * the set and logic in the converter methods accordingly.
  */
-const addPseudoClassWithValue = (pseudo, value) => {
-    return `${CSS_PSEUDO_MARKER}${pseudo}${CSS_PSEUDO_OPEN}${value}${CSS_PSEUDO_CLOSE}`;
-};
-const AttributeSelectors = {
+const AdgAttributeSelectors = {
     MaxLength: 'max-length',
     MinLength: 'min-length',
-    TagContent: 'tag-content'};
-const SUPPORTED_UBO_PSEUDO_CLASSES = new Set([
-    PseudoClasses.Contains,
-    PseudoClasses.HasText,
-    PseudoClasses.MinTextLength,
-]);
-const ERROR_MESSAGES = {
-    ABP_NOT_SUPPORTED: 'Invalid rule, ABP does not support HTML filtering rules',
-    TAG_SHOULD_BE_FIRST_CHILD: "Unexpected token '%s' with value '%s', tag selector should be the first child",
-    INVALID_ATTRIBUTE_NAME: "Attribute name should be an identifier, but got '%s' with value '%s'",
-    // eslint-disable-next-line max-len
-    INVALID_ATTRIBUTE_VALUE: `Expected '${getFormattedTokenName(TokenType.Ident)}' or '${getFormattedTokenName(TokenType.String)}' as attribute value, but got '%s' with value '%s`,
-    VALUE_FOR_ATTR_SHOULD_BE_INT: "Value for '%s' attribute should be an integer, but got '%s'",
-    INVALID_PSEUDO_CLASS: "Unsupported pseudo class '%s'",
-    VALUE_FOR_PSEUDO_CLASS_SHOULD_BE_INT: "Value for '%s' pseudo class should be an integer, but got '%s'",
-    // eslint-disable-next-line max-len
-    REGEXP_NOT_SUPPORTED: "Cannot convert RegExp parameter '%s' from '%s' pseudo class, because converting RegExp patterns are not supported yet",
-    ATTRIBUTE_SELECTOR_REQUIRES_VALUE: "Attribute selector '%s' requires a value",
-    VALUE_SHOULD_BE_SPECIFIED: 'Value should be specified if operator is specified',
-    VALUE_SHOULD_BE_POSITIVE: 'Value should be positive',
-    UNEXPECTED_TOKEN_WITH_VALUE: "Unexpected token '%s' with value '%s'",
-    FLAGS_NOT_SUPPORTED: 'Flags are not supported for attribute selectors',
+    TagContent: 'tag-content',
+    Wildcard: 'wildcard',
 };
 /**
- * Convert `""` to `\"` within strings, because it does not compatible with the standard CSS syntax.
+ * Supported special pseudo-classes from AdGuard.
  *
- * @param selector CSS selector string
- * @returns Escaped CSS selector
- * @note In the legacy syntax, `""` is used to escape double quotes, but it cannot be used in the standard CSS syntax,
- * so we use conversion functions to handle this.
- * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#tag-content}
+ * Note: If new pseudo-classes are added here, ensure to update
+ * the set and logic in the converter methods accordingly.
  */
-function escapeDoubleQuotes(selector) {
-    let withinString = false;
-    const buffer = [];
-    for (let i = 0; i < selector.length; i += 1) {
-        if (!withinString && selector[i] === DOUBLE_QUOTE_MARKER) {
-            withinString = true;
-            buffer.push(selector[i]);
-        }
-        else if (withinString && selector[i] === DOUBLE_QUOTE_MARKER && selector[i + 1] === DOUBLE_QUOTE_MARKER) {
-            buffer.push(ESCAPE_CHARACTER);
-            buffer.push(DOUBLE_QUOTE_MARKER);
-            i += 1;
-        }
-        else if (withinString && selector[i] === DOUBLE_QUOTE_MARKER && selector[i + 1] !== DOUBLE_QUOTE_MARKER) {
-            buffer.push(DOUBLE_QUOTE_MARKER);
-            withinString = false;
-        }
-        else {
-            buffer.push(selector[i]);
-        }
-    }
-    return buffer.join(EMPTY);
-}
+const AdgPseudoClasses = {
+    Contains: 'contains',
+};
 /**
- * Safely parses length values from attribute selectors, like `"262144"` from `[max-length="262144"]`
- *
- * @param value The string value to parse
- * @param attrName The attribute name for error messages
- * @returns Parsed number
- * @throws A {@link RuleConversionError} if parsing fails
+ * Set of {@link UboPseudoClasses}.
  */
-function parseLengthValue(value, attrName) {
-    const cleanValue = QuoteUtils.removeQuotes(value);
-    const parsed = Number(cleanValue);
-    if (Number.isNaN(parsed)) {
-        throw new RuleConversionError(sprintf(ERROR_MESSAGES.VALUE_FOR_ATTR_SHOULD_BE_INT, attrName, value));
-    }
-    if (parsed < 0) {
-        throw new RuleConversionError(sprintf(ERROR_MESSAGES.VALUE_SHOULD_BE_POSITIVE, attrName, value));
-    }
-    return parsed;
-}
+const SUPPORTED_UBO_PSEUDO_CLASSES = new Set([
+    UboPseudoClasses.HasText,
+    UboPseudoClasses.MinTextLength,
+]);
 /**
- * Convert escaped double quotes `\"` to `""` within strings.
- *
- * @param selector CSS selector string
- * @returns Unescaped CSS selector
- * @note In the legacy syntax, `""` is used to escape double quotes, but it cannot be used in the standard CSS syntax,
- * so we use conversion functions to handle this.
- * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#tag-content}
+ * Set of {@link AdgAttributeSelectors}.
  */
-function unescapeDoubleQuotes(selector) {
-    let withinString = false;
-    const buffer = [];
-    for (let i = 0; i < selector.length; i += 1) {
-        if (selector[i] === DOUBLE_QUOTE_MARKER && selector[i - 1] !== ESCAPE_CHARACTER) {
-            withinString = !withinString;
-            buffer.push(selector[i]);
-        }
-        else if (withinString && selector[i] === ESCAPE_CHARACTER && selector[i + 1] === DOUBLE_QUOTE_MARKER) {
-            buffer.push(DOUBLE_QUOTE_MARKER);
-        }
-        else {
-            buffer.push(selector[i]);
-        }
-    }
-    return buffer.join(EMPTY);
-}
+const SUPPORTED_ADG_ATTRIBUTE_SELECTORS = new Set([
+    AdgAttributeSelectors.MaxLength,
+    AdgAttributeSelectors.MinLength,
+    AdgAttributeSelectors.TagContent,
+    AdgAttributeSelectors.Wildcard,
+]);
 /**
- * Helper function to render an attribute selector
- *
- * @param attr Attribute name
- * @param op Operator (optional)
- * @param value Attribute value (optional)
- * @param flags Attribute flags (optional)
- * @returns Rendered attribute selector string
+ * Set of {@link AdgPseudoClasses}.
  */
-function renderAttrSelector(attr, op, value, flags) {
-    const result = [];
-    result.push(OPEN_SQUARE_BRACKET);
-    result.push(attr);
-    {
-        if (value === undefined) {
-            throw new Error(ERROR_MESSAGES.VALUE_SHOULD_BE_SPECIFIED);
-        }
-        result.push(op);
-    }
-    if (value !== undefined) {
-        result.push(DOUBLE_QUOTE_MARKER);
-        result.push(value);
-        result.push(DOUBLE_QUOTE_MARKER);
-    }
-    result.push(CLOSE_SQUARE_BRACKET);
-    return result.join(EMPTY);
-}
+const SUPPORTED_ADG_PSEUDO_CLASSES = new Set([
+    AdgPseudoClasses.Contains,
+]);
+/**
+ * Error messages used in HTML filtering rule conversion.
+ */
+/* eslint-disable max-len */
+const ERROR_MESSAGES = {
+    ABP_NOT_SUPPORTED: 'Invalid rule, ABP does not support HTML filtering rules',
+    INVALID_RULE: 'Invalid HTML filtering rule: %s',
+    MIXED_SYNTAX_ADG_UBO: 'Mixed AdGuard and uBlock syntax',
+    EMPTY_SELECTOR_LIST: 'Selector list of HTML filtering rule must not be empty',
+    EMPTY_COMPLEX_SELECTOR: 'Complex selector of selector list must not be empty',
+    INVALID_SELECTOR_COMBINATOR: "Invalid selector combinator '%s' used between selectors",
+    UNKNOWN_SELECTOR_TYPE: "Unknown selector type '%s' found during conversion",
+    SPECIAL_ATTRIBUTE_SELECTOR_OPERATOR_INVALID: "Special attribute selector '%s' has invalid operator '%s'",
+    SPECIAL_ATTRIBUTE_SELECTOR_FLAG_NOT_SUPPORTED: "Special attribute selector '%s' does not support flags",
+    SPECIAL_ATTRIBUTE_SELECTOR_VALUE_REQUIRED: "Special attribute selector '%s' requires a value",
+    SPECIAL_ATTRIBUTE_SELECTOR_VALUE_INT: "Value of special attribute selector '%s' must be an integer, got '%s'",
+    SPECIAL_ATTRIBUTE_SELECTOR_VALUE_POSITIVE: "Value of special attribute selector '%s' must be a positive integer, got '%s'",
+    SPECIAL_ATTRIBUTE_SELECTOR_NOT_SUPPORTED: "Special attribute selector '%s' is not supported in conversion",
+    SPECIAL_PSEUDO_CLASS_SELECTOR_ARGUMENT_REQUIRED: "Special pseudo-class selector '%s' requires an argument",
+    SPECIAL_PSEUDO_CLASS_SELECTOR_ARGUMENT_INT: "Argument of special pseudo-class selector '%s' must be an integer, got '%s'",
+    SPECIAL_PSEUDO_CLASS_SELECTOR_ARGUMENT_POSITIVE: "Argument of special pseudo-class selector '%s' must be a positive integer, got '%s'",
+    SPECIAL_PSEUDO_CLASS_SELECTOR_NOT_SUPPORTED: "Special pseudo-class selector '%s' is not supported in conversion",
+};
 /**
  * HTML filtering rule converter class
  *
@@ -188,344 +115,559 @@ function renderAttrSelector(attr, op, value, flags) {
  */
 class HtmlRuleConverter extends RuleConverterBase {
     /**
-     * Converts a HTML rule to AdGuard syntax, if possible. Also can be used to convert
-     * AdGuard rules to AdGuard syntax to validate them.
+     * Converts a HTML rule to AdGuard syntax, if possible.
+     * Also can be used to convert AdGuard rules to AdGuard syntax to validate them.
      *
-     * _Note:_ uBlock Origin supports multiple selectors within a single rule, but AdGuard doesn't,
-     * so the following rule
-     * ```
-     * example.com##^div[attr1="value1"][attr2="value2"], script:has-text(value)
-     * ```
-     * will be converted to multiple AdGuard rules:
-     * ```
-     * example.com$$div[attr1="value1"][attr2="value2"][max-length="262144"]
-     * example.com$$script[tag-content="value"][max-length="262144"]
-     * ```
+     * @param rule Rule node to convert.
      *
-     * @param rule Rule node to convert
      * @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
+     * 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) {
-        // Ignore AdGuard rules
+        let parser;
+        let onSpecialAttributeSelector;
+        let onSpecialPseudoClassSelector;
+        let isConverted = false;
         if (rule.syntax === AdblockSyntax.Adg) {
+            parser = AdgHtmlFilteringBodyParser;
+            onSpecialAttributeSelector = (name, value) => {
+                /**
+                 * Mark rule as converted in ADG -> ADG conversion only if
+                 * special attribute selectors are present in the rule body,
+                 * because they are deprecated and will be removed soon,
+                 * so we convert them to pseudo-class selectors
+                 */
+                isConverted = true;
+                return HtmlRuleConverter.convertSpecialAttributeSelectorAdgToAdg(name, value);
+            };
+            onSpecialPseudoClassSelector = HtmlRuleConverter.convertSpecialPseudoClassSelectorAdgToAdg;
+        }
+        else if (rule.syntax === AdblockSyntax.Ubo) {
+            /**
+             * Always mark rule as converted in UBO -> ADG conversion.
+             */
+            isConverted = true;
+            parser = UboHtmlFilteringBodyParser;
+            onSpecialAttributeSelector = HtmlRuleConverter.convertSpecialAttributeSelectorUboToAdg;
+            onSpecialPseudoClassSelector = HtmlRuleConverter.convertSpecialPseudoClassSelectorUboToAdg;
+        }
+        else {
+            throw new RuleConversionError(ERROR_MESSAGES.ABP_NOT_SUPPORTED);
+        }
+        // Convert body
+        const convertedBody = HtmlRuleConverter.convertBody(rule.body, parser, AdgHtmlFilteringBodyGenerator, onSpecialAttributeSelector, onSpecialPseudoClassSelector);
+        if (!isConverted) {
+            return createNodeConversionResult([rule], false);
+        }
+        return createNodeConversionResult([{
+                category: RuleCategory.Cosmetic,
+                type: CosmeticRuleType.HtmlFilteringRule,
+                syntax: AdblockSyntax.Adg,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
+                // Convert the separator based on the exception status
+                separator: {
+                    type: 'Value',
+                    value: rule.exception
+                        ? CosmeticRuleSeparator.AdgHtmlFilteringException
+                        : CosmeticRuleSeparator.AdgHtmlFiltering,
+                },
+                body: convertedBody,
+            }], true);
+    }
+    /**
+     * Converts a HTML rule to uBlock syntax, if possible.
+     * Also can be used to convert uBlock rules to uBlock syntax to validate them.
+     *
+     * @param rule Rule node to convert.
+     *
+     * @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 Error if the rule is invalid or cannot be converted.
+     */
+    static convertToUbo(rule) {
+        // Ignore uBlock rules
+        if (rule.syntax === AdblockSyntax.Ubo) {
             return createNodeConversionResult([rule], false);
         }
         if (rule.syntax === AdblockSyntax.Abp) {
             throw new RuleConversionError(ERROR_MESSAGES.ABP_NOT_SUPPORTED);
         }
-        const source = escapeDoubleQuotes(rule.body.value);
-        const stream = new CssTokenStream(source);
-        const convertedSelector = [];
-        const convertedSelectorList = [];
-        let minLen = NOT_SPECIFIED;
-        let maxLen = NOT_SPECIFIED;
-        // Skip leading whitespace
-        stream.skipWhitespace();
-        // Skip ^
-        stream.expect(TokenType.Delim, { value: UBO_HTML_MASK });
-        stream.advance();
-        while (!stream.isEof()) {
-            const token = stream.getOrFail();
-            if (token.type === TokenType.Ident) {
-                // Tag selector should be the first child, if present, but whitespace is allowed before it
-                if (convertedSelector.length !== 0 && stream.lookbehindForNonWs() !== undefined) {
-                    throw new RuleConversionError(sprintf(ERROR_MESSAGES.TAG_SHOULD_BE_FIRST_CHILD, getFormattedTokenName(token.type), source.slice(token.start, token.end)));
-                }
-                convertedSelector.push(source.slice(token.start, token.end));
-                stream.advance();
+        // Convert body
+        const convertedBody = HtmlRuleConverter.convertBody(rule.body, AdgHtmlFilteringBodyParser, UboHtmlFilteringBodyGenerator, HtmlRuleConverter.convertSpecialAttributeSelectorAdgToUbo, HtmlRuleConverter.convertSpecialPseudoClassSelectorAdgToUbo);
+        return createNodeConversionResult([{
+                category: RuleCategory.Cosmetic,
+                type: CosmeticRuleType.HtmlFilteringRule,
+                syntax: AdblockSyntax.Ubo,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: rule.exception
+                        ? CosmeticRuleSeparator.ElementHidingException
+                        : CosmeticRuleSeparator.ElementHiding,
+                },
+                body: convertedBody,
+            }], true);
+    }
+    /**
+     * Handles special attribute selectors during AdGuard to AdGuard conversion:
+     * - `[tag-content="content"]` -> `:contains(content)`
+     *   direct conversion, no changes to value
+     * - `[wildcard="*content*"]` -> `:contains(/*.content*./s)`
+     *   convert search pattern to regular expression
+     * - `[min-length="min"]` -> `:contains(/^(?=.{min,}$).*\/s)`
+     *   converts to a length-matching regular expression
+     * - `[max-length="max"]` -> `:contains(/^(?=.{0,max}$).*\/s)`
+     *   converts to a length-matching regular expression
+     *
+     * Note: This attribute selector to pseudo-class selector conversion
+     * is needed because AdGuard special attribute selectors are going
+     * to be deprecated and removed soon.
+     *
+     * @param name Name of the special attribute selector.
+     * @param value Value of the special attribute selector.
+     *
+     * @returns A {@link SimpleSelector} to add to the current complex selector.
+     */
+    static convertSpecialAttributeSelectorAdgToAdg(name, value) {
+        switch (name) {
+            // `[tag-content="content"]` -> `:contains(content)`
+            // direct conversion, no changes to value
+            case AdgAttributeSelectors.TagContent: {
+                return HtmlRuleConverter.getPseudoClassSelectorNode(AdgPseudoClasses.Contains, value);
             }
-            else if (token.type === TokenType.OpenSquareBracket) {
-                // Attribute selectors: https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors#syntax
-                const { start } = token;
-                let tempToken;
-                // Advance opening square bracket
-                stream.advance();
-                // Skip optional whitespace after the opening square bracket
-                stream.skipWhitespace();
-                // Parse attribute name
-                tempToken = stream.getOrFail();
-                if (tempToken.type !== TokenType.Ident) {
-                    throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_ATTRIBUTE_NAME, getFormattedTokenName(tempToken.type), source.slice(tempToken.start, tempToken.end)));
-                }
-                const attr = source.slice(tempToken.start, tempToken.end);
-                stream.advance();
-                // Skip optional whitespace after the attribute name
-                stream.skipWhitespace();
-                // Maybe attribute selector ends here, because value is not required, like in '[disabled]'
-                tempToken = stream.getOrFail();
-                // So check if the next non whitespace token is a closing square bracket
-                if (tempToken.type === TokenType.CloseSquareBracket) {
-                    const { end } = tempToken;
-                    stream.advance();
-                    // Special case for min-length and max-length attributes
-                    if (attr === AttributeSelectors.MinLength || attr === AttributeSelectors.MaxLength) {
-                        throw new RuleConversionError(sprintf(ERROR_MESSAGES.ATTRIBUTE_SELECTOR_REQUIRES_VALUE, attr));
-                    }
-                    convertedSelector.push(source.slice(start, end));
-                    continue;
-                }
-                // Next token should be a valid attribute selector operator
-                // Only '=' operator is supported
-                stream.expect(TokenType.Delim, { value: EQUALS });
-                // Advance the operator
-                stream.advance();
-                // Skip optional whitespace after the operator
-                stream.skipWhitespace();
-                // Parse attribute value
-                tempToken = stream.getOrFail();
-                // According to the spec, attribute value should be an identifier or a string
-                if (tempToken.type !== TokenType.Ident && tempToken.type !== TokenType.String) {
-                    throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_ATTRIBUTE_VALUE, getFormattedTokenName(tempToken.type), source.slice(tempToken.start, tempToken.end)));
-                }
-                const value = source.slice(tempToken.start, tempToken.end);
-                // Advance the attribute value
-                stream.advance();
-                // Skip optional whitespace after the attribute value
-                stream.skipWhitespace();
-                // Attribute selector may have flags - but AdGuard HTML filtering does not support them
-                tempToken = stream.getOrFail();
-                if (tempToken.type === TokenType.Ident) {
-                    throw new RuleConversionError(sprintf(ERROR_MESSAGES.FLAGS_NOT_SUPPORTED));
-                }
-                // Next token should be a closing square bracket
-                stream.expect(TokenType.CloseSquareBracket);
-                const { end } = stream.getOrFail();
-                stream.advance();
-                if (attr === AttributeSelectors.MinLength) {
-                    // Min length attribute
-                    const parsed = parseInt(value, 10);
-                    if (Number.isNaN(parsed)) {
-                        throw new RuleConversionError(sprintf(ERROR_MESSAGES.VALUE_FOR_ATTR_SHOULD_BE_INT, attr, value));
-                    }
-                    minLen = parsed;
-                }
-                else if (attr === AttributeSelectors.MaxLength) {
-                    // Max length attribute
-                    const parsed = parseInt(value, 10);
-                    if (Number.isNaN(parsed)) {
-                        throw new RuleConversionError(sprintf(ERROR_MESSAGES.VALUE_FOR_ATTR_SHOULD_BE_INT, attr, value));
-                    }
-                    maxLen = parsed;
+            // `[wildcard="*content*"] -> `:contains(/*.content*./s)`
+            // convert search pattern to regular expression
+            case AdgAttributeSelectors.Wildcard: {
+                return HtmlRuleConverter.getPseudoClassSelectorNode(AdgPseudoClasses.Contains, RegExpUtils.globToRegExp(value));
+            }
+            // `[min-length="min"]` -> `:contains(/^(?=.{min,}$).*\/s)`
+            // `[max-length="max"]` -> `:contains(/^(?=.{0,max}$).*\/s)`
+            // converts to a length-matching regular expression
+            case AdgAttributeSelectors.MinLength:
+            case AdgAttributeSelectors.MaxLength: {
+                // Validate length value
+                HtmlRuleConverter.assertValidLengthValue(name, value, ERROR_MESSAGES.SPECIAL_ATTRIBUTE_SELECTOR_VALUE_INT, ERROR_MESSAGES.SPECIAL_ATTRIBUTE_SELECTOR_VALUE_POSITIVE);
+                // It's safe to cast to number here after validation
+                const length = Number(value);
+                let min = null;
+                let max = null;
+                if (name === AdgAttributeSelectors.MinLength) {
+                    min = length;
                 }
                 else {
-                    convertedSelector.push(source.slice(start, end));
+                    max = length;
                 }
+                return HtmlRuleConverter.getPseudoClassSelectorNode(AdgPseudoClasses.Contains, RegExpUtils.getLengthRegexp(min, max));
             }
-            else if (token.type === TokenType.Colon) {
-                let tempToken;
-                // Pseudo classes: https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes#syntax
-                stream.advance();
-                // Next token should be a pseudo class name
-                stream.expect(TokenType.Function);
-                tempToken = stream.getOrFail();
-                const fn = source.slice(tempToken.start, tempToken.end - 1); // do not include '('
-                // Pseudo class should be supported
-                if (!SUPPORTED_UBO_PSEUDO_CLASSES.has(fn)) {
-                    throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_PSEUDO_CLASS, fn));
-                }
-                const paramStart = tempToken.end;
-                // Find the closing paren
-                stream.skipUntilBalanced();
-                tempToken = stream.getOrFail();
-                const paramEnd = tempToken.end;
-                // Get the parameter
-                const param = source.slice(paramStart, paramEnd - 1);
-                if (fn === PseudoClasses.MinTextLength) {
-                    // Min text length pseudo class
-                    // Parameter should be parsed as an integer
-                    const parsed = parseInt(param, 10);
-                    if (Number.isNaN(parsed)) {
-                        throw new RuleConversionError(sprintf(ERROR_MESSAGES.VALUE_FOR_PSEUDO_CLASS_SHOULD_BE_INT, fn, param));
-                    }
-                    minLen = parsed;
-                }
-                else if (fn === PseudoClasses.Contains || fn === PseudoClasses.HasText) {
-                    // Contains and has-text pseudo classes
-                    // Check if the argument is a RegExp
-                    if (RegExpUtils.isRegexPattern(param)) {
-                        // TODO: Add some support for RegExp patterns later
-                        // Need to find a way to convert some RegExp patterns to glob patterns
-                        throw new RuleConversionError(sprintf(ERROR_MESSAGES.REGEXP_NOT_SUPPORTED, param, fn));
-                    }
-                    // Escape unescaped double quotes in the parameter
-                    const paramEscaped = StringUtils.escapeCharacter(param, DOUBLE_QUOTE_MARKER);
-                    convertedSelector.push(renderAttrSelector(AttributeSelectors.TagContent, EQUALS, paramEscaped));
-                }
-                stream.advance();
+            // This line is unreachable due to exhausted cases, but we keep it to satisfy TS
+            default: {
+                throw new RuleConversionError(sprintf(ERROR_MESSAGES.SPECIAL_ATTRIBUTE_SELECTOR_NOT_SUPPORTED, name));
             }
-            else if (token.type === TokenType.Comma && token.balance === 0) {
-                if (minLen !== NOT_SPECIFIED) {
-                    convertedSelector.push(renderAttrSelector(AttributeSelectors.MinLength, EQUALS, minLen.toString()));
-                }
-                convertedSelector.push(renderAttrSelector(AttributeSelectors.MaxLength, EQUALS, maxLen !== NOT_SPECIFIED ? maxLen.toString() : ADG_HTML_CONVERSION_MAX_LENGTH.toString()));
-                convertedSelectorList.push(convertedSelector.join(EMPTY));
-                convertedSelector.length = 0;
-                stream.advance();
+        }
+    }
+    /**
+     * Since special pseudo-class selectors do not need conversion
+     * in AdGuard to AdGuard conversion, we simply return `true` to keep them as-is.
+     *
+     * @param name Name of the special pseudo-class selector.
+     *
+     * @returns `true` to keep the special pseudo-class selector as-is.
+     *
+     * @throws Rule conversion error for mixed syntax.
+     */
+    static convertSpecialPseudoClassSelectorAdgToAdg(name) {
+        if (SUPPORTED_UBO_PSEUDO_CLASSES.has(name)) {
+            throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_RULE, ERROR_MESSAGES.MIXED_SYNTAX_ADG_UBO));
+        }
+        return true;
+    }
+    /**
+     * Since special attribute selectors only AdGuard-specific,
+     * we should never encounter them in uBlock rules.
+     *
+     * @throws Rule conversion error for mixed syntax.
+     */
+    static convertSpecialAttributeSelectorUboToAdg() {
+        throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_RULE, ERROR_MESSAGES.MIXED_SYNTAX_ADG_UBO));
+    }
+    /**
+     * Handles special pseudo-class selectors during uBlock to AdGuard conversion:
+     * - `:has-text(text)` -> `:contains(text)`
+     *   direct conversion, no changes to argument
+     * - `:min-text-length(min)` -> `:contains(/^(?=.{min,MAX_CONVERSION_DEFAULT}$).*\/s)`
+     *   converts to a length-matching regular expression
+     *
+     * @param name Name of the special pseudo-class selector.
+     * @param argument Argument of the special pseudo-class selector.
+     *
+     * @returns A {@link SimpleSelector} to add to the current complex selector.
+     *
+     * @throws If AdGuard-specific pseudo-class selector is found in uBlock rule.
+     */
+    static convertSpecialPseudoClassSelectorUboToAdg(name, argument) {
+        switch (name) {
+            // `:has-text(text)` -> `:contains(text)`
+            // direct conversion, no changes to argument
+            case UboPseudoClasses.HasText: {
+                return HtmlRuleConverter.getPseudoClassSelectorNode(AdgPseudoClasses.Contains, argument);
+            }
+            // `:min-text-length(min)` -> `:contains(/^(?=.{min,MAX_CONVERSION_DEFAULT}$).*\/s)`
+            // converts to a length-matching regular expression
+            case UboPseudoClasses.MinTextLength: {
+                // Validate length value
+                HtmlRuleConverter.assertValidLengthValue(name, argument, ERROR_MESSAGES.SPECIAL_PSEUDO_CLASS_SELECTOR_ARGUMENT_INT, ERROR_MESSAGES.SPECIAL_PSEUDO_CLASS_SELECTOR_ARGUMENT_POSITIVE);
+                // It's safe to cast to number here after validation
+                const minLength = Number(argument);
+                return HtmlRuleConverter.getPseudoClassSelectorNode(AdgPseudoClasses.Contains, RegExpUtils.getLengthRegexp(minLength, ADG_HTML_CONVERSION_MAX_LENGTH));
             }
-            else if (token.type === TokenType.Whitespace) {
-                stream.advance();
+            // Throw an error if the AdGuard-specific pseudo-class selector found in uBlock rule
+            case AdgPseudoClasses.Contains: {
+                throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_RULE, ERROR_MESSAGES.MIXED_SYNTAX_ADG_UBO));
             }
-            else {
-                throw new RuleConversionError(sprintf(ERROR_MESSAGES.UNEXPECTED_TOKEN_WITH_VALUE, getFormattedTokenName(token.type), source.slice(token.start, token.end)));
+            // This line is unreachable due to exhausted cases, but we keep it to satisfy TS
+            default: {
+                throw new RuleConversionError(sprintf(ERROR_MESSAGES.SPECIAL_PSEUDO_CLASS_SELECTOR_NOT_SUPPORTED, name));
             }
         }
-        if (convertedSelector.length !== 0) {
-            if (minLen !== NOT_SPECIFIED) {
-                convertedSelector.push(renderAttrSelector(AttributeSelectors.MinLength, EQUALS, minLen.toString()));
+    }
+    /**
+     * Handles special attribute selectors during AdGuard to uBlock conversion:
+     * - `[tag-content="content"]` -> `:has-text(content)`
+     *   direct conversion, no changes to value
+     * - `[wildcard="*content*"]` -> `:has-text(/*.content*./s)`
+     *   convert search pattern to regular expression
+     * - `[min-length="min"]` -> `:min-text-length(min)`
+     *   direct conversion, no changes to value
+     * - `[max-length]` is skipped
+     *
+     * @param name Name of the special attribute selector.
+     * @param value Value of the special attribute selector.
+     *
+     * @returns A {@link SimpleSelector} to add to the current complex selector, or `false` to skip it.
+     */
+    static convertSpecialAttributeSelectorAdgToUbo(name, value) {
+        switch (name) {
+            // `[tag-content="content"]` -> `:has-text(content)`
+            // direct conversion, no changes to value
+            case AdgAttributeSelectors.TagContent: {
+                return HtmlRuleConverter.getPseudoClassSelectorNode(UboPseudoClasses.HasText, value);
+            }
+            // `[wildcard="*content*"] -> `:has-text(/*.content*./s)`
+            // convert search pattern to regular expression
+            case AdgAttributeSelectors.Wildcard: {
+                return HtmlRuleConverter.getPseudoClassSelectorNode(UboPseudoClasses.HasText, RegExpUtils.globToRegExp(value));
+            }
+            // `[min-length="min"]` -> `:min-text-length(min)`
+            // direct conversion, no changes to value
+            case AdgAttributeSelectors.MinLength: {
+                // Validate length value
+                HtmlRuleConverter.assertValidLengthValue(name, value, ERROR_MESSAGES.SPECIAL_ATTRIBUTE_SELECTOR_VALUE_INT, ERROR_MESSAGES.SPECIAL_ATTRIBUTE_SELECTOR_VALUE_POSITIVE);
+                return HtmlRuleConverter.getPseudoClassSelectorNode(UboPseudoClasses.MinTextLength, value);
+            }
+            // `[max-length]` is skipped
+            case AdgAttributeSelectors.MaxLength: {
+                return false;
+            }
+            // This line is unreachable due to exhausted cases, but we keep it to satisfy TS
+            default: {
+                throw new RuleConversionError(sprintf(ERROR_MESSAGES.SPECIAL_ATTRIBUTE_SELECTOR_NOT_SUPPORTED, name));
             }
-            convertedSelector.push(renderAttrSelector(AttributeSelectors.MaxLength, EQUALS, maxLen !== NOT_SPECIFIED ? maxLen.toString() : ADG_HTML_CONVERSION_MAX_LENGTH.toString()));
-            convertedSelectorList.push(convertedSelector.join(EMPTY));
         }
-        return createNodeConversionResult(
-        // Since AdGuard HTML filtering rules do not support multiple selectors, we need to split each selector
-        // into a separate rule node.
-        convertedSelectorList.map((selector) => ({
-            category: RuleCategory.Cosmetic,
-            type: CosmeticRuleType.HtmlFilteringRule,
-            syntax: AdblockSyntax.Adg,
-            exception: rule.exception,
-            domains: cloneDomainListNode(rule.domains),
-            // Convert the separator based on the exception status
-            separator: {
-                type: 'Value',
-                value: rule.exception
-                    ? CosmeticRuleSeparator.AdgHtmlFilteringException
-                    : CosmeticRuleSeparator.AdgHtmlFiltering,
-            },
-            body: {
-                type: 'Value',
-                value: unescapeDoubleQuotes(selector),
-            },
-        })), true);
     }
     /**
-     * Converts a HTML rule to uBlock Origin syntax, if possible.
+     * Handles special pseudo-class selectors during AdGuard to uBlock conversion:
+     * - `:contains(text)` -> `:has-text(text)`
+     *   direct conversion, no changes to argument
      *
-     * @note AdGuard rules are often more specific than uBlock Origin rules, so some information
-     * may be lost in conversion. AdGuard's `[max-length]` and `[tag-content]` attributes will be converted to
-     * uBlock's `:min-text-length()` and `:has-text()` pseudo-classes when possible.
+     * @param name Name of the special pseudo-class selector.
+     * @param argument Argument of the special pseudo-class selector.
      *
-     * @param rule Rule node to convert
-     * @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 Error if the rule is invalid or cannot be converted
+     * @returns A {@link SimpleSelector} to add to the current complex selector.
+     *
+     * @throws If uBlock-specific pseudo-class selector is found in AdGuard rule.
      */
-    static convertToUbo(rule) {
-        // Ignore uBlock Origin rules
-        if (rule.syntax === AdblockSyntax.Ubo) {
-            return createNodeConversionResult([rule], false);
+    static convertSpecialPseudoClassSelectorAdgToUbo(name, argument) {
+        switch (name) {
+            // `:contains(text)` -> `:has-text(text)`
+            // direct conversion, no changes to argument
+            case AdgPseudoClasses.Contains: {
+                return HtmlRuleConverter.getPseudoClassSelectorNode(UboPseudoClasses.HasText, argument);
+            }
+            // Throw an error if the uBlock-specific pseudo-class selector found in AdGuard rule
+            case UboPseudoClasses.HasText:
+            case UboPseudoClasses.MinTextLength: {
+                throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_RULE, ERROR_MESSAGES.MIXED_SYNTAX_ADG_UBO));
+            }
+            // This line is unreachable due to exhausted cases, but we keep it to satisfy TS
+            default: {
+                throw new RuleConversionError(sprintf(ERROR_MESSAGES.SPECIAL_PSEUDO_CLASS_SELECTOR_NOT_SUPPORTED, name));
+            }
         }
-        if (rule.syntax === AdblockSyntax.Abp) {
-            throw new RuleConversionError(ERROR_MESSAGES.ABP_NOT_SUPPORTED);
+    }
+    /**
+     * Converts a HTML filtering rule body by handling special simple selectors via callbacks.
+     * Special simple selectors are skipped in the converted selector list and should be handled from callee.
+     *
+     * @param body HTML filtering rule body to convert.
+     * @param parser HTML filtering rule body parser used for parsing raw value bodies.
+     * @param generator HTML filtering rule body generator used for generating raw value bodies.
+     * @param onSpecialAttributeSelector Callback invoked when a special attribute selector is found.
+     * @param onSpecialPseudoClassSelector Callback invoked when a special pseudo-class selector is found.
+     *
+     * @returns Converted selector list without special simple selectors.
+     */
+    static convertBody(body, parser, generator, onSpecialAttributeSelector, onSpecialPseudoClassSelector) {
+        // Handle case when body is raw value string.
+        // If so, parse it first as we need to work with AST nodes.
+        let processedBody;
+        if (body.type === 'Value') {
+            processedBody = parser.parse(body.value, {
+                isLocIncluded: false,
+                parseHtmlFilteringRuleBodies: true,
+            });
         }
-        const source = escapeDoubleQuotes(rule.body.value);
-        const stream = new CssTokenStream(source);
-        const convertedSelector = [];
-        let minTextLength;
-        // Skip leading whitespace
-        stream.skipWhitespace();
-        while (!stream.isEof()) {
-            const token = stream.getOrFail();
-            if (token.type === TokenType.Ident) {
-                convertedSelector.push(source.slice(token.start, token.end));
-                stream.advance();
-            }
-            else if (token.type === TokenType.OpenSquareBracket) {
-                // Attribute selectors
-                const { start } = token;
-                let tempToken;
-                // Advance opening square bracket
-                stream.advance();
-                // Skip optional whitespace
-                stream.skipWhitespace();
-                // Parse attribute name
-                tempToken = stream.getOrFail();
-                if (tempToken.type !== TokenType.Ident) {
-                    throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_ATTRIBUTE_NAME, getFormattedTokenName(tempToken.type), source.slice(tempToken.start, tempToken.end)));
-                }
-                const attr = source.slice(tempToken.start, tempToken.end);
-                stream.advance();
-                // Skip optional whitespace
-                stream.skipWhitespace();
-                // Check if this is a standalone attribute (like [disabled])
-                tempToken = stream.getOrFail();
-                if (tempToken.type === TokenType.CloseSquareBracket) {
-                    const { end } = tempToken;
-                    stream.advance();
-                    convertedSelector.push(source.slice(start, end));
-                    continue;
-                }
-                // Expect equals operator
-                stream.expect(TokenType.Delim, { value: EQUALS });
-                stream.advance();
-                // Skip optional whitespace
-                stream.skipWhitespace();
-                // Parse attribute value
-                tempToken = stream.getOrFail();
-                if (tempToken.type !== TokenType.Ident && tempToken.type !== TokenType.String) {
-                    throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_ATTRIBUTE_VALUE, getFormattedTokenName(tempToken.type), source.slice(tempToken.start, tempToken.end)));
-                }
-                const value = source.slice(tempToken.start, tempToken.end);
-                stream.advance();
-                // Skip optional whitespace
-                stream.skipWhitespace();
-                // Check for closing bracket
-                tempToken = stream.getOrFail();
-                if (tempToken.type !== TokenType.CloseSquareBracket) {
-                    throw new RuleConversionError(sprintf(ERROR_MESSAGES.FLAGS_NOT_SUPPORTED));
-                }
-                const { end } = stream.getOrFail();
-                stream.advance();
-                // Handle special attributes with improved number parsing
-                if (attr === AttributeSelectors.MinLength || attr === AttributeSelectors.MaxLength) {
-                    const parsedValue = parseLengthValue(value, attr);
-                    if (attr === AttributeSelectors.MinLength) {
-                        minTextLength = parsedValue;
+        else {
+            processedBody = body;
+        }
+        const { children: complexSelectors } = processedBody.selectorList;
+        // Selector list node must not be empty
+        HtmlRuleConverter.assertNotEmpty(complexSelectors, ERROR_MESSAGES.EMPTY_SELECTOR_LIST);
+        // Convert each complex selector
+        const convertedComplexSelectors = [];
+        for (let i = 0; i < complexSelectors.length; i += 1) {
+            const { children: selectors } = complexSelectors[i];
+            // Complex selector node must not be empty
+            HtmlRuleConverter.assertNotEmpty(selectors, ERROR_MESSAGES.EMPTY_COMPLEX_SELECTOR);
+            // Convert each selector
+            const convertedSelectors = [];
+            for (let j = 0; j < selectors.length; j += 1) {
+                const selector = selectors[j];
+                switch (selector.type) {
+                    case 'SelectorCombinator': {
+                        // Throw if selector combinator used incorrectly
+                        if (
+                        // If first selector in the complex selector (`> div`)
+                        j === 0
+                            // If the previous selector is also a combinator (`div > + span`)
+                            || j === selectors.length - 1
+                            // If the last selector in the complex selector (`div +`)
+                            || (j > 0 && selectors[j - 1].type === 'SelectorCombinator')) {
+                            throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_RULE, sprintf(ERROR_MESSAGES.INVALID_SELECTOR_COMBINATOR, selector.value)));
+                        }
+                        break;
+                    }
+                    case 'AttributeSelector': {
+                        // Not a special attribute selector - clone as-is after the switch
+                        if (!SUPPORTED_ADG_ATTRIBUTE_SELECTORS.has(selector.name.value)) {
+                            break;
+                        }
+                        // Throw an error if value is missing
+                        if (!('value' in selector) || selector.value.value === EMPTY) {
+                            throw new RuleConversionError(sprintf(ERROR_MESSAGES.SPECIAL_ATTRIBUTE_SELECTOR_VALUE_REQUIRED, selector.name.value));
+                        }
+                        // Throw an error if operator is not '='
+                        if (selector.operator.value !== EQUALS) {
+                            throw new RuleConversionError(sprintf(ERROR_MESSAGES.SPECIAL_ATTRIBUTE_SELECTOR_OPERATOR_INVALID, selector.name.value, selector.operator.value));
+                        }
+                        // Throw an error if flag is specified
+                        if (selector.flag) {
+                            throw new RuleConversionError(sprintf(ERROR_MESSAGES.SPECIAL_ATTRIBUTE_SELECTOR_FLAG_NOT_SUPPORTED, selector.name.value));
+                        }
+                        const name = selector.name.value;
+                        const { value } = selector.value;
+                        // Invoke callback and:
+                        // - add returned simple selector if it's not boolean
+                        // - skip adding if returned value is false
+                        // - keep original simple selector if returned value is true
+                        const result = onSpecialAttributeSelector(name, value);
+                        if (typeof result !== 'boolean') {
+                            convertedSelectors.push(result);
+                            continue;
+                        }
+                        else if (result === false) {
+                            continue;
+                        }
+                        break;
+                    }
+                    case 'PseudoClassSelector': {
+                        // Not a special pseudo-class selector - clone as-is after the switch
+                        if (!SUPPORTED_ADG_PSEUDO_CLASSES.has(selector.name.value)
+                            && !SUPPORTED_UBO_PSEUDO_CLASSES.has(selector.name.value)) {
+                            break;
+                        }
+                        // Throw an error if argument is missing
+                        if (!selector.argument || selector.argument.value === EMPTY) {
+                            throw new RuleConversionError(sprintf(ERROR_MESSAGES.SPECIAL_PSEUDO_CLASS_SELECTOR_ARGUMENT_REQUIRED, selector.name.value));
+                        }
+                        const name = selector.name.value;
+                        const argument = selector.argument.value;
+                        // Invoke callback and:
+                        // - add returned simple selector if it's not boolean
+                        // - skip adding if returned value is false
+                        // - keep original simple selector if returned value is true
+                        const result = onSpecialPseudoClassSelector(name, argument);
+                        if (typeof result !== 'boolean') {
+                            convertedSelectors.push(result);
+                            continue;
+                        }
+                        else if (result === false) {
+                            continue;
+                        }
+                        break;
                     }
                 }
-                else if (attr === AttributeSelectors.TagContent) {
-                    const unescapedValue = unescapeDoubleQuotes(value);
-                    const valueWithoutQuotes = QuoteUtils.removeQuotes(unescapedValue);
-                    convertedSelector.push(addPseudoClassWithValue(PseudoClasses.HasText, valueWithoutQuotes));
-                }
-                else {
-                    convertedSelector.push(source.slice(start, end));
+                // Clone selector if previous conditions are not met
+                convertedSelectors.push(HtmlRuleConverter.cloneSelector(selector));
+            }
+            convertedComplexSelectors.push({
+                type: 'ComplexSelector',
+                children: convertedSelectors,
+            });
+        }
+        let convertedBody = {
+            type: 'HtmlFilteringRuleBody',
+            selectorList: {
+                type: 'SelectorList',
+                children: convertedComplexSelectors,
+            },
+        };
+        // Convert back to Value if the original body was Value
+        if (body.type === 'Value') {
+            convertedBody = {
+                type: 'Value',
+                value: generator.generate(convertedBody),
+            };
+        }
+        return convertedBody;
+    }
+    /**
+     * Clones a simple selector or selector combinator node.
+     *
+     * @param selector Simple selector or selector combinator node to clone.
+     *
+     * @returns Cloned simple selector or selector combinator node.
+     */
+    static cloneSelector(selector) {
+        const { type } = selector;
+        switch (type) {
+            case 'TypeSelector':
+            case 'IdSelector':
+            case 'ClassSelector':
+                return {
+                    type: selector.type,
+                    value: selector.value,
+                };
+            case 'SelectorCombinator':
+                return {
+                    type: selector.type,
+                    value: selector.value,
+                };
+            case 'AttributeSelector': {
+                const attributeSelectorClone = {
+                    type: selector.type,
+                    name: {
+                        type: selector.name.type,
+                        value: selector.name.value,
+                    },
+                };
+                if ('value' in selector && selector.value) {
+                    attributeSelectorClone.operator = {
+                        type: selector.operator.type,
+                        value: selector.operator.value,
+                    };
+                    attributeSelectorClone.value = {
+                        type: selector.value.type,
+                        value: selector.value.value,
+                    };
+                    if (selector.flag) {
+                        attributeSelectorClone.flag = {
+                            type: selector.flag.type,
+                            value: selector.flag.value,
+                        };
+                    }
                 }
+                return attributeSelectorClone;
             }
-            else if (token.type === TokenType.Whitespace) {
-                stream.advance();
+            case 'PseudoClassSelector': {
+                const pseudoClassSelectorClone = {
+                    type: selector.type,
+                    name: {
+                        type: selector.name.type,
+                        value: selector.name.value,
+                    },
+                };
+                if (selector.argument) {
+                    pseudoClassSelectorClone.argument = {
+                        type: selector.argument.type,
+                        value: selector.argument.value,
+                    };
+                }
+                return pseudoClassSelectorClone;
             }
-            else {
-                throw new RuleConversionError(sprintf(ERROR_MESSAGES.UNEXPECTED_TOKEN_WITH_VALUE, getFormattedTokenName(token.type), source.slice(token.start, token.end)));
+            default: {
+                throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_RULE, sprintf(ERROR_MESSAGES.UNKNOWN_SELECTOR_TYPE, type)));
             }
         }
-        // Handle min length conversions
-        if (minTextLength !== undefined) {
-            convertedSelector.push(addPseudoClassWithValue(PseudoClasses.MinTextLength, minTextLength));
+    }
+    /**
+     * Creates a CSS pseudo-class selector node.
+     *
+     * @param name The name of the pseudo-class selector.
+     * @param argument Optional argument of the pseudo-class selector.
+     *
+     * @returns CSS pseudo-class selector node.
+     */
+    static getPseudoClassSelectorNode(name, argument) {
+        return {
+            type: 'PseudoClassSelector',
+            name: {
+                type: 'Value',
+                value: name,
+            },
+            argument: argument ? {
+                type: 'Value',
+                value: argument,
+            } : undefined,
+        };
+    }
+    /**
+     * Asserts that the given array is not empty.
+     *
+     * @param array Array to check.
+     * @param errorMessage Error message to use if the array is empty.
+     *
+     * @throws If the array is empty.
+     */
+    static assertNotEmpty(array, errorMessage) {
+        if (array.length === 0) {
+            throw new RuleConversionError(sprintf(ERROR_MESSAGES.INVALID_RULE, errorMessage));
+        }
+    }
+    /**
+     * Asserts that the given special attribute / pseudo-class length value is valid.
+     *
+     * @param name Name of the attribute or pseudo-class.
+     * @param value Value to parse.
+     * @param notIntErrorMessage Error message when the value is not an integer.
+     * @param notPositiveErrorMessage Error message when the value is not positive.
+     *
+     * @throws If the value is not a valid number or not positive.
+     */
+    static assertValidLengthValue(name, value, notIntErrorMessage, notPositiveErrorMessage) {
+        const parsed = Number(value);
+        if (Number.isNaN(parsed)) {
+            throw new RuleConversionError(sprintf(notIntErrorMessage, name, value));
+        }
+        if (parsed < 0) {
+            throw new RuleConversionError(sprintf(notPositiveErrorMessage, name, value));
         }
-        // Combine all selectors
-        const uboSelector = `${convertedSelector.join(EMPTY)}`;
-        return createNodeConversionResult([{
-                category: RuleCategory.Cosmetic,
-                type: CosmeticRuleType.HtmlFilteringRule,
-                syntax: AdblockSyntax.Ubo,
-                exception: rule.exception,
-                domains: cloneDomainListNode(rule.domains),
-                separator: {
-                    type: 'Value',
-                    value: rule.exception
-                        ? `${CosmeticRuleSeparator.ElementHidingException}${UBO_HTML_MASK}`
-                        : `${CosmeticRuleSeparator.ElementHiding}${UBO_HTML_MASK}`,
-                },
-                body: {
-                    type: 'Value',
-                    value: unescapeDoubleQuotes(uboSelector),
-                },
-            }], true);
     }
 }