@adguard/agtree 2.1.3 → 3.0.0

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

@@ -0,0 +1,75 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 valueSerializer = require('../misc/value-serializer.js');
+var typeGuards = require('../../utils/type-guards.js');
+var baseSerializer = require('../base-serializer.js');
+var metadataCommentCommon = require('../../marshalling-utils/comment/metadata-comment-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/**
+ * Value map for binary serialization. This helps to reduce the size of the serialized data,
+ * as it allows us to use a single byte to represent frequently used values.
+ *
+ * ! IMPORTANT: If you change values here, please update the {@link BINARY_SCHEMA_VERSION}!
+ *
+ * @note Only 256 values can be represented this way.
+ * @note This map is generated from `FREQUENT_HEADERS_DESERIALIZATION_MAP` to keep uppercase characters
+ * while deserializing.
+ */
+let frequentHeadersSerializationMap;
+const getFrequentHeadersSerializationMap = () => {
+    if (!frequentHeadersSerializationMap) {
+        frequentHeadersSerializationMap = new Map(Array.from(metadataCommentCommon.FREQUENT_HEADERS_DESERIALIZATION_MAP.entries())
+            .map(([key, value]) => [value.toLowerCase(), key]));
+    }
+    return frequentHeadersSerializationMap;
+};
+/**
+ * `MetadataCommentSerializer` is responsible for serializing 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 MetadataCommentSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a metadata comment node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    // TODO: add support for raws, if ever needed
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.MetadataCommentRuleNode);
+        buffer.writeUint8(metadataCommentCommon.MetadataCommentMarshallingMap.Marker);
+        valueSerializer.ValueSerializer.serialize(node.marker, buffer);
+        buffer.writeUint8(metadataCommentCommon.MetadataCommentMarshallingMap.Header);
+        valueSerializer.ValueSerializer.serialize(node.header, buffer, getFrequentHeadersSerializationMap(), true);
+        buffer.writeUint8(metadataCommentCommon.MetadataCommentMarshallingMap.Value);
+        valueSerializer.ValueSerializer.serialize(node.value, buffer);
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(metadataCommentCommon.MetadataCommentMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(metadataCommentCommon.MetadataCommentMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.MetadataCommentSerializer = MetadataCommentSerializer;

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

@@ -0,0 +1,73 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 logicalExpressionSerializer = require('../misc/logical-expression-serializer.js');
+var parameterListSerializer = require('../misc/parameter-list-serializer.js');
+var valueSerializer = require('../misc/value-serializer.js');
+var typeGuards = require('../../utils/type-guards.js');
+var baseSerializer = require('../base-serializer.js');
+var preProcessorCommentCommon = require('../../marshalling-utils/comment/pre-processor-comment-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+var syntaxSerializationMap = require('../../marshalling-utils/syntax-serialization-map.js');
+
+/**
+ * `PreProcessorSerializer` is responsible for serializing 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 PreProcessorCommentSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a pre-processor comment node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    // TODO: add support for raws, if ever needed
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.PreProcessorCommentRuleNode);
+        buffer.writeUint8(preProcessorCommentCommon.PreProcessorRuleMarshallingMap.Name);
+        valueSerializer.ValueSerializer.serialize(node.name, buffer, preProcessorCommentCommon.FREQUENT_DIRECTIVES_SERIALIZATION_MAP);
+        buffer.writeUint8(preProcessorCommentCommon.PreProcessorRuleMarshallingMap.Syntax);
+        buffer.writeUint8(syntaxSerializationMap.getSyntaxSerializationMap().get(node.syntax) ?? 0);
+        if (!typeGuards.isUndefined(node.params)) {
+            buffer.writeUint8(preProcessorCommentCommon.PreProcessorRuleMarshallingMap.Params);
+            if (node.params.type === 'Value') {
+                valueSerializer.ValueSerializer.serialize(node.params, buffer);
+            }
+            else if (node.params.type === 'ParameterList') {
+                parameterListSerializer.ParameterListSerializer.serialize(node.params, buffer, preProcessorCommentCommon.FREQUENT_PARAMS_SERIALIZATION_MAP, true);
+            }
+            else {
+                logicalExpressionSerializer.LogicalExpressionSerializer.serialize(node.params, buffer);
+            }
+        }
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(preProcessorCommentCommon.PreProcessorRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(preProcessorCommentCommon.PreProcessorRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.PreProcessorCommentSerializer = PreProcessorCommentSerializer;

package/dist/cjs/serializer/comment/simple-comment-serializer.js

@@ -0,0 +1,54 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 typeGuards = require('../../utils/type-guards.js');
+var valueSerializer = require('../misc/value-serializer.js');
+var baseSerializer = require('../base-serializer.js');
+var simpleCommentCommon = require('../../marshalling-utils/comment/simple-comment-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/**
+ * `SimpleCommentSerializer` is responsible for parsing 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 SimpleCommentSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a simple comment rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    // TODO: add support for raws, if ever needed
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.CommentRuleNode);
+        buffer.writeUint8(simpleCommentCommon.SimpleCommentMarshallingMap.Marker);
+        valueSerializer.ValueSerializer.serialize(node.marker, buffer);
+        buffer.writeUint8(simpleCommentCommon.SimpleCommentMarshallingMap.Text);
+        valueSerializer.ValueSerializer.serialize(node.text, buffer);
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(simpleCommentCommon.SimpleCommentMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(simpleCommentCommon.SimpleCommentMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.SimpleCommentSerializer = SimpleCommentSerializer;

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

@@ -0,0 +1,38 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var baseSerializer = require('../../base-serializer.js');
+var scriptletBodySerializer = require('./scriptlet-body-serializer.js');
+var abpSnippetInjectionBodyCommon = require('../../../marshalling-utils/cosmetic/body/abp-snippet-injection-body-common.js');
+
+/**
+ * `AbpSnippetInjectionBodyParser` is responsible for parsing the body of an Adblock Plus-style snippet rule.
+ *
+ * Please note that the parser will parse any scriptlet rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com#$#snippet0 arg0
+ * ```
+ *
+ * but it didn't check if the scriptlet `snippet0` actually supported by any adblocker.
+ *
+ * @see {@link https://help.eyeo.com/adblockplus/snippet-filters-tutorial}
+ */
+class AbpSnippetInjectionBodySerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a scriptlet call body node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        scriptletBodySerializer.ScriptletBodySerializer.serialize(node, buffer, abpSnippetInjectionBodyCommon.FREQUENT_ABP_SNIPPET_ARGS_SERIALIZATION_MAP);
+    }
+}
+
+exports.AbpSnippetInjectionBodySerializer = AbpSnippetInjectionBodySerializer;

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

