@adguard/agtree 2.1.3 → 3.0.0

package/dist/types/converter/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @file Converter entry point
+ */
+export { RawFilterListConverter } from './raw-filter-list';
+export { RuleConverter } from './rule';

package/dist/types/converter/misc/network-rule-modifier.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @file Network rule modifier list converter.
+ */
+import { type ModifierList } from '../../nodes';
+import { BaseConverter } from '../base-interfaces/base-converter';
+import { type ConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * Helper class for converting network rule modifier lists.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class NetworkRuleModifierListConverter extends BaseConverter {
+    /**
+     * Converts a network rule modifier list to AdGuard format, if possible.
+     *
+     * @param modifierList Network rule modifier list node to convert
+     * @param isException If `true`, the rule is an exception rule
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
+     * @throws If the conversion is not possible
+     */
+    static convertToAdg(modifierList: ModifierList, isException?: boolean): ConversionResult<ModifierList>;
+    /**
+     * Converts a network rule modifier list to uBlock format, if possible.
+     *
+     * @param modifierList Network rule modifier list node to convert
+     * @param isException If `true`, the rule is an exception rule
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
+     * @throws If the conversion is not possible
+     */
+    static convertToUbo(modifierList: ModifierList, isException?: boolean): ConversionResult<ModifierList>;
+}

package/dist/types/converter/network/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Network rule converter
+ */
+import { type NetworkRule, type AnyNetworkRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * Network rule converter class (also known as "basic rule converter")
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class NetworkRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a network rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule: AnyNetworkRule): NodeConversionResult<NetworkRule>;
+    /**
+     * Converts a network rule to uBlock format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToUbo(rule: AnyNetworkRule): NodeConversionResult<NetworkRule>;
+}

package/dist/types/converter/raw-filter-list.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file Filter list converter for raw filter lists
+ *
+ * Technically, this is a wrapper around `FilterListConverter` that works with nodes instead of strings.
+ */
+import { type ConversionResult } from './base-interfaces/conversion-result';
+import { BaseConverter } from './base-interfaces/base-converter';
+/**
+ * Adblock filter list converter class.
+ *
+ * You can use this class to convert string-based filter lists, since most of the converters work with nodes.
+ * This class just provides an extra layer on top of the {@link FilterListConverter} and calls the parser/serializer
+ * before/after the conversion internally.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class RawFilterListConverter extends BaseConverter {
+    /**
+     * Converts an adblock filter list text to AdGuard format, if possible.
+     *
+     * @param rawFilterList Raw filter list text to convert
+     * @param tolerant Indicates whether the converter should be tolerant to invalid rules. If enabled and a rule is
+     * invalid, it will be left as is. If disabled and a rule is invalid, the whole filter list will be failed.
+     * Defaults to `true`.
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the array of converted filter list text, and its `isConverted` flag indicates whether the original rule was
+     * converted. If the rule was not converted, the original filter list text will be returned
+     * @throws If the filter list is invalid or cannot be converted (if the tolerant mode is disabled)
+     */
+    static convertToAdg(rawFilterList: string, tolerant?: boolean): ConversionResult<string>;
+}

