@adguard/agtree 2.2.0 → 3.0.0-alpha.2

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

@@ -0,0 +1,56 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { createConversionResult } from './base-interfaces/conversion-result.js';
+import { BaseConverter } from './base-interfaces/base-converter.js';
+import { FilterListParser } from '../parser/filterlist-parser.js';
+import { FilterListConverter } from './filter-list.js';
+import { defaultParserOptions } from '../parser/options.js';
+import { FilterListGenerator } from '../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 {
+    /**
+     * 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 = FilterListConverter.convertToAdg(FilterListParser.parse(rawFilterList, {
+            ...defaultParserOptions,
+            isLocIncluded: false,
+            tolerant,
+        }), tolerant);
+        // If the filter list was not converted, return the original text
+        if (!conversionResult.isConverted) {
+            return createConversionResult(rawFilterList, false);
+        }
+        // Otherwise, serialize the filter list and return the result
+        return createConversionResult(FilterListGenerator.generate(conversionResult.result, false, tolerant), true);
+    }
+}
+
+export { RawFilterListConverter };

package/dist/converter/rule.js

@@ -0,0 +1,81 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { RuleCategory, NetworkRuleType } from '../nodes/index.js';
+import { CommentRuleConverter } from './comment/index.js';
+import { CosmeticRuleConverter } from './cosmetic/index.js';
+import { NetworkRuleConverter } from './network/index.js';
+import { RuleConversionError } from '../errors/rule-conversion-error.js';
+import { RuleConverterBase } from './base-interfaces/rule-converter-base.js';
+import { createConversionResult } from './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 {
+    /**
+     * 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 RuleCategory.Comment:
+                return CommentRuleConverter.convertToAdg(rule);
+            case RuleCategory.Cosmetic:
+                return CosmeticRuleConverter.convertToAdg(rule);
+            case RuleCategory.Network:
+                // TODO: Handle hosts rules later
+                if (rule.type === NetworkRuleType.HostRule) {
+                    return createConversionResult([rule], false);
+                }
+                return NetworkRuleConverter.convertToAdg(rule);
+            case RuleCategory.Invalid:
+            case RuleCategory.Empty:
+                // Just forward the rule as is
+                return createConversionResult([rule], false);
+            default:
+                // Never happens during normal operation
+                throw new 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 === RuleCategory.Cosmetic) {
+            return CosmeticRuleConverter.convertToUbo(rule);
+        }
+        if (rule.category === RuleCategory.Network) {
+            return NetworkRuleConverter.convertToUbo(rule);
+        }
+        return createConversionResult([rule], false);
+    }
+}
+
+export { RuleConverter };

package/dist/deserializer/base-deserializer.js

@@ -0,0 +1,29 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { NotImplementedError } from '../errors/not-implemented-error.js';
+
+/**
+ * @file Base deserializer 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();
+    }
+}
+
+export { BaseDeserializer };

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

@@ -0,0 +1,79 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 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.js';
+import { CommentRuleType, RuleCategory } from '../../nodes/index.js';
+import { AdblockSyntax } from '../../utils/adblockers.js';
+import { BaseDeserializer } from '../base-deserializer.js';
+import { AgentCommentMarshallingMap } from '../../marshalling-utils/comment/agent-comment-common.js';
+import { AgentDeserializer } from './agent-deserializer.js';
+import { BinaryTypeMarshallingMap } from '../../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 {
+    /**
+     * 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(BinaryTypeMarshallingMap.AgentRuleNode);
+        node.type = CommentRuleType.AgentCommentRule;
+        node.syntax = AdblockSyntax.Common;
+        node.category = RuleCategory.Comment;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case AgentCommentMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint8());
+                    // read children
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        AgentDeserializer.deserialize(buffer, node.children[i] = {});
+                    }
+                    break;
+                case AgentCommentMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case AgentCommentMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+        // Maybe children are not present in the binary data,
+        // in this case, we should initialize it as an empty array.
+        if (!node.children) {
+            node.children = [];
+        }
+    }
+}
+
+export { AgentCommentDeserializer };

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

@@ -0,0 +1,65 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 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.js';
+import { BaseDeserializer } from '../base-deserializer.js';
+import { AgentNodeMarshallingMap, FREQUENT_AGENTS_DESERIALIZATION_MAP } from '../../marshalling-utils/comment/agent-common.js';
+import { getAdblockSyntax } from '../../common/agent-common.js';
+import { ValueDeserializer } from '../misc/value-deserializer.js';
+import { BinaryTypeMarshallingMap } from '../../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 {
+    /**
+     * 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(BinaryTypeMarshallingMap.AgentNode);
+        node.type = 'Agent';
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case AgentNodeMarshallingMap.Adblock:
+                    // eslint-disable-next-line max-len
+                    ValueDeserializer.deserialize(buffer, node.adblock = {}, FREQUENT_AGENTS_DESERIALIZATION_MAP);
+                    if (node.adblock) {
+                        node.syntax = getAdblockSyntax(node.adblock.value);
+                    }
+                    break;
+                case AgentNodeMarshallingMap.Version:
+                    ValueDeserializer.deserialize(buffer, node.version = {});
+                    break;
+                case AgentNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case AgentNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { AgentDeserializer };

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

@@ -0,0 +1,54 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { AgentCommentDeserializer } from './agent-comment-deserializer.js';
+import { ConfigCommentDeserializer } from './config-comment-deserializer.js';
+import { HintCommentDeserializer } from './hint-comment-deserializer.js';
+import { MetadataCommentDeserializer } from './metadata-comment-deserializer.js';
+import { PreProcessorCommentDeserializer } from './pre-processor-comment-deserializer.js';
+import { SimpleCommentDeserializer } from './simple-comment-deserializer.js';
+import { BaseDeserializer } from '../base-deserializer.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+
+/**
+ * `CommentRuleDeserializer` is responsible for deserializing any comment-like adblock rules.
+ */
+class CommentRuleDeserializer extends 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 BinaryTypeMarshallingMap.AgentRuleNode:
+                AgentCommentDeserializer.deserialize(buffer, node);
+                return;
+            case BinaryTypeMarshallingMap.HintRuleNode:
+                HintCommentDeserializer.deserialize(buffer, node);
+                return;
+            case BinaryTypeMarshallingMap.PreProcessorCommentRuleNode:
+                PreProcessorCommentDeserializer.deserialize(buffer, node);
+                return;
+            case BinaryTypeMarshallingMap.MetadataCommentRuleNode:
+                MetadataCommentDeserializer.deserialize(buffer, node);
+                return;
+            case BinaryTypeMarshallingMap.ConfigCommentRuleNode:
+                ConfigCommentDeserializer.deserialize(buffer, node);
+                return;
+            case BinaryTypeMarshallingMap.CommentRuleNode:
+                SimpleCommentDeserializer.deserialize(buffer, node);
+                return;
+            default:
+                throw new Error(`Unknown comment rule type: ${type}`);
+        }
+    }
+}
+
+export { CommentRuleDeserializer };

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

