@adguard/agtree 2.2.0 → 3.0.0-alpha.2

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

@@ -0,0 +1,69 @@
+/*
+ * 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 { MetadataCommentMarshallingMap, FREQUENT_HEADERS_DESERIALIZATION_MAP } from '../../marshalling-utils/comment/metadata-comment-common.js';
+import { AdblockSyntax } from '../../utils/adblockers.js';
+import { ValueDeserializer } from '../misc/value-deserializer.js';
+import { BinaryTypeMarshallingMap } from '../../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 {
+    /**
+     * 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.MetadataCommentRuleNode);
+        node.type = CommentRuleType.MetadataCommentRule;
+        node.category = RuleCategory.Comment;
+        node.syntax = AdblockSyntax.Common;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case MetadataCommentMarshallingMap.Marker:
+                    ValueDeserializer.deserialize(buffer, node.marker = {});
+                    break;
+                case MetadataCommentMarshallingMap.Header:
+                    // eslint-disable-next-line max-len
+                    ValueDeserializer.deserialize(buffer, node.header = {}, FREQUENT_HEADERS_DESERIALIZATION_MAP);
+                    break;
+                case MetadataCommentMarshallingMap.Value:
+                    ValueDeserializer.deserialize(buffer, node.value = {});
+                    break;
+                case MetadataCommentMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case MetadataCommentMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { MetadataCommentDeserializer };

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

@@ -0,0 +1,112 @@
+/*
+ * 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 { PreProcessorRuleMarshallingMap, FREQUENT_DIRECTIVES_SERIALIZATION_MAP, FREQUENT_PARAMS_SERIALIZATION_MAP } from '../../marshalling-utils/comment/pre-processor-comment-common.js';
+import { AdblockSyntax } from '../../utils/adblockers.js';
+import { ValueDeserializer } from '../misc/value-deserializer.js';
+import { LogicalExpressionDeserializer } from '../misc/logical-expression-deserializer.js';
+import { ParameterListDeserializer } from '../misc/parameter-list-deserializer.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+import { getSyntaxDeserializationMap } from '../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(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(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 {
+    /**
+     * 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(BinaryTypeMarshallingMap.PreProcessorCommentRuleNode);
+        node.type = CommentRuleType.PreProcessorCommentRule;
+        node.category = RuleCategory.Comment;
+        node.syntax = AdblockSyntax.Common;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case PreProcessorRuleMarshallingMap.Name:
+                    // eslint-disable-next-line max-len
+                    ValueDeserializer.deserialize(buffer, node.name = {}, getFrequentDirectivesDeserializationMap());
+                    break;
+                case PreProcessorRuleMarshallingMap.Syntax:
+                    node.syntax = getSyntaxDeserializationMap().get(buffer.readUint8()) ?? AdblockSyntax.Common;
+                    break;
+                case PreProcessorRuleMarshallingMap.Params:
+                    switch (buffer.peekUint8()) {
+                        case BinaryTypeMarshallingMap.ValueNode:
+                            ValueDeserializer.deserialize(buffer, node.params = {});
+                            break;
+                        case BinaryTypeMarshallingMap.ParameterListNode:
+                            // eslint-disable-next-line max-len
+                            ParameterListDeserializer.deserialize(buffer, node.params = {}, getFrequentParamsDeserializationMap());
+                            break;
+                        case BinaryTypeMarshallingMap.ExpressionOperatorNode:
+                        case BinaryTypeMarshallingMap.ExpressionParenthesisNode:
+                        case BinaryTypeMarshallingMap.ExpressionVariableNode:
+                            LogicalExpressionDeserializer.deserialize(buffer, node.params = {});
+                            break;
+                        default:
+                            throw new Error(`Invalid binary type: ${prop}`);
+                    }
+                    break;
+                case PreProcessorRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case PreProcessorRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { PreProcessorCommentDeserializer };

package/dist/deserializer/comment/simple-comment-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 { CommentRuleType, RuleCategory } from '../../nodes/index.js';
+import { BaseDeserializer } from '../base-deserializer.js';
+import { AdblockSyntax } from '../../utils/adblockers.js';
+import { SimpleCommentMarshallingMap } from '../../marshalling-utils/comment/simple-comment-common.js';
+import { ValueDeserializer } from '../misc/value-deserializer.js';
+import { BinaryTypeMarshallingMap } from '../../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 {
+    /**
+     * 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(BinaryTypeMarshallingMap.CommentRuleNode);
+        node.type = CommentRuleType.CommentRule;
+        node.category = RuleCategory.Comment;
+        node.syntax = AdblockSyntax.Common;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case SimpleCommentMarshallingMap.Marker:
+                    ValueDeserializer.deserialize(buffer, node.marker = {});
+                    break;
+                case SimpleCommentMarshallingMap.Text:
+                    ValueDeserializer.deserialize(buffer, node.text = {});
+                    break;
+                case SimpleCommentMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case SimpleCommentMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { SimpleCommentDeserializer };

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

@@ -0,0 +1,131 @@
+/*
+ * 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 { AdblockSyntax } from '../../utils/adblockers.js';
+import { DomainListDeserializer } from '../misc/domain-list-deserializer.js';
+import { NULL } from '../../utils/constants.js';
+import { CosmeticRuleType, RuleCategory } from '../../nodes/index.js';
+import { AbpSnippetInjectionBodyDeserializer } from './scriptlet-body/abp-snippet-injection-body-deserializer.js';
+import { UboScriptletInjectionBodyDeserializer } from './scriptlet-body/ubo-scriptlet-injection-body-deserializer.js';
+import { AdgScriptletInjectionBodyDeserializer } from './scriptlet-body/adg-scriptlet-injection-body-deserializer.js';
+import { ValueDeserializer } from '../misc/value-deserializer.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { BaseDeserializer } from '../base-deserializer.js';
+import { ElementHidingBodyDeserializer } from './element-hiding-body-deserializer.js';
+import { CssInjectionBodyDeserializer } from './css-injection-body-deserializer.js';
+import { ModifierListDeserializer } from '../misc/modifier-list-deserializer.js';
+import { CosmeticRuleMarshallingMap, COSMETIC_RULE_SEPARATOR_SERIALIZATION_MAP } from '../../marshalling-utils/cosmetic/cosmetic-rule-common.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+import { getSyntaxDeserializationMap } from '../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(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([
+    [BinaryTypeMarshallingMap.ElementHidingRule, CosmeticRuleType.ElementHidingRule],
+    [BinaryTypeMarshallingMap.CssInjectionRule, CosmeticRuleType.CssInjectionRule],
+    [BinaryTypeMarshallingMap.ScriptletInjectionRule, CosmeticRuleType.ScriptletInjectionRule],
+    [BinaryTypeMarshallingMap.JsInjectionRule, CosmeticRuleType.JsInjectionRule],
+    [BinaryTypeMarshallingMap.HtmlFilteringRule, CosmeticRuleType.HtmlFilteringRule],
+]);
+/**
+ * Deserializer for cosmetic rules.
+ * Converts binary data into structured cosmetic rule nodes, supporting various types
+ * like element hiding, CSS injection, scriptlet injection, JavaScript injection, and HTML filtering.
+ * Handles rule type, syntax, exceptions, separators, modifiers, and domain lists.
+ */
+class CosmeticRuleDeserializer extends 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 (isUndefined(type)) {
+            throw new Error(`Unknown rule type: ${type}`);
+        }
+        node.type = type;
+        node.category = RuleCategory.Cosmetic;
+        const syntax = getSyntaxDeserializationMap().get(buffer.readUint8()) ?? AdblockSyntax.Common;
+        node.syntax = syntax;
+        node.modifiers = undefined;
+        switch (type) {
+            case CosmeticRuleType.ElementHidingRule:
+                ElementHidingBodyDeserializer.deserializeElementHidingBody(buffer, node.body = {});
+                break;
+            case CosmeticRuleType.CssInjectionRule:
+                CssInjectionBodyDeserializer.deserialize(buffer, node.body = {});
+                break;
+            case CosmeticRuleType.JsInjectionRule:
+                ValueDeserializer.deserialize(buffer, node.body = {});
+                break;
+            case CosmeticRuleType.HtmlFilteringRule:
+                ValueDeserializer.deserialize(buffer, node.body = {});
+                break;
+            case CosmeticRuleType.ScriptletInjectionRule:
+                switch (syntax) {
+                    case AdblockSyntax.Adg:
+                        AdgScriptletInjectionBodyDeserializer.deserialize(buffer, node.body = {});
+                        break;
+                    case AdblockSyntax.Abp:
+                        AbpSnippetInjectionBodyDeserializer.deserialize(buffer, node.body = {});
+                        break;
+                    case AdblockSyntax.Ubo:
+                        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 !== NULL) {
+            switch (prop) {
+                case CosmeticRuleMarshallingMap.Exception:
+                    node.exception = buffer.readUint8() === 1;
+                    break;
+                case CosmeticRuleMarshallingMap.Separator:
+                    ValueDeserializer.deserialize(buffer, node.separator = {}, getCosmeticRuleSeparatorDeserializationMap());
+                    break;
+                case CosmeticRuleMarshallingMap.Modifiers:
+                    node.modifiers = {};
+                    ModifierListDeserializer.deserialize(buffer, node.modifiers);
+                    break;
+                case CosmeticRuleMarshallingMap.Domains:
+                    DomainListDeserializer.deserialize(buffer, node.domains = {});
+                    break;
+                case CosmeticRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case CosmeticRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Unknown property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { CosmeticRuleDeserializer };

package/dist/deserializer/cosmetic/css-injection-body-deserializer.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 { ValueDeserializer } from '../misc/value-deserializer.js';
+import { NULL } from '../../utils/constants.js';
+import { BaseDeserializer } from '../base-deserializer.js';
+import { CssInjectionRuleMarshallingMap } from '../../marshalling-utils/cosmetic/body/css-injection-body-common.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+
+/**
+ * Deserializes CSS injection rule body nodes from binary format.
+ */
+class CssInjectionBodyDeserializer extends 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(BinaryTypeMarshallingMap.CssInjectionRuleBody);
+        node.type = 'CssInjectionRuleBody';
+        node.remove = false;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case CssInjectionRuleMarshallingMap.MediaQueryList:
+                    ValueDeserializer.deserialize(buffer, node.mediaQueryList = {});
+                    break;
+                case CssInjectionRuleMarshallingMap.SelectorList:
+                    ValueDeserializer.deserialize(buffer, node.selectorList = {});
+                    break;
+                case CssInjectionRuleMarshallingMap.DeclarationList:
+                    ValueDeserializer.deserialize(buffer, node.declarationList = {});
+                    break;
+                case CssInjectionRuleMarshallingMap.Remove:
+                    node.remove = true;
+                    break;
+                case CssInjectionRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case CssInjectionRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Unknown property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { CssInjectionBodyDeserializer };

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

@@ -0,0 +1,48 @@
+/*
+ * 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 { BaseDeserializer } from '../base-deserializer.js';
+import { NULL } from '../../utils/constants.js';
+import { ElementHidingRuleMarshallingMap } from '../../marshalling-utils/cosmetic/body/element-hiding-body-common.js';
+import { ValueDeserializer } from '../misc/value-deserializer.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+
+/* eslint-disable no-param-reassign */
+/**
+ * Deserializes element hiding rule body nodes from binary data.
+ * Populates the provided node with the deserialized data.
+ */
+class ElementHidingBodyDeserializer extends 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(BinaryTypeMarshallingMap.ElementHidingRuleBody);
+        node.type = 'ElementHidingRuleBody';
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case ElementHidingRuleMarshallingMap.SelectorList:
+                    ValueDeserializer.deserialize(buffer, node.selectorList = {});
+                    break;
+                case ElementHidingRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case ElementHidingRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Unknown property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { ElementHidingBodyDeserializer };

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

@@ -0,0 +1,39 @@
+/*
+ * 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 { BaseDeserializer } from '../../base-deserializer.js';
+import { ScriptletBodyDeserializer } from './scriptlet-body-deserializer.js';
+import { FREQUENT_ABP_SNIPPET_ARGS_SERIALIZATION_MAP } from '../../../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(FREQUENT_ABP_SNIPPET_ARGS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentAbpSnippetArgsDeserializationMap;
+};
+/**
+ * Deserializer for ABP snippet injection rule body nodes.
+ * Converts binary data into a structured format using a map of frequently used arguments.
+ */
+class AbpSnippetInjectionBodyDeserializer extends 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.deserialize(buffer, node, getFrequentAbpSnippetArgsDeserializationMap());
+    }
+}
+
+export { AbpSnippetInjectionBodyDeserializer };

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

@@ -0,0 +1,40 @@
+/*
+ * 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 { BaseDeserializer } from '../../base-deserializer.js';
+import { ScriptletBodyDeserializer } from './scriptlet-body-deserializer.js';
+import { FREQUENT_ADG_SCRIPTLET_ARGS_SERIALIZATION_MAP } from '../../../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(FREQUENT_ADG_SCRIPTLET_ARGS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentAdgScriptletArgsDeserializationMap;
+};
+/**
+ * Deserializer for AdGuard scriptlet injection body nodes.
+ * Converts binary data into a structured scriptlet call body node specific to AdGuard,
+ * using a predefined deserialization map for frequently used scriptlet arguments.
+ */
+class AdgScriptletInjectionBodyDeserializer extends 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.deserialize(buffer, node, getFrequentAdgScriptletArgsDeserializationMap());
+    }
+}
+
+export { AdgScriptletInjectionBodyDeserializer };