package/dist/types/converter/raw-rule.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file Rule converter for raw rules
+ *
+ * Technically, this is a wrapper around `RuleConverter` that works with nodes instead of strings.
+ */
+import { type ConversionResult } from './base-interfaces/conversion-result';
+import { BaseConverter } from './base-interfaces/base-converter';
+/**
+ * Adblock filtering rule converter class.
+ *
+ * You can use this class to convert string-based adblock rules, since most of the converters work with nodes.
+ * This class just provides an extra layer on top of the {@link RuleConverter} and calls the parser/serializer
+ * before/after the conversion internally.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class RawRuleConverter extends BaseConverter {
+    /**
+     * Converts an adblock filtering rule to AdGuard format, if possible.
+     *
+     * @param rawRule Raw rule text to convert
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the array of converted rule texts, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the original rule text will be returned
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rawRule: string): ConversionResult<string, string[]>;
+}

package/dist/types/converter/rule.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @file Adblock rule converter
+ *
+ * This file is the entry point for all rule converters
+ * which automatically detects the rule type and calls
+ * the corresponding "sub-converter".
+ */
+import { type AnyRule } from '../nodes';
+import { RuleConverterBase } from './base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from './base-interfaces/conversion-result';
+/**
+ * Adblock filtering rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class RuleConverter extends RuleConverterBase {
+    /**
+     * Converts an adblock filtering rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule: AnyRule): NodeConversionResult<AnyRule>;
+    /**
+     * Converts an adblock filtering rule to uBlock Origin format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToUbo(rule: AnyRule): NodeConversionResult<AnyRule>;
+}

package/dist/types/deserializer/base-deserializer.d.ts

@@ -0,0 +1,15 @@
+import { type Node } from '../nodes';
+import { type InputByteBuffer } from '../utils/input-byte-buffer';
+/**
+ * Base class for deserializers. Each deserializer should extend this class.
+ */
+export declare class BaseDeserializer {
+    /**
+     * Deserializes the AST node from a byte buffer.
+     *
+     * @param buffer Input byte buffer to read from.
+     * @param node Destination node to write to.
+     * @param args Additional, parser-specific arguments, if needed.
+     */
+    static deserialize(buffer: InputByteBuffer, node: Partial<Node>, ...args: unknown[]): void;
+}

package/dist/types/deserializer/comment/agent-comment-deserializer.d.ts

@@ -0,0 +1,34 @@
+import { type AgentCommentRule } from '../../nodes';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+import { BaseDeserializer } from '../base-deserializer';
+/**
+ * `AgentCommentDeserializer` is responsible for deserializing an Adblock agent comments.
+ * Adblock agent comment marks that the filter list is supposed to
+ * be used by the specified ad blockers.
+ *
+ * @example
+ *  - ```adblock
+ *    [AdGuard]
+ *    ```
+ *  - ```adblock
+ *    [Adblock Plus 2.0]
+ *    ```
+ *  - ```adblock
+ *    [uBlock Origin]
+ *    ```
+ *  - ```adblock
+ *    [uBlock Origin 1.45.3]
+ *    ```
+ *  - ```adblock
+ *    [Adblock Plus 2.0; AdGuard]
+ *    ```
+ */
+export declare class AgentCommentDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes an agent list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer: InputByteBuffer, node: Partial<AgentCommentRule>): void;
+}

package/dist/types/deserializer/comment/agent-deserializer.d.ts

@@ -0,0 +1,25 @@
+import { type Agent } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+/**
+ * `AgentDeserializer` is responsible for deserializing single adblock agent elements.
+ *
+ * @example
+ * If the adblock agent rule is
+ * ```adblock
+ * [Adblock Plus 2.0; AdGuard]
+ * ```
+ * then the adblock agents are `Adblock Plus 2.0` and `AdGuard`, and this
+ * class is responsible for parsing them. The rule itself is parsed by
+ * `AgentCommentSerializer`, which uses this class to parse single agents.
+ */
+export declare class AgentDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes an agent 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: InputByteBuffer, node: Partial<Agent>): void;
+}

package/dist/types/deserializer/comment/comment-rule-deserializer.d.ts

@@ -0,0 +1,69 @@
+import { type AnyCommentRule } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+/**
+ * `CommentRuleSerializer` is responsible for serializing any comment-like adblock rules.
+ *
+ * @example
+ * Example rules:
+ *  - Adblock agent rules:
+ *      - ```adblock
+ *        [AdGuard]
+ *        ```
+ *      - ```adblock
+ *        [Adblock Plus 2.0]
+ *        ```
+ *      - etc.
+ *  - AdGuard hint rules:
+ *      - ```adblock
+ *        !+ NOT_OPTIMIZED
+ *        ```
+ *      - ```adblock
+ *        !+ NOT_OPTIMIZED PLATFORM(windows)
+ *        ```
+ *      - etc.
+ *  - Pre-processor rules:
+ *      - ```adblock
+ *        !#if (adguard)
+ *        ```
+ *      - ```adblock
+ *        !#endif
+ *        ```
+ *      - etc.
+ *  - Metadata rules:
+ *      - ```adblock
+ *        ! Title: My List
+ *        ```
+ *      - ```adblock
+ *        ! Version: 2.0.150
+ *        ```
+ *      - etc.
+ *  - AGLint inline config rules:
+ *      - ```adblock
+ *        ! aglint-enable some-rule
+ *        ```
+ *      - ```adblock
+ *        ! aglint-disable some-rule
+ *        ```
+ *      - etc.
+ *  - Simple comments:
+ *      - Regular version:
+ *        ```adblock
+ *        ! This is just a comment
+ *        ```
+ *      - uBlock Origin / "hostlist" version:
+ *        ```adblock
+ *        # This is just a comment
+ *        ```
+ *      - etc.
+ */
+export declare class CommentRuleDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a comment rule 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: InputByteBuffer, node: Partial<AnyCommentRule>): void;
+}

