@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/esm/parser/misc/list-items-parser.mjs

@@ -0,0 +1,113 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { ListItemNodeType } from '../../nodes/index.mjs';
+import { defaultParserOptions } from '../options.mjs';
+import { NEGATION_MARKER, COMMA } from '../../utils/constants.mjs';
+import { StringUtils } from '../../utils/string.mjs';
+import { AdblockSyntaxError } from '../../errors/adblock-syntax-error.mjs';
+
+/**
+ * Prefixes for error messages which are used for parsing of value lists.
+ */
+const LIST_PARSE_ERROR_PREFIX = {
+    EMPTY_ITEM: 'Empty value specified in the list',
+    NO_MULTIPLE_NEGATION: 'Exception marker cannot be followed by another exception marker',
+    NO_SEPARATOR_AFTER_NEGATION: 'Exception marker cannot be followed by a separator',
+    NO_SEPARATOR_AT_THE_BEGINNING: 'Value list cannot start with a separator',
+    NO_SEPARATOR_AT_THE_END: 'Value list cannot end with a separator',
+    NO_WHITESPACE_AFTER_NEGATION: 'Exception marker cannot be followed by whitespace',
+};
+class ListItemsParser {
+    /**
+     * Parses a `raw` modifier value which may be represented as a list of items separated by `separator`.
+     * Needed for $app, $denyallow, $domain, $method.
+     *
+     * @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.
+     * @param separator Separator character (default: comma)
+     * @param type Type of the list items (default: {@link ListItemNodeType.Domain}).
+     * @template T Type of the list items.
+     *
+     * @returns List of parsed items.
+     * @throws An {@link AdblockSyntaxError} if the list is syntactically invalid
+     *
+     * @example
+     * - parses an app list — `com.example.app|Example.exe`
+     * - parses a domain list — `example.com,example.org,~example.org` or `example.com|~example.org`
+     * - parses a method list — `~post|~put`
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0, separator = COMMA, type = ListItemNodeType.Unknown) {
+        // Function body here
+        const rawListItems = [];
+        let offset = 0;
+        // Skip whitespace before the list
+        offset = StringUtils.skipWS(raw, offset);
+        // If the first character is a separator, then the list is invalid
+        // and no need to continue parsing
+        if (raw[offset] === separator) {
+            throw new AdblockSyntaxError(LIST_PARSE_ERROR_PREFIX.NO_SEPARATOR_AT_THE_BEGINNING, baseOffset + offset, baseOffset + raw.length);
+        }
+        // If the last character is a separator, then the list item is invalid
+        // and no need to continue parsing
+        const realEndIndex = StringUtils.skipWSBack(raw);
+        if (raw[realEndIndex] === separator) {
+            throw new AdblockSyntaxError(LIST_PARSE_ERROR_PREFIX.NO_SEPARATOR_AT_THE_END, baseOffset + realEndIndex, baseOffset + realEndIndex + 1);
+        }
+        // Split list items by unescaped separators
+        while (offset < raw.length) {
+            // Skip whitespace before the list item
+            offset = StringUtils.skipWS(raw, offset);
+            let itemStart = offset;
+            // Find the index of the first unescaped separator character
+            const separatorStartIndex = StringUtils.findNextUnescapedCharacter(raw, separator, offset);
+            const itemEnd = separatorStartIndex === -1
+                ? StringUtils.skipWSBack(raw) + 1
+                : StringUtils.skipWSBack(raw, separatorStartIndex - 1) + 1;
+            const exception = raw[itemStart] === NEGATION_MARKER;
+            // Skip the exception marker
+            if (exception) {
+                itemStart += 1;
+                const item = raw[itemStart];
+                // Exception marker cannot be followed by another exception marker
+                if (item === NEGATION_MARKER) {
+                    throw new AdblockSyntaxError(LIST_PARSE_ERROR_PREFIX.NO_MULTIPLE_NEGATION, baseOffset + itemStart, baseOffset + itemStart + 1);
+                }
+                // Exception marker cannot be followed by a separator
+                if (item === separator) {
+                    throw new AdblockSyntaxError(LIST_PARSE_ERROR_PREFIX.NO_SEPARATOR_AFTER_NEGATION, baseOffset + itemStart, baseOffset + itemStart + 1);
+                }
+                // Exception marker cannot be followed by whitespace
+                if (StringUtils.isWhitespace(item)) {
+                    throw new AdblockSyntaxError(LIST_PARSE_ERROR_PREFIX.NO_WHITESPACE_AFTER_NEGATION, baseOffset + itemStart, baseOffset + itemStart + 1);
+                }
+            }
+            // List item can't be empty
+            // Note we use '<=' instead of '===' because we have bidirectional trim
+            // This is needed to handle cases like 'example.com, ,example.org'
+            if (itemEnd <= itemStart) {
+                throw new AdblockSyntaxError(LIST_PARSE_ERROR_PREFIX.EMPTY_ITEM, baseOffset + itemStart, baseOffset + raw.length);
+            }
+            const listItem = {
+                type,
+                value: raw.slice(itemStart, itemEnd),
+                exception,
+            };
+            if (options.isLocIncluded) {
+                listItem.start = baseOffset + itemStart;
+                listItem.end = baseOffset + itemEnd;
+            }
+            // Collect list item
+            rawListItems.push(listItem);
+            // Increment the offset to the next list item (or the end of the string)
+            offset = separatorStartIndex === -1 ? raw.length : separatorStartIndex + 1;
+        }
+        return rawListItems;
+    }
+}
+
+export { LIST_PARSE_ERROR_PREFIX, ListItemsParser };

package/dist/esm/parser/misc/logical-expression-parser.mjs

@@ -0,0 +1,281 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { StringUtils } from '../../utils/string.mjs';
+import { OperatorValue } from '../../nodes/index.mjs';
+import { UNDERSCORE, OPEN_PARENTHESIS, CLOSE_PARENTHESIS, AMPERSAND, PIPE, EXCLAMATION_MARK } from '../../utils/constants.mjs';
+import { AdblockSyntaxError } from '../../errors/adblock-syntax-error.mjs';
+import { defaultParserOptions } from '../options.mjs';
+import { BaseParser } from '../base-parser.mjs';
+
+/**
+ * Possible token types in the logical expression.
+ */
+var TokenType;
+(function (TokenType) {
+    TokenType[TokenType["Variable"] = 0] = "Variable";
+    TokenType[TokenType["Operator"] = 1] = "Operator";
+    TokenType[TokenType["Parenthesis"] = 2] = "Parenthesis";
+})(TokenType || (TokenType = {}));
+/**
+ * Possible node types in the logical expression.
+ */
+var NodeType;
+(function (NodeType) {
+    NodeType["Variable"] = "Variable";
+    NodeType["Operator"] = "Operator";
+    NodeType["Parenthesis"] = "Parenthesis";
+})(NodeType || (NodeType = {}));
+/**
+ * Precedence of the operators, larger number means higher precedence.
+ */
+const OPERATOR_PRECEDENCE = {
+    [OperatorValue.Not]: 3,
+    [OperatorValue.And]: 2,
+    [OperatorValue.Or]: 1,
+};
+/**
+ * `LogicalExpressionParser` is responsible for parsing logical expressions.
+ *
+ * @example
+ * From the following rule:
+ * ```adblock
+ * !#if (adguard_ext_android_cb || adguard_ext_safari)
+ * ```
+ * this parser will parse the expression `(adguard_ext_android_cb || adguard_ext_safari)`.
+ */
+// TODO: Refactor this class
+class LogicalExpressionParser extends BaseParser {
+    /**
+     * Split the expression into tokens.
+     *
+     * @param raw Source code of the expression
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Token list
+     * @throws {AdblockSyntaxError} If the expression is invalid
+     */
+    static tokenize(raw, baseOffset = 0) {
+        const tokens = [];
+        let offset = 0;
+        while (offset < raw.length) {
+            const char = raw[offset];
+            if (StringUtils.isWhitespace(char)) {
+                // Ignore whitespace
+                offset += 1;
+            }
+            else if (StringUtils.isLetter(char)) {
+                // Save the start offset of the variable name
+                const nameStart = offset;
+                // Variable name shouldn't start with a number or underscore,
+                // but can contain them
+                while (offset + 1 < raw.length
+                    && (StringUtils.isAlphaNumeric(raw[offset + 1]) || raw[offset + 1] === UNDERSCORE)) {
+                    offset += 1;
+                }
+                tokens.push({
+                    type: TokenType.Variable,
+                    start: nameStart,
+                    end: offset + 1,
+                });
+                offset += 1;
+            }
+            else if (char === OPEN_PARENTHESIS || char === CLOSE_PARENTHESIS) {
+                // Parenthesis
+                tokens.push({
+                    type: TokenType.Parenthesis,
+                    start: offset,
+                    end: offset + 1,
+                });
+                offset += 1;
+            }
+            else if (char === AMPERSAND || char === PIPE) {
+                // Parse operator
+                if (offset + 1 < raw.length && raw[offset + 1] === char) {
+                    tokens.push({
+                        type: TokenType.Operator,
+                        start: offset,
+                        end: offset + 2,
+                    });
+                    offset += 2;
+                }
+                else {
+                    throw new AdblockSyntaxError(`Unexpected character "${char}"`, baseOffset + offset, baseOffset + offset + 1);
+                }
+            }
+            else if (char === EXCLAMATION_MARK) {
+                tokens.push({
+                    type: TokenType.Operator,
+                    start: offset,
+                    end: offset + 1,
+                });
+                offset += 1;
+            }
+            else {
+                throw new AdblockSyntaxError(`Unexpected character "${char}"`, baseOffset + offset, baseOffset + offset + 1);
+            }
+        }
+        return tokens;
+    }
+    /**
+     * Parses a logical expression.
+     *
+     * @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 Parsed expression
+     * @throws {AdblockSyntaxError} If the expression is invalid
+     */
+    // TODO: Create a separate TokenStream class
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        // Tokenize the source (produces an array of tokens)
+        const tokens = LogicalExpressionParser.tokenize(raw, baseOffset);
+        // Current token index
+        let tokenIndex = 0;
+        /**
+         * Consumes a token of the expected type.
+         *
+         * @param type Expected token type
+         * @returns The consumed token
+         */
+        function consume(type) {
+            const token = tokens[tokenIndex];
+            if (!token) {
+                throw new AdblockSyntaxError(`Expected token of type "${type}", but reached end of input`, baseOffset, baseOffset + raw.length);
+            }
+            // We only use this function internally, so we can safely ignore this
+            // from the coverage report
+            // istanbul ignore next
+            if (token.type !== type) {
+                throw new AdblockSyntaxError(`Expected token of type "${type}", but got "${token.type}"`, baseOffset + token.start, baseOffset + token.end);
+            }
+            tokenIndex += 1;
+            return token;
+        }
+        /**
+         * Parses a variable.
+         *
+         * @returns Variable node
+         */
+        function parseVariable() {
+            const token = consume(TokenType.Variable);
+            const result = {
+                type: NodeType.Variable,
+                name: raw.slice(token.start, token.end),
+            };
+            if (options.isLocIncluded) {
+                result.start = baseOffset + token.start;
+                result.end = baseOffset + token.end;
+            }
+            return result;
+        }
+        /**
+         * Parses a binary expression.
+         *
+         * @param left Left-hand side of the expression
+         * @param minPrecedence Minimum precedence of the operator
+         * @returns Binary expression node
+         */
+        function parseBinaryExpression(left, minPrecedence = 0) {
+            let node = left;
+            let operatorToken;
+            while (tokens[tokenIndex]) {
+                operatorToken = tokens[tokenIndex];
+                if (!operatorToken || operatorToken.type !== TokenType.Operator) {
+                    break;
+                }
+                // It is safe to cast here, because we already checked the type
+                const operator = raw.slice(operatorToken.start, operatorToken.end);
+                const precedence = OPERATOR_PRECEDENCE[operator];
+                if (precedence < minPrecedence) {
+                    break;
+                }
+                tokenIndex += 1;
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                const right = parseExpression(precedence + 1);
+                const newNode = {
+                    type: NodeType.Operator,
+                    operator,
+                    left: node,
+                    right,
+                };
+                if (options.isLocIncluded) {
+                    newNode.start = node.start ?? baseOffset + operatorToken.start;
+                    newNode.end = right.end ?? baseOffset + operatorToken.end;
+                }
+                node = newNode;
+            }
+            return node;
+        }
+        /**
+         * Parses a parenthesized expression.
+         *
+         * @returns Parenthesized expression node
+         */
+        function parseParenthesizedExpression() {
+            consume(TokenType.Parenthesis);
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            const expression = parseExpression();
+            consume(TokenType.Parenthesis);
+            const result = {
+                type: NodeType.Parenthesis,
+                expression,
+            };
+            if (options.isLocIncluded) {
+                result.start = expression.start;
+                result.end = expression.end;
+            }
+            return result;
+        }
+        /**
+         * Parses an expression.
+         *
+         * @param minPrecedence Minimum precedence of the operator
+         * @returns Expression node
+         */
+        function parseExpression(minPrecedence = 0) {
+            let node;
+            const token = tokens[tokenIndex];
+            const value = raw.slice(token.start, token.end);
+            if (token.type === TokenType.Variable) {
+                node = parseVariable();
+            }
+            else if (token.type === TokenType.Operator && value === OperatorValue.Not) {
+                tokenIndex += 1;
+                const expression = parseExpression(OPERATOR_PRECEDENCE[OperatorValue.Not]);
+                node = {
+                    type: NodeType.Operator,
+                    operator: OperatorValue.Not,
+                    left: expression,
+                };
+                if (options.isLocIncluded) {
+                    if (expression.end) {
+                        node.start = baseOffset + token.start;
+                        // no need to shift the node location, because it's already shifted
+                        node.end = expression.end;
+                    }
+                    else {
+                        node.start = baseOffset + token.start;
+                        node.end = baseOffset + token.end;
+                    }
+                }
+            }
+            else if (token.type === TokenType.Parenthesis && value === OPEN_PARENTHESIS) {
+                node = parseParenthesizedExpression();
+            }
+            else {
+                throw new AdblockSyntaxError(`Unexpected token "${value}"`, baseOffset + token.start, baseOffset + token.end);
+            }
+            return parseBinaryExpression(node, minPrecedence);
+        }
+        const expression = parseExpression();
+        if (tokenIndex !== tokens.length) {
+            throw new AdblockSyntaxError(`Unexpected token "${tokens[tokenIndex].type}"`, baseOffset + tokens[tokenIndex].start, baseOffset + tokens[tokenIndex].end);
+        }
+        return expression;
+    }
+}
+
+export { LogicalExpressionParser, NodeType };

