@adguard/agtree 2.2.0 → 3.0.0-alpha.2

package/dist/types/converter/cosmetic/header-removal.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @file Converter for request header removal rules
+ */
+import { type AnyRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+export declare const ERROR_MESSAGES: {
+    EMPTY_PARAMETER: string;
+    EXPECTED_END_OF_RULE: string;
+    MULTIPLE_DOMAINS_NOT_SUPPORTED: string;
+};
+/**
+ * Converter for request header removal rules
+ *
+ * @todo Implement `convertToUbo` (ABP currently doesn't support header removal rules)
+ */
+export declare class HeaderRemovalRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a header removal rule to AdGuard syntax, 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
+     * @example
+     * If the input rule is:
+     * ```adblock
+     * example.com##^responseheader(header-name)
+     * ```
+     * The output will be:
+     * ```adblock
+     * ||example.com^$removeheader=header-name
+     * ```
+     */
+    static convertToAdg(rule: AnyRule): NodeConversionResult<AnyRule>;
+}

package/dist/types/converter/cosmetic/html.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @file HTML filtering rule converter
+ */
+import { type HtmlFilteringRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+export declare const ERROR_MESSAGES: {
+    ABP_NOT_SUPPORTED: string;
+    TAG_SHOULD_BE_FIRST_CHILD: string;
+    EXPECTED_BUT_GOT_WITH_VALUE: string;
+    INVALID_ATTRIBUTE_NAME: string;
+    INVALID_ATTRIBUTE_VALUE: string;
+    INVALID_FLAG: string;
+    INVALID_OPERATOR_FOR_ATTR: string;
+    VALUE_FOR_ATTR_SHOULD_BE_INT: string;
+    INVALID_PSEUDO_CLASS: string;
+    VALUE_FOR_PSEUDO_CLASS_SHOULD_BE_INT: string;
+    REGEXP_NOT_SUPPORTED: string;
+    ATTRIBUTE_SELECTOR_REQUIRES_VALUE: string;
+    INVALID_ATTRIBUTE_SELECTOR_OPERATOR: string;
+    VALUE_SHOULD_BE_SPECIFIED: string;
+    OPERATOR_SHOULD_BE_SPECIFIED: string;
+    UNEXPECTED_TOKEN_WITH_VALUE: string;
+    FLAGS_NOT_SUPPORTED: string;
+};
+/**
+ * HTML filtering rule converter class
+ *
+ * @todo Implement `convertToUbo` (ABP currently doesn't support HTML filtering rules)
+ */
+export declare class HtmlRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a HTML rule to AdGuard syntax, if possible. Also can be used to convert
+     * AdGuard rules to AdGuard syntax to validate them.
+     *
+     * _Note:_ uBlock Origin supports multiple selectors within a single rule, but AdGuard doesn't,
+     * so the following rule
+     * ```
+     * example.com##^div[attr1="value1"][attr2="value2"], script:has-text(value)
+     * ```
+     * will be converted to multiple AdGuard rules:
+     * ```
+     * example.com$$div[attr1="value1"][attr2="value2"][max-length="262144"]
+     * example.com$$script[tag-content="value"][max-length="262144"]
+     * ```
+     *
+     * @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: HtmlFilteringRule): NodeConversionResult<HtmlFilteringRule>;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * @file Cosmetic rule converter
+ */
+import { type AnyCosmeticRule, type AnyRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * Cosmetic rule converter class (also known as "non-basic rule converter")
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class CosmeticRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a cosmetic rule to AdGuard syntax, 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: AnyCosmeticRule): NodeConversionResult<AnyRule>;
+    /**
+     * Converts a cosmetic rule to uBlock Origin syntax, 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: AnyCosmeticRule): NodeConversionResult<AnyRule>;
+}

package/dist/types/converter/cosmetic/rule-modifiers/adg.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file Cosmetic rule modifier converter from uBO to ADG
+ */
+import { type ModifierList } from '../../../nodes';
+import { type ConversionResult } from '../../base-interfaces/conversion-result';
+/**
+ * Helper class for converting cosmetic rule modifiers from uBO to ADG
+ */
+export declare class AdgCosmeticRuleModifierConverter {
+    /**
+     * Converts a uBO cosmetic rule modifier list to ADG, if possible.
+     *
+     * @param modifierList Cosmetic rule modifier list node to convert
+     * @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 modifier list cannot be converted
+     * @see {@link https://github.com/gorhill/uBlock/wiki/Procedural-cosmetic-filters#cosmetic-filter-operators}
+     */
+    static convertFromUbo(modifierList: ModifierList): ConversionResult<ModifierList>;
+}