package/dist/types/deserializer/comment/config-comment-deserializer.d.ts

@@ -0,0 +1,27 @@
+import { type ConfigCommentRule } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+/**
+ * `ConfigCommentDeserializer` is responsible for deserializing inline AGLint configuration rules.
+ * Generally, the idea is inspired by ESLint inline configuration comments.
+ *
+ * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
+ */
+export declare class ConfigCommentDeserializer 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.
+     */
+    private static deserializeConfigNode;
+    /**
+     * 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: InputByteBuffer, node: Partial<ConfigCommentRule>): void;
+}

package/dist/types/deserializer/comment/hint-comment-deserializer.d.ts

@@ -0,0 +1,24 @@
+import { type HintCommentRule } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+/**
+ * `HintCommentDeserializer` is responsible for deserializing AdGuard hint rules.
+ *
+ * @example
+ * The following hint rule
+ * ```adblock
+ * !+ NOT_OPTIMIZED PLATFORM(windows)
+ * ```
+ * contains two hints: `NOT_OPTIMIZED` and `PLATFORM`.
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#hints}
+ */
+export declare class HintCommentDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a hint rule 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: InputByteBuffer, node: Partial<HintCommentRule>): void;
+}

package/dist/types/deserializer/comment/hint-deserializer.d.ts

@@ -0,0 +1,26 @@
+import { type Hint } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+export declare const getFrequentPlatformsDeserializationMap: () => Map<number, string>;
+/**
+ * `HintDeserializer` is responsible for deserializing AdGuard hints.
+ *
+ * @example
+ * If the hint rule is
+ * ```adblock
+ * !+ NOT_OPTIMIZED PLATFORM(windows)
+ * ```
+ * then the hints are `NOT_OPTIMIZED` and `PLATFORM(windows)`, and this
+ * class is responsible for parsing them. The rule itself is parsed by
+ * the `HintRuleParser`, which uses this class to parse single hints.
+ */
+export declare class HintDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a hint node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
+     */
+    static deserialize(buffer: InputByteBuffer, node: Partial<Hint>): void;
+}

package/dist/types/deserializer/comment/metadata-comment-deserializer.d.ts

@@ -0,0 +1,26 @@
+import { type MetadataCommentRule } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+/**
+ * `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}
+ */
+export declare 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: InputByteBuffer, node: Partial<MetadataCommentRule>): void;
+}

package/dist/types/deserializer/comment/pre-processor-comment-deserializer.d.ts

@@ -0,0 +1,29 @@
+import type { PreProcessorCommentRule } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+/**
+ * `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}
+ */
+export declare 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: InputByteBuffer, node: Partial<PreProcessorCommentRule>): void;
+}

package/dist/types/deserializer/comment/simple-comment-deserializer.d.ts

@@ -0,0 +1,26 @@
+import { type CommentRule } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+/**
+ * `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
+ * ```
+ */
+export declare 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: InputByteBuffer, node: Partial<CommentRule>): void;
+}

package/dist/types/deserializer/cosmetic/cosmetic-rule-deserializer.d.ts

@@ -0,0 +1,12 @@
+import { type AnyCosmeticRule } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+export declare 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: InputByteBuffer, node: Partial<AnyCosmeticRule>): void;
+}

package/dist/types/deserializer/cosmetic/css-injection-body-deserializer.d.ts

@@ -0,0 +1,12 @@
+import { type CssInjectionRuleBody } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+export declare 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: InputByteBuffer, node: CssInjectionRuleBody): void;
+}

package/dist/types/deserializer/cosmetic/element-hiding-body-deserializer.d.ts