package/dist/esm/parser/misc/method-list-parser.mjs

@@ -0,0 +1,46 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { PIPE } from '../../utils/constants.mjs';
+import { ListNodeType, ListItemNodeType } from '../../nodes/index.mjs';
+import { defaultParserOptions } from '../options.mjs';
+import { BaseParser } from '../base-parser.mjs';
+import { ListItemsParser } from './list-items-parser.mjs';
+
+const METHOD_LIST_SEPARATOR = PIPE;
+/**
+ * `MethodListParser` is responsible for parsing a method list.
+ *
+ * @see {@link https://adguard.app/kb/general/ad-filtering/create-own-filters/#method-modifier}
+ */
+class MethodListParser extends BaseParser {
+    /**
+     * Parses a method list which items are separated by `|`,
+     * e.g. `get|post|put`.
+     *
+     * @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 Method list AST.
+     * @throws An {@link AdblockSyntaxError} if the method list is syntactically invalid.
+     * @throws An {@link Error} if the options are invalid.
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        const result = {
+            type: ListNodeType.MethodList,
+            separator: METHOD_LIST_SEPARATOR,
+            children: ListItemsParser.parse(raw, options, baseOffset, METHOD_LIST_SEPARATOR, ListItemNodeType.Method),
+        };
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        return result;
+    }
+}
+
+export { MethodListParser };

package/dist/esm/parser/misc/modifier-list.mjs

@@ -0,0 +1,70 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { MODIFIERS_SEPARATOR } from '../../utils/constants.mjs';
+import { StringUtils } from '../../utils/string.mjs';
+import { BaseParser } from '../base-parser.mjs';
+import { defaultParserOptions } from '../options.mjs';
+import { ModifierParser } from './modifier-parser.mjs';
+
+/* eslint-disable no-param-reassign */
+/**
+ * `ModifierListParser` is responsible for parsing modifier lists. Please note that the name is not
+ * uniform, "modifiers" are also known as "options".
+ *
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#basic-rules-modifiers}
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#non-basic-rules-modifiers}
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#options}
+ */
+class ModifierListParser extends BaseParser {
+    /**
+     * Parses the cosmetic rule modifiers, eg. `third-party,domain=example.com|~example.org`.
+     *
+     * _Note:_ you should remove `$` separator before passing the raw modifiers to this function,
+     *  or it will be parsed in the first modifier.
+     *
+     * @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 Parsed modifiers interface
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        const result = {
+            type: 'ModifierList',
+            children: [],
+        };
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        let offset = StringUtils.skipWS(raw);
+        let separatorIndex = -1;
+        // Split modifiers by unescaped commas
+        while (offset < raw.length) {
+            // Skip whitespace before the modifier
+            offset = StringUtils.skipWS(raw, offset);
+            const modifierStart = offset;
+            // Find the index of the first unescaped comma
+            separatorIndex = StringUtils.findNextUnescapedCharacter(raw, MODIFIERS_SEPARATOR, offset);
+            const modifierEnd = separatorIndex === -1
+                ? raw.length
+                : StringUtils.skipWSBack(raw, separatorIndex - 1) + 1;
+            // Parse the modifier
+            const modifier = ModifierParser.parse(raw.slice(modifierStart, modifierEnd), options, baseOffset + modifierStart);
+            result.children.push(modifier);
+            // Increment the offset to the next modifier (or the end of the string)
+            offset = separatorIndex === -1 ? raw.length : separatorIndex + 1;
+        }
+        // Check if there are any modifiers after the last separator
+        if (separatorIndex !== -1) {
+            const modifierStart = StringUtils.skipWS(raw, separatorIndex + 1);
+            result.children.push(ModifierParser.parse(raw.slice(modifierStart, raw.length), options, baseOffset + modifierStart));
+        }
+        return result;
+    }
+}
+
+export { ModifierListParser };

package/dist/esm/parser/misc/modifier-parser.mjs

@@ -0,0 +1,89 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { NEGATION_MARKER, MODIFIER_ASSIGN_OPERATOR } from '../../utils/constants.mjs';
+import { StringUtils } from '../../utils/string.mjs';
+import { AdblockSyntaxError } from '../../errors/adblock-syntax-error.mjs';
+import { defaultParserOptions } from '../options.mjs';
+import { BaseParser } from '../base-parser.mjs';
+import { ValueParser } from './value-parser.mjs';
+
+/**
+ * `ModifierParser` is responsible for parsing modifiers.
+ *
+ * @example
+ * `match-case`, `~third-party`, `domain=example.com|~example.org`
+ */
+class ModifierParser extends BaseParser {
+    /**
+     * Parses a modifier.
+     *
+     * @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 Parsed modifier
+     * @throws An error if modifier name or value is empty.
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        let offset = 0;
+        // Skip leading whitespace
+        offset = StringUtils.skipWS(raw, offset);
+        // Save the offset of the first character of the modifier (whole modifier)
+        const modifierStart = offset;
+        // Check if the modifier is an exception
+        let exception = false;
+        if (raw[offset] === NEGATION_MARKER) {
+            offset += NEGATION_MARKER.length;
+            exception = true;
+        }
+        // Skip whitespace after the exception marker (if any)
+        offset = StringUtils.skipWS(raw, offset);
+        // Save the offset of the first character of the modifier name
+        const modifierNameStart = offset;
+        // Find assignment operator
+        const assignmentIndex = StringUtils.findNextUnescapedCharacter(raw, MODIFIER_ASSIGN_OPERATOR);
+        // Find the end of the modifier
+        const modifierEnd = Math.max(StringUtils.skipWSBack(raw) + 1, modifierNameStart);
+        // Modifier name can't be empty
+        if (modifierNameStart === modifierEnd) {
+            throw new AdblockSyntaxError('Modifier name cannot be empty', baseOffset, baseOffset + raw.length);
+        }
+        let modifier;
+        let value;
+        // If there is no assignment operator, the whole modifier is the name
+        // without a value
+        if (assignmentIndex === -1) {
+            modifier = ValueParser.parse(raw.slice(modifierNameStart, modifierEnd), options, baseOffset + modifierNameStart);
+        }
+        else {
+            // If there is an assignment operator, first we need to find the
+            // end of the modifier name, then we can parse the value
+            const modifierNameEnd = StringUtils.skipWSBack(raw, assignmentIndex - 1) + 1;
+            modifier = ValueParser.parse(raw.slice(modifierNameStart, modifierNameEnd), options, baseOffset + modifierNameStart);
+            // Value can't be empty
+            if (assignmentIndex + 1 === modifierEnd) {
+                throw new AdblockSyntaxError('Modifier value cannot be empty', baseOffset, baseOffset + raw.length);
+            }
+            // Skip whitespace after the assignment operator
+            const valueStart = StringUtils.skipWS(raw, assignmentIndex + MODIFIER_ASSIGN_OPERATOR.length);
+            value = ValueParser.parse(raw.slice(valueStart, modifierEnd), options, baseOffset + valueStart);
+        }
+        const result = {
+            type: 'Modifier',
+            name: modifier,
+            value,
+            exception,
+        };
+        if (options.isLocIncluded) {
+            result.start = baseOffset + modifierStart;
+            result.end = baseOffset + modifierEnd;
+        }
+        return result;
+    }
+}
+
+export { ModifierParser };

package/dist/esm/parser/misc/parameter-list-parser.mjs

@@ -0,0 +1,72 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { StringUtils } from '../../utils/string.mjs';
+import { COMMA } from '../../utils/constants.mjs';
+import { defaultParserOptions } from '../options.mjs';
+import { BaseParser } from '../base-parser.mjs';
+import { ValueParser } from './value-parser.mjs';
+
+class ParameterListParser extends BaseParser {
+    /**
+     * Parses a raw parameter list.
+     *
+     * @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.
+     * @param separator Separator character (default: comma)
+     * @returns Parameter list AST
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0, separator = COMMA) {
+        // Prepare the parameter list node
+        const params = {
+            type: 'ParameterList',
+            children: [],
+        };
+        const { length } = raw;
+        if (options.isLocIncluded) {
+            params.start = baseOffset;
+            params.end = baseOffset + length;
+        }
+        let offset = 0;
+        // Parse parameters: skip whitespace before and after each parameter, and
+        // split parameters by the separator character.
+        while (offset < length) {
+            // Skip whitespace before parameter
+            offset = StringUtils.skipWS(raw, offset);
+            // Parameter may only contain whitespace
+            // In this case, we reached the end of the parameter list
+            if (raw[offset] === separator || offset === length) {
+                // Add a null for empty parameter
+                params.children.push(null);
+                // Skip separator
+                offset += 1;
+            }
+            else {
+                // Get parameter start position
+                const paramStart = offset;
+                // Get next unescaped separator position
+                const nextSeparator = StringUtils.findUnescapedNonStringNonRegexChar(raw, separator, offset);
+                // Get parameter end position
+                const paramEnd = nextSeparator !== -1
+                    ? StringUtils.skipWSBack(raw, nextSeparator - 1)
+                    : StringUtils.skipWSBack(raw);
+                // Add parameter to the list
+                const param = ValueParser.parse(raw.slice(paramStart, paramEnd + 1), options, baseOffset + paramStart);
+                params.children.push(param);
+                // Set offset to the next separator position + 1
+                offset = nextSeparator !== -1 ? nextSeparator + 1 : length;
+            }
+        }
+        // If the last character was a separator, add an additional null parameter
+        if (raw[length - 1] === separator) {
+            params.children.push(null);
+        }
+        return params;
+    }
+}
+
+export { ParameterListParser };