@adguard/agtree 2.1.3 → 3.0.0

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

@@ -0,0 +1,48 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 typeGuards = require('../utils/type-guards.js');
+var baseSerializer = require('./base-serializer.js');
+var ruleSerializer = require('./rule-serializer.js');
+var filterListCommon = require('../marshalling-utils/filter-list-common.js');
+var binaryTypeCommon = require('../marshalling-utils/misc/binary-type-common.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 FilterListSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a filter list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    // TODO: add support for raws, if ever needed
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.FilterListNode);
+        buffer.writeUint8(filterListCommon.FilterListNodeMarshallingMap.Children);
+        const count = node.children.length;
+        buffer.writeUint32(count);
+        for (let i = 0; i < count; i += 1) {
+            ruleSerializer.RuleSerializer.serialize(node.children[i], buffer);
+        }
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(filterListCommon.FilterListNodeMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(filterListCommon.FilterListNodeMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.FilterListSerializer = FilterListSerializer;

package/dist/cjs/serializer/index.js

@@ -0,0 +1,13 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var ruleSerializer = require('./rule-serializer.js');
+
+
+
+exports.RuleSerializer = ruleSerializer.RuleSerializer;

package/dist/cjs/serializer/invalid-rule-error-node-serializer.js

@@ -0,0 +1,40 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var baseSerializer = require('./base-serializer.js');
+var typeGuards = require('../utils/type-guards.js');
+var constants = require('../utils/constants.js');
+var invalidRuleErrorNodeCommon = require('../marshalling-utils/invalid-rule-error-node-common.js');
+var binaryTypeCommon = require('../marshalling-utils/misc/binary-type-common.js');
+
+class InvalidRuleErrorNodeSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes an invalid rule error node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.InvalidRuleErrorNode);
+        buffer.writeUint8(invalidRuleErrorNodeCommon.InvalidRuleErrorNodeMarshallingMap.Name);
+        buffer.writeString(node.name);
+        buffer.writeUint8(invalidRuleErrorNodeCommon.InvalidRuleErrorNodeMarshallingMap.Message);
+        buffer.writeString(node.message);
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(invalidRuleErrorNodeCommon.InvalidRuleErrorNodeMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(invalidRuleErrorNodeCommon.InvalidRuleErrorNodeMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.InvalidRuleErrorNodeSerializer = InvalidRuleErrorNodeSerializer;

package/dist/cjs/serializer/invalid-rule-serializer.js

@@ -0,0 +1,39 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var baseSerializer = require('./base-serializer.js');
+var typeGuards = require('../utils/type-guards.js');
+var constants = require('../utils/constants.js');
+var invalidRuleErrorNodeSerializer = require('./invalid-rule-error-node-serializer.js');
+var invalidRuleCommon = require('../marshalling-utils/invalid-rule-common.js');
+var binaryTypeCommon = require('../marshalling-utils/misc/binary-type-common.js');
+
+class InvalidRuleSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes an invalid rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.InvalidRule);
+        buffer.writeUint8(invalidRuleCommon.InvalidRuleMarshallingMap.Error);
+        invalidRuleErrorNodeSerializer.InvalidRuleErrorNodeSerializer.serialize(node.error, buffer);
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(invalidRuleCommon.InvalidRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(invalidRuleCommon.InvalidRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.InvalidRuleSerializer = InvalidRuleSerializer;

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

@@ -0,0 +1,66 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 typeGuards = require('../../utils/type-guards.js');
+var baseSerializer = require('../base-serializer.js');
+var listItemsSerializer = require('./list-items-serializer.js');
+var domainListCommon = require('../../marshalling-utils/misc/domain-list-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/**
+ * Value map for binary serialization. This helps to reduce the size of the serialized data,
+ * as it allows us to use a single byte to represent frequently used values.
+ *
+ * ! IMPORTANT: If you change values here, please update the {@link BINARY_SCHEMA_VERSION}!
+ *
+ * @note Only 256 values can be represented this way.
+ */
+const SEPARATOR_SERIALIZATION_MAP = new Map([
+    [constants.COMMA, 0],
+    [constants.PIPE, 1],
+]);
+/**
+ * `DomainListParser` is responsible for parsing a domain list.
+ *
+ * @example
+ * - If the rule is `example.com,~example.net##.ads`, the domain list is `example.com,~example.net`.
+ * - If the rule is `ads.js^$script,domains=example.com|~example.org`, the domain list is `example.com|~example.org`.
+ * This parser is responsible for parsing these domain lists.
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_domains}
+ */
+class DomainListSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a domain list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.DomainListNode);
+        const separator = SEPARATOR_SERIALIZATION_MAP.get(node.separator);
+        if (typeGuards.isUndefined(separator)) {
+            throw new Error(`Invalid separator: ${node.separator}`);
+        }
+        buffer.writeUint8(domainListCommon.DomainListMarshallingMap.Separator);
+        buffer.writeUint8(separator);
+        buffer.writeUint8(domainListCommon.DomainListMarshallingMap.Children);
+        listItemsSerializer.ListItemsSerializer.serialize(node.children, buffer);
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(domainListCommon.DomainListMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(domainListCommon.DomainListMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.DomainListSerializer = DomainListSerializer;

package/dist/cjs/serializer/misc/list-item-serializer.js

@@ -0,0 +1,57 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var baseSerializer = require('../base-serializer.js');
+var index = require('../../nodes/index.js');
+var typeGuards = require('../../utils/type-guards.js');
+var constants = require('../../utils/constants.js');
+var listItemCommon = require('../../marshalling-utils/misc/list-item-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+class ListItemSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a list item to binary format.
+     *
+     * @param item List item to serialize.
+     * @param buffer Output byte buffer.
+     * @template T Type of the list item.
+     */
+    static serialize(item, buffer) {
+        switch (item.type) {
+            case index.ListItemNodeType.App:
+                buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.AppNode);
+                break;
+            case index.ListItemNodeType.Domain:
+                buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.DomainNode);
+                break;
+            case index.ListItemNodeType.Method:
+                buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.MethodNode);
+                break;
+            case index.ListItemNodeType.StealthOption:
+                buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.StealthOptionNode);
+                break;
+            default:
+                throw new Error(`Invalid list item type: ${item.type}`);
+        }
+        buffer.writeUint8(listItemCommon.ListItemMarshallingMap.Exception);
+        buffer.writeUint8(item.exception ? 1 : 0);
+        buffer.writeUint8(listItemCommon.ListItemMarshallingMap.Value);
+        buffer.writeString(item.value);
+        if (!typeGuards.isUndefined(item.start)) {
+            buffer.writeUint8(listItemCommon.ListItemMarshallingMap.Start);
+            buffer.writeUint32(item.start);
+        }
+        if (!typeGuards.isUndefined(item.end)) {
+            buffer.writeUint8(listItemCommon.ListItemMarshallingMap.End);
+            buffer.writeUint32(item.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.ListItemSerializer = ListItemSerializer;

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

@@ -0,0 +1,28 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var listItemSerializer = require('./list-item-serializer.js');
+
+class ListItemsSerializer {
+    /**
+     * Serializes a list of items to binary format.
+     *
+     * @param items List of items to serialize.
+     * @param buffer Output byte buffer.
+     * @template T Type of the list items.
+     */
+    static serialize(items, buffer) {
+        const { length } = items;
+        buffer.writeUint16(length);
+        for (let i = 0; i < length; i += 1) {
+            listItemSerializer.ListItemSerializer.serialize(items[i], buffer);
+        }
+    }
+}
+
+exports.ListItemsSerializer = ListItemsSerializer;

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

@@ -0,0 +1,138 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 typeGuards = require('../../utils/type-guards.js');
+var baseSerializer = require('../base-serializer.js');
+var logicalExpressionCommon = require('../../marshalling-utils/misc/logical-expression-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/**
+ * Possible node types in the logical expression.
+ */
+exports.NodeType = void 0;
+(function (NodeType) {
+    NodeType["Variable"] = "Variable";
+    NodeType["Operator"] = "Operator";
+    NodeType["Parenthesis"] = "Parenthesis";
+})(exports.NodeType || (exports.NodeType = {}));
+/**
+ * `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 LogicalExpressionSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a variable node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    // TODO: create a common serialize / deserialize interface for such nodes (Variable, Value, Parameter, etc.)
+    static serializeVariableNode(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionVariableNode);
+        const frequentName = logicalExpressionCommon.KNOWN_VARIABLES_SERIALIZATION_MAP.get(node.name);
+        if (!typeGuards.isUndefined(frequentName)) {
+            buffer.writeUint8(logicalExpressionCommon.VariableNodeBinaryPropMarshallingMap.FrequentName);
+            buffer.writeUint8(frequentName);
+        }
+        else {
+            buffer.writeUint8(logicalExpressionCommon.VariableNodeBinaryPropMarshallingMap.Name);
+            buffer.writeString(node.name);
+        }
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(logicalExpressionCommon.VariableNodeBinaryPropMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(logicalExpressionCommon.VariableNodeBinaryPropMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+    /**
+     * Serializes a parenthesis node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serializeParenthesisNode(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionParenthesisNode);
+        buffer.writeUint8(logicalExpressionCommon.ParenthesisNodeBinaryPropMarshallingMap.Expression);
+        LogicalExpressionSerializer.serialize(node.expression, buffer);
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(logicalExpressionCommon.ParenthesisNodeBinaryPropMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(logicalExpressionCommon.ParenthesisNodeBinaryPropMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+    /**
+     * Serializes an operator node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serializeOperatorNode(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionOperatorNode);
+        buffer.writeUint8(logicalExpressionCommon.OperatorNodeBinaryPropMarshallingMap.Operator);
+        const operatorBinary = logicalExpressionCommon.LOGICAL_EXPRESSION_OPERATOR_SERIALISATION_MAP.get(node.operator);
+        if (typeGuards.isUndefined(operatorBinary)) {
+            throw new Error(`Unknown operator: ${node.operator}`);
+        }
+        buffer.writeUint8(operatorBinary);
+        buffer.writeUint8(logicalExpressionCommon.OperatorNodeBinaryPropMarshallingMap.Left);
+        LogicalExpressionSerializer.serialize(node.left, buffer);
+        if (node.right) {
+            buffer.writeUint8(logicalExpressionCommon.OperatorNodeBinaryPropMarshallingMap.Right);
+            LogicalExpressionSerializer.serialize(node.right, buffer);
+        }
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(logicalExpressionCommon.OperatorNodeBinaryPropMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(logicalExpressionCommon.OperatorNodeBinaryPropMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+    /**
+     * Serializes a logical expression node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        switch (node.type) {
+            case exports.NodeType.Variable:
+                LogicalExpressionSerializer.serializeVariableNode(node, buffer);
+                break;
+            case exports.NodeType.Operator:
+                LogicalExpressionSerializer.serializeOperatorNode(node, buffer);
+                break;
+            case exports.NodeType.Parenthesis:
+                LogicalExpressionSerializer.serializeParenthesisNode(node, buffer);
+                break;
+            default:
+                throw new Error(`Unexpected node type: ${node.type}`);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.LogicalExpressionSerializer = LogicalExpressionSerializer;

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

@@ -0,0 +1,57 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 typeGuards = require('../../utils/type-guards.js');
+var baseSerializer = require('../base-serializer.js');
+var modifierSerializer = require('./modifier-serializer.js');
+var modifierListCommon = require('../../marshalling-utils/misc/modifier-list-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/**
+ * `ModifierListSerializer` is responsible for serializing 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 ModifierListSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a modifier list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ModifierListNode);
+        const count = node.children.length;
+        if (count) {
+            buffer.writeUint8(modifierListCommon.ModifierListNodeMarshallingMap.Children);
+            // note: we store the count, because re-construction of the array is faster if we know the length
+            if (count > constants.UINT16_MAX) {
+                throw new Error(`Too many modifiers: ${count}, the limit is ${constants.UINT16_MAX}`);
+            }
+            buffer.writeUint16(count);
+            for (let i = 0; i < count; i += 1) {
+                modifierSerializer.ModifierSerializer.serialize(node.children[i], buffer);
+            }
+        }
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(modifierListCommon.ModifierListNodeMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(modifierListCommon.ModifierListNodeMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.ModifierListSerializer = ModifierListSerializer;

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

@@ -0,0 +1,51 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 valueSerializer = require('./value-serializer.js');
+var typeGuards = require('../../utils/type-guards.js');
+var baseSerializer = require('../base-serializer.js');
+var modifierCommon = require('../../marshalling-utils/misc/modifier-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/**
+ * `ModifierSerializer` is responsible for serializing modifiers.
+ *
+ * @example
+ * `match-case`, `~third-party`, `domain=example.com|~example.org`
+ */
+class ModifierSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a modifier node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ModifierNode);
+        buffer.writeUint8(modifierCommon.ModifierNodeMarshallingMap.Name);
+        valueSerializer.ValueSerializer.serialize(node.name, buffer, modifierCommon.FREQUENT_MODIFIERS_SERIALIZATION_MAP);
+        if (!typeGuards.isUndefined(node.value)) {
+            buffer.writeUint8(modifierCommon.ModifierNodeMarshallingMap.Value);
+            valueSerializer.ValueSerializer.serialize(node.value, buffer, modifierCommon.FREQUENT_REDIRECT_MODIFIERS_SERIALIZATION_MAP.get(node.name.value));
+        }
+        buffer.writeUint8(modifierCommon.ModifierNodeMarshallingMap.Exception);
+        buffer.writeUint8(node.exception ? 1 : 0);
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(modifierCommon.ModifierNodeMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(modifierCommon.ModifierNodeMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.ModifierSerializer = ModifierSerializer;

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

@@ -0,0 +1,51 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 valueSerializer = require('./value-serializer.js');
+var typeGuards = require('../../utils/type-guards.js');
+var baseSerializer = require('../base-serializer.js');
+var parameterListCommon = require('../../marshalling-utils/misc/parameter-list-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+class ParameterListSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a parameter list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     * @param frequentValuesMap Optional map of frequent values.
+     * @param toLower Whether to lowercase the value before the frequent value match (defaults to `false`).
+     */
+    static serialize(node, buffer, frequentValuesMap, toLower = false) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ParameterListNode);
+        const count = node.children.length;
+        buffer.writeUint8(parameterListCommon.ParameterListNodeMarshallingMap.Children);
+        // note: we store the count, because re-construction of the array is faster if we know the length
+        buffer.writeUint32(count);
+        for (let i = 0; i < count; i += 1) {
+            const child = node.children[i];
+            if (typeGuards.isNull(child)) {
+                buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.Null);
+                continue;
+            }
+            valueSerializer.ValueSerializer.serialize(child, buffer, frequentValuesMap, toLower);
+        }
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(parameterListCommon.ParameterListNodeMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(parameterListCommon.ParameterListNodeMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.ParameterListSerializer = ParameterListSerializer;

package/dist/cjs/serializer/misc/value-serializer.js

@@ -0,0 +1,52 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 typeGuards = require('../../utils/type-guards.js');
+var baseSerializer = require('../base-serializer.js');
+var valueCommon = require('../../marshalling-utils/misc/value-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/**
+ * Value serializer.
+ */
+class ValueSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a value node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     * @param frequentValuesMap Optional map of frequent values.
+     * @param toLower Whether to lowercase the value before the frequent value match (defaults to `false`).
+     */
+    static serialize(node, buffer, frequentValuesMap, toLower = false) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ValueNode);
+        const frequentValue = frequentValuesMap?.get(toLower ? node.value.toLowerCase() : node.value);
+        // note: do not use just `if (frequentValue)` because it can be 0
+        if (!typeGuards.isUndefined(frequentValue)) {
+            buffer.writeUint8(valueCommon.ValueNodeMarshallingMap.FrequentValue);
+            buffer.writeUint8(frequentValue);
+        }
+        else {
+            buffer.writeUint8(valueCommon.ValueNodeMarshallingMap.Value);
+            buffer.writeString(node.value);
+        }
+        // note: do not use just `if (node.start)` because it can be 0
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(valueCommon.ValueNodeMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(valueCommon.ValueNodeMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.ValueSerializer = ValueSerializer;