@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/cjs/generator/cosmetic/body/abp-snippet-injection-body-generator.js

@@ -0,0 +1,36 @@
+/*
+ * 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
+ */
+'use strict';
+
+var constants = require('../../../utils/constants.js');
+var baseGenerator = require('../../base-generator.js');
+var parameterListGenerator = require('../../misc/parameter-list-generator.js');
+var abpSnippetInjectionBodyCommon = require('../../../common/abp-snippet-injection-body-common.js');
+
+class AbpSnippetInjectionBodyGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Generates a string representation of the Adblock Plus-style snippet call body.
+     *
+     * @param node Scriptlet injection rule body
+     * @returns String representation of the rule body
+     */
+    static generate(node) {
+        const result = [];
+        if (node.children.length === 0) {
+            throw new Error(abpSnippetInjectionBodyCommon.AbpSnippetInjectionBodyCommon.ERROR_MESSAGES.EMPTY_SCRIPTLET_CALL);
+        }
+        for (const scriptletCall of node.children) {
+            if (scriptletCall.children.length === 0) {
+                throw new Error(abpSnippetInjectionBodyCommon.AbpSnippetInjectionBodyCommon.ERROR_MESSAGES.EMPTY_SCRIPTLET_CALL);
+            }
+            result.push(parameterListGenerator.ParameterListGenerator.generate(scriptletCall, constants.SPACE));
+        }
+        return result.join(constants.SEMICOLON + constants.SPACE);
+    }
+}
+
+exports.AbpSnippetInjectionBodyGenerator = AbpSnippetInjectionBodyGenerator;

package/dist/cjs/generator/cosmetic/body/adg-scriptlet-injection-body-generator.js

@@ -0,0 +1,41 @@
+/*
+ * 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
+ */
+'use strict';
+
+var constants = require('../../../utils/constants.js');
+var parameterListGenerator = require('../../misc/parameter-list-generator.js');
+var baseGenerator = require('../../base-generator.js');
+
+class AdgScriptletInjectionBodyGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Error messages used by the parser.
+     */
+    static ERROR_MESSAGES = {
+        NO_MULTIPLE_SCRIPTLET_CALLS: 'ADG syntaxes does not support multiple scriptlet calls within one single rule',
+    };
+    /**
+     * Generates a string representation of the AdGuard scriptlet call body.
+     *
+     * @param node Scriptlet injection rule body
+     * @returns String representation of the rule body
+     */
+    static generate(node) {
+        const result = [];
+        if (node.children.length > 1) {
+            throw new Error(AdgScriptletInjectionBodyGenerator.ERROR_MESSAGES.NO_MULTIPLE_SCRIPTLET_CALLS);
+        }
+        result.push(constants.ADG_SCRIPTLET_MASK);
+        result.push(constants.OPEN_PARENTHESIS);
+        if (node.children.length > 0) {
+            result.push(parameterListGenerator.ParameterListGenerator.generate(node.children[0]));
+        }
+        result.push(constants.CLOSE_PARENTHESIS);
+        return result.join(constants.EMPTY);
+    }
+}
+
+exports.AdgScriptletInjectionBodyGenerator = AdgScriptletInjectionBodyGenerator;

package/dist/cjs/generator/cosmetic/body/ubo-scriptlet-injection-body-generator.js

