@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/esm/deserializer/filterlist-deserializer.mjs

@@ -0,0 +1,81 @@
+/*
+ * 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 { NULL } from '../utils/constants.mjs';
+import { BaseDeserializer } from './base-deserializer.mjs';
+import { RuleDeserializer } from './rule-deserializer.mjs';
+import { FilterListNodeMarshallingMap } from '../marshalling-utils/filter-list-common.mjs';
+import { BinaryTypeMarshallingMap } from '../marshalling-utils/misc/binary-type-common.mjs';
+
+class FilterListDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a filter list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.FilterListNode);
+        node.type = 'FilterList';
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case FilterListNodeMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint32());
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        RuleDeserializer.deserialize(buffer, node.children[i] = {});
+                    }
+                    break;
+                case FilterListNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case FilterListNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+    /**
+     * Helper method to jump to the children of the filter list node.
+     *
+     * Filter lists serialized in binary format are structured as follows:
+     * - `FilterListNode` filter list node indicator (1 byte)
+     * - Properties:
+     *      - `Children` (1 byte) - children count, followed by children nodes
+     *      - `Start` (1 byte) - start offset, if present, followed by the value
+     *      - `End` (1 byte) - end offset, if present, followed by the value
+     *      - `NULL` (1 byte) - closing indicator
+     *
+     * This method skips indicators, reads the children count and returns it.
+     * This way the buffer is positioned at the beginning of the children nodes.
+     *
+     * @param buffer Reference to the input byte buffer.
+     * @returns Number of children nodes.
+     */
+    static jumpToChildren(buffer) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.FilterListNode); // filter list indicator
+        let prop = buffer.readUint8();
+        while (prop) {
+            switch (prop) {
+                case FilterListNodeMarshallingMap.Children:
+                    return buffer.readUint32();
+                case FilterListNodeMarshallingMap.Start:
+                case FilterListNodeMarshallingMap.End:
+                    buffer.readUint32(); // ignore value
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+        return 0;
+    }
+}
+
+export { FilterListDeserializer };

package/dist/esm/deserializer/index.mjs

@@ -0,0 +1,8 @@
+/*
+ * 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
+ */
+export { RuleDeserializer } from './rule-deserializer.mjs';
+export { getSyntaxDeserializationMap } from './syntax-deserialization-map.mjs';

package/dist/esm/deserializer/invalid-rule-deserializer.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 { BaseDeserializer } from './base-deserializer.mjs';
+import { RuleCategory } from '../nodes/index.mjs';
+import { NULL } from '../utils/constants.mjs';
+import { InvalidRuleErrorNodeDeserializer } from './invalid-rule-error-node-deserializer.mjs';
+import { InvalidRuleMarshallingMap } from '../marshalling-utils/invalid-rule-common.mjs';
+import { BinaryTypeMarshallingMap } from '../marshalling-utils/misc/binary-type-common.mjs';
+
+/* eslint-disable no-param-reassign */
+class InvalidRuleDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes an invalid rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.InvalidRule);
+        node.type = 'InvalidRule';
+        node.category = RuleCategory.Invalid;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case InvalidRuleMarshallingMap.Error:
+                    InvalidRuleErrorNodeDeserializer.deserialize(buffer, node.error = {});
+                    break;
+                case InvalidRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case InvalidRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { InvalidRuleDeserializer };

package/dist/esm/deserializer/invalid-rule-error-node-deserializer.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 { BaseDeserializer } from './base-deserializer.mjs';
+import { NULL } from '../utils/constants.mjs';
+import { InvalidRuleErrorNodeMarshallingMap } from '../marshalling-utils/invalid-rule-error-node-common.mjs';
+import { BinaryTypeMarshallingMap } from '../marshalling-utils/misc/binary-type-common.mjs';
+
+/* eslint-disable no-param-reassign */
+class InvalidRuleErrorNodeDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes an invalid rule error node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.InvalidRuleErrorNode);
+        node.type = 'InvalidRuleError';
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case InvalidRuleErrorNodeMarshallingMap.Name:
+                    node.name = buffer.readString();
+                    break;
+                case InvalidRuleErrorNodeMarshallingMap.Message:
+                    node.message = buffer.readString();
+                    break;
+                case InvalidRuleErrorNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case InvalidRuleErrorNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { InvalidRuleErrorNodeDeserializer };

package/dist/esm/deserializer/misc/domain-list-deserializer.mjs

