@adguard/agtree 2.2.0 → 3.0.0-alpha.2

package/dist/types/parser/options.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @file Common options for all parsers.
+ */
+/**
+ * Common options for all parsers.
+ */
+export interface ParserOptions {
+    /**
+     * If `true`, then the parser will not throw an error if the rule is syntactically invalid, instead it will
+     * return an `InvalidRule` object with the error attached to it.
+     */
+    tolerant?: boolean;
+    /**
+     * Whether to include location information in the AST nodes.
+     */
+    isLocIncluded?: boolean;
+    /**
+     * Whether to parse AdBlock-specific rules.
+     */
+    parseAbpSpecificRules?: boolean;
+    /**
+     * Whether to parse uBlock Origin-specific rules.
+     */
+    parseUboSpecificRules?: boolean;
+    /**
+     * Whether to parse raw parts.
+     */
+    includeRaws?: boolean;
+    /**
+     * Whether to ignore comment-rules.
+     */
+    ignoreComments?: boolean;
+    /**
+     * Whether to parse host rules.
+     */
+    parseHostRules?: boolean;
+}
+/**
+ * Default parser options.
+ */
+export declare const defaultParserOptions: ParserOptions;

package/dist/types/parser/rule-parser.d.ts

@@ -0,0 +1,78 @@
+import { type AnyRule } from '../nodes';
+import { BaseParser } from './base-parser';
+/**
+ * `RuleParser` is responsible for parsing the rules.
+ *
+ * It automatically determines the category and syntax of the rule, so you can pass any kind of rule to it.
+ */
+export declare class RuleParser extends BaseParser {
+    /**
+     * Helper method to parse host rules if the `parseHostRules` option is enabled, otherwise it will
+     * parse network rules.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Host rule or network rule node.
+     */
+    private static parseHostOrNetworkRule;
+    /**
+     * Parse an adblock rule. You can pass any kind of rule to this method, since it will automatically determine
+     * the category and syntax. If the rule is syntactically invalid, then an error will be thrown. If the
+     * syntax / compatibility cannot be determined clearly, then the value of the `syntax` property will be
+     * `Common`.
+     *
+     * For example, let's have this network rule:
+     * ```adblock
+     * ||example.org^$important
+     * ```
+     * The `syntax` property will be `Common`, since the rule is syntactically correct in every adblockers, but we
+     * cannot determine at parsing level whether `important` is an existing option or not, nor if it exists, then
+     * which adblocker supports it. This is why the `syntax` property is simply `Common` at this point.
+     * The concrete COMPATIBILITY of the rule will be determined later, in a different, higher-level layer, called
+     * "Compatibility table".
+     *
+     * But we can determinate the concrete syntax of this rule:
+     * ```adblock
+     * example.org#%#//scriptlet("scriptlet0", "arg0")
+     * ```
+     * since it is clearly an AdGuard-specific rule and no other adblockers uses this syntax natively. However, we also
+     * cannot determine the COMPATIBILITY of this rule, as it is not clear at this point whether the `scriptlet0`
+     * scriptlet is supported by AdGuard or not. This is also the task of the "Compatibility table". Here, we simply
+     * mark the rule with the `AdGuard` syntax in this case.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Adblock rule node
+     * @throws If the input matches a pattern but syntactically invalid
+     * @example
+     * Take a look at the following example:
+     * ```js
+     * // Parse a network rule
+     * const ast1 = RuleParser.parse("||example.org^$important");
+     *
+     * // Parse another network rule
+     * const ast2 = RuleParser.parse("/ads.js^$important,third-party,domain=example.org|~example.com");
+     *
+     * // Parse a cosmetic rule
+     * const ast2 = RuleParser.parse("example.org##.banner");
+     *
+     * // Parse another cosmetic rule
+     * const ast3 = RuleParser.parse("example.org#?#.banner:-abp-has(.ad)");
+     *
+     * // Parse a comment rule
+     * const ast4 = RuleParser.parse("! Comment");
+     *
+     * // Parse an empty rule
+     * const ast5 = RuleParser.parse("");
+     *
+     * // Parse a comment rule (with metadata)
+     * const ast6 = RuleParser.parse("! Title: Example");
+     *
+     * // Parse a pre-processor rule
+     * const ast7 = RuleParser.parse("!#if (adguard)");
+     * ```
+     */
+    static parse(raw: string, options?: import("./options").ParserOptions, baseOffset?: number): AnyRule;
+}

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

