@adguard/agtree 2.1.2 → 3.0.0-alpha.1

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

@@ -0,0 +1,88 @@
+/*
+ * 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 hintCommon = require('../../marshalling-utils/comment/hint-common.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 frequentHintsDeserializationMap;
+const getFrequentHintsDeserializationMap = () => {
+    if (!frequentHintsDeserializationMap) {
+        frequentHintsDeserializationMap = new Map(Array.from(hintCommon.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(hintCommon.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.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(binaryTypeCommon.BinaryTypeMarshallingMap.HintNode);
+        node.type = 'Hint';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case hintCommon.HintNodeMarshallingMap.Name:
+                    // eslint-disable-next-line max-len
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.name = {}, getFrequentHintsDeserializationMap());
+                    break;
+                case hintCommon.HintNodeMarshallingMap.Params:
+                    // eslint-disable-next-line max-len
+                    parameterListDeserializer.ParameterListDeserializer.deserialize(buffer, node.params = {}, getFrequentPlatformsDeserializationMap());
+                    break;
+                case hintCommon.HintNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case hintCommon.HintNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.HintDeserializer = HintDeserializer;
+exports.getFrequentPlatformsDeserializationMap = getFrequentPlatformsDeserializationMap;

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

@@ -0,0 +1,71 @@
+/*
+ * 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 metadataCommentCommon = require('../../marshalling-utils/comment/metadata-comment-common.js');
+var adblockers = require('../../utils/adblockers.js');
+var valueDeserializer = require('../misc/value-deserializer.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+/**
+ * `MetadataCommentDeserializer` is responsible for deserializing metadata comments.
+ * Metadata comments are special comments that specify some properties of the list.
+ *
+ * @example
+ * For example, in the case of
+ * ```adblock
+ * ! Title: My List
+ * ```
+ * the name of the header is `Title`, and the value is `My List`, which means that
+ * the list title is `My List`, and it can be used in the adblocker UI.
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#special-comments}
+ */
+class MetadataCommentDeserializer 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 deserialize(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.MetadataCommentRuleNode);
+        node.type = index.CommentRuleType.MetadataCommentRule;
+        node.category = index.RuleCategory.Comment;
+        node.syntax = adblockers.AdblockSyntax.Common;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case metadataCommentCommon.MetadataCommentMarshallingMap.Marker:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.marker = {});
+                    break;
+                case metadataCommentCommon.MetadataCommentMarshallingMap.Header:
+                    // eslint-disable-next-line max-len
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.header = {}, metadataCommentCommon.FREQUENT_HEADERS_DESERIALIZATION_MAP);
+                    break;
+                case metadataCommentCommon.MetadataCommentMarshallingMap.Value:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.value = {});
+                    break;
+                case metadataCommentCommon.MetadataCommentMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case metadataCommentCommon.MetadataCommentMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.MetadataCommentDeserializer = MetadataCommentDeserializer;

package/dist/cjs/deserializer/comment/pre-processor-comment-deserializer.js