@@ -0,0 +1,12 @@
+import { BaseDeserializer } from '../base-deserializer';
+import { type ElementHidingRuleBody } from '../../nodes';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+export declare 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: InputByteBuffer, node: Partial<ElementHidingRuleBody>): void;
+}

package/dist/types/deserializer/cosmetic/scriptlet-body/abp-snippet-injection-body-deserializer.d.ts

@@ -0,0 +1,13 @@
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+import { BaseDeserializer } from '../../base-deserializer';
+import { type InputByteBuffer } from '../../../utils/input-byte-buffer';
+export declare 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: InputByteBuffer, node: Partial<ScriptletInjectionRuleBody>): void;
+}

package/dist/types/deserializer/cosmetic/scriptlet-body/adg-scriptlet-injection-body-deserializer.d.ts

@@ -0,0 +1,13 @@
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+import { BaseDeserializer } from '../../base-deserializer';
+import { type InputByteBuffer } from '../../../utils/input-byte-buffer';
+export declare 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: InputByteBuffer, node: Partial<ScriptletInjectionRuleBody>): void;
+}

package/dist/types/deserializer/cosmetic/scriptlet-body/scriptlet-body-deserializer.d.ts

@@ -0,0 +1,15 @@
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+import { BaseDeserializer } from '../../base-deserializer';
+import { type InputByteBuffer } from '../../../utils/input-byte-buffer';
+export declare 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: InputByteBuffer, node: Partial<ScriptletInjectionRuleBody>, frequentScriptletArgs?: Map<number, string>) => void;
+}

package/dist/types/deserializer/cosmetic/scriptlet-body/ubo-scriptlet-injection-body-deserializer.d.ts

@@ -0,0 +1,14 @@
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+import { BaseDeserializer } from '../../base-deserializer';
+import { type InputByteBuffer } from '../../../utils/input-byte-buffer';
+export declare const getFrequentPlatformsDeserializationMap: () => Map<number, string>;
+export declare 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: InputByteBuffer, node: Partial<ScriptletInjectionRuleBody>): void;
+}

package/dist/types/deserializer/empty-rule-deserializer.d.ts

@@ -0,0 +1,12 @@
+import { BaseDeserializer } from './base-deserializer';
+import { type EmptyRule } from '../nodes';
+import { type InputByteBuffer } from '../utils/input-byte-buffer';
+export declare 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: InputByteBuffer, node: EmptyRule): void;
+}

package/dist/types/deserializer/filterlist-deserializer.d.ts

@@ -0,0 +1,30 @@
+import { type FilterList } from '../nodes';
+import { BaseDeserializer } from './base-deserializer';
+import { type InputByteBuffer } from '../utils/input-byte-buffer';
+export declare class FilterListDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes a filter list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer: InputByteBuffer, node: Partial<FilterList>): void;
+    /**
+     * Helper method to jump to the children of the filter list node.
+     *
+     * Filter lists serialized in binary format are structured as follows:
+     * - `FilterListNode` filter list node indicator (1 byte)
+     * - Properties:
+     *      - `Children` (1 byte) - children count, followed by children nodes
+     *      - `Start` (1 byte) - start offset, if present, followed by the value
+     *      - `End` (1 byte) - end offset, if present, followed by the value
+     *      - `NULL` (1 byte) - closing indicator
+     *
+     * This method skips indicators, reads the children count and returns it.
+     * This way the buffer is positioned at the beginning of the children nodes.
+     *
+     * @param buffer Reference to the input byte buffer.
+     * @returns Number of children nodes.
+     */
+    static jumpToChildren(buffer: InputByteBuffer): number;
+}

package/dist/types/deserializer/index.d.ts

@@ -0,0 +1,2 @@
+export { RuleDeserializer } from './rule-deserializer';
+export { getSyntaxDeserializationMap } from './syntax-deserialization-map';

package/dist/types/deserializer/invalid-rule-deserializer.d.ts

@@ -0,0 +1,12 @@
+import { BaseDeserializer } from './base-deserializer';
+import { type InvalidRule } from '../nodes';
+import { type InputByteBuffer } from '../utils/input-byte-buffer';
+export declare class InvalidRuleDeserializer extends BaseDeserializer {
+    /**
+     * Deserializes an invalid rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer: InputByteBuffer, node: InvalidRule): void;
+}