@@ -0,0 +1,43 @@
+/*
+ * 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
+ */
+'use strict';
+
+var baseGenerator = require('../../base-generator.js');
+var constants = require('../../../utils/constants.js');
+var parameterListGenerator = require('../../misc/parameter-list-generator.js');
+
+class UboScriptletInjectionBodyGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Error messages used by the parser.
+     */
+    static ERROR_MESSAGES = {
+        NO_MULTIPLE_SCRIPTLET_CALLS: 'uBO syntaxes does not support multiple scriptlet calls within one single rule',
+    };
+    /**
+     * Generates a string representation of the uBlock scriptlet call body.
+     *
+     * @param node Scriptlet injection rule body
+     * @returns String representation of the rule body
+     */
+    static generate(node) {
+        const result = [];
+        if (node.children.length > 1) {
+            throw new Error(UboScriptletInjectionBodyGenerator.ERROR_MESSAGES.NO_MULTIPLE_SCRIPTLET_CALLS);
+        }
+        // During generation, we only support the modern scriptlet mask
+        result.push(constants.UBO_SCRIPTLET_MASK);
+        result.push(constants.OPEN_PARENTHESIS);
+        if (node.children.length > 0) {
+            const [parameterListNode] = node.children;
+            result.push(parameterListGenerator.ParameterListGenerator.generate(parameterListNode));
+        }
+        result.push(constants.CLOSE_PARENTHESIS);
+        return result.join(constants.EMPTY);
+    }
+}
+
+exports.UboScriptletInjectionBodyGenerator = UboScriptletInjectionBodyGenerator;

package/dist/cjs/generator/cosmetic/cosmetic-rule-body-generator.js

@@ -0,0 +1,92 @@
+/*
+ * 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
+ */
+'use strict';
+
+var baseGenerator = require('../base-generator.js');
+var index = require('../../nodes/index.js');
+var constants = require('../../utils/constants.js');
+var adblockers = require('../../utils/adblockers.js');
+var adgScriptletInjectionBodyGenerator = require('./body/adg-scriptlet-injection-body-generator.js');
+var adgCssInjectionGenerator = require('../css/adg-css-injection-generator.js');
+var abpSnippetInjectionBodyGenerator = require('./body/abp-snippet-injection-body-generator.js');
+var uboScriptletInjectionBodyGenerator = require('./body/ubo-scriptlet-injection-body-generator.js');
+var uboSelectorCommon = require('../../common/ubo-selector-common.js');
+
+class CosmeticRuleBodyGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Generates the rule body from the node.
+     *
+     * @param node Cosmetic rule node
+     * @returns Raw rule body
+     * @example
+     * - '##.foo' → '.foo'
+     * - 'example.com,example.org##.foo' → '.foo'
+     * - 'example.com#%#//scriptlet('foo')' → '//scriptlet('foo')'
+     */
+    static generate(node) {
+        let result = constants.EMPTY;
+        // Body
+        switch (node.type) {
+            case index.CosmeticRuleType.ElementHidingRule:
+                result = node.body.selectorList.value;
+                break;
+            case index.CosmeticRuleType.CssInjectionRule:
+                if (node.syntax === adblockers.AdblockSyntax.Adg) {
+                    result = adgCssInjectionGenerator.AdgCssInjectionGenerator.generate(node.body);
+                }
+                else if (node.syntax === adblockers.AdblockSyntax.Ubo) {
+                    if (node.body.mediaQueryList) {
+                        result += constants.COLON;
+                        result += uboSelectorCommon.UboPseudoName.MatchesMedia;
+                        result += constants.OPEN_PARENTHESIS;
+                        result += node.body.mediaQueryList.value;
+                        result += constants.CLOSE_PARENTHESIS;
+                        result += constants.SPACE;
+                    }
+                    result += node.body.selectorList.value;
+                    if (node.body.remove) {
+                        result += constants.COLON;
+                        result += uboSelectorCommon.UboPseudoName.Remove;
+                        result += constants.OPEN_PARENTHESIS;
+                        result += constants.CLOSE_PARENTHESIS;
+                    }
+                    else if (node.body.declarationList) {
+                        result += constants.COLON;
+                        result += uboSelectorCommon.UboPseudoName.Style;
+                        result += constants.OPEN_PARENTHESIS;
+                        result += node.body.declarationList.value;
+                        result += constants.CLOSE_PARENTHESIS;
+                    }
+                }
+                break;
+            case index.CosmeticRuleType.HtmlFilteringRule:
+            case index.CosmeticRuleType.JsInjectionRule:
+                result = node.body.value;
+                break;
+            case index.CosmeticRuleType.ScriptletInjectionRule:
+                switch (node.syntax) {
+                    case adblockers.AdblockSyntax.Adg:
+                        result = adgScriptletInjectionBodyGenerator.AdgScriptletInjectionBodyGenerator.generate(node.body);
+                        break;
+                    case adblockers.AdblockSyntax.Abp:
+                        result = abpSnippetInjectionBodyGenerator.AbpSnippetInjectionBodyGenerator.generate(node.body);
+                        break;
+                    case adblockers.AdblockSyntax.Ubo:
+                        result = uboScriptletInjectionBodyGenerator.UboScriptletInjectionBodyGenerator.generate(node.body);
+                        break;
+                    default:
+                        throw new Error('Scriptlet rule should have an explicit syntax');
+                }
+                break;
+            default:
+                throw new Error('Unknown cosmetic rule type');
+        }
+        return result;
+    }
+}
+
+exports.CosmeticRuleBodyGenerator = CosmeticRuleBodyGenerator;