package/dist/deserializer/cosmetic/scriptlet-body/scriptlet-body-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 { NULL } from '../../../utils/constants.js';
+import { ParameterListDeserializer } from '../../misc/parameter-list-deserializer.js';
+import { BaseDeserializer } from '../../base-deserializer.js';
+import { AbpSnippetBodyMarshallingMap } from '../../../marshalling-utils/cosmetic/body/abp-snippet-injection-body-common.js';
+import { BinaryTypeMarshallingMap } from '../../../marshalling-utils/misc/binary-type-common.js';
+
+/**
+ * Deserializes binary data into scriptlet body nodes.
+ * Optionally uses a map of frequently used scriptlet arguments.
+ */
+class ScriptletBodyDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a hint rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @param frequentScriptletArgs Map of frequently used scriptlet names / arguments
+     * and their serialization index (optional).
+     * @throws If the binary data is malformed.
+     */
+    static deserialize = (buffer, node, frequentScriptletArgs) => {
+        buffer.assertUint8(BinaryTypeMarshallingMap.ScriptletInjectionRuleBodyNode);
+        node.type = 'ScriptletInjectionRuleBody';
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case AbpSnippetBodyMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint8());
+                    // read children
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        ParameterListDeserializer.deserialize(buffer, node.children[i] = {}, frequentScriptletArgs);
+                    }
+                    break;
+                case AbpSnippetBodyMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case AbpSnippetBodyMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    };
+}
+
+export { ScriptletBodyDeserializer };

