@adguard/agtree 2.1.3 → 3.0.0

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

@@ -0,0 +1,199 @@
+/*
+ * 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 logicalExpressionCommon = require('../../marshalling-utils/misc/logical-expression-common.js');
+var logicalExpressionSerializer = require('../../serializer/misc/logical-expression-serializer.js');
+var constants = require('../../utils/constants.js');
+var typeGuards = require('../../utils/type-guards.js');
+var baseDeserializer = require('../base-deserializer.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+let logicalExpressionOperatorMarshallingMapReverse;
+const getOperatorBinaryMapReverse = () => {
+    if (!logicalExpressionOperatorMarshallingMapReverse) {
+        logicalExpressionOperatorMarshallingMapReverse = new Map(Array.from(logicalExpressionCommon.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 (typeGuards.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(logicalExpressionCommon.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 (typeGuards.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.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(binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionVariableNode);
+        node.type = logicalExpressionSerializer.NodeType.Variable;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case logicalExpressionCommon.VariableNodeBinaryPropMarshallingMap.Name:
+                    node.name = buffer.readString();
+                    break;
+                case logicalExpressionCommon.VariableNodeBinaryPropMarshallingMap.FrequentName:
+                    node.name = getFrequentNameOrFail(buffer.readUint8());
+                    break;
+                case logicalExpressionCommon.VariableNodeBinaryPropMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case logicalExpressionCommon.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(binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionParenthesisNode);
+        node.type = logicalExpressionSerializer.NodeType.Parenthesis;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case logicalExpressionCommon.ParenthesisNodeBinaryPropMarshallingMap.Expression:
+                    LogicalExpressionDeserializer.deserialize(buffer, node.expression = {});
+                    break;
+                case logicalExpressionCommon.ParenthesisNodeBinaryPropMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case logicalExpressionCommon.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(binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionOperatorNode);
+        node.type = logicalExpressionSerializer.NodeType.Operator;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case logicalExpressionCommon.OperatorNodeBinaryPropMarshallingMap.Operator:
+                    node.operator = getOperatorOrFail(buffer.readUint8());
+                    break;
+                case logicalExpressionCommon.OperatorNodeBinaryPropMarshallingMap.Left:
+                    LogicalExpressionDeserializer.deserialize(buffer, node.left = {});
+                    break;
+                case logicalExpressionCommon.OperatorNodeBinaryPropMarshallingMap.Right:
+                    LogicalExpressionDeserializer.deserialize(buffer, node.right = {});
+                    break;
+                case logicalExpressionCommon.OperatorNodeBinaryPropMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case logicalExpressionCommon.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 !== constants.NULL) {
+            switch (type) {
+                case binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionVariableNode:
+                    LogicalExpressionDeserializer.deserializeVariableNode(buffer, node);
+                    break;
+                case binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionOperatorNode:
+                    LogicalExpressionDeserializer.deserializeOperatorNode(buffer, node);
+                    break;
+                case binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionParenthesisNode:
+                    LogicalExpressionDeserializer.deserializeParenthesisNode(buffer, node);
+                    break;
+                default:
+                    throw new Error(`Unexpected node type: ${type}`);
+            }
+            type = buffer.peekUint8();
+        }
+        // consume NULL
+        buffer.readUint8();
+    }
+}
+
+exports.LogicalExpressionDeserializer = LogicalExpressionDeserializer;
+exports.getFrequentNameOrFail = getFrequentNameOrFail;

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

@@ -0,0 +1,89 @@
+/*
+ * 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 valueDeserializer = require('./value-deserializer.js');
+var baseDeserializer = require('../base-deserializer.js');
+var modifierCommon = require('../../marshalling-utils/misc/modifier-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/* 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(modifierCommon.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(modifierCommon.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.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(binaryTypeCommon.BinaryTypeMarshallingMap.ModifierNode);
+        node.type = 'Modifier';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case modifierCommon.ModifierNodeMarshallingMap.Name:
+                    // eslint-disable-next-line max-len
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.name = {}, getFrequentModifiersDeserializationMap());
+                    break;
+                case modifierCommon.ModifierNodeMarshallingMap.Value:
+                    if (node.name) {
+                        // eslint-disable-next-line max-len
+                        valueDeserializer.ValueDeserializer.deserialize(buffer, node.value = {}, getFrequentValuesDeserializationMaps().get(node.name.value));
+                    }
+                    else {
+                        valueDeserializer.ValueDeserializer.deserialize(buffer, node.value = {});
+                    }
+                    break;
+                case modifierCommon.ModifierNodeMarshallingMap.Exception:
+                    node.exception = buffer.readUint8() === 1;
+                    break;
+                case modifierCommon.ModifierNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case modifierCommon.ModifierNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.ModifierDeserializer = ModifierDeserializer;

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

@@ -0,0 +1,58 @@
+/*
+ * 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 baseDeserializer = require('../base-deserializer.js');
+var modifierDeserializer = require('./modifier-deserializer.js');
+var modifierListCommon = require('../../marshalling-utils/misc/modifier-list-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/* 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.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(binaryTypeCommon.BinaryTypeMarshallingMap.ModifierListNode);
+        node.type = 'ModifierList';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case modifierListCommon.ModifierListNodeMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint16());
+                    // read children
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        modifierDeserializer.ModifierDeserializer.deserialize(buffer, node.children[i] = {});
+                    }
+                    break;
+                case modifierListCommon.ModifierListNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case modifierListCommon.ModifierListNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.ModifierListDeserializer = ModifierListDeserializer;

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

@@ -0,0 +1,62 @@
+/*
+ * 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 valueDeserializer = require('./value-deserializer.js');
+var baseDeserializer = require('../base-deserializer.js');
+var parameterListCommon = require('../../marshalling-utils/misc/parameter-list-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+class ParameterListDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a parameter list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @param frequentValuesMap Optional map of frequent values.
+     * @throws If the binary data is malformed.
+     */
+    static deserialize(buffer, node, frequentValuesMap) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ParameterListNode);
+        node.type = 'ParameterList';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case parameterListCommon.ParameterListNodeMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint32());
+                    // read children
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        switch (buffer.peekUint8()) {
+                            case binaryTypeCommon.BinaryTypeMarshallingMap.Null:
+                                buffer.readUint8();
+                                node.children[i] = null;
+                                break;
+                            case binaryTypeCommon.BinaryTypeMarshallingMap.ValueNode:
+                                // eslint-disable-next-line max-len
+                                valueDeserializer.ValueDeserializer.deserialize(buffer, node.children[i] = {}, frequentValuesMap);
+                                break;
+                            default:
+                                throw new Error(`Invalid child type: ${buffer.peekUint8()}`);
+                        }
+                    }
+                    break;
+                case parameterListCommon.ParameterListNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case parameterListCommon.ParameterListNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.ParameterListDeserializer = ParameterListDeserializer;