package/dist/cjs/generator/cosmetic/cosmetic-rule-generator.js

@@ -0,0 +1,66 @@
+/*
+ * 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
+ */
+'use strict';
+
+var adblockers = require('../../utils/adblockers.js');
+var constants = require('../../utils/constants.js');
+var baseGenerator = require('../base-generator.js');
+var cosmeticRulePatternGenerator = require('./cosmetic-rule-pattern-generator.js');
+var cosmeticRuleBodyGenerator = require('./cosmetic-rule-body-generator.js');
+
+/**
+ * `CosmeticRuleParser` is responsible for parsing cosmetic rules.
+ *
+ * Where possible, it automatically detects the difference between supported syntaxes:
+ *  - AdGuard
+ *  - uBlock Origin
+ *  - Adblock Plus
+ *
+ * If the syntax is common / cannot be determined, the parser gives `Common` syntax.
+ *
+ * Please note that syntactically correct rules are parsed even if they are not actually
+ * compatible with the given adblocker. This is a completely natural behavior, meaningful
+ * checking of compatibility is not done at the parser level.
+ */
+// TODO: Make raw body parsing optional
+// TODO: Split into smaller sections
+class CosmeticRuleGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Converts a cosmetic rule AST into a string.
+     *
+     * @param node Cosmetic rule AST
+     * @returns Raw string
+     */
+    static generate(node) {
+        let result = constants.EMPTY;
+        // Pattern
+        result += cosmeticRulePatternGenerator.CosmeticRulePatternGenerator.generate(node);
+        // Separator
+        result += node.separator.value;
+        // uBO rule modifiers
+        if (node.syntax === adblockers.AdblockSyntax.Ubo && node.modifiers) {
+            node.modifiers.children.forEach((modifier) => {
+                result += constants.COLON;
+                result += modifier.name.value;
+                if (modifier.value) {
+                    result += constants.OPEN_PARENTHESIS;
+                    result += modifier.value.value;
+                    result += constants.CLOSE_PARENTHESIS;
+                }
+            });
+            // If there are at least one modifier, add a space
+            if (node.modifiers.children.length) {
+                result += constants.SPACE;
+            }
+        }
+        // Body
+        result += cosmeticRuleBodyGenerator.CosmeticRuleBodyGenerator.generate(node);
+        return result;
+    }
+}
+
+exports.CosmeticRuleGenerator = CosmeticRuleGenerator;

package/dist/cjs/generator/cosmetic/cosmetic-rule-pattern-generator.js