@@ -0,0 +1,38 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var baseSerializer = require('../../base-serializer.js');
+var scriptletBodySerializer = require('./scriptlet-body-serializer.js');
+var adgScriptletInjectionBodyCommon = require('../../../marshalling-utils/cosmetic/body/adg-scriptlet-injection-body-common.js');
+
+/**
+ * `AdgScriptletInjectionBodyParser` is responsible for parsing the body of an AdGuard-style scriptlet rule.
+ *
+ * Please note that the parser will parse any scriptlet rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com#%#//scriptlet('scriptlet0', 'arg0')
+ * ```
+ *
+ * but it didn't check if the scriptlet `scriptlet0` actually supported by any adblocker.
+ *
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
+ */
+class AdgScriptletInjectionBodySerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a scriptlet call body node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        scriptletBodySerializer.ScriptletBodySerializer.serialize(node, buffer, adgScriptletInjectionBodyCommon.FREQUENT_ADG_SCRIPTLET_ARGS_SERIALIZATION_MAP);
+    }
+}
+
+exports.AdgScriptletInjectionBodySerializer = AdgScriptletInjectionBodySerializer;

package/dist/cjs/serializer/cosmetic/body/scriptlet-body-serializer.js

@@ -0,0 +1,49 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 parameterListSerializer = require('../../misc/parameter-list-serializer.js');
+var typeGuards = require('../../../utils/type-guards.js');
+var baseSerializer = require('../../base-serializer.js');
+var abpSnippetInjectionBodyCommon = require('../../../marshalling-utils/cosmetic/body/abp-snippet-injection-body-common.js');
+var binaryTypeCommon = require('../../../marshalling-utils/misc/binary-type-common.js');
+
+class ScriptletBodySerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a hint rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     * @param frequentScriptletArgs Map of frequently used scriptlet names / arguments
+     * and their serialization index (optional).
+     */
+    static serialize = (node, buffer, frequentScriptletArgs) => {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ScriptletInjectionRuleBodyNode);
+        const { length } = node.children;
+        buffer.writeUint8(abpSnippetInjectionBodyCommon.AbpSnippetBodyMarshallingMap.Children);
+        // note: we store the count, because re-construction of the array is faster if we know the length
+        if (length > constants.UINT8_MAX) {
+            throw new Error(`Too many scriptlet children: ${length}, the limit is ${constants.UINT8_MAX}`);
+        }
+        buffer.writeUint8(length);
+        for (let i = 0; i < length; i += 1) {
+            parameterListSerializer.ParameterListSerializer.serialize(node.children[i], buffer, frequentScriptletArgs);
+        }
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(abpSnippetInjectionBodyCommon.AbpSnippetBodyMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(abpSnippetInjectionBodyCommon.AbpSnippetBodyMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    };
+}
+
+exports.ScriptletBodySerializer = ScriptletBodySerializer;