package/dist/cjs/deserializer/misc/value-deserializer.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 baseDeserializer = require('../base-deserializer.js');
+var valueCommon = require('../../marshalling-utils/misc/value-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/**
+ * Value deserializer.
+ */
+class ValueDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a value node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @param frequentValuesMap Optional map of frequent values.
+     * @throws If the binary data is malformed.
+     */
+    static deserialize(buffer, node, frequentValuesMap) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ValueNode);
+        node.type = 'Value';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case valueCommon.ValueNodeMarshallingMap.Value:
+                    node.value = buffer.readString();
+                    break;
+                case valueCommon.ValueNodeMarshallingMap.FrequentValue:
+                    node.value = frequentValuesMap?.get(buffer.readUint8()) ?? constants.EMPTY;
+                    break;
+                case valueCommon.ValueNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case valueCommon.ValueNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.ValueDeserializer = ValueDeserializer;

package/dist/cjs/deserializer/network/host-rule-deserializer.js

@@ -0,0 +1,81 @@
+/*
+ * 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 index = require('../../nodes/index.js');
+var valueDeserializer = require('../misc/value-deserializer.js');
+var hostnameListDeserializer = require('./hostname-list-deserializer.js');
+var baseDeserializer = require('../base-deserializer.js');
+var hostRuleCommon = require('../../marshalling-utils/misc/host-rule-common.js');
+var adblockers = require('../../utils/adblockers.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+var syntaxDeserializationMap = require('../syntax-deserialization-map.js');
+
+/* eslint-disable no-param-reassign */
+/**
+ * `HostRuleSerializer` is responsible for serializing hosts-like rules.
+ *
+ * HostRule is a structure for simple host-level rules (i.e. /etc/hosts syntax).
+ * It also supports "just domain" syntax. In this case, the IP will be set to 0.0.0.0.
+ *
+ * Rules syntax looks like this:
+ * ```text
+ * IP_address canonical_hostname [aliases...]
+ * ```
+ *
+ * @example
+ * `192.168.1.13 bar.mydomain.org bar` -- ipv4
+ * `ff02::1 ip6-allnodes` -- ipv6
+ * `::1 localhost ip6-localhost ip6-loopback` -- ipv6 aliases
+ * `example.org` -- "just domain" syntax
+ * @see {@link http://man7.org/linux/man-pages/man5/hosts.5.html}
+ */
+class HostRuleDeserializer extends baseDeserializer.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(binaryTypeCommon.BinaryTypeMarshallingMap.HostRuleNode);
+        node.category = index.RuleCategory.Network;
+        node.type = index.NetworkRuleType.HostRule;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case hostRuleCommon.HostRuleMarshallingMap.Syntax:
+                    node.syntax = syntaxDeserializationMap.getSyntaxDeserializationMap().get(buffer.readUint8()) ?? adblockers.AdblockSyntax.Common;
+                    break;
+                case hostRuleCommon.HostRuleMarshallingMap.Ip:
+                    node.ip = {};
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.ip);
+                    break;
+                case hostRuleCommon.HostRuleMarshallingMap.HostnameList:
+                    node.hostnames = {};
+                    hostnameListDeserializer.HostnameListDeserializer.deserialize(buffer, node.hostnames);
+                    break;
+                case hostRuleCommon.HostRuleMarshallingMap.Comment:
+                    node.comment = {};
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.comment);
+                    break;
+                case hostRuleCommon.HostRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case hostRuleCommon.HostRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.HostRuleDeserializer = HostRuleDeserializer;

