@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/cjs/converter/raw-filter-list.js

@@ -0,0 +1,58 @@
+/*
+ * 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 conversionResult = require('./base-interfaces/conversion-result.js');
+var baseConverter = require('./base-interfaces/base-converter.js');
+var filterlistParser = require('../parser/filterlist-parser.js');
+var filterList = require('./filter-list.js');
+var options = require('../parser/options.js');
+var filterlistGenerator = require('../generator/filterlist-generator.js');
+
+/**
+ * @file Filter list converter for raw filter lists
+ *
+ * Technically, this is a wrapper around `FilterListConverter` that works with nodes instead of strings.
+ */
+/**
+ * Adblock filter list converter class.
+ *
+ * You can use this class to convert string-based filter lists, since most of the converters work with nodes.
+ * This class just provides an extra layer on top of the {@link FilterListConverter} and calls the parser/serializer
+ * before/after the conversion internally.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class RawFilterListConverter extends baseConverter.BaseConverter {
+    /**
+     * Converts an adblock filter list text to AdGuard format, if possible.
+     *
+     * @param rawFilterList Raw filter list text to convert
+     * @param tolerant Indicates whether the converter should be tolerant to invalid rules. If enabled and a rule is
+     * invalid, it will be left as is. If disabled and a rule is invalid, the whole filter list will be failed.
+     * Defaults to `true`.
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the array of converted filter list text, and its `isConverted` flag indicates whether the original rule was
+     * converted. If the rule was not converted, the original filter list text will be returned
+     * @throws If the filter list is invalid or cannot be converted (if the tolerant mode is disabled)
+     */
+    static convertToAdg(rawFilterList, tolerant = true) {
+        const conversionResult$1 = filterList.FilterListConverter.convertToAdg(filterlistParser.FilterListParser.parse(rawFilterList, {
+            ...options.defaultParserOptions,
+            isLocIncluded: false,
+            tolerant,
+        }), tolerant);
+        // If the filter list was not converted, return the original text
+        if (!conversionResult$1.isConverted) {
+            return conversionResult.createConversionResult(rawFilterList, false);
+        }
+        // Otherwise, serialize the filter list and return the result
+        return conversionResult.createConversionResult(filterlistGenerator.FilterListGenerator.generate(conversionResult$1.result), true);
+    }
+}
+
+exports.RawFilterListConverter = RawFilterListConverter;

package/dist/cjs/converter/rule.js

