@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/esm/deserializer/comment/pre-processor-comment-deserializer.mjs

@@ -0,0 +1,112 @@
+/*
+ * 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
+ */
+import { NULL } from '../../utils/constants.mjs';
+import { CommentRuleType, RuleCategory } from '../../nodes/index.mjs';
+import { BaseDeserializer } from '../base-deserializer.mjs';
+import { PreProcessorRuleMarshallingMap, FREQUENT_DIRECTIVES_SERIALIZATION_MAP, FREQUENT_PARAMS_SERIALIZATION_MAP } from '../../marshalling-utils/comment/pre-processor-comment-common.mjs';
+import { AdblockSyntax } from '../../utils/adblockers.mjs';
+import { ValueDeserializer } from '../misc/value-deserializer.mjs';
+import { LogicalExpressionDeserializer } from '../misc/logical-expression-deserializer.mjs';
+import { ParameterListDeserializer } from '../misc/parameter-list-deserializer.mjs';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.mjs';
+import { getSyntaxDeserializationMap } from '../syntax-deserialization-map.mjs';
+
+/* 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/esm/deserializer/comment/simple-comment-deserializer.mjs

@@ -0,0 +1,65 @@
+/*
+ * 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
+ */
+import { NULL } from '../../utils/constants.mjs';
+import { CommentRuleType, RuleCategory } from '../../nodes/index.mjs';
+import { BaseDeserializer } from '../base-deserializer.mjs';
+import { AdblockSyntax } from '../../utils/adblockers.mjs';
+import { SimpleCommentMarshallingMap } from '../../marshalling-utils/comment/simple-comment-common.mjs';
+import { ValueDeserializer } from '../misc/value-deserializer.mjs';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.mjs';
+
+/* 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/esm/deserializer/cosmetic/cosmetic-rule-deserializer.mjs

@@ -0,0 +1,125 @@
+/*
+ * 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
+ */
+import { AdblockSyntax } from '../../utils/adblockers.mjs';
+import { DomainListDeserializer } from '../misc/domain-list-deserializer.mjs';
+import { NULL } from '../../utils/constants.mjs';
+import { CosmeticRuleType, RuleCategory } from '../../nodes/index.mjs';
+import { AbpSnippetInjectionBodyDeserializer } from './scriptlet-body/abp-snippet-injection-body-deserializer.mjs';
+import { UboScriptletInjectionBodyDeserializer } from './scriptlet-body/ubo-scriptlet-injection-body-deserializer.mjs';
+import { AdgScriptletInjectionBodyDeserializer } from './scriptlet-body/adg-scriptlet-injection-body-deserializer.mjs';
+import { ValueDeserializer } from '../misc/value-deserializer.mjs';
+import { isUndefined } from '../../utils/type-guards.mjs';
+import { BaseDeserializer } from '../base-deserializer.mjs';
+import { ElementHidingBodyDeserializer } from './element-hiding-body-deserializer.mjs';
+import { CssInjectionBodyDeserializer } from './css-injection-body-deserializer.mjs';
+import { ModifierListDeserializer } from '../misc/modifier-list-deserializer.mjs';
+import { CosmeticRuleMarshallingMap, COSMETIC_RULE_SEPARATOR_SERIALIZATION_MAP } from '../../marshalling-utils/cosmetic/cosmetic-rule-common.mjs';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.mjs';
+import { getSyntaxDeserializationMap } from '../syntax-deserialization-map.mjs';
+
+/* 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],
+]);
+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/esm/deserializer/cosmetic/css-injection-body-deserializer.mjs

@@ -0,0 +1,53 @@
+/*
+ * 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
+ */
+import { ValueDeserializer } from '../misc/value-deserializer.mjs';
+import { NULL } from '../../utils/constants.mjs';
+import { BaseDeserializer } from '../base-deserializer.mjs';
+import { CssInjectionRuleMarshallingMap } from '../../marshalling-utils/cosmetic/body/css-injection-body-common.mjs';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.mjs';
+
+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/esm/deserializer/cosmetic/element-hiding-body-deserializer.mjs