@@ -0,0 +1,41 @@
+/*
+ * 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
+ */
+'use strict';
+
+var constants = require('../../utils/constants.js');
+var adblockers = require('../../utils/adblockers.js');
+var baseGenerator = require('../base-generator.js');
+var modifierListGenerator = require('../misc/modifier-list-generator.js');
+var domainListGenerator = require('../misc/domain-list-generator.js');
+
+class CosmeticRulePatternGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Generates the rule pattern from the AST.
+     *
+     * @param node Cosmetic rule node
+     * @returns Raw rule pattern
+     * @example
+     * - '##.foo' → ''
+     * - 'example.com,example.org##.foo' → 'example.com,example.org'
+     * - '[$path=/foo/bar]example.com##.foo' → '[$path=/foo/bar]example.com'
+     */
+    static generate(node) {
+        let result = constants.EMPTY;
+        // AdGuard modifiers (if any)
+        if (node.syntax === adblockers.AdblockSyntax.Adg && node.modifiers && node.modifiers.children.length > 0) {
+            result += constants.OPEN_SQUARE_BRACKET;
+            result += constants.DOLLAR_SIGN;
+            result += modifierListGenerator.ModifierListGenerator.generate(node.modifiers);
+            result += constants.CLOSE_SQUARE_BRACKET;
+        }
+        // Domain list (if any)
+        result += domainListGenerator.DomainListGenerator.generate(node.domains);
+        return result;
+    }
+}
+
+exports.CosmeticRulePatternGenerator = CosmeticRulePatternGenerator;

package/dist/cjs/generator/css/adg-css-injection-generator.js

@@ -0,0 +1,41 @@
+/*
+ * 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
+ */
+'use strict';
+
+var constants = require('../../utils/constants.js');
+var baseGenerator = require('../base-generator.js');
+var adgCssInjectionParser = require('../../parser/css/adg-css-injection-parser.js');
+
+class AdgCssInjectionGenerator extends baseGenerator.BaseGenerator {
+    static removeDeclaration = `${adgCssInjectionParser.REMOVE_PROPERTY}${constants.COLON}${constants.SPACE}${adgCssInjectionParser.REMOVE_VALUE}${constants.SEMICOLON}`;
+    /**
+     * Serializes an AdGuard CSS injection node into a raw string.
+     *
+     * @param node Node to serialize.
+     * @returns Raw string.
+     */
+    static generate(node) {
+        const result = [];
+        if (node.mediaQueryList) {
+            result.push(constants.CSS_MEDIA_MARKER, constants.SPACE, node.mediaQueryList.value, constants.SPACE, constants.OPEN_CURLY_BRACKET, constants.SPACE);
+        }
+        result.push(node.selectorList.value, constants.SPACE, constants.OPEN_CURLY_BRACKET, constants.SPACE);
+        if (node.remove) {
+            result.push(AdgCssInjectionGenerator.removeDeclaration);
+        }
+        else if (node.declarationList?.value) {
+            result.push(node.declarationList.value);
+        }
+        result.push(constants.SPACE, constants.CLOSE_CURLY_BRACKET);
+        if (node.mediaQueryList) {
+            result.push(constants.SPACE, constants.CLOSE_CURLY_BRACKET);
+        }
+        return result.join(constants.EMPTY);
+    }
+}
+
+exports.AdgCssInjectionGenerator = AdgCssInjectionGenerator;

package/dist/cjs/generator/filterlist-generator.js