package/dist/cjs/deserializer/network/hostname-list-deserializer.js

@@ -0,0 +1,50 @@
+/*
+ * 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 baseDeserializer = require('../base-deserializer.js');
+var constants = require('../../utils/constants.js');
+var valueDeserializer = require('../misc/value-deserializer.js');
+var hostnameListCommon = require('../../marshalling-utils/misc/hostname-list-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+class HostnameListDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a hostname list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.HostnameListNode);
+        node.type = 'HostnameList';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case hostnameListCommon.HostnameListNodeMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint16());
+                    // read children
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        valueDeserializer.ValueDeserializer.deserialize(buffer, node.children[i] = {});
+                    }
+                    break;
+                case hostnameListCommon.HostnameListNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case hostnameListCommon.HostnameListNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Unknown property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.HostnameListDeserializer = HostnameListDeserializer;

package/dist/cjs/deserializer/network/network-rule-deserializer.js

@@ -0,0 +1,67 @@
+/*
+ * 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 index = require('../../nodes/index.js');
+var valueDeserializer = require('../misc/value-deserializer.js');
+var baseDeserializer = require('../base-deserializer.js');
+var modifierListDeserializer = require('../misc/modifier-list-deserializer.js');
+var networkRuleCommon = require('../../marshalling-utils/network/network-rule-common.js');
+var adblockers = require('../../utils/adblockers.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+var syntaxDeserializationMap = require('../syntax-deserialization-map.js');
+
+/* eslint-disable no-param-reassign */
+/**
+ * `NetworkRuleDeserializer` is responsible for deserializing network rules.
+ *
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#basic-rules}
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#basic}
+ */
+class NetworkRuleDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a network rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.NetworkRuleNode);
+        node.type = index.NetworkRuleType.NetworkRule;
+        node.category = index.RuleCategory.Network;
+        node.modifiers = undefined;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case networkRuleCommon.NetworkRuleMarshallingMap.Syntax:
+                    node.syntax = syntaxDeserializationMap.getSyntaxDeserializationMap().get(buffer.readUint8()) ?? adblockers.AdblockSyntax.Common;
+                    break;
+                case networkRuleCommon.NetworkRuleMarshallingMap.Exception:
+                    node.exception = buffer.readUint8() === 1;
+                    break;
+                case networkRuleCommon.NetworkRuleMarshallingMap.Pattern:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.pattern = {});
+                    break;
+                case networkRuleCommon.NetworkRuleMarshallingMap.ModifierList:
+                    modifierListDeserializer.ModifierListDeserializer.deserialize(buffer, node.modifiers = {});
+                    break;
+                case networkRuleCommon.NetworkRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case networkRuleCommon.NetworkRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.NetworkRuleDeserializer = NetworkRuleDeserializer;