@@ -0,0 +1,15 @@
+import { type OutputByteBuffer } from '../utils/output-byte-buffer';
+import { type Node } from '../nodes';
+/**
+ * Base class for serializers. Each serializer should extend this class.
+ */
+export declare class BaseSerializer {
+    /**
+     * Serializes the AST node to a byte buffer.
+     *
+     * @param node AST node to serialize.
+     * @param buffer Output byte buffer to write to.
+     * @param args Additional, parser-specific arguments, if needed.
+     */
+    static serialize(node: Node, buffer: OutputByteBuffer, ...args: unknown[]): void;
+}

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

@@ -0,0 +1,34 @@
+import { type AgentCommentRule } from '../../nodes';
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `AgentCommentSerializer` is responsible for serializing 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 AgentCommentSerializer extends BaseSerializer {
+    /**
+     * Serializes an adblock agent list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: AgentCommentRule, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,15 @@
+import { type Agent } from '../../nodes';
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `AgentSerializer` is responsible for serializing single adblock agent elements into a binary format.
+ */
+export declare class AgentSerializer extends BaseSerializer {
+    /**
+     * Serializes an agent node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: Agent, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,68 @@
+import { type AnyCommentRule } from '../../nodes';
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `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 CommentRuleSerializer extends BaseSerializer {
+    /**
+     * Serializes a comment rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: AnyCommentRule, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,25 @@
+import { type ConfigCommentRule } from '../../nodes';
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `ConfigCommentSerializer` is responsible for serializing inline AGLint configuration rules into a binary format.
+ * 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 ConfigCommentSerializer extends BaseSerializer {
+    /**
+     * Serializes a config node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    private static serializeConfigNode;
+    /**
+     * Serializes a metadata comment node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: ConfigCommentRule, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,23 @@
+import { type HintCommentRule } from '../../nodes';
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `HintCommentSerializer` is responsible for serializing 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 HintCommentSerializer extends BaseSerializer {
+    /**
+     * Serializes a hint rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: HintCommentRule, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,24 @@
+import { type Hint } from '../../nodes';
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `HintSerializer` is responsible for serializing 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 HintSerializer extends BaseSerializer {
+    /**
+     * Serializes a hint node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: Hint, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,25 @@
+import { type MetadataCommentRule } from '../../nodes';
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `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}
+ */
+export declare class MetadataCommentSerializer extends BaseSerializer {
+    /**
+     * Serializes a metadata comment node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: MetadataCommentRule, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,28 @@
+import type { PreProcessorCommentRule } from '../../nodes';
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `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}
+ */
+export declare 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.
+     */
+    static serialize(node: PreProcessorCommentRule, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,24 @@
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { type CommentRule } from '../../nodes';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `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
+ * ```
+ */
+export declare 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.
+     */
+    static serialize(node: CommentRule, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,25 @@
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+import { type OutputByteBuffer } from '../../../utils/output-byte-buffer';
+import { BaseSerializer } from '../../base-serializer';
+/**
+ * `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}
+ */
+export declare 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: ScriptletInjectionRuleBody, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,25 @@
+import { type OutputByteBuffer } from '../../../utils/output-byte-buffer';
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+import { BaseSerializer } from '../../base-serializer';
+/**
+ * `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}
+ */
+export declare 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: ScriptletInjectionRuleBody, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,17 @@
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+import { type OutputByteBuffer } from '../../../utils/output-byte-buffer';
+import { BaseSerializer } from '../../base-serializer';
+/**
+ * Serializer for scriptlet injection rule body nodes.
+ */
+export declare 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: ScriptletInjectionRuleBody, buffer: OutputByteBuffer, frequentScriptletArgs?: Map<string, number>) => void;
+}

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

@@ -0,0 +1,25 @@
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+import { type OutputByteBuffer } from '../../../utils/output-byte-buffer';
+import { BaseSerializer } from '../../base-serializer';
+/**
+ * `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}
+ */
+export declare 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: ScriptletInjectionRuleBody, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,19 @@
+import { type AnyCosmeticRule } from '../../nodes';
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `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.
+ */
+export declare class CosmeticRuleSerializer extends BaseSerializer {
+    /**
+     * Serializes a cosmetic rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: AnyCosmeticRule, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,15 @@
+import { type CssInjectionRuleBody } from '../../nodes';
+import type { OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * Serializer for CSS injection rule body nodes.
+ */
+export declare 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: CssInjectionRuleBody, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,15 @@
+import { BaseSerializer } from '../base-serializer';
+import { type ElementHidingRuleBody } from '../../nodes';
+import type { OutputByteBuffer } from '../../utils/output-byte-buffer';
+/**
+ * Serializer for element hiding rule body nodes.
+ */
+export declare 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: ElementHidingRuleBody, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,15 @@
+import { BaseSerializer } from './base-serializer';
+import { type EmptyRule } from '../nodes';
+import type { OutputByteBuffer } from '../utils/output-byte-buffer';
+/**
+ * Serializer for empty rule nodes.
+ */
+export declare 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: EmptyRule, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,15 @@
+import { type FilterList } from '../nodes';
+import { type OutputByteBuffer } from '../utils/output-byte-buffer';
+import { BaseSerializer } from './base-serializer';
+/**
+ * Serializes filter list nodes to binary format.
+ */
+export declare class FilterListSerializer extends BaseSerializer {
+    /**
+     * Serializes a filter list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: FilterList, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1 @@
+export { RuleSerializer } from './rule-serializer';

package/dist/types/serializer/invalid-rule-error-node-serializer.d.ts

@@ -0,0 +1,15 @@
+import { BaseSerializer } from './base-serializer';
+import { type InvalidRuleError } from '../nodes';
+import type { OutputByteBuffer } from '../utils/output-byte-buffer';
+/**
+ * Serializer for invalid rule error nodes.
+ */
+export declare class InvalidRuleErrorNodeSerializer extends BaseSerializer {
+    /**
+     * Serializes an invalid rule error node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: InvalidRuleError, buffer: OutputByteBuffer): void;
+}

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

@@ -0,0 +1,15 @@
+import { BaseSerializer } from './base-serializer';
+import { type InvalidRule } from '../nodes';
+import type { OutputByteBuffer } from '../utils/output-byte-buffer';
+/**
+ * Serializer for invalid rule nodes.
+ */
+export declare class InvalidRuleSerializer extends BaseSerializer {
+    /**
+     * Serializes an invalid rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: InvalidRule, buffer: OutputByteBuffer): void;
+}

package/dist/types/serializer/misc/domain-list-serializer.d.ts

@@ -0,0 +1,21 @@
+import { type DomainList } from '../../nodes';
+import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
+import { BaseSerializer } from '../base-serializer';
+/**
+ * `DomainListSerializer` is responsible for serializing a domain list.
+ *
+ * @example
+ * - If the rule is `example.com,~example.net##.ads`, the domain list is `example.com,~example.net`.
+ * - If the rule is `ads.js^$script,domains=example.com|~example.org`, the domain list is `example.com|~example.org`.
+ * This serializer is responsible for serializing these domain lists.
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_domains}
+ */
+export declare class DomainListSerializer extends BaseSerializer {
+    /**
+     * Serializes a domain list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: DomainList, buffer: OutputByteBuffer): void;
+}