package/dist/cjs/serializer/cosmetic/body/ubo-scriptlet-injection-body-serializer.js

@@ -0,0 +1,38 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var scriptletBodySerializer = require('./scriptlet-body-serializer.js');
+var baseSerializer = require('../../base-serializer.js');
+var uboScriptletInjectionBodyCommon = require('../../../marshalling-utils/cosmetic/body/ubo-scriptlet-injection-body-common.js');
+
+/**
+ * `UboScriptletInjectionBodySerializer` is responsible for serializing the body of a uBlock-style scriptlet rule.
+ *
+ * Please note that the parser will parse any scriptlet rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com##+js(scriptlet0, arg0)
+ * ```
+ *
+ * but it didn't check if the scriptlet `scriptlet0` actually supported by any adblocker.
+ *
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#scriptlet-injection}
+ */
+class UboScriptletInjectionBodySerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a scriptlet call body node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        scriptletBodySerializer.ScriptletBodySerializer.serialize(node, buffer, uboScriptletInjectionBodyCommon.FREQUENT_UBO_SCRIPTLET_ARGS_SERIALIZATION_MAP);
+    }
+}
+
+exports.UboScriptletInjectionBodySerializer = UboScriptletInjectionBodySerializer;

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

@@ -0,0 +1,131 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 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 domainListSerializer = require('../misc/domain-list-serializer.js');
+var constants = require('../../utils/constants.js');
+var index = require('../../nodes/index.js');
+var abpSnippetInjectionBodySerializer = require('./body/abp-snippet-injection-body-serializer.js');
+var uboScriptletInjectionBodySerializer = require('./body/ubo-scriptlet-injection-body-serializer.js');
+var adgScriptletInjectionBodySerializer = require('./body/adg-scriptlet-injection-body-serializer.js');
+var valueSerializer = require('../misc/value-serializer.js');
+var typeGuards = require('../../utils/type-guards.js');
+var baseSerializer = require('../base-serializer.js');
+var elementHidingBodySerializer = require('./element-hiding-body-serializer.js');
+var cssInjectionBodySerializer = require('./css-injection-body-serializer.js');
+var modifierListSerializer = require('../misc/modifier-list-serializer.js');
+var cosmeticRuleCommon = require('../../marshalling-utils/cosmetic/cosmetic-rule-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+var syntaxSerializationMap = require('../../marshalling-utils/syntax-serialization-map.js');
+
+/**
+ * `CosmeticRuleParser` is responsible for parsing cosmetic rules.
+ *
+ * Where possible, it automatically detects the difference between supported syntaxes:
+ *  - AdGuard
+ *  - uBlock Origin
+ *  - Adblock Plus
+ *
+ * If the syntax is common / cannot be determined, the parser gives `Common` syntax.
+ *
+ * Please note that syntactically correct rules are parsed even if they are not actually
+ * compatible with the given adblocker. This is a completely natural behavior, meaningful
+ * checking of compatibility is not done at the parser level.
+ */
+// TODO: Make raw body parsing optional
+// TODO: Split into smaller sections
+class CosmeticRuleSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a cosmetic rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    // TODO: add support for raws, if ever needed
+    static serialize(node, buffer) {
+        // specific properties
+        switch (node.type) {
+            case index.CosmeticRuleType.ElementHidingRule:
+                // rule type
+                buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ElementHidingRule);
+                // syntax
+                buffer.writeUint8(syntaxSerializationMap.getSyntaxSerializationMap().get(node.syntax) ?? 0);
+                // rule body
+                elementHidingBodySerializer.ElementHidingBodySerializer.serialize(node.body, buffer);
+                break;
+            case index.CosmeticRuleType.CssInjectionRule:
+                // rule type
+                buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.CssInjectionRule);
+                // syntax
+                buffer.writeUint8(syntaxSerializationMap.getSyntaxSerializationMap().get(node.syntax) ?? 0);
+                // rule body
+                cssInjectionBodySerializer.CssInjectionBodySerializer.serialize(node.body, buffer);
+                break;
+            case index.CosmeticRuleType.JsInjectionRule:
+                // rule type
+                buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.JsInjectionRule);
+                // syntax
+                buffer.writeUint8(syntaxSerializationMap.getSyntaxSerializationMap().get(node.syntax) ?? 0);
+                // rule body
+                valueSerializer.ValueSerializer.serialize(node.body, buffer);
+                break;
+            case index.CosmeticRuleType.HtmlFilteringRule:
+                // rule type
+                buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.HtmlFilteringRule);
+                // syntax
+                buffer.writeUint8(syntaxSerializationMap.getSyntaxSerializationMap().get(node.syntax) ?? 0);
+                // rule body
+                valueSerializer.ValueSerializer.serialize(node.body, buffer);
+                break;
+            case index.CosmeticRuleType.ScriptletInjectionRule:
+                // rule type
+                buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ScriptletInjectionRule);
+                // syntax
+                buffer.writeUint8(syntaxSerializationMap.getSyntaxSerializationMap().get(node.syntax) ?? 0);
+                // rule body
+                switch (node.syntax) {
+                    case adblockers.AdblockSyntax.Adg:
+                        adgScriptletInjectionBodySerializer.AdgScriptletInjectionBodySerializer.serialize(node.body, buffer);
+                        break;
+                    case adblockers.AdblockSyntax.Abp:
+                        abpSnippetInjectionBodySerializer.AbpSnippetInjectionBodySerializer.serialize(node.body, buffer);
+                        break;
+                    case adblockers.AdblockSyntax.Ubo:
+                        uboScriptletInjectionBodySerializer.UboScriptletInjectionBodySerializer.serialize(node.body, buffer);
+                        break;
+                    default:
+                        throw new Error('Scriptlet rule should have an explicit syntax');
+                }
+                break;
+            default:
+                throw new Error('Unknown cosmetic rule type');
+        }
+        // common properties
+        buffer.writeUint8(cosmeticRuleCommon.CosmeticRuleMarshallingMap.Exception);
+        buffer.writeUint8(node.exception ? 1 : 0);
+        buffer.writeUint8(cosmeticRuleCommon.CosmeticRuleMarshallingMap.Separator);
+        valueSerializer.ValueSerializer.serialize(node.separator, buffer, cosmeticRuleCommon.COSMETIC_RULE_SEPARATOR_SERIALIZATION_MAP);
+        if (node.modifiers) {
+            buffer.writeUint8(cosmeticRuleCommon.CosmeticRuleMarshallingMap.Modifiers);
+            modifierListSerializer.ModifierListSerializer.serialize(node.modifiers, buffer);
+        }
+        buffer.writeUint8(cosmeticRuleCommon.CosmeticRuleMarshallingMap.Domains);
+        domainListSerializer.DomainListSerializer.serialize(node.domains, buffer);
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(cosmeticRuleCommon.CosmeticRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(cosmeticRuleCommon.CosmeticRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.CosmeticRuleSerializer = CosmeticRuleSerializer;

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

@@ -0,0 +1,50 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var valueSerializer = require('../misc/value-serializer.js');
+var typeGuards = require('../../utils/type-guards.js');
+var constants = require('../../utils/constants.js');
+var baseSerializer = require('../base-serializer.js');
+var cssInjectionBodyCommon = require('../../marshalling-utils/cosmetic/body/css-injection-body-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+class CssInjectionBodySerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes a CSS injection rule body node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.CssInjectionRuleBody);
+        if (node.mediaQueryList) {
+            buffer.writeUint8(cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.MediaQueryList);
+            valueSerializer.ValueSerializer.serialize(node.mediaQueryList, buffer);
+        }
+        buffer.writeUint8(cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.SelectorList);
+        valueSerializer.ValueSerializer.serialize(node.selectorList, buffer);
+        if (node.declarationList) {
+            buffer.writeUint8(cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.DeclarationList);
+            valueSerializer.ValueSerializer.serialize(node.declarationList, buffer);
+        }
+        if (node.remove) {
+            buffer.writeUint8(cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.Remove);
+        }
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(cssInjectionBodyCommon.CssInjectionRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.CssInjectionBodySerializer = CssInjectionBodySerializer;

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

@@ -0,0 +1,39 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var baseSerializer = require('../base-serializer.js');
+var valueSerializer = require('../misc/value-serializer.js');
+var typeGuards = require('../../utils/type-guards.js');
+var constants = require('../../utils/constants.js');
+var elementHidingBodyCommon = require('../../marshalling-utils/cosmetic/body/element-hiding-body-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+class ElementHidingBodySerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes an element hiding rule body node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ElementHidingRuleBody);
+        buffer.writeUint8(elementHidingBodyCommon.ElementHidingRuleMarshallingMap.SelectorList);
+        valueSerializer.ValueSerializer.serialize(node.selectorList, buffer);
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(elementHidingBodyCommon.ElementHidingRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(elementHidingBodyCommon.ElementHidingRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.ElementHidingBodySerializer = ElementHidingBodySerializer;

package/dist/cjs/serializer/empty-rule-serializer.js

@@ -0,0 +1,36 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var baseSerializer = require('./base-serializer.js');
+var typeGuards = require('../utils/type-guards.js');
+var constants = require('../utils/constants.js');
+var emptyRuleCommon = require('../marshalling-utils/empty-rule-common.js');
+var binaryTypeCommon = require('../marshalling-utils/misc/binary-type-common.js');
+
+class EmptyRuleSerializer extends baseSerializer.BaseSerializer {
+    /**
+     * Serializes an empty rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        buffer.writeUint8(binaryTypeCommon.BinaryTypeMarshallingMap.EmptyRule);
+        if (!typeGuards.isUndefined(node.start)) {
+            buffer.writeUint8(emptyRuleCommon.EmptyRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!typeGuards.isUndefined(node.end)) {
+            buffer.writeUint8(emptyRuleCommon.EmptyRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(constants.NULL);
+    }
+}
+
+exports.EmptyRuleSerializer = EmptyRuleSerializer;