@adguard/agtree 3.4.3 → 4.0.1

package/dist/parser/comment/simple-comment-parser.js

@@ -1,6 +1,6 @@
 /*
- * 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
  */

package/dist/parser/cosmetic/cosmetic-rule-parser.js

@@ -1,6 +1,6 @@
 /*
- * 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
  */
@@ -18,9 +18,11 @@ import { CommentParser } from '../comment/comment-parser.js';
 import { defaultParserOptions } from '../options.js';
 import { UboSelectorParser } from '../css/ubo-selector-parser.js';
 import { AdgCssInjectionParser } from '../css/adg-css-injection-parser.js';
-import { AbpSnippetInjectionBodyParser } from './body/abp-snippet-injection-body-parser.js';
-import { UboScriptletInjectionBodyParser } from './body/ubo-scriptlet-injection-body-parser.js';
-import { AdgScriptletInjectionBodyParser } from './body/adg-scriptlet-injection-body-parser.js';
+import { AbpSnippetInjectionBodyParser } from './scriptlet-body/abp-snippet-injection-body-parser.js';
+import { UboScriptletInjectionBodyParser } from './scriptlet-body/ubo-scriptlet-injection-body-parser.js';
+import { AdgScriptletInjectionBodyParser } from './scriptlet-body/adg-scriptlet-injection-body-parser.js';
+import { AdgHtmlFilteringBodyParser } from './html-filtering-body/adg-html-filtering-body-parser.js';
+import { UboHtmlFilteringBodyParser } from './html-filtering-body/ubo-html-filtering-body-parser.js';
 import { BaseParser } from '../base-parser.js';
 import { UboPseudoName } from '../../common/ubo-selector-common.js';
 
@@ -412,14 +414,8 @@ class CosmeticRuleParser extends BaseParser {
                 throw new AdblockSyntaxError(sprintf(ERROR_MESSAGES.SYNTAX_DISABLED, AdblockSyntax.Ubo), baseOffset + bodyStart, baseOffset + bodyEnd);
             }
             expectCommonOrSpecificSyntax(AdblockSyntax.Ubo);