@@ -0,0 +1,57 @@
+/*
+ * 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
+ */
+'use strict';
+
+var constants = require('../utils/constants.js');
+var ruleGenerator = require('./rule-generator.js');
+var baseGenerator = require('./base-generator.js');
+
+/**
+ * `FilterListParser` is responsible for parsing a whole adblock filter list (list of rules).
+ * It is a wrapper around `RuleParser` which parses each line separately.
+ */
+class FilterListGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Serializes a whole adblock filter list (list of rules).
+     *
+     * @param ast AST to generate
+     * @param preferRaw If `true`, then the parser will use `raws.text` property of each rule
+     * if it is available. Default is `false`.
+     * @returns Serialized filter list
+     */
+    static generate(ast, preferRaw = false) {
+        let result = constants.EMPTY;
+        for (let i = 0; i < ast.children.length; i += 1) {
+            const rule = ast.children[i];
+            if (preferRaw && rule.raws?.text) {
+                result += rule.raws.text;
+            }
+            else {
+                result += ruleGenerator.RuleGenerator.generate(rule);
+            }
+            switch (rule.raws?.nl) {
+                case 'crlf':
+                    result += constants.CRLF;
+                    break;
+                case 'cr':
+                    result += constants.CR;
+                    break;
+                case 'lf':
+                    result += constants.LF;
+                    break;
+                default:
+                    if (i !== ast.children.length - 1) {
+                        result += constants.LF;
+                    }
+                    break;
+            }
+        }
+        return result;
+    }
+}
+
+exports.FilterListGenerator = FilterListGenerator;

package/dist/cjs/generator/index.js

@@ -0,0 +1,17 @@
+/*
+ * 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
+ */
+'use strict';
+
+var ruleGenerator = require('./rule-generator.js');
+var cosmeticRuleGenerator = require('./cosmetic/cosmetic-rule-generator.js');
+var cosmeticRuleBodyGenerator = require('./cosmetic/cosmetic-rule-body-generator.js');
+
+
+
+exports.RuleGenerator = ruleGenerator.RuleGenerator;
+exports.CosmeticRuleGenerator = cosmeticRuleGenerator.CosmeticRuleGenerator;
+exports.CosmeticRuleBodyGenerator = cosmeticRuleBodyGenerator.CosmeticRuleBodyGenerator;

package/dist/cjs/generator/misc/domain-list-generator.js

@@ -0,0 +1,25 @@
+/*
+ * 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
+ */
+'use strict';
+
+var baseGenerator = require('../base-generator.js');
+var listItemsGenerator = require('./list-items-generator.js');
+
+class DomainListGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Converts a domain list node to a string.
+     *
+     * @param node Domain list node.
+     *
+     * @returns Raw string.
+     */
+    static generate(node) {
+        return listItemsGenerator.ListItemsGenerator.generate(node.children, node.separator);
+    }
+}
+
+exports.DomainListGenerator = DomainListGenerator;

package/dist/cjs/generator/misc/list-items-generator.js

@@ -0,0 +1,38 @@
+/*
+ * 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
+ */
+'use strict';
+
+var constants = require('../../utils/constants.js');
+
+class ListItemsGenerator {
+    /**
+     * Generates a string representation of a list item.
+     *
+     * @param item List item to generate.
+     * @template T Type of the list item.
+     *
+     * @returns String representation of the list item.
+     */
+    static generateListItem = (item) => {
+        return `${item.exception ? constants.NEGATION_MARKER : constants.EMPTY}${item.value}`;
+    };
+    /**
+     * Generates a string representation of a list of items.
+     *
+     * @param items List of items to generate.
+     * @param separator Separator character.
+     * @template T Type of the list items.
+     *
+     * @returns String representation of the list of items.
+     */
+    static generate = (items, separator) => {
+        return items.map(ListItemsGenerator.generateListItem)
+            .join(separator);
+    };
+}
+
+exports.ListItemsGenerator = ListItemsGenerator;

package/dist/cjs/generator/misc/logical-expression-generator.js

