@adguard/agtree 2.2.0 → 3.0.0-alpha.2

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

@@ -0,0 +1,73 @@
+/*
+ * 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 { ValueSerializer } from '../misc/value-serializer.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { BaseSerializer } from '../base-serializer.js';
+import { MetadataCommentMarshallingMap, FREQUENT_HEADERS_DESERIALIZATION_MAP } from '../../marshalling-utils/comment/metadata-comment-common.js';
+import { BinaryTypeMarshallingMap } from '../../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(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 {
+    /**
+     * 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(BinaryTypeMarshallingMap.MetadataCommentRuleNode);
+        buffer.writeUint8(MetadataCommentMarshallingMap.Marker);
+        ValueSerializer.serialize(node.marker, buffer);
+        buffer.writeUint8(MetadataCommentMarshallingMap.Header);
+        ValueSerializer.serialize(node.header, buffer, getFrequentHeadersSerializationMap(), true);
+        buffer.writeUint8(MetadataCommentMarshallingMap.Value);
+        ValueSerializer.serialize(node.value, buffer);
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(MetadataCommentMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(MetadataCommentMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(NULL);
+    }
+}
+
+export { MetadataCommentSerializer };

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

@@ -0,0 +1,71 @@
+/*
+ * 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 { LogicalExpressionSerializer } from '../misc/logical-expression-serializer.js';
+import { ParameterListSerializer } from '../misc/parameter-list-serializer.js';
+import { ValueSerializer } from '../misc/value-serializer.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { BaseSerializer } from '../base-serializer.js';
+import { PreProcessorRuleMarshallingMap, FREQUENT_DIRECTIVES_SERIALIZATION_MAP, FREQUENT_PARAMS_SERIALIZATION_MAP } from '../../marshalling-utils/comment/pre-processor-comment-common.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+import { getSyntaxSerializationMap } from '../../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 {
+    /**
+     * 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(BinaryTypeMarshallingMap.PreProcessorCommentRuleNode);
+        buffer.writeUint8(PreProcessorRuleMarshallingMap.Name);
+        ValueSerializer.serialize(node.name, buffer, FREQUENT_DIRECTIVES_SERIALIZATION_MAP);
+        buffer.writeUint8(PreProcessorRuleMarshallingMap.Syntax);
+        buffer.writeUint8(getSyntaxSerializationMap().get(node.syntax) ?? 0);
+        if (!isUndefined(node.params)) {
+            buffer.writeUint8(PreProcessorRuleMarshallingMap.Params);
+            if (node.params.type === 'Value') {
+                ValueSerializer.serialize(node.params, buffer);
+            }
+            else if (node.params.type === 'ParameterList') {
+                ParameterListSerializer.serialize(node.params, buffer, FREQUENT_PARAMS_SERIALIZATION_MAP, true);
+            }
+            else {
+                LogicalExpressionSerializer.serialize(node.params, buffer);
+            }
+        }
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(PreProcessorRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(PreProcessorRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(NULL);
+    }
+}
+
+export { PreProcessorCommentSerializer };

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

@@ -0,0 +1,52 @@
+/*
+ * 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 { isUndefined } from '../../utils/type-guards.js';
+import { ValueSerializer } from '../misc/value-serializer.js';
+import { BaseSerializer } from '../base-serializer.js';
+import { SimpleCommentMarshallingMap } from '../../marshalling-utils/comment/simple-comment-common.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+
+/**
+ * `SimpleCommentSerializer` is responsible for serializing simple comments.
+ * Some comments have a special meaning in adblock syntax, like agent comments or hints,
+ * but this serializer is only responsible for serializing 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 {
+    /**
+     * 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(BinaryTypeMarshallingMap.CommentRuleNode);
+        buffer.writeUint8(SimpleCommentMarshallingMap.Marker);
+        ValueSerializer.serialize(node.marker, buffer);
+        buffer.writeUint8(SimpleCommentMarshallingMap.Text);
+        ValueSerializer.serialize(node.text, buffer);
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(SimpleCommentMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(SimpleCommentMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(NULL);
+    }
+}
+
+export { SimpleCommentSerializer };

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

@@ -0,0 +1,36 @@
+/*
+ * 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 { BaseSerializer } from '../../base-serializer.js';
+import { ScriptletBodySerializer } from './scriptlet-body-serializer.js';
+import { FREQUENT_ABP_SNIPPET_ARGS_SERIALIZATION_MAP } from '../../../marshalling-utils/cosmetic/body/abp-snippet-injection-body-common.js';
+
+/**
+ * `AbpSnippetInjectionBodySerializer` is responsible for serializing the body of an Adblock Plus-style snippet rule.
+ *
+ * Please note that the serializer will serialize any scriptlet rule if it is syntactically correct.
+ * For example, it will serialize this:
+ * ```adblock
+ * example.com#$#snippet0 arg0
+ * ```
+ *
+ * but it doesn't check if the scriptlet `snippet0` is actually supported by any adblocker.
+ *
+ * @see {@link https://help.eyeo.com/adblockplus/snippet-filters-tutorial}
+ */
+class AbpSnippetInjectionBodySerializer extends 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.serialize(node, buffer, FREQUENT_ABP_SNIPPET_ARGS_SERIALIZATION_MAP);
+    }
+}
+
+export { AbpSnippetInjectionBodySerializer };

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