@@ -0,0 +1,114 @@
+/*
+ * 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 preProcessorCommentCommon = require('../../marshalling-utils/comment/pre-processor-comment-common.js');
+var adblockers = require('../../utils/adblockers.js');
+var valueDeserializer = require('../misc/value-deserializer.js');
+var logicalExpressionDeserializer = require('../misc/logical-expression-deserializer.js');
+var parameterListDeserializer = require('../misc/parameter-list-deserializer.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+var syntaxDeserializationMap = require('../syntax-deserialization-map.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 frequentDirectivesDeserializationMap;
+const getFrequentDirectivesDeserializationMap = () => {
+    if (!frequentDirectivesDeserializationMap) {
+        frequentDirectivesDeserializationMap = new Map(Array.from(preProcessorCommentCommon.FREQUENT_DIRECTIVES_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentDirectivesDeserializationMap;
+};
+/**
+ * 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 frequentParamsDeserializationMap;
+const getFrequentParamsDeserializationMap = () => {
+    if (!frequentParamsDeserializationMap) {
+        frequentParamsDeserializationMap = new Map(Array.from(preProcessorCommentCommon.FREQUENT_PARAMS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentParamsDeserializationMap;
+};
+/**
+ * `PreProcessorCommentDeserializer` is responsible for deserializing preprocessor rules.
+ * Pre-processor comments are special comments that are used to control the behavior of the filter list processor.
+ * Please note that this parser only handles general syntax for now, and does not validate the parameters at
+ * the parsing stage.
+ *
+ * @example
+ * If your rule is
+ * ```adblock
+ * !#if (adguard)
+ * ```
+ * then the directive's name is `if` and its value is `(adguard)`, but the parameter list
+ * is not parsed / validated further.
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#pre-processor-directives}
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#pre-parsing-directives}
+ */
+class PreProcessorCommentDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a pre-processor 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.PreProcessorCommentRuleNode);
+        node.type = index.CommentRuleType.PreProcessorCommentRule;
+        node.category = index.RuleCategory.Comment;
+        node.syntax = adblockers.AdblockSyntax.Common;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case preProcessorCommentCommon.PreProcessorRuleMarshallingMap.Name:
+                    // eslint-disable-next-line max-len
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.name = {}, getFrequentDirectivesDeserializationMap());
+                    break;
+                case preProcessorCommentCommon.PreProcessorRuleMarshallingMap.Syntax:
+                    node.syntax = syntaxDeserializationMap.getSyntaxDeserializationMap().get(buffer.readUint8()) ?? adblockers.AdblockSyntax.Common;
+                    break;
+                case preProcessorCommentCommon.PreProcessorRuleMarshallingMap.Params:
+                    switch (buffer.peekUint8()) {
+                        case binaryTypeCommon.BinaryTypeMarshallingMap.ValueNode:
+                            valueDeserializer.ValueDeserializer.deserialize(buffer, node.params = {});
+                            break;
+                        case binaryTypeCommon.BinaryTypeMarshallingMap.ParameterListNode:
+                            // eslint-disable-next-line max-len
+                            parameterListDeserializer.ParameterListDeserializer.deserialize(buffer, node.params = {}, getFrequentParamsDeserializationMap());
+                            break;
+                        case binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionOperatorNode:
+                        case binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionParenthesisNode:
+                        case binaryTypeCommon.BinaryTypeMarshallingMap.ExpressionVariableNode:
+                            logicalExpressionDeserializer.LogicalExpressionDeserializer.deserialize(buffer, node.params = {});
+                            break;
+                        default:
+                            throw new Error(`Invalid binary type: ${prop}`);
+                    }
+                    break;
+                case preProcessorCommentCommon.PreProcessorRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case preProcessorCommentCommon.PreProcessorRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.PreProcessorCommentDeserializer = PreProcessorCommentDeserializer;

package/dist/cjs/deserializer/comment/simple-comment-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 index = require('../../nodes/index.js');
+var baseDeserializer = require('../base-deserializer.js');
+var adblockers = require('../../utils/adblockers.js');
+var simpleCommentCommon = require('../../marshalling-utils/comment/simple-comment-common.js');
+var valueDeserializer = require('../misc/value-deserializer.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+/**
+ * `SimpleCommentDeserializer` is responsible for deserializing simple comments.
+ *
+ * Some comments have a special meaning in adblock syntax, like agent comments or hints,
+ * but this parser is only responsible for parsing regular comments,
+ * whose only purpose is to provide some human-readable information.
+ *
+ * @example
+ * ```adblock
+ * ! This is a simple comment
+ * # This is a simple comment, but in host-like syntax
+ * ```
+ */
+class SimpleCommentDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a simple 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.CommentRuleNode);
+        node.type = index.CommentRuleType.CommentRule;
+        node.category = index.RuleCategory.Comment;
+        node.syntax = adblockers.AdblockSyntax.Common;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case simpleCommentCommon.SimpleCommentMarshallingMap.Marker:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.marker = {});
+                    break;
+                case simpleCommentCommon.SimpleCommentMarshallingMap.Text:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.text = {});
+                    break;
+                case simpleCommentCommon.SimpleCommentMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case simpleCommentCommon.SimpleCommentMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.SimpleCommentDeserializer = SimpleCommentDeserializer;

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