package/dist/types/converter/cosmetic/scriptlet.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Scriptlet injection rule converter
+ */
+import { type ScriptletInjectionRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * Scriptlet injection rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class ScriptletRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a scriptlet injection 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: ScriptletInjectionRule): NodeConversionResult<ScriptletInjectionRule>;
+    /**
+     * Converts a scriptlet injection 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: ScriptletInjectionRule): NodeConversionResult<ScriptletInjectionRule>;
+}

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

@@ -0,0 +1,40 @@
+import { BaseConverter } from '../base-interfaces/base-converter';
+import { type ConversionResult } from '../base-interfaces/conversion-result';
+import { CssTokenStream } from '../../parser/css/css-token-stream';
+export declare const ERROR_MESSAGES: {
+    INVALID_ATTRIBUTE_VALUE: string;
+};
+export declare const PseudoClasses: {
+    readonly AbpContains: "-abp-contains";
+    readonly AbpHas: "-abp-has";
+    readonly Contains: "contains";
+    readonly Has: "has";
+    readonly HasText: "has-text";
+    readonly MatchesCss: "matches-css";
+    readonly MatchesCssAfter: "matches-css-after";
+    readonly MatchesCssBefore: "matches-css-before";
+    readonly Not: "not";
+};
+export type PseudoClasses = typeof PseudoClasses[keyof typeof PseudoClasses];
+export declare const PseudoElements: {
+    readonly After: "after";
+    readonly Before: "before";
+};
+export type PseudoElements = typeof PseudoElements[keyof typeof PseudoElements];
+/**
+ * CSS selector converter
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class CssSelectorConverter extends BaseConverter {
+    /**
+     * Converts Extended CSS elements to AdGuard-compatible ones
+     *
+     * @param selectorList Selector list to convert
+     * @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 rule is invalid or incompatible
+     */
+    static convertToAdg(selectorList: string | CssTokenStream): ConversionResult<string>;
+}

package/dist/types/converter/data/css.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @file Known CSS elements and attributes.
+ * TODO: Implement a compatibility table for Extended CSS
+ */
+/**
+ * Legacy Extended CSS attribute prefix.
+ *
+ * @example
+ * ```css
+ * [-ext-<name>=...]
+ * ```
+ */
+export declare const LEGACY_EXT_CSS_ATTRIBUTE_PREFIX = "-ext-";
+/**
+ * ABP Extended CSS prefix.
+ *
+ * @example
+ * ```css
+ * [-abp-<name>=...]
+ * -abp-<name>(...)
+ * ```
+ */
+export declare const ABP_EXT_CSS_PREFIX = "-abp";
+/**
+ * Known _strict_ Extended CSS pseudo-classes. Please, keep this list sorted.
+ * Strict means that these pseudo-classes are not supported by any browser natively,
+ * and they always require Extended CSS libraries to work.
+ */
+export declare const EXT_CSS_PSEUDO_CLASSES_STRICT: Set<string>;
+/**
+ * _ALL_ known Extended CSS pseudo-classes. Please, keep this list sorted.
+ * It includes strict pseudo-classes and additional pseudo-classes that may be
+ * supported by some browsers natively.
+ */
+export declare const EXT_CSS_PSEUDO_CLASSES: Set<string>;
+/**
+ * Known legacy Extended CSS attributes. These attributes are deprecated and
+ * should be replaced with the corresponding pseudo-classes. In a long term,
+ * these attributes will be COMPLETELY removed from the Extended CSS syntax.
+ *
+ * Please, keep this list sorted.
+ */
+export declare const EXT_CSS_LEGACY_ATTRIBUTES: Set<string>;
+/**
+ * Known CSS functions that aren't allowed in CSS injection rules, because they
+ * able to load external resources. Please, keep this list sorted.
+ */
+export declare const FORBIDDEN_CSS_FUNCTIONS: Set<string>;

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

@@ -0,0 +1,31 @@
+/**
+ * @file Adblock filter list converter
+ */
+import { type FilterList } from '../nodes';
+import { type ConversionResult } from './base-interfaces/conversion-result';
+import { BaseConverter } from './base-interfaces/base-converter';
+/**
+ * Adblock filter list converter class
+ *
+ * This class just provides an extra layer on top of the {@link RuleConverter}
+ * and can be used to convert entire filter lists.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ * @todo Implement tolerant mode, which will allow to convert a filter list
+ * even if some of its rules are invalid
+ */
+export declare class FilterListConverter extends BaseConverter {
+    /**
+     * Converts an adblock filter list to AdGuard format, if possible.
+     *
+     * @param filterListNode Filter list node 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 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 filter list is invalid or cannot be converted (if the tolerant mode is disabled)
+     */
+    static convertToAdg(filterListNode: FilterList, tolerant?: boolean): ConversionResult<FilterList>;
+}

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,16 @@
+import { type AnyCommentRule } from '../../nodes';
+import { BaseDeserializer } from '../base-deserializer';
+import { type InputByteBuffer } from '../../utils/input-byte-buffer';
+/**
+ * `CommentRuleDeserializer` is responsible for deserializing any comment-like adblock rules.
+ */
+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;
+}