@@ -0,0 +1,44 @@
+/*
+ * 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
+ */
+import { BaseDeserializer } from '../base-deserializer.mjs';
+import { NULL } from '../../utils/constants.mjs';
+import { ElementHidingRuleMarshallingMap } from '../../marshalling-utils/cosmetic/body/element-hiding-body-common.mjs';
+import { ValueDeserializer } from '../misc/value-deserializer.mjs';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.mjs';
+
+/* eslint-disable no-param-reassign */
+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/esm/deserializer/cosmetic/scriptlet-body/abp-snippet-injection-body-deserializer.mjs

@@ -0,0 +1,35 @@
+/*
+ * 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
+ */
+import { BaseDeserializer } from '../../base-deserializer.mjs';
+import { ScriptletBodyDeserializer } from './scriptlet-body-deserializer.mjs';
+import { FREQUENT_ABP_SNIPPET_ARGS_SERIALIZATION_MAP } from '../../../marshalling-utils/cosmetic/body/abp-snippet-injection-body-common.mjs';
+
+/**
+ * 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;
+};
+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/esm/deserializer/cosmetic/scriptlet-body/adg-scriptlet-injection-body-deserializer.mjs

@@ -0,0 +1,35 @@
+/*
+ * 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
+ */
+import { BaseDeserializer } from '../../base-deserializer.mjs';
+import { ScriptletBodyDeserializer } from './scriptlet-body-deserializer.mjs';
+import { FREQUENT_ADG_SCRIPTLET_ARGS_SERIALIZATION_MAP } from '../../../marshalling-utils/cosmetic/body/adg-scriptlet-injection-body-common.mjs';
+
+/**
+ * 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;
+};
+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/esm/deserializer/cosmetic/scriptlet-body/scriptlet-body-deserializer.mjs

@@ -0,0 +1,50 @@
+/*
+ * 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
+ */
+import { NULL } from '../../../utils/constants.mjs';
+import { ParameterListDeserializer } from '../../misc/parameter-list-deserializer.mjs';
+import { BaseDeserializer } from '../../base-deserializer.mjs';
+import { AbpSnippetBodyMarshallingMap } from '../../../marshalling-utils/cosmetic/body/abp-snippet-injection-body-common.mjs';
+import { BinaryTypeMarshallingMap } from '../../../marshalling-utils/misc/binary-type-common.mjs';
+
+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/esm/deserializer/cosmetic/scriptlet-body/ubo-scriptlet-injection-body-deserializer.mjs

@@ -0,0 +1,35 @@
+/*
+ * 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
+ */
+import { BaseDeserializer } from '../../base-deserializer.mjs';
+import { ScriptletBodyDeserializer } from './scriptlet-body-deserializer.mjs';
+import { FREQUENT_UBO_SCRIPTLET_ARGS_SERIALIZATION_MAP } from '../../../marshalling-utils/cosmetic/body/ubo-scriptlet-injection-body-common.mjs';
+
+/**
+ * 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;
+};
+class UboScriptletInjectionBodyDeserializer 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, getFrequentPlatformsDeserializationMap());
+    }
+}
+
+export { UboScriptletInjectionBodyDeserializer, getFrequentPlatformsDeserializationMap };

package/dist/esm/deserializer/empty-rule-deserializer.mjs

@@ -0,0 +1,44 @@
+/*
+ * 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
+ */
+import { BaseDeserializer } from './base-deserializer.mjs';
+import { RuleCategory } from '../nodes/index.mjs';
+import { NULL } from '../utils/constants.mjs';
+import { EmptyRuleMarshallingMap } from '../marshalling-utils/empty-rule-common.mjs';
+import { AdblockSyntax } from '../utils/adblockers.mjs';
+import { BinaryTypeMarshallingMap } from '../marshalling-utils/misc/binary-type-common.mjs';
+
+/* eslint-disable no-param-reassign */
+class EmptyRuleDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes an empty rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(BinaryTypeMarshallingMap.EmptyRule);
+        node.type = 'EmptyRule';
+        node.category = RuleCategory.Empty;
+        node.syntax = AdblockSyntax.Common;
+        let prop = buffer.readUint8();
+        while (prop !== NULL) {
+            switch (prop) {
+                case EmptyRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case EmptyRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+export { EmptyRuleDeserializer };