-            const body = {
-                type: 'Value',
-                value: rawBody,
-            };
-            if (options.isLocIncluded) {
-                body.start = baseOffset + bodyStart;
-                body.end = baseOffset + bodyEnd;
-            }
+            const rawBodyWithoutMask = rawBody.slice(UBO_HTML_MASK.length);
+            const body = UboHtmlFilteringBodyParser.parse(rawBodyWithoutMask, options, baseOffset + bodyStart + UBO_HTML_MASK.length);
             return {
                 syntax: AdblockSyntax.Ubo,
                 type: CosmeticRuleType.HtmlFilteringRule,
@@ -428,14 +424,7 @@ class CosmeticRuleParser extends BaseParser {
         };
         const parseAdgHtmlFiltering = () => {
             expectCommonOrSpecificSyntax(AdblockSyntax.Adg);
-            const body = {
-                type: 'Value',
-                value: rawBody,
-            };
-            if (options.isLocIncluded) {
-                body.start = baseOffset + bodyStart;
-                body.end = baseOffset + bodyEnd;
-            }
+            const body = AdgHtmlFilteringBodyParser.parse(rawBody, options, baseOffset + bodyStart);
             return {
                 syntax: AdblockSyntax.Adg,
                 type: CosmeticRuleType.HtmlFilteringRule,

package/dist/parser/cosmetic/html-filtering-body/adg-html-filtering-body-parser.js

@@ -0,0 +1,49 @@
+/*
+ * 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 { QuoteUtils } from '../../../utils/quotes.js';
+import { BaseParser } from '../../base-parser.js';
+import { defaultParserOptions } from '../../options.js';
+import { HtmlFilteringBodyParser } from './html-filtering-body-parser.js';
+
+/**
+ * `AdgHtmlFilteringBodyParser` is responsible for parsing the body of an AdGuard-style HTML filtering rule.
+ *
+ * Please note that the parser will parse any HTML filtering rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com$$div[special-attr="value"]
+ * ```
+ *
+ * but it didn't check if the attribute `special-attr` actually supported by any adblocker.
+ *
+ * @see {@link https://www.w3.org/TR/selectors-4}
+ * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#html-filtering-rules}
+ */
+class AdgHtmlFilteringBodyParser extends BaseParser {
+    /**
+     * Parses the body of an AdGuard-style HTML filtering rule.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     *
+     * @returns Node of the parsed HTML filtering rule body.
+     *
+     * @throws If the body is syntactically incorrect.
+     *
+     * @example
+     * ```
+     * div[some_attribute="some_value"]
+     * ```
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        const escapedRaw = QuoteUtils.escapeAttributeDoubleQuotes(raw);
+        return HtmlFilteringBodyParser.parse(escapedRaw, options, baseOffset);
+    }
+}
+
+export { AdgHtmlFilteringBodyParser };

package/dist/parser/cosmetic/html-filtering-body/html-filtering-body-parser.js

@@ -0,0 +1,70 @@
+/*
+ * 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 { BaseParser } from '../../base-parser.js';
+import { defaultParserOptions } from '../../options.js';
+import { SelectorListParser } from '../selector/selector-list-parser.js';
+
+/**
+ * Class responsible for parsing HTML filtering rule body.
+ *
+ * Please note that the parser will parse any HTML filtering rule body if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * span[special-attr="Example"]
+ * div:special-pseudo(Example)
+ * ```
+ *
+ * but it didn't check if the pseudo selector `special-pseudo` or if
+ * the attribute selector `special-attr` actually supported by any adblocker.
+ *
+ * @see {@link https://www.w3.org/TR/selectors-4}
+ * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#html-filtering-rules}
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#html-filters}
+ */
+class HtmlFilteringBodyParser extends BaseParser {
+    /**
+     * Parses a HTML filtering rule body.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     *
+     * @returns Node of the parsed HTML filtering rule body.
+     *
+     * @throws If the body is syntactically incorrect.
+     *
+     * @example
+     * ```
+     * span[tag-content="Example"]
+     * div:has-text(Example)
+     * ```
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        // If HTML filtering rules parsing is disabled, return raw value node
+        let result;
+        if (options.parseHtmlFilteringRuleBodies) {
+            result = {
+                type: 'HtmlFilteringRuleBody',
+                selectorList: SelectorListParser.parse(raw, options, baseOffset),
+            };
+        }
+        else {
+            result = {
+                type: 'Value',
+                value: raw,
+            };
+        }
+        // Include body locations if needed
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        return result;
+    }
+}
+
+export { HtmlFilteringBodyParser };

package/dist/parser/cosmetic/html-filtering-body/ubo-html-filtering-body-parser.js

@@ -0,0 +1,180 @@
+/*
+ * 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 { TokenType, getFormattedTokenName } from '@adguard/css-tokenizer';
+import { sprintf } from 'sprintf-js';
+import { BaseParser } from '../../base-parser.js';
+import { CssTokenStream } from '../../css/css-token-stream.js';
+import { defaultParserOptions } from '../../options.js';
+import { AdblockSyntaxError } from '../../../errors/adblock-syntax-error.js';
+import { ValueParser } from '../../misc/value-parser.js';
+import { UBO_RESPONSEHEADER_FN } from '../../../utils/constants.js';
+import { HtmlFilteringBodyParser } from './html-filtering-body-parser.js';
+
+/**
+ * `UboHtmlFilteringBodyParser` is responsible for parsing the body of
+ * an uBlock-style HTML filtering rule, and also uBlock-style response header removal rule.
+ *
+ * Please note that the parser will parse any HTML filtering rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com##^script:pseudo(content)
+ * example.com##^responseheader(header-name)
+ * ```
+ *
+ * but it didn't check if the pseudo selector `pseudo` or if
+ * the header name `header-name` actually supported by any adblocker.
+ *
+ * @see {@link https://www.w3.org/TR/selectors-4}
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#html-filters}
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#response-header-filtering}
+ */
+class UboHtmlFilteringBodyParser extends BaseParser {
+    /**
+     * Parses the body of an uBlock-style HTML filtering rule
+     * and also uBlock-style response header removal rule.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     *
+     * @returns Node of the parsed HTML filtering rule body.
+     *
+     * @throws If the body is syntactically incorrect.
+     *
+     * @example
+     * ```
+     * div:has-text(Example)
+     * responseheader(header-name)
+     * ```
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        // First, check if it's a response header removal rule and return if so
+        const responseHeaderBody = UboHtmlFilteringBodyParser.parseResponseHeaderRule(raw, options, baseOffset);
+        if (responseHeaderBody !== null) {
+            return responseHeaderBody;
+        }
+        return HtmlFilteringBodyParser.parse(raw, options, baseOffset);
+    }
+    /**
+     * Parses uBlock-style response header removal rule body.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     *
+     * @returns Node of the parsed response header removal rule body
+     * or `null` if the body is not a response header removal rule.
+     *
+     * @throws If the body is syntactically incorrect.
+     *
+     * @example
+     * ```
+     * responseheader(header-name)
+     * ```
+     *
+     * @note This method returns `HtmlFilteringRuleBody` because,
+     * response header removal rule syntax is same as uBlock-style
+     * HTML filtering rule syntax.
+     */
+    static parseResponseHeaderRule(raw, options = defaultParserOptions, baseOffset = 0) {
+        // If HTML filtering rules parsing is disabled, return null
+        if (!options.parseHtmlFilteringRuleBodies) {
+            return null;
+        }
+        // Construct the stream
+        const stream = new CssTokenStream(raw, baseOffset);
+        // Skip whitespaces before function
+        stream.skipWhitespace();
+        // Get token
+        let token = stream.get();
+        // Token should be a function
+        if (!token || token.type !== TokenType.Function) {
+            return null;
+        }
+        // Save the function start position
+        const { start } = token;
+        // Extract function name raw value (without opening parenthesis)
+        const functionNameRaw = raw.slice(token.start, token.end - 1);
+        // Check if it's `responseheader` function
+        if (functionNameRaw !== UBO_RESPONSEHEADER_FN) {
+            return null;
+        }
+        // Advance function token
+        stream.advance();
+        // Skip whitespaces after opening parenthesis
+        stream.skipWhitespace();
+        // Get argument token
+        token = stream.getOrFail();
+        // Save argument start position (starts after opening parenthesis and whitespaces)
+        const argumentStart = token.start;
+        // Skip until balanced (search for closing parenthesis)
+        stream.skipUntilBalanced();
+        // Get closing parenthesis token
+        token = stream.getOrFail();
+        // Save argument end position (ends before closing parenthesis)
+        const argumentEnd = token.start;
+        // Extract argument raw value
+        const argumentRaw = raw.slice(argumentStart, argumentEnd).trimEnd();
+        // Throw if the argument is empty
+        if (argumentRaw.length === 0) {
+            throw new AdblockSyntaxError(`Empty parameter for '${UBO_RESPONSEHEADER_FN}' function`, argumentStart + baseOffset, argumentEnd + baseOffset);
+        }
+        // Expect closing parenthesis
+        stream.expect(TokenType.CloseParenthesis);
+        // Advance closing parenthesis token
+        stream.advance();
+        // Skip whitespaces after closing parenthesis
+        stream.skipWhitespace();
+        // Expect the end of the rule - so nothing should be left in the stream
+        if (!stream.isEof()) {
+            token = stream.getOrFail();
+            throw new AdblockSyntaxError(sprintf("Expected end of rule, but got '%s'", getFormattedTokenName(token.type)), token.start + baseOffset, token.end + baseOffset);
+        }
+        // Construct pseudo-class selector node
+        const pseudoClassSelectorNode = {
+            type: 'PseudoClassSelector',
+            name: ValueParser.parse(functionNameRaw, options, start + baseOffset),
+            argument: ValueParser.parse(argumentRaw, options, argumentStart + baseOffset),
+        };
+        // Construct complex selector node
+        const complexSelectorNode = {
+            type: 'ComplexSelector',
+            children: [pseudoClassSelectorNode],
+        };
+        // Construct selector list node
+        const selectorList = {
+            type: 'SelectorList',
+            children: [complexSelectorNode],
+        };
+        // Construct body node
+        const result = {
+            type: 'HtmlFilteringRuleBody',
+            selectorList,
+        };
+        // Get last non-whitespace token
+        const lastNonWsToken = stream.lookbehindForNonWs();
+        // It shouldn't be null here, but just to be safe if it is
+        // it means that raw is empty or contains only whitespaces
+        if (!lastNonWsToken) {
+            return null;
+        }
+        // Include locations info if needed
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = raw.length + baseOffset;
+            selectorList.start = start + baseOffset;
+            selectorList.end = lastNonWsToken.end + baseOffset;
+            complexSelectorNode.start = selectorList.start;
+            complexSelectorNode.end = selectorList.end;
+            pseudoClassSelectorNode.start = complexSelectorNode.start;
+            pseudoClassSelectorNode.end = complexSelectorNode.end;
+        }
+        return result;
+    }
+}
+
+export { UboHtmlFilteringBodyParser };

package/dist/parser/cosmetic/{body → scriptlet-body}/abp-snippet-injection-body-parser.js

@@ -1,6 +1,6 @@
 /*
- * 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
  */

package/dist/parser/cosmetic/{body → scriptlet-body}/adg-scriptlet-injection-body-parser.js

@@ -1,6 +1,6 @@
 /*
- * 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
  */

package/dist/parser/cosmetic/{body → scriptlet-body}/ubo-scriptlet-injection-body-parser.js

@@ -1,6 +1,6 @@
 /*
- * 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
  */

package/dist/parser/cosmetic/selector/handlers/attribute-selector-handler.js

@@ -0,0 +1,206 @@
+/*
+ * 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 { TokenType, getFormattedTokenName } from '@adguard/css-tokenizer';
+import { sprintf } from 'sprintf-js';
+import { AdblockSyntaxError } from '../../../../errors/adblock-syntax-error.js';
+import { TILDE, CARET, DOLLAR_SIGN, ASTERISK, PIPE, EQUALS } from '../../../../utils/constants.js';
+import { QuoteUtils } from '../../../../utils/quotes.js';
+import { ValueParser } from '../../../misc/value-parser.js';
+
+/**
+ * Handles attribute selector parsing in selector list.
+ */
+class AttributeSelectorHandler {
+    /**
+     * Set of attribute equality prefixes.
+     *
+     * @see {@link AttributeSelectorOperatorValue}
+     */
+    static ATTR_EQUALITY_PREFIXES = new Set([
+        // [attr~="value"]
+        TILDE,
+        // [attr^="value"]
+        CARET,
+        // [attr$="value"]
+        DOLLAR_SIGN,
+        // [attr*="value"]
+        ASTERISK,
+        // [attr|="value"]
+        PIPE,
+    ]);
+    /**
+     * Set of valid flags for attribute selector values.
+     *
+     * @see {@link AttributeSelectorFlagValue}
+     */
+    static ALLOWED_ATTRIBUTE_FLAGS = new Set([
+        'i',
+        's',
+    ]);
+    /**
+     * Handles attribute selector parsing by creating an attribute selector node
+     * and appending it to the current complex selector node.
+     *
+     * @param context Selector list parser context.
+     *
+     * @throws If the attribute selector is syntactically incorrect.
+     */
+    static handle(context) {
+        const { options, baseOffset, stream, complexSelector, } = context;
+        // Get open square bracket token
+        let token = stream.getOrFail();
+        // Save attribute selector node start position
+        const { start } = token;
+        // Advance open square bracket token
+        stream.advance();
+        // Skip whitespaces after open square bracket
+        stream.skipWhitespace();
+        // Expect next token to be an identifier (attribute selector name)
+        stream.expect(TokenType.Ident);
+        // Get attribute selector name token
+        token = stream.getOrFail();
+        // Extract attribute selector name raw value
+        const nameRaw = stream.fragment();
+        // Construct attribute selector node and attribute selector name node
+        const result = {
+            type: 'AttributeSelector',
+            name: ValueParser.parse(nameRaw, options, baseOffset + token.start),
+        };
+        // Include attribute selector node start location if needed
+        if (options.isLocIncluded) {
+            result.start = baseOffset + start;
+        }
+        // Advance attribute selector name token
+        stream.advance();
+        // Skip whitespaces after attribute selector name
+        stream.skipWhitespace();
+        // Get closing square bracket or equality sign/prefix token
+        token = stream.getOrFail();
+        // Check if there is an any value
+        if (token.type !== TokenType.CloseSquareBracket) {
+            // Expect next token to be a delimiter (equality sign/prefix)
+            stream.expect(TokenType.Delim);
+            // Extract operator raw value
+            let operatorRaw = stream.fragment();
+            // Check if it's prefix operator
+            if (AttributeSelectorHandler.ATTR_EQUALITY_PREFIXES.has(operatorRaw)) {
+                // Advance prefix operator token
+                stream.advance();
+                // Expect equal sign token
+                stream.expect(TokenType.Delim, { value: EQUALS });
+                // Append equal sign to prefix value
+                operatorRaw += EQUALS;
+            }
+            else if (operatorRaw !== EQUALS) {
+                // Throw error if it's not equal sign either
+                throw new AdblockSyntaxError(sprintf("Invalid attribute selector operator '%s'", operatorRaw), baseOffset + token.start, baseOffset + token.end);
+            }
+            // Save operator node start position
+            const operatorStart = token.start;
+            // Advance equal sign token
+            stream.advance();
+            // Skip whitespaces after equal sign
+            stream.skipWhitespace();
+            // Get attribute selector value token
+            token = stream.getOrFail();
+            // It should be a string or identifier
+            const isValueString = token.type === TokenType.String;
+            if (!isValueString && token.type !== TokenType.Ident) {
+                throw new AdblockSyntaxError(sprintf(
+                // eslint-disable-next-line max-len
+                `Expected '${getFormattedTokenName(TokenType.Ident)}' or '${getFormattedTokenName(TokenType.String)}' as attribute selector value, but got '%s' with value '%s'`, getFormattedTokenName(token.type), stream.fragment()), baseOffset + token.start, baseOffset + token.end);
+            }
+            // Save attribute selector value node start position
+            const valueStart = token.start + (isValueString ? 1 : 0);
+            // Save attribute selector value node end position
+            const valueEnd = token.end - (isValueString ? 1 : 0);
+            // Extract attribute selector value raw value
+            const valueRaw = stream.fragment();
+            // We should unescape respective quotes inside of the string value
+            const valueUnquotedAndUnescaped = QuoteUtils.removeQuotesAndUnescape(valueRaw);
+            // Construct attribute selector operator node
+            const operatorNode = {
+                type: 'Value',
+                value: operatorRaw,
+            };
+            // Construct attribute selector value node
+            const valueNode = {
+                type: 'Value',
+                value: valueUnquotedAndUnescaped,
+            };
+            // Set attribute selector operator and value nodes to result node
+            result.operator = operatorNode;
+            result.value = valueNode;
+            // Include attribute selector operator and value nodes locations if needed
+            if (options.isLocIncluded) {
+                operatorNode.start = baseOffset + operatorStart;
+                operatorNode.end = baseOffset + operatorStart + operatorRaw.length;
+                valueNode.start = baseOffset + valueStart;
+                valueNode.end = baseOffset + valueEnd;
+            }
+            // Advance attribute selector value token
+            stream.advance();
+            // Skip whitespaces after attribute selector value
+            stream.skipWhitespace();
+            // Get close square bracket or attribute selector value flag token
+            token = stream.getOrFail();
+            // Check if there is an any flag part
+            if (token.type !== TokenType.CloseSquareBracket) {
+                // Expect a identifier (attribute selector value flag)
+                stream.expect(TokenType.Ident);
+                // Extract attribute selector value flag raw value
+                const flagRaw = stream.fragment();
+                // Validate attribute selector value flag
+                if (!AttributeSelectorHandler.isValidFlag(flagRaw)) {
+                    throw new AdblockSyntaxError(sprintf("Unexpected token '%s' with value '%s'", getFormattedTokenName(token.type), flagRaw), baseOffset + token.start, baseOffset + token.end);
+                }
+                // Save flag node start position
+                const flagStart = token.start;
+                // Construct attribute selector flag node
+                const flagNode = {
+                    type: 'Value',
+                    value: flagRaw,
+                };
+                // Set attribute selector flag node to result node
+                result.flag = flagNode;
+                // Include attribute selector flag node locations if needed
+                if (options.isLocIncluded) {
+                    flagNode.start = baseOffset + flagStart;
+                    flagNode.end = baseOffset + flagStart + flagRaw.length;
+                }
+                // Advance attribute selector value flag token
+                stream.advance();
+                // Skip whitespaces after attribute selector value flag
+                stream.skipWhitespace();
+                // Get close square bracket token
+                token = stream.getOrFail();
+            }
+        }
+        // Expect close square bracket token
+        stream.expect(TokenType.CloseSquareBracket);
+        // Include attribute selector node end location if needed
+        if (options.isLocIncluded) {
+            result.end = baseOffset + token.end;
+        }
+        // Append attribute selector node to the current complex selector node
+        complexSelector.children.push(result);
+        // Advance close square bracket token
+        stream.advance();
+    }
+    /**
+     * Validates attribute selector flag.
+     *
+     * @param flag Attribute selector flag.
+     *
+     * @returns `true` if the flag is valid, otherwise `false`.
+     */
+    static isValidFlag(flag) {
+        return AttributeSelectorHandler.ALLOWED_ATTRIBUTE_FLAGS.has(flag);
+    }
+}
+
+export { AttributeSelectorHandler };

package/dist/parser/cosmetic/selector/handlers/class-selector-handler.js

@@ -0,0 +1,48 @@
+/*
+ * 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 { TokenType } from '@adguard/css-tokenizer';
+
+/**
+ * Handles class selector parsing in selector list.
+ */
+class ClassSelectorHandler {
+    /**
+     * Handles class selector parsing by creating a class selector node
+     * and appending it to the current complex selector node.
+     *
+     * @param context Selector list parser context.
+     *
+     * @throws If the class selector is syntactically incorrect.
+     */
+    static handle(context) {
+        const { options, baseOffset, stream, complexSelector, } = context;
+        // Get class selector dot token
+        const token = stream.getOrFail();
+        // Advance class selector dot token
+        stream.advance();
+        // Expect next token to be an identifier (class selector value)
+        stream.expect(TokenType.Ident);
+        // Extract class selector value (without dot)
+        const value = stream.fragment();
+        // Construct class selector node
+        const result = {
+            type: 'ClassSelector',
+            value,
+        };
+        // Include class selector node locations if needed
+        if (options.isLocIncluded) {
+            result.start = baseOffset + token.start;
+            result.end = baseOffset + token.end + value.length;
+        }
+        // Append class selector node to the current complex selector node
+        complexSelector.children.push(result);
+        // Advance class selector value token
+        stream.advance();
+    }
+}
+
+export { ClassSelectorHandler };