@@ -0,0 +1,64 @@
+/*
+ * 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 { NULL, COMMA } from '../../utils/constants.mjs';
+import { ListNodeType } from '../../nodes/index.mjs';
+import { BaseDeserializer } from '../base-deserializer.mjs';
+import { DomainListMarshallingMap, SEPARATOR_SERIALIZATION_MAP } from '../../marshalling-utils/misc/domain-list-common.mjs';
+import { ListItemsDeserializer } from './list-items-deserializer.mjs';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.mjs';
+
+/* eslint-disable no-param-reassign */
+/**
+ * Value map for binary deserialization. This helps to reduce the size of the serialized data,
+ * as it allows us to use a single byte to represent frequently used values.
+ */
+let separatorDeserializationMap;
+const getSeparatorDeserializationMap = () => {
+    if (!separatorDeserializationMap) {
+        separatorDeserializationMap = new Map(Array.from(SEPARATOR_SERIALIZATION_MAP)
+            .map(([key, value]) => [value, key]));
+    }
+    return separatorDeserializationMap;
+};
+/**
+ * `DomainListDeserializer` is responsible for deserializing a domain list.
+ */
+class DomainListDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a modifier list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.DomainListNode);
+        node.type = ListNodeType.DomainList;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case DomainListMarshallingMap.Separator:
+                    // eslint-disable-next-line max-len
+                    node.separator = (getSeparatorDeserializationMap().get(buffer.readUint8()) ?? COMMA);
+                    break;
+                case DomainListMarshallingMap.Children:
+                    ListItemsDeserializer.deserialize(buffer, node.children = []);
+                    break;
+                case DomainListMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case DomainListMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { DomainListDeserializer };

package/dist/esm/deserializer/misc/list-item-deserializer.mjs