package/dist/deserializer/cosmetic/scriptlet-body/ubo-scriptlet-injection-body-deserializer.js

@@ -0,0 +1,38 @@
+/*
+ * 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 { BaseDeserializer } from '../../base-deserializer.js';
+import { ScriptletBodyDeserializer } from './scriptlet-body-deserializer.js';
+import { FREQUENT_UBO_SCRIPTLET_ARGS_SERIALIZATION_MAP } from '../../../marshalling-utils/cosmetic/body/ubo-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 frequentUboScriptletArgsDeserializationMap;
+const getFrequentPlatformsDeserializationMap = () => {
+    if (!frequentUboScriptletArgsDeserializationMap) {
+        frequentUboScriptletArgsDeserializationMap = new Map(Array.from(FREQUENT_UBO_SCRIPTLET_ARGS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentUboScriptletArgsDeserializationMap;
+};
+/**
+ * Deserializes uBlock Origin scriptlet injection body nodes from binary data.
+ */
+class UboScriptletInjectionBodyDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a scriptlet call body node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node to populate with deserialized data.
+     * @throws If the binary data is malformed.
+     */
+    static deserialize(buffer, node) {
+        ScriptletBodyDeserializer.deserialize(buffer, node, getFrequentPlatformsDeserializationMap());
+    }
+}
+
+export { UboScriptletInjectionBodyDeserializer, getFrequentPlatformsDeserializationMap };