@@ -0,0 +1,83 @@
+/*
+ * 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 index = require('../nodes/index.js');
+var index$3 = require('./comment/index.js');
+var index$2 = require('./cosmetic/index.js');
+var index$1 = require('./network/index.js');
+var ruleConversionError = require('../errors/rule-conversion-error.js');
+var ruleConverterBase = require('./base-interfaces/rule-converter-base.js');
+var conversionResult = require('./base-interfaces/conversion-result.js');
+
+/**
+ * @file Adblock rule converter
+ *
+ * This file is the entry point for all rule converters
+ * which automatically detects the rule type and calls
+ * the corresponding "sub-converter".
+ */
+/**
+ * Adblock filtering rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class RuleConverter extends ruleConverterBase.RuleConverterBase {
+    /**
+     * Converts an adblock filtering rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Delegate conversion to the corresponding sub-converter
+        // based on the rule category
+        switch (rule.category) {
+            case index.RuleCategory.Comment:
+                return index$3.CommentRuleConverter.convertToAdg(rule);
+            case index.RuleCategory.Cosmetic:
+                return index$2.CosmeticRuleConverter.convertToAdg(rule);
+            case index.RuleCategory.Network:
+                // TODO: Handle hosts rules later
+                if (rule.type === index.NetworkRuleType.HostRule) {
+                    return conversionResult.createConversionResult([rule], false);
+                }
+                return index$1.NetworkRuleConverter.convertToAdg(rule);
+            case index.RuleCategory.Invalid:
+            case index.RuleCategory.Empty:
+                // Just forward the rule as is
+                return conversionResult.createConversionResult([rule], false);
+            default:
+                // Never happens during normal operation
+                throw new ruleConversionError.RuleConversionError('Unknown rule category');
+        }
+    }
+    /**
+     * Converts an adblock filtering rule to uBlock Origin format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    // TODO: Add support for other rule types
+    static convertToUbo(rule) {
+        if (rule.category === index.RuleCategory.Cosmetic) {
+            return index$2.CosmeticRuleConverter.convertToUbo(rule);
+        }
+        if (rule.category === index.RuleCategory.Network) {
+            return index$1.NetworkRuleConverter.convertToUbo(rule);
+        }
+        return conversionResult.createConversionResult([rule], false);
+    }
+}
+
+exports.RuleConverter = RuleConverter;

package/dist/cjs/deserializer/base-deserializer.js

@@ -0,0 +1,31 @@
+/*
+ * 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 notImplementedError = require('../errors/not-implemented-error.js');
+
+/**
+ * @file Base serializer class.
+ */
+/**
+ * Base class for deserializers. Each deserializer should extend this class.
+ */
+class BaseDeserializer {
+    /**
+     * Deserializes the AST node from a byte buffer.
+     *
+     * @param buffer Input byte buffer to read from.
+     * @param node Destination node to write to.
+     * @param args Additional, parser-specific arguments, if needed.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static deserialize(buffer, node, ...args) {
+        throw new notImplementedError.NotImplementedError();
+    }
+}
+
+exports.BaseDeserializer = BaseDeserializer;

package/dist/cjs/deserializer/comment/agent-comment-deserializer.js

@@ -0,0 +1,76 @@
+/*
+ * 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 index = require('../../nodes/index.js');
+var adblockers = require('../../utils/adblockers.js');
+var baseDeserializer = require('../base-deserializer.js');
+var agentCommentCommon = require('../../marshalling-utils/comment/agent-comment-common.js');
+var agentDeserializer = require('./agent-deserializer.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+/**
+ * `AgentCommentDeserializer` is responsible for deserializing an Adblock agent comments.
+ * Adblock agent comment marks that the filter list is supposed to
+ * be used by the specified ad blockers.
+ *
+ * @example
+ *  - ```adblock
+ *    [AdGuard]
+ *    ```
+ *  - ```adblock
+ *    [Adblock Plus 2.0]
+ *    ```
+ *  - ```adblock
+ *    [uBlock Origin]
+ *    ```
+ *  - ```adblock
+ *    [uBlock Origin 1.45.3]
+ *    ```
+ *  - ```adblock
+ *    [Adblock Plus 2.0; AdGuard]
+ *    ```
+ */
+class AgentCommentDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes an agent list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.AgentRuleNode);
+        node.type = index.CommentRuleType.AgentCommentRule;
+        node.syntax = adblockers.AdblockSyntax.Common;
+        node.category = index.RuleCategory.Comment;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case agentCommentCommon.AgentCommentMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint8());
+                    // read children
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        agentDeserializer.AgentDeserializer.deserialize(buffer, node.children[i] = {});
+                    }
+                    break;
+                case agentCommentCommon.AgentCommentMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case agentCommentCommon.AgentCommentMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.AgentCommentDeserializer = AgentCommentDeserializer;

package/dist/cjs/deserializer/comment/agent-deserializer.js

@@ -0,0 +1,67 @@
+/*
+ * 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 baseDeserializer = require('../base-deserializer.js');
+var agentCommon = require('../../marshalling-utils/comment/agent-common.js');
+var agentCommon$1 = require('../../common/agent-common.js');
+var valueDeserializer = require('../misc/value-deserializer.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+/**
+ * `AgentDeserializer` is responsible for deserializing single adblock agent elements.
+ *
+ * @example
+ * If the adblock agent rule is
+ * ```adblock
+ * [Adblock Plus 2.0; AdGuard]
+ * ```
+ * then the adblock agents are `Adblock Plus 2.0` and `AdGuard`, and this
+ * class is responsible for parsing them. The rule itself is parsed by
+ * `AgentCommentSerializer`, which uses this class to parse single agents.
+ */
+class AgentDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes an agent 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) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.AgentNode);
+        node.type = 'Agent';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case agentCommon.AgentNodeMarshallingMap.Adblock:
+                    // eslint-disable-next-line max-len
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.adblock = {}, agentCommon.FREQUENT_AGENTS_DESERIALIZATION_MAP);
+                    if (node.adblock) {
+                        node.syntax = agentCommon$1.getAdblockSyntax(node.adblock.value);
+                    }
+                    break;
+                case agentCommon.AgentNodeMarshallingMap.Version:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.version = {});
+                    break;
+                case agentCommon.AgentNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case agentCommon.AgentNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.AgentDeserializer = AgentDeserializer;

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