@@ -0,0 +1,36 @@
+/*
+ * 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 { BaseSerializer } from '../../base-serializer.js';
+import { ScriptletBodySerializer } from './scriptlet-body-serializer.js';
+import { FREQUENT_ADG_SCRIPTLET_ARGS_SERIALIZATION_MAP } from '../../../marshalling-utils/cosmetic/body/adg-scriptlet-injection-body-common.js';
+
+/**
+ * `AdgScriptletInjectionBodySerializer` is responsible for serializing the body of an AdGuard-style scriptlet rule.
+ *
+ * Please note that the serializer will serialize any scriptlet rule if it is syntactically correct.
+ * For example, it will serialize this:
+ * ```adblock
+ * example.com#%#//scriptlet('scriptlet0', 'arg0')
+ * ```
+ *
+ * but it doesn't check if the scriptlet `scriptlet0` is 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 {
+    /**
+     * 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.serialize(node, buffer, FREQUENT_ADG_SCRIPTLET_ARGS_SERIALIZATION_MAP);
+    }
+}
+
+export { AdgScriptletInjectionBodySerializer };

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

@@ -0,0 +1,50 @@
+/*
+ * 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 { UINT8_MAX, NULL } from '../../../utils/constants.js';
+import { ParameterListSerializer } from '../../misc/parameter-list-serializer.js';
+import { isUndefined } from '../../../utils/type-guards.js';
+import { BaseSerializer } from '../../base-serializer.js';
+import { AbpSnippetBodyMarshallingMap } from '../../../marshalling-utils/cosmetic/body/abp-snippet-injection-body-common.js';
+import { BinaryTypeMarshallingMap } from '../../../marshalling-utils/misc/binary-type-common.js';
+
+/**
+ * Serializer for scriptlet injection rule body nodes.
+ */
+class ScriptletBodySerializer extends BaseSerializer {
+    /**
+     * Serializes a scriptlet injection rule body node into a compact binary format.
+     *
+     * @param node The ScriptletInjectionRuleBody node to serialize.
+     * @param buffer The OutputByteBuffer used for writing the binary data.
+     * @param frequentScriptletArgs An optional map of frequently used scriptlet names and their arguments,
+     * along with their corresponding serialization index.
+     */
+    static serialize = (node, buffer, frequentScriptletArgs) => {
+        buffer.writeUint8(BinaryTypeMarshallingMap.ScriptletInjectionRuleBodyNode);
+        const { length } = node.children;
+        buffer.writeUint8(AbpSnippetBodyMarshallingMap.Children);
+        // note: we store the count, because re-construction of the array is faster if we know the length
+        if (length > UINT8_MAX) {
+            throw new Error(`Too many scriptlet children: ${length}, the limit is ${UINT8_MAX}`);
+        }
+        buffer.writeUint8(length);
+        for (let i = 0; i < length; i += 1) {
+            ParameterListSerializer.serialize(node.children[i], buffer, frequentScriptletArgs);
+        }
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(AbpSnippetBodyMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(AbpSnippetBodyMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(NULL);
+    };
+}
+
+export { ScriptletBodySerializer };

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

@@ -0,0 +1,36 @@
+/*
+ * 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 { ScriptletBodySerializer } from './scriptlet-body-serializer.js';
+import { BaseSerializer } from '../../base-serializer.js';
+import { FREQUENT_UBO_SCRIPTLET_ARGS_SERIALIZATION_MAP } from '../../../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 {
+    /**
+     * 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.serialize(node, buffer, FREQUENT_UBO_SCRIPTLET_ARGS_SERIALIZATION_MAP);
+    }
+}
+
+export { UboScriptletInjectionBodySerializer };

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

@@ -0,0 +1,120 @@
+/*
+ * 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 { DomainListSerializer } from '../misc/domain-list-serializer.js';
+import { NULL } from '../../utils/constants.js';
+import { CosmeticRuleType } from '../../nodes/index.js';
+import { AbpSnippetInjectionBodySerializer } from './body/abp-snippet-injection-body-serializer.js';
+import { UboScriptletInjectionBodySerializer } from './body/ubo-scriptlet-injection-body-serializer.js';
+import { AdgScriptletInjectionBodySerializer } from './body/adg-scriptlet-injection-body-serializer.js';
+import { ValueSerializer } from '../misc/value-serializer.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { BaseSerializer } from '../base-serializer.js';
+import { ElementHidingBodySerializer } from './element-hiding-body-serializer.js';
+import { CssInjectionBodySerializer } from './css-injection-body-serializer.js';
+import { ModifierListSerializer } from '../misc/modifier-list-serializer.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 { getSyntaxSerializationMap } from '../../marshalling-utils/syntax-serialization-map.js';
+
+/**
+ * `CosmeticRuleSerializer` is responsible for serializing cosmetic rules into a binary format.
+ *
+ * This class takes a cosmetic rule Abstract Syntax Tree (AST) and converts it into a compact binary representation.
+ * It handles the serialization of different types of cosmetic rules, including element hiding, CSS injection,
+ * JavaScript injection, HTML filtering, and scriptlet injection rules.
+ */
+class CosmeticRuleSerializer extends 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 CosmeticRuleType.ElementHidingRule:
+                // rule type
+                buffer.writeUint8(BinaryTypeMarshallingMap.ElementHidingRule);
+                // syntax
+                buffer.writeUint8(getSyntaxSerializationMap().get(node.syntax) ?? 0);
+                // rule body
+                ElementHidingBodySerializer.serialize(node.body, buffer);
+                break;
+            case CosmeticRuleType.CssInjectionRule:
+                // rule type
+                buffer.writeUint8(BinaryTypeMarshallingMap.CssInjectionRule);
+                // syntax
+                buffer.writeUint8(getSyntaxSerializationMap().get(node.syntax) ?? 0);
+                // rule body
+                CssInjectionBodySerializer.serialize(node.body, buffer);
+                break;
+            case CosmeticRuleType.JsInjectionRule:
+                // rule type
+                buffer.writeUint8(BinaryTypeMarshallingMap.JsInjectionRule);
+                // syntax
+                buffer.writeUint8(getSyntaxSerializationMap().get(node.syntax) ?? 0);
+                // rule body
+                ValueSerializer.serialize(node.body, buffer);
+                break;
+            case CosmeticRuleType.HtmlFilteringRule:
+                // rule type
+                buffer.writeUint8(BinaryTypeMarshallingMap.HtmlFilteringRule);
+                // syntax
+                buffer.writeUint8(getSyntaxSerializationMap().get(node.syntax) ?? 0);
+                // rule body
+                ValueSerializer.serialize(node.body, buffer);
+                break;
+            case CosmeticRuleType.ScriptletInjectionRule:
+                // rule type
+                buffer.writeUint8(BinaryTypeMarshallingMap.ScriptletInjectionRule);
+                // syntax
+                buffer.writeUint8(getSyntaxSerializationMap().get(node.syntax) ?? 0);
+                // rule body
+                switch (node.syntax) {
+                    case AdblockSyntax.Adg:
+                        AdgScriptletInjectionBodySerializer.serialize(node.body, buffer);
+                        break;
+                    case AdblockSyntax.Abp:
+                        AbpSnippetInjectionBodySerializer.serialize(node.body, buffer);
+                        break;
+                    case AdblockSyntax.Ubo:
+                        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(CosmeticRuleMarshallingMap.Exception);
+        buffer.writeUint8(node.exception ? 1 : 0);
+        buffer.writeUint8(CosmeticRuleMarshallingMap.Separator);
+        ValueSerializer.serialize(node.separator, buffer, COSMETIC_RULE_SEPARATOR_SERIALIZATION_MAP);
+        if (node.modifiers) {
+            buffer.writeUint8(CosmeticRuleMarshallingMap.Modifiers);
+            ModifierListSerializer.serialize(node.modifiers, buffer);
+        }
+        buffer.writeUint8(CosmeticRuleMarshallingMap.Domains);
+        DomainListSerializer.serialize(node.domains, buffer);
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(CosmeticRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(CosmeticRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(NULL);
+    }
+}
+
+export { CosmeticRuleSerializer };

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

@@ -0,0 +1,51 @@
+/*
+ * 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 { ValueSerializer } from '../misc/value-serializer.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { NULL } from '../../utils/constants.js';
+import { BaseSerializer } from '../base-serializer.js';
+import { CssInjectionRuleMarshallingMap } from '../../marshalling-utils/cosmetic/body/css-injection-body-common.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+
+/**
+ * Serializer for CSS injection rule body nodes.
+ */
+class CssInjectionBodySerializer extends 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(BinaryTypeMarshallingMap.CssInjectionRuleBody);
+        if (node.mediaQueryList) {
+            buffer.writeUint8(CssInjectionRuleMarshallingMap.MediaQueryList);
+            ValueSerializer.serialize(node.mediaQueryList, buffer);
+        }
+        buffer.writeUint8(CssInjectionRuleMarshallingMap.SelectorList);
+        ValueSerializer.serialize(node.selectorList, buffer);
+        if (node.declarationList) {
+            buffer.writeUint8(CssInjectionRuleMarshallingMap.DeclarationList);
+            ValueSerializer.serialize(node.declarationList, buffer);
+        }
+        if (node.remove) {
+            buffer.writeUint8(CssInjectionRuleMarshallingMap.Remove);
+        }
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(CssInjectionRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(CssInjectionRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(NULL);
+    }
+}
+
+export { CssInjectionBodySerializer };

package/dist/serializer/cosmetic/element-hiding-body-serializer.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 { BaseSerializer } from '../base-serializer.js';
+import { ValueSerializer } from '../misc/value-serializer.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { NULL } from '../../utils/constants.js';
+import { ElementHidingRuleMarshallingMap } from '../../marshalling-utils/cosmetic/body/element-hiding-body-common.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+
+/**
+ * Serializer for element hiding rule body nodes.
+ */
+class ElementHidingBodySerializer extends 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(BinaryTypeMarshallingMap.ElementHidingRuleBody);
+        buffer.writeUint8(ElementHidingRuleMarshallingMap.SelectorList);
+        ValueSerializer.serialize(node.selectorList, buffer);
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(ElementHidingRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(ElementHidingRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(NULL);
+    }
+}
+
+export { ElementHidingBodySerializer };

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

@@ -0,0 +1,37 @@
+/*
+ * 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 { BaseSerializer } from './base-serializer.js';
+import { isUndefined } from '../utils/type-guards.js';
+import { NULL } from '../utils/constants.js';
+import { EmptyRuleMarshallingMap } from '../marshalling-utils/empty-rule-common.js';
+import { BinaryTypeMarshallingMap } from '../marshalling-utils/misc/binary-type-common.js';
+
+/**
+ * Serializer for empty rule nodes.
+ */
+class EmptyRuleSerializer extends 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(BinaryTypeMarshallingMap.EmptyRule);
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(EmptyRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(EmptyRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(NULL);
+    }
+}
+
+export { EmptyRuleSerializer };

package/dist/serializer/filterlist-serializer.js

@@ -0,0 +1,45 @@
+/*
+ * 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 { isUndefined } from '../utils/type-guards.js';
+import { BaseSerializer } from './base-serializer.js';
+import { RuleSerializer } from './rule-serializer.js';
+import { FilterListNodeMarshallingMap } from '../marshalling-utils/filter-list-common.js';
+import { BinaryTypeMarshallingMap } from '../marshalling-utils/misc/binary-type-common.js';
+
+/**
+ * Serializes filter list nodes to binary format.
+ */
+class FilterListSerializer extends BaseSerializer {
+    /**
+     * Serializes a filter list 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(BinaryTypeMarshallingMap.FilterListNode);
+        buffer.writeUint8(FilterListNodeMarshallingMap.Children);
+        const count = node.children.length;
+        buffer.writeUint32(count);
+        for (let i = 0; i < count; i += 1) {
+            RuleSerializer.serialize(node.children[i], buffer);
+        }
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(FilterListNodeMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(FilterListNodeMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(NULL);
+    }
+}
+
+export { FilterListSerializer };

package/dist/serializer/index.js

@@ -0,0 +1,7 @@
+/*
+ * 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
+ */
+export { RuleSerializer } from './rule-serializer.js';