@@ -0,0 +1,127 @@
+/*
+ * 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 adblockers = require('../../utils/adblockers.js');
+var domainListDeserializer = require('../misc/domain-list-deserializer.js');
+var constants = require('../../utils/constants.js');
+var index = require('../../nodes/index.js');
+var abpSnippetInjectionBodyDeserializer = require('./scriptlet-body/abp-snippet-injection-body-deserializer.js');
+var uboScriptletInjectionBodyDeserializer = require('./scriptlet-body/ubo-scriptlet-injection-body-deserializer.js');
+var adgScriptletInjectionBodyDeserializer = require('./scriptlet-body/adg-scriptlet-injection-body-deserializer.js');
+var valueDeserializer = require('../misc/value-deserializer.js');
+var typeGuards = require('../../utils/type-guards.js');
+var baseDeserializer = require('../base-deserializer.js');
+var elementHidingBodyDeserializer = require('./element-hiding-body-deserializer.js');
+var cssInjectionBodyDeserializer = require('./css-injection-body-deserializer.js');
+var modifierListDeserializer = require('../misc/modifier-list-deserializer.js');
+var cosmeticRuleCommon = require('../../marshalling-utils/cosmetic/cosmetic-rule-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+var syntaxDeserializationMap = require('../syntax-deserialization-map.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 cosmeticRuleSeparatorDeserializationMap;
+const getCosmeticRuleSeparatorDeserializationMap = () => {
+    if (!cosmeticRuleSeparatorDeserializationMap) {
+        cosmeticRuleSeparatorDeserializationMap = new Map(Array.from(cosmeticRuleCommon.COSMETIC_RULE_SEPARATOR_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return cosmeticRuleSeparatorDeserializationMap;
+};
+/**
+ * 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.
+ */
+const COSMETIC_RULE_TYPE_DESERIALIZATION_MAP = new Map([
+    [binaryTypeCommon.BinaryTypeMarshallingMap.ElementHidingRule, index.CosmeticRuleType.ElementHidingRule],
+    [binaryTypeCommon.BinaryTypeMarshallingMap.CssInjectionRule, index.CosmeticRuleType.CssInjectionRule],
+    [binaryTypeCommon.BinaryTypeMarshallingMap.ScriptletInjectionRule, index.CosmeticRuleType.ScriptletInjectionRule],
+    [binaryTypeCommon.BinaryTypeMarshallingMap.JsInjectionRule, index.CosmeticRuleType.JsInjectionRule],
+    [binaryTypeCommon.BinaryTypeMarshallingMap.HtmlFilteringRule, index.CosmeticRuleType.HtmlFilteringRule],
+]);
+class CosmeticRuleDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a cosmetic rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        const type = COSMETIC_RULE_TYPE_DESERIALIZATION_MAP.get(buffer.readUint8());
+        if (typeGuards.isUndefined(type)) {
+            throw new Error(`Unknown rule type: ${type}`);
+        }
+        node.type = type;
+        node.category = index.RuleCategory.Cosmetic;
+        const syntax = syntaxDeserializationMap.getSyntaxDeserializationMap().get(buffer.readUint8()) ?? adblockers.AdblockSyntax.Common;
+        node.syntax = syntax;
+        node.modifiers = undefined;
+        switch (type) {
+            case index.CosmeticRuleType.ElementHidingRule:
+                elementHidingBodyDeserializer.ElementHidingBodyDeserializer.deserializeElementHidingBody(buffer, node.body = {});
+                break;
+            case index.CosmeticRuleType.CssInjectionRule:
+                cssInjectionBodyDeserializer.CssInjectionBodyDeserializer.deserialize(buffer, node.body = {});
+                break;
+            case index.CosmeticRuleType.JsInjectionRule:
+                valueDeserializer.ValueDeserializer.deserialize(buffer, node.body = {});
+                break;
+            case index.CosmeticRuleType.HtmlFilteringRule:
+                valueDeserializer.ValueDeserializer.deserialize(buffer, node.body = {});
+                break;
+            case index.CosmeticRuleType.ScriptletInjectionRule:
+                switch (syntax) {
+                    case adblockers.AdblockSyntax.Adg:
+                        adgScriptletInjectionBodyDeserializer.AdgScriptletInjectionBodyDeserializer.deserialize(buffer, node.body = {});
+                        break;
+                    case adblockers.AdblockSyntax.Abp:
+                        abpSnippetInjectionBodyDeserializer.AbpSnippetInjectionBodyDeserializer.deserialize(buffer, node.body = {});
+                        break;
+                    case adblockers.AdblockSyntax.Ubo:
+                        uboScriptletInjectionBodyDeserializer.UboScriptletInjectionBodyDeserializer.deserialize(buffer, node.body = {});
+                        break;
+                    default:
+                        throw new Error('Scriptlet rule should have an explicit syntax');
+                }
+                break;
+            default:
+                throw new Error('Unknown cosmetic rule type');
+        }
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case cosmeticRuleCommon.CosmeticRuleMarshallingMap.Exception:
+                    node.exception = buffer.readUint8() === 1;
+                    break;
+                case cosmeticRuleCommon.CosmeticRuleMarshallingMap.Separator:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.separator = {}, getCosmeticRuleSeparatorDeserializationMap());
+                    break;
+                case cosmeticRuleCommon.CosmeticRuleMarshallingMap.Modifiers:
+                    node.modifiers = {};
+                    modifierListDeserializer.ModifierListDeserializer.deserialize(buffer, node.modifiers);
+                    break;
+                case cosmeticRuleCommon.CosmeticRuleMarshallingMap.Domains:
+                    domainListDeserializer.DomainListDeserializer.deserialize(buffer, node.domains = {});
+                    break;
+                case cosmeticRuleCommon.CosmeticRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case cosmeticRuleCommon.CosmeticRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Unknown property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.CosmeticRuleDeserializer = CosmeticRuleDeserializer;