@@ -0,0 +1,109 @@
+/*
+ * 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 agentCommentDeserializer = require('./agent-comment-deserializer.js');
+var configCommentDeserializer = require('./config-comment-deserializer.js');
+var hintCommentDeserializer = require('./hint-comment-deserializer.js');
+var metadataCommentDeserializer = require('./metadata-comment-deserializer.js');
+var preProcessorCommentDeserializer = require('./pre-processor-comment-deserializer.js');
+var simpleCommentDeserializer = require('./simple-comment-deserializer.js');
+var baseDeserializer = require('../base-deserializer.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/**
+ * `CommentRuleSerializer` is responsible for serializing any comment-like adblock rules.
+ *
+ * @example
+ * Example rules:
+ *  - Adblock agent rules:
+ *      - ```adblock
+ *        [AdGuard]
+ *        ```
+ *      - ```adblock
+ *        [Adblock Plus 2.0]
+ *        ```
+ *      - etc.
+ *  - AdGuard hint rules:
+ *      - ```adblock
+ *        !+ NOT_OPTIMIZED
+ *        ```
+ *      - ```adblock
+ *        !+ NOT_OPTIMIZED PLATFORM(windows)
+ *        ```
+ *      - etc.
+ *  - Pre-processor rules:
+ *      - ```adblock
+ *        !#if (adguard)
+ *        ```
+ *      - ```adblock
+ *        !#endif
+ *        ```
+ *      - etc.
+ *  - Metadata rules:
+ *      - ```adblock
+ *        ! Title: My List
+ *        ```
+ *      - ```adblock
+ *        ! Version: 2.0.150
+ *        ```
+ *      - etc.
+ *  - AGLint inline config rules:
+ *      - ```adblock
+ *        ! aglint-enable some-rule
+ *        ```
+ *      - ```adblock
+ *        ! aglint-disable some-rule
+ *        ```
+ *      - etc.
+ *  - Simple comments:
+ *      - Regular version:
+ *        ```adblock
+ *        ! This is just a comment
+ *        ```
+ *      - uBlock Origin / "hostlist" version:
+ *        ```adblock
+ *        # This is just a comment
+ *        ```
+ *      - etc.
+ */
+class CommentRuleDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a comment rule 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) {
+        const type = buffer.peekUint8();
+        switch (type) {
+            case binaryTypeCommon.BinaryTypeMarshallingMap.AgentRuleNode:
+                agentCommentDeserializer.AgentCommentDeserializer.deserialize(buffer, node);
+                return;
+            case binaryTypeCommon.BinaryTypeMarshallingMap.HintRuleNode:
+                hintCommentDeserializer.HintCommentDeserializer.deserialize(buffer, node);
+                return;
+            case binaryTypeCommon.BinaryTypeMarshallingMap.PreProcessorCommentRuleNode:
+                preProcessorCommentDeserializer.PreProcessorCommentDeserializer.deserialize(buffer, node);
+                return;
+            case binaryTypeCommon.BinaryTypeMarshallingMap.MetadataCommentRuleNode:
+                metadataCommentDeserializer.MetadataCommentDeserializer.deserialize(buffer, node);
+                return;
+            case binaryTypeCommon.BinaryTypeMarshallingMap.ConfigCommentRuleNode:
+                configCommentDeserializer.ConfigCommentDeserializer.deserialize(buffer, node);
+                return;
+            case binaryTypeCommon.BinaryTypeMarshallingMap.CommentRuleNode:
+                simpleCommentDeserializer.SimpleCommentDeserializer.deserialize(buffer, node);
+                return;
+            default:
+                throw new Error(`Unknown comment rule type: ${type}`);
+        }
+    }
+}
+
+exports.CommentRuleDeserializer = CommentRuleDeserializer;

package/dist/cjs/deserializer/comment/config-comment-deserializer.js