@@ -0,0 +1,47 @@
+/*
+ * 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
+ */
+'use strict';
+
+var baseGenerator = require('../base-generator.js');
+var index = require('../../nodes/index.js');
+var logicalExpressionParser = require('../../parser/misc/logical-expression-parser.js');
+
+class LogicalExpressionGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Generates a string representation of the logical expression (serialization).
+     *
+     * @param node Expression node
+     * @returns String representation of the logical expression
+     */
+    static generate(node) {
+        if (node.type === logicalExpressionParser.NodeType.Variable) {
+            return node.name;
+        }
+        if (node.type === logicalExpressionParser.NodeType.Operator) {
+            const left = LogicalExpressionGenerator.generate(node.left);
+            const right = node.right ? LogicalExpressionGenerator.generate(node.right) : undefined;
+            const { operator } = node;
+            // Special case for NOT operator
+            if (operator === index.OperatorValue.Not) {
+                return `${operator}${left}`;
+            }
+            // Right operand is required for AND and OR operators
+            if (!right) {
+                throw new Error('Expected right operand');
+            }
+            return `${left} ${operator} ${right}`;
+        }
+        if (node.type === logicalExpressionParser.NodeType.Parenthesis) {
+            const expressionString = LogicalExpressionGenerator.generate(node.expression);
+            return `(${expressionString})`;
+        }
+        // Theoretically, this shouldn't happen if the library is used correctly
+        throw new Error('Unexpected node type');
+    }
+}
+
+exports.LogicalExpressionGenerator = LogicalExpressionGenerator;

package/dist/cjs/generator/misc/modifier-generator.js

@@ -0,0 +1,33 @@
+/*
+ * 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
+ */
+'use strict';
+
+var constants = require('../../utils/constants.js');
+var baseGenerator = require('../base-generator.js');
+
+class ModifierGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Generates a string from a modifier (serializes it).
+     *
+     * @param modifier Modifier to generate string from
+     * @returns String representation of the modifier
+     */
+    static generate(modifier) {
+        let result = constants.EMPTY;
+        if (modifier.exception) {
+            result += constants.NEGATION_MARKER;
+        }
+        result += modifier.name.value;
+        if (modifier.value !== undefined) {
+            result += constants.MODIFIER_ASSIGN_OPERATOR;
+            result += modifier.value.value;
+        }
+        return result;
+    }
+}
+
+exports.ModifierGenerator = ModifierGenerator;

package/dist/cjs/generator/misc/modifier-list-generator.js

@@ -0,0 +1,28 @@
+/*
+ * 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
+ */
+'use strict';
+
+var baseGenerator = require('../base-generator.js');
+var constants = require('../../utils/constants.js');
+var modifierGenerator = require('./modifier-generator.js');
+
+class ModifierListGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Converts a modifier list AST to a string.
+     *
+     * @param ast Modifier list AST
+     * @returns Raw string
+     */
+    static generate(ast) {
+        const result = ast.children
+            .map(modifierGenerator.ModifierGenerator.generate)
+            .join(constants.MODIFIERS_SEPARATOR);
+        return result;
+    }
+}
+
+exports.ModifierListGenerator = ModifierListGenerator;

package/dist/cjs/generator/misc/parameter-list-generator.js

@@ -0,0 +1,41 @@
+/*
+ * 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
+ */
+'use strict';
+
+var constants = require('../../utils/constants.js');
+var baseGenerator = require('../base-generator.js');
+var valueGenerator = require('./value-generator.js');
+
+class ParameterListGenerator extends baseGenerator.BaseGenerator {
+    /**
+     * Converts a parameter list AST to a string.
+     *
+     * @param params Parameter list AST
+     * @param separator Separator character (default: comma)
+     * @returns String representation of the parameter list
+     */
+    static generate(params, separator = constants.COMMA) {
+        const collection = [];
+        // add parameters
+        let i = 0;
+        for (; i < params.children.length; i += 1) {
+            const param = params.children[i];
+            if (param === null) {
+                collection.push(constants.EMPTY);
+            }
+            else {
+                collection.push(valueGenerator.ValueGenerator.generate(param));
+            }
+        }
+        // join parameters with separator
+        // if the separator is a space, join with a single space
+        const result = collection.join(separator === constants.SPACE ? separator : `${separator}${constants.SPACE}`);
+        return result;
+    }
+}
+
+exports.ParameterListGenerator = ParameterListGenerator;