@@ -0,0 +1,63 @@
+/*
+ * 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 { BaseDeserializer } from '../base-deserializer.mjs';
+import { ListItemNodeType } from '../../nodes/index.mjs';
+import { NULL } from '../../utils/constants.mjs';
+import { ListItemMarshallingMap } from '../../marshalling-utils/misc/list-item-common.mjs';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.mjs';
+
+/* eslint-disable no-param-reassign */
+class ListItemDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a list item from binary format.
+     *
+     * @param buffer Input byte buffer.
+     * @param node Partial list item to deserialize.
+     * @template T Type of the list item.
+     */
+    static deserialize = (buffer, node) => {
+        const type = buffer.readUint8();
+        switch (type) {
+            case BinaryTypeMarshallingMap.AppNode:
+                node.type = ListItemNodeType.App;
+                break;
+            case BinaryTypeMarshallingMap.DomainNode:
+                node.type = ListItemNodeType.Domain;
+                break;
+            case BinaryTypeMarshallingMap.MethodNode:
+                node.type = ListItemNodeType.Method;
+                break;
+            case BinaryTypeMarshallingMap.StealthOptionNode:
+                node.type = ListItemNodeType.StealthOption;
+                break;
+            default:
+                throw new Error(`Invalid list item type: ${type}`);
+        }
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case ListItemMarshallingMap.Exception:
+                    node.exception = buffer.readUint8() === 1;
+                    break;
+                case ListItemMarshallingMap.Value:
+                    node.value = buffer.readString();
+                    break;
+                case ListItemMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case ListItemMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${type}`);
+            }
+            prop = buffer.readUint8();
+        }
+    };
+}
+
+export { ListItemDeserializer };

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

@@ -0,0 +1,26 @@
+/*
+ * 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 { ListItemDeserializer } from './list-item-deserializer.mjs';
+
+class ListItemsDeserializer {
+    /**
+     * Deserializes a list of items from binary format.
+     *
+     * @param buffer Input byte buffer.
+     * @param items Partial list of items to deserialize.
+     * @template T Type of the list items.
+     */
+    static deserialize = (buffer, items) => {
+        const length = buffer.readUint16();
+        items.length = length;
+        for (let i = 0; i < length; i += 1) {
+            ListItemDeserializer.deserialize(buffer, items[i] = {});
+        }
+    };
+}
+
+export { ListItemsDeserializer };

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

@@ -0,0 +1,196 @@
+/*
+ * 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 { VariableNodeBinaryPropMarshallingMap, ParenthesisNodeBinaryPropMarshallingMap, OperatorNodeBinaryPropMarshallingMap, LOGICAL_EXPRESSION_OPERATOR_SERIALISATION_MAP, KNOWN_VARIABLES_SERIALIZATION_MAP } from '../../marshalling-utils/misc/logical-expression-common.mjs';
+import { NodeType } from '../../serializer/misc/logical-expression-serializer.mjs';
+import { NULL } from '../../utils/constants.mjs';
+import { isUndefined } from '../../utils/type-guards.mjs';
+import { BaseDeserializer } from '../base-deserializer.mjs';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.mjs';
+
+let logicalExpressionOperatorMarshallingMapReverse;
+const getOperatorBinaryMapReverse = () => {
+    if (!logicalExpressionOperatorMarshallingMapReverse) {
+        logicalExpressionOperatorMarshallingMapReverse = new Map(Array.from(LOGICAL_EXPRESSION_OPERATOR_SERIALISATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return logicalExpressionOperatorMarshallingMapReverse;
+};
+/**
+ * Gets the string representation of the operator from the binary representation.
+ *
+ * @param binary Binary representation of the operator
+ * @returns String representation of the operator
+ * @throws If the operator is unknown
+ */
+const getOperatorOrFail = (binary) => {
+    const operator = getOperatorBinaryMapReverse().get(binary);
+    if (isUndefined(operator)) {
+        throw new Error(`Unknown operator: ${binary}`);
+    }
+    return operator;
+};
+/**
+ * Deserialization map for known variables.
+ */
+let knownVariablesMapReverse;
+const getKnownVariablesMapReverse = () => {
+    if (!knownVariablesMapReverse) {
+        knownVariablesMapReverse = new Map(Array.from(KNOWN_VARIABLES_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return knownVariablesMapReverse;
+};
+/**
+ * Gets the frequent name of the variable from the binary representation.
+ *
+ * @param binary Binary representation of the variable
+ * @returns Frequent name of the variable
+ * @throws If the variable is unknown
+ */
+const getFrequentNameOrFail = (binary) => {
+    const name = getKnownVariablesMapReverse().get(binary);
+    if (isUndefined(name)) {
+        throw new Error(`Unknown frequent name: ${binary}`);
+    }
+    return name;
+};
+/**
+ * `LogicalExpressionDeserializer` is responsible for deserializing 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 LogicalExpressionDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a variable node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
+     */
+    static deserializeVariableNode(buffer, node) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.ExpressionVariableNode);
+        node.type = NodeType.Variable;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case VariableNodeBinaryPropMarshallingMap.Name:
+                    node.name = buffer.readString();
+                    break;
+                case VariableNodeBinaryPropMarshallingMap.FrequentName:
+                    node.name = getFrequentNameOrFail(buffer.readUint8());
+                    break;
+                case VariableNodeBinaryPropMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case VariableNodeBinaryPropMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+    /**
+     * Deserializes a parenthesis node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
+     */
+    static deserializeParenthesisNode(buffer, node) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.ExpressionParenthesisNode);
+        node.type = NodeType.Parenthesis;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case ParenthesisNodeBinaryPropMarshallingMap.Expression:
+                    LogicalExpressionDeserializer.deserialize(buffer, node.expression = {});
+                    break;
+                case ParenthesisNodeBinaryPropMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case ParenthesisNodeBinaryPropMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+    /**
+     * Deserializes an operator node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
+     */
+    static deserializeOperatorNode(buffer, node) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.ExpressionOperatorNode);
+        node.type = NodeType.Operator;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case OperatorNodeBinaryPropMarshallingMap.Operator:
+                    node.operator = getOperatorOrFail(buffer.readUint8());
+                    break;
+                case OperatorNodeBinaryPropMarshallingMap.Left:
+                    LogicalExpressionDeserializer.deserialize(buffer, node.left = {});
+                    break;
+                case OperatorNodeBinaryPropMarshallingMap.Right:
+                    LogicalExpressionDeserializer.deserialize(buffer, node.right = {});
+                    break;
+                case OperatorNodeBinaryPropMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case OperatorNodeBinaryPropMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+    /**
+     * Deserializes a logical expression node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
+     */
+    static deserialize(buffer, node) {
+        // note: we just do a simple lookahead here, because advancing the buffer is done in the
+        // 'sub-deserialize' methods
+        let type = buffer.peekUint8();
+        while (type !== NULL) {
+            switch (type) {
+                case BinaryTypeMarshallingMap.ExpressionVariableNode:
+                    LogicalExpressionDeserializer.deserializeVariableNode(buffer, node);
+                    break;
+                case BinaryTypeMarshallingMap.ExpressionOperatorNode:
+                    LogicalExpressionDeserializer.deserializeOperatorNode(buffer, node);
+                    break;
+                case BinaryTypeMarshallingMap.ExpressionParenthesisNode:
+                    LogicalExpressionDeserializer.deserializeParenthesisNode(buffer, node);
+                    break;
+                default:
+                    throw new Error(`Unexpected node type: ${type}`);
+            }
+            type = buffer.peekUint8();
+        }
+        // consume NULL
+        buffer.readUint8();
+    }
+}
+
+export { LogicalExpressionDeserializer, getFrequentNameOrFail };

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

@@ -0,0 +1,87 @@
+/*
+ * 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 { NULL } from '../../utils/constants.mjs';
+import { ValueDeserializer } from './value-deserializer.mjs';
+import { BaseDeserializer } from '../base-deserializer.mjs';
+import { ModifierNodeMarshallingMap, FREQUENT_MODIFIERS_SERIALIZATION_MAP, FREQUENT_REDIRECT_MODIFIERS_SERIALIZATION_MAP } from '../../marshalling-utils/misc/modifier-common.mjs';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.mjs';
+
+/* eslint-disable no-param-reassign */
+/**
+ * Value map for binary deserialization. This helps to reduce the size of the serialized data,
+ * as it allows us to use a single byte to represent frequently used values.
+ *
+ * @note Only 256 values can be represented this way.
+ */
+let frequentModifiersDeserializationMap;
+const getFrequentModifiersDeserializationMap = () => {
+    if (!frequentModifiersDeserializationMap) {
+        frequentModifiersDeserializationMap = new Map(Array.from(FREQUENT_MODIFIERS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentModifiersDeserializationMap;
+};
+/**
+ * Value map for binary deserialization. This helps to reduce the size of the serialized data,
+ * as it allows us to use a single byte to represent frequently used values.
+ */
+let frequentValuesDeserializationMaps;
+const getFrequentValuesDeserializationMaps = () => {
+    if (!frequentValuesDeserializationMaps) {
+        frequentValuesDeserializationMaps = new Map(Array.from(FREQUENT_REDIRECT_MODIFIERS_SERIALIZATION_MAP, ([modifier, valueMap]) => [modifier, new Map(Array.from(valueMap, ([key, value]) => [value, key]))]));
+    }
+    return frequentValuesDeserializationMaps;
+};
+/**
+ * `ModifierSerializer` is responsible for serializing modifiers.
+ *
+ * @example
+ * `match-case`, `~third-party`, `domain=example.com|~example.org`
+ */
+class ModifierDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a modifier node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.ModifierNode);
+        node.type = 'Modifier';
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case ModifierNodeMarshallingMap.Name:
+                    // eslint-disable-next-line max-len
+                    ValueDeserializer.deserialize(buffer, node.name = {}, getFrequentModifiersDeserializationMap());
+                    break;
+                case ModifierNodeMarshallingMap.Value:
+                    if (node.name) {
+                        // eslint-disable-next-line max-len
+                        ValueDeserializer.deserialize(buffer, node.value = {}, getFrequentValuesDeserializationMaps().get(node.name.value));
+                    }
+                    else {
+                        ValueDeserializer.deserialize(buffer, node.value = {});
+                    }
+                    break;
+                case ModifierNodeMarshallingMap.Exception:
+                    node.exception = buffer.readUint8() === 1;
+                    break;
+                case ModifierNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case ModifierNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { ModifierDeserializer };

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

@@ -0,0 +1,56 @@
+/*
+ * 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 { NULL } from '../../utils/constants.mjs';
+import { BaseDeserializer } from '../base-deserializer.mjs';
+import { ModifierDeserializer } from './modifier-deserializer.mjs';
+import { ModifierListNodeMarshallingMap } from '../../marshalling-utils/misc/modifier-list-common.mjs';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.mjs';
+
+/* eslint-disable no-param-reassign */
+/**
+ * `ModifierListDeserializer` is responsible for deserializing 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 ModifierListDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a modifier list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.ModifierListNode);
+        node.type = 'ModifierList';
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case ModifierListNodeMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint16());
+                    // read children
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        ModifierDeserializer.deserialize(buffer, node.children[i] = {});
+                    }
+                    break;
+                case ModifierListNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case ModifierListNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { ModifierListDeserializer };