package/dist/cjs/deserializer/cosmetic/css-injection-body-deserializer.js

@@ -0,0 +1,55 @@
+/*
+ * 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 valueDeserializer = require('../misc/value-deserializer.js');
+var constants = require('../../utils/constants.js');
+var baseDeserializer = require('../base-deserializer.js');
+var cssInjectionBodyCommon = require('../../marshalling-utils/cosmetic/body/css-injection-body-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+class CssInjectionBodyDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes CSS injection rule body node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.CssInjectionRuleBody);
+        node.type = 'CssInjectionRuleBody';
+        node.remove = false;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.MediaQueryList:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.mediaQueryList = {});
+                    break;
+                case cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.SelectorList:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.selectorList = {});
+                    break;
+                case cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.DeclarationList:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.declarationList = {});
+                    break;
+                case cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.Remove:
+                    node.remove = true;
+                    break;
+                case cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Unknown property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.CssInjectionBodyDeserializer = CssInjectionBodyDeserializer;

package/dist/cjs/deserializer/cosmetic/element-hiding-body-deserializer.js

@@ -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
+ */
+'use strict';
+
+var baseDeserializer = require('../base-deserializer.js');
+var constants = require('../../utils/constants.js');
+var elementHidingBodyCommon = require('../../marshalling-utils/cosmetic/body/element-hiding-body-common.js');
+var valueDeserializer = require('../misc/value-deserializer.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+class ElementHidingBodyDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes an element hiding rule body node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserializeElementHidingBody(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ElementHidingRuleBody);
+        node.type = 'ElementHidingRuleBody';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case elementHidingBodyCommon.ElementHidingRuleMarshallingMap.SelectorList:
+                    valueDeserializer.ValueDeserializer.deserialize(buffer, node.selectorList = {});
+                    break;
+                case elementHidingBodyCommon.ElementHidingRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case elementHidingBodyCommon.ElementHidingRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Unknown property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.ElementHidingBodyDeserializer = ElementHidingBodyDeserializer;

package/dist/cjs/deserializer/cosmetic/scriptlet-body/abp-snippet-injection-body-deserializer.js

@@ -0,0 +1,37 @@
+/*
+ * 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 baseDeserializer = require('../../base-deserializer.js');
+var scriptletBodyDeserializer = require('./scriptlet-body-deserializer.js');
+var abpSnippetInjectionBodyCommon = require('../../../marshalling-utils/cosmetic/body/abp-snippet-injection-body-common.js');
+
+/**
+ * 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 frequentAbpSnippetArgsDeserializationMap;
+const getFrequentAbpSnippetArgsDeserializationMap = () => {
+    if (!frequentAbpSnippetArgsDeserializationMap) {
+        frequentAbpSnippetArgsDeserializationMap = new Map(Array.from(abpSnippetInjectionBodyCommon.FREQUENT_ABP_SNIPPET_ARGS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentAbpSnippetArgsDeserializationMap;
+};
+class AbpSnippetInjectionBodyDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a scriptlet call body 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) {
+        scriptletBodyDeserializer.ScriptletBodyDeserializer.deserialize(buffer, node, getFrequentAbpSnippetArgsDeserializationMap());
+    }
+}
+
+exports.AbpSnippetInjectionBodyDeserializer = AbpSnippetInjectionBodyDeserializer;

package/dist/cjs/deserializer/cosmetic/scriptlet-body/adg-scriptlet-injection-body-deserializer.js

@@ -0,0 +1,37 @@
+/*
+ * 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 baseDeserializer = require('../../base-deserializer.js');
+var scriptletBodyDeserializer = require('./scriptlet-body-deserializer.js');
+var adgScriptletInjectionBodyCommon = require('../../../marshalling-utils/cosmetic/body/adg-scriptlet-injection-body-common.js');
+
+/**
+ * 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 frequentAdgScriptletArgsDeserializationMap;
+const getFrequentAdgScriptletArgsDeserializationMap = () => {
+    if (!frequentAdgScriptletArgsDeserializationMap) {
+        frequentAdgScriptletArgsDeserializationMap = new Map(Array.from(adgScriptletInjectionBodyCommon.FREQUENT_ADG_SCRIPTLET_ARGS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentAdgScriptletArgsDeserializationMap;
+};
+class AdgScriptletInjectionBodyDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a scriptlet call body 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) {
+        scriptletBodyDeserializer.ScriptletBodyDeserializer.deserialize(buffer, node, getFrequentAdgScriptletArgsDeserializationMap());
+    }
+}
+
+exports.AdgScriptletInjectionBodyDeserializer = AdgScriptletInjectionBodyDeserializer;