@@ -0,0 +1,111 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 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.js';
+import { CommentRuleType, RuleCategory } from '../../nodes/index.js';
+import { BaseDeserializer } from '../base-deserializer.js';
+import { ConfigNodeMarshallingMap, ConfigCommentRuleMarshallingMap, FREQUENT_COMMANDS_SERIALIZATION_MAP } from '../../marshalling-utils/comment/config-comment-common.js';
+import { AdblockSyntax } from '../../utils/adblockers.js';
+import { ValueDeserializer } from '../misc/value-deserializer.js';
+import { ParameterListDeserializer } from '../misc/parameter-list-deserializer.js';
+import { BinaryTypeMarshallingMap } from '../../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(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 {
+    /**
+     * 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(BinaryTypeMarshallingMap.ConfigNode);
+        node.type = 'ConfigNode';
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case 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 ConfigNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case 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(BinaryTypeMarshallingMap.ConfigCommentRuleNode);
+        node.type = CommentRuleType.ConfigCommentRule;
+        node.category = RuleCategory.Comment;
+        node.syntax = AdblockSyntax.Common;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case ConfigCommentRuleMarshallingMap.Marker:
+                    ValueDeserializer.deserialize(buffer, node.marker = {});
+                    break;
+                case ConfigCommentRuleMarshallingMap.Command:
+                    // eslint-disable-next-line max-len
+                    ValueDeserializer.deserialize(buffer, node.command = {}, getFrequentCommandsDeserializationMap());
+                    break;
+                case ConfigCommentRuleMarshallingMap.Params:
+                    if (buffer.peekUint8() === BinaryTypeMarshallingMap.ConfigNode) {
+                        ConfigCommentDeserializer.deserializeConfigNode(buffer, node.params = {});
+                    }
+                    else {
+                        ParameterListDeserializer.deserialize(buffer, node.params = {});
+                    }
+                    break;
+                case ConfigCommentRuleMarshallingMap.Comment:
+                    ValueDeserializer.deserialize(buffer, node.comment = {});
+                    break;
+                case ConfigCommentRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case ConfigCommentRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { ConfigCommentDeserializer };

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

@@ -0,0 +1,72 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 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.js';
+import { RuleCategory, CommentRuleType } from '../../nodes/index.js';
+import { HintDeserializer } from './hint-deserializer.js';
+import { AdblockSyntax } from '../../utils/adblockers.js';
+import { BaseDeserializer } from '../base-deserializer.js';
+import { HintCommentMarshallingMap } from '../../marshalling-utils/comment/hint-comment-common.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+import { getSyntaxDeserializationMap } from '../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 {
+    /**
+     * 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(BinaryTypeMarshallingMap.HintRuleNode);
+        node.category = RuleCategory.Comment;
+        node.type = CommentRuleType.HintCommentRule;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case HintCommentMarshallingMap.Syntax:
+                    node.syntax = getSyntaxDeserializationMap().get(buffer.readUint8()) ?? AdblockSyntax.Common;
+                    break;
+                case HintCommentMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint8());
+                    // read children
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        HintDeserializer.deserialize(buffer, node.children[i] = {});
+                    }
+                    break;
+                case HintCommentMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case HintCommentMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+        // Maybe children are not present in the binary data,
+        // in this case, we should initialize it as an empty array.
+        if (!node.children) {
+            node.children = [];
+        }
+    }
+}
+
+export { HintCommentDeserializer };

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

@@ -0,0 +1,85 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 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.js';
+import { BaseDeserializer } from '../base-deserializer.js';
+import { HintNodeMarshallingMap, FREQUENT_HINTS_SERIALIZATION_MAP, FREQUENT_PLATFORMS_SERIALIZATION_MAP } from '../../marshalling-utils/comment/hint-common.js';
+import { ValueDeserializer } from '../misc/value-deserializer.js';
+import { ParameterListDeserializer } from '../misc/parameter-list-deserializer.js';
+import { BinaryTypeMarshallingMap } from '../../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 frequentHintsDeserializationMap;
+const getFrequentHintsDeserializationMap = () => {
+    if (!frequentHintsDeserializationMap) {
+        frequentHintsDeserializationMap = new Map(Array.from(FREQUENT_HINTS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentHintsDeserializationMap;
+};
+/**
+ * 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 frequentPlatformsDeserializationMap;
+const getFrequentPlatformsDeserializationMap = () => {
+    if (!frequentPlatformsDeserializationMap) {
+        frequentPlatformsDeserializationMap = new Map(Array.from(FREQUENT_PLATFORMS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentPlatformsDeserializationMap;
+};
+/**
+ * `HintDeserializer` is responsible for deserializing AdGuard hints.
+ *
+ * @example
+ * If the hint rule is
+ * ```adblock
+ * !+ NOT_OPTIMIZED PLATFORM(windows)
+ * ```
+ * then the hints are `NOT_OPTIMIZED` and `PLATFORM(windows)`, and this
+ * class is responsible for parsing them. The rule itself is parsed by
+ * the `HintRuleParser`, which uses this class to parse single hints.
+ */
+class HintDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a hint 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(BinaryTypeMarshallingMap.HintNode);
+        node.type = 'Hint';
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case HintNodeMarshallingMap.Name:
+                    // eslint-disable-next-line max-len
+                    ValueDeserializer.deserialize(buffer, node.name = {}, getFrequentHintsDeserializationMap());
+                    break;
+                case HintNodeMarshallingMap.Params:
+                    // eslint-disable-next-line max-len
+                    ParameterListDeserializer.deserialize(buffer, node.params = {}, getFrequentPlatformsDeserializationMap());
+                    break;
+                case HintNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case HintNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { HintDeserializer, getFrequentPlatformsDeserializationMap };