@@ -0,0 +1,113 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var constants = require('../../utils/constants.js');
+var index = require('../../nodes/index.js');
+var baseDeserializer = require('../base-deserializer.js');
+var configCommentCommon = require('../../marshalling-utils/comment/config-comment-common.js');
+var adblockers = require('../../utils/adblockers.js');
+var valueDeserializer = require('../misc/value-deserializer.js');
+var parameterListDeserializer = require('../misc/parameter-list-deserializer.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.
+ */
+let frequentCommandsDeserializationMap;
+const getFrequentCommandsDeserializationMap = () => {
+    if (!frequentCommandsDeserializationMap) {
+        frequentCommandsDeserializationMap = new Map(Array.from(configCommentCommon.FREQUENT_COMMANDS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentCommandsDeserializationMap;
+};
+/**
+ * `ConfigCommentDeserializer` is responsible for deserializing inline AGLint configuration rules.
+ * Generally, the idea is inspired by ESLint inline configuration comments.
+ *
+ * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
+ */
+class ConfigCommentDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a metadata comment node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
+     */
+    static deserializeConfigNode(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ConfigNode);
+        node.type = 'ConfigNode';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case configCommentCommon.ConfigNodeMarshallingMap.Value:
+                    // note: it is safe to use JSON.parse here, because we serialized it with JSON.stringify
+                    node.value = JSON.parse(buffer.readString());
+                    break;
+                case configCommentCommon.ConfigNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case configCommentCommon.ConfigNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+    /**
+     * Deserializes a metadata comment 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) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ConfigCommentRuleNode);
+        node.type = index.CommentRuleType.ConfigCommentRule;
+        node.category = index.RuleCategory.Comment;
+        node.syntax = adblockers.AdblockSyntax.Common;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case configCommentCommon.ConfigCommentRuleMarshallingMap.Marker:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.marker = {});
+                    break;
+                case configCommentCommon.ConfigCommentRuleMarshallingMap.Command:
+                    // eslint-disable-next-line max-len
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.command = {}, getFrequentCommandsDeserializationMap());
+                    break;
+                case configCommentCommon.ConfigCommentRuleMarshallingMap.Params:
+                    if (buffer.peekUint8() === binaryTypeCommon.BinaryTypeMarshallingMap.ConfigNode) {
+                        ConfigCommentDeserializer.deserializeConfigNode(buffer, node.params = {});
+                    }
+                    else {
+                        parameterListDeserializer.ParameterListDeserializer.deserialize(buffer, node.params = {});
+                    }
+                    break;
+                case configCommentCommon.ConfigCommentRuleMarshallingMap.Comment:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.comment = {});
+                    break;
+                case configCommentCommon.ConfigCommentRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case configCommentCommon.ConfigCommentRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.ConfigCommentDeserializer = ConfigCommentDeserializer;

package/dist/cjs/deserializer/comment/hint-comment-deserializer.js

@@ -0,0 +1,69 @@
+/*
+ * 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 index = require('../../nodes/index.js');
+var hintDeserializer = require('./hint-deserializer.js');
+var adblockers = require('../../utils/adblockers.js');
+var baseDeserializer = require('../base-deserializer.js');
+var hintCommentCommon = require('../../marshalling-utils/comment/hint-comment-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+var syntaxDeserializationMap = require('../syntax-deserialization-map.js');
+
+/* eslint-disable no-param-reassign */
+/**
+ * `HintCommentDeserializer` is responsible for deserializing AdGuard hint rules.
+ *
+ * @example
+ * The following hint rule
+ * ```adblock
+ * !+ NOT_OPTIMIZED PLATFORM(windows)
+ * ```
+ * contains two hints: `NOT_OPTIMIZED` and `PLATFORM`.
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#hints}
+ */
+class HintCommentDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a hint rule 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) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.HintRuleNode);
+        node.category = index.RuleCategory.Comment;
+        node.type = index.CommentRuleType.HintCommentRule;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case hintCommentCommon.HintCommentMarshallingMap.Syntax:
+                    node.syntax = syntaxDeserializationMap.getSyntaxDeserializationMap().get(buffer.readUint8()) ?? adblockers.AdblockSyntax.Common;
+                    break;
+                case hintCommentCommon.HintCommentMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint8());
+                    // read children
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        hintDeserializer.HintDeserializer.deserialize(buffer, node.children[i] = {});
+                    }
+                    break;
+                case hintCommentCommon.HintCommentMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case hintCommentCommon.HintCommentMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.HintCommentDeserializer = HintCommentDeserializer;