@adguard/agtree 1.1.8 → 2.0.0

package/dist/agtree.d.ts

@@ -1,12 +1,52 @@
 /*
- * AGTree v1.1.8 (build date: Wed, 24 Apr 2024 15:20:41 GMT)
+ * AGTree v2.0.0 (build date: Thu, 15 Aug 2024 15:06:58 GMT)
  * (c) 2024 Adguard Software Ltd.
  * Released under the MIT license
  * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
  */
-import { MediaQueryListPlain, SelectorListPlain, DeclarationListPlain, FunctionNodePlain, CssNode, CssNodePlain, SelectorList, DeclarationList, MediaQueryList, MediaQuery, Selector, SelectorPlain, AttributeSelector, PseudoClassSelectorPlain, PseudoClassSelector, FunctionNode } from '@adguard/ecss-tree';
-import * as ecssTree from '@adguard/ecss-tree';
-export { ecssTree as ECSSTree };
+import zod from 'zod';
+
+/**
+ * @file Common options for all parsers.
+ */
+/**
+ * Common options for all parsers.
+ */
+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.
+ */
+declare const defaultParserOptions: ParserOptions;
 
 /**
  * @file Possible adblock syntaxes are listed here.
@@ -14,7 +54,7 @@ export { ecssTree as ECSSTree };
 /**
  * Possible adblock syntaxes (supported by this library)
  */
-declare const enum AdblockSyntax {
+declare enum AdblockSyntax {
     /**
      * Common syntax, which is supported by more than one adblocker (or by all adblockers).
      *
@@ -58,7 +98,7 @@ declare const enum AdblockSyntax {
 }
 
 declare const ADG_SCRIPTLET_MASK = "//scriptlet";
-declare const UBO_SCRIPTLET_MASK = "js";
+declare const UBO_SCRIPTLET_MASK = "+js";
 declare const MODIFIERS_SEPARATOR = ",";
 declare const MODIFIER_ASSIGN_OPERATOR = "=";
 declare const NEGATION_MARKER = "~";
@@ -92,9 +132,13 @@ declare const IF = "if";
 declare const INCLUDE = "include";
 
 /**
- * Represents possible logical expression operators.
+ * Possible operators in the logical expression.
  */
-type AnyOperator = '&&' | '||' | '!';
+declare const enum OperatorValue {
+    Not = "!",
+    And = "&&",
+    Or = "||"
+}
 /**
  * Represents possible new line types.
  */
@@ -106,7 +150,7 @@ type AnyExpressionNode = ExpressionVariableNode | ExpressionOperatorNode | Expre
 /**
  * Represents any kind of adblock rule.
  */
-type AnyRule = EmptyRule | AnyCommentRule | AnyCosmeticRule | NetworkRule | InvalidRule;
+type AnyRule = EmptyRule | AnyCommentRule | AnyCosmeticRule | AnyNetworkRule | InvalidRule;
 /**
  * Represents any comment-like adblock rule.
  */
@@ -115,6 +159,10 @@ type AnyCommentRule = AgentCommentRule | CommentRule | ConfigCommentRule | HintC
  * Represents any cosmetic adblock rule.
  */
 type AnyCosmeticRule = CssInjectionRule | ElementHidingRule | ScriptletInjectionRule | HtmlFilteringRule | JsInjectionRule;
+/**
+ * Represents any network adblock rule.
+ */
+type AnyNetworkRule = NetworkRule | HostRule;
 /**
  * Represents the different comment markers that can be used in an adblock rule.
  *
@@ -137,7 +185,7 @@ declare const enum CommentMarker {
  * Represents the main categories that an adblock rule can belong to.
  * Of course, these include additional subcategories.
  */
-declare const enum RuleCategory {
+declare enum RuleCategory {
     /**
      * Empty "rules" that are only containing whitespaces. These rules are handled just for convenience.
      */
@@ -165,6 +213,7 @@ declare const enum RuleCategory {
  * which may be separated by a comma `,` (only for DomainList) or a pipe `|`.
  */
 declare const enum ListNodeType {
+    Unknown = "Unknown",
     AppList = "AppList",
     DomainList = "DomainList",
     MethodList = "MethodList",
@@ -173,7 +222,8 @@ declare const enum ListNodeType {
 /**
  * Represents child items for {@link ListNodeType}.
  */
-declare const enum ListItemNodeType {
+declare enum ListItemNodeType {
+    Unknown = "Unknown",
     App = "App",
     Domain = "Domain",
     Method = "Method",
@@ -182,7 +232,7 @@ declare const enum ListItemNodeType {
 /**
  * Represents possible comment types.
  */
-declare const enum CommentRuleType {
+declare enum CommentRuleType {
     AgentCommentRule = "AgentCommentRule",
     CommentRule = "CommentRule",
     ConfigCommentRule = "ConfigCommentRule",
@@ -193,7 +243,7 @@ declare const enum CommentRuleType {
 /**
  * Represents possible cosmetic rule types.
  */
-declare const enum CosmeticRuleType {
+declare enum CosmeticRuleType {
     ElementHidingRule = "ElementHidingRule",
     CssInjectionRule = "CssInjectionRule",
     ScriptletInjectionRule = "ScriptletInjectionRule",
@@ -259,23 +309,7 @@ declare const enum CosmeticRuleSeparator {
     /**
      * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#html-filtering-rules}
      */
-    AdgHtmlFilteringException = "$@$",
-    /**
-     * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#scriptlet-injection}
-     */
-    UboScriptletInjection = "##+",
-    /**
-     * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#scriptlet-injection}
-     */
-    UboScriptletInjectionException = "#@#+",
-    /**
-     * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#html-filters}
-     */
-    UboHtmlFiltering = "##^",
-    /**
-     * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#html-filters}
-     */
-    UboHtmlFilteringException = "#@#^"
+    AdgHtmlFilteringException = "$@$"
 }
 /**
  * Represents a basic node in the AST.
@@ -285,27 +319,18 @@ interface Node {
      * The type of the node. Every node should have a type.
      */
     type: string;
-    /**
-     * Every node should support a loc property, which refers to the location of the node in the source code.
-     */
-    loc?: LocationRange;
     /**
      * Optionally the raw representation of the node in the source code.
      */
     raw?: string;
-}
-/**
- * Represents a location range in the source code.
- */
-interface LocationRange {
     /**
-     * The start location of the node.
+     * Start offset of the node.
      */
-    start: Location;
+    start?: number;
     /**
-     * The end location of the node.
+     * End offset of the node.
      */
-    end: Location;
+    end?: number;
 }
 /**
  * Represents a location in the source code.
@@ -325,24 +350,27 @@ interface Location {
     column: number;
 }
 /**
- * Represents a basic value node in the AST.
+ * Represents a location range in the source code.
  */
-interface Value<T = string> extends Node {
-    type: 'Value';
+interface LocationRange {
     /**
-     * Value of the node.
+     * The start location of the node.
      */
-    value: T;
+    start: Location;
+    /**
+     * The end location of the node.
+     */
+    end: Location;
 }
 /**
- * Represents a basic parameter node in the AST.
+ * Represents a basic value node in the AST.
  */
-interface Parameter extends Node {
-    type: 'Parameter';
+interface Value<T = string> extends Node {
+    type: 'Value';
     /**
      * Value of the node.
      */
-    value: string;
+    value: T;
 }
 /**
  * Represents a list of parameters.
@@ -351,8 +379,10 @@ interface ParameterList extends Node {
     type: 'ParameterList';
     /**
      * List of values
+     *
+     * @note `null` values are allowed in the list, they represent empty parameters.
      */
-    children: Parameter[];
+    children: (Value | null)[];
 }
 /**
  * Represents a logical expression variable node in the AST.
@@ -366,7 +396,7 @@ interface ExpressionVariableNode extends Node {
  */
 interface ExpressionOperatorNode extends Node {
     type: 'Operator';
-    operator: AnyOperator;
+    operator: OperatorValue;
     left: AnyExpressionNode;
     right?: AnyExpressionNode;
 }
@@ -415,6 +445,17 @@ interface RuleBase extends Node {
         nl?: NewLine;
     };
 }
+interface InvalidRuleError extends Node {
+    type: 'InvalidRuleError';
+    /**
+     * Error name
+     */
+    name: string;
+    /**
+     * Error message
+     */
+    message: string;
+}
 /**
  * Represents an invalid rule (used by tolerant mode).
  */
@@ -431,20 +472,7 @@ interface InvalidRule extends RuleBase {
     /**
      * Error details
      */
-    error: {
-        /**
-         * Error name
-         */
-        name: string;
-        /**
-         * Error message
-         */
-        message: string;
-        /**
-         * Error location (if any)
-         */
-        loc?: LocationRange;
-    };
+    error: InvalidRuleError;
 }
 /**
  * Represents an "empty rule" (practically an empty line)
@@ -487,7 +515,7 @@ interface CommentRule extends CommentBase {
      * - If the rule is `! This is just a comment`, then the marker will be `!`.
      * - If the rule is `# This is just a comment`, then the marker will be `#`.
      */
-    marker: Value<CommentMarker>;
+    marker: Value;
     /**
      * Comment text.
      *
@@ -512,7 +540,7 @@ interface MetadataCommentRule extends CommentBase {
     /**
      * Comment marker.
      */
-    marker: Value<CommentMarker>;
+    marker: Value;
     /**
      * Metadata header name.
      */
@@ -522,6 +550,21 @@ interface MetadataCommentRule extends CommentBase {
      */
     value: Value;
 }
+/**
+ * Represents an AGLint configuration node.
+ *
+ * Used within config comments.
+ *
+ * @example
+ * ```adblock
+ * ! aglint "rule-1": ["warn", { "option1": "value1" }], "rule-2": "off"
+ * !        ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
+ * ```
+ */
+interface ConfigNode extends Node {
+    type: 'ConfigNode';
+    value: object;
+}
 /**
  * Represents an inline linter configuration comment.
  *
@@ -538,7 +581,7 @@ interface ConfigCommentRule extends CommentBase {
     /**
      * The marker for the comment. It can be `!` or `#`. It is always the first non-whitespace character in the comment.
      */
-    marker: Value<CommentMarker>;
+    marker: Value;
     /**
      * The command for the comment. It is always begins with the `aglint` prefix.
      *
@@ -558,7 +601,7 @@ interface ConfigCommentRule extends CommentBase {
      * ```
      * the params would be `["some-rule", "another-rule"]`.
      */
-    params?: Value<object> | ParameterList;
+    params?: ConfigNode | ParameterList;
     /**
      * Config comment text. The idea is generally the same as in ESLint.
      *
@@ -605,7 +648,7 @@ interface Agent extends Node {
     /**
      * Adblock version (if specified).
      */
-    version: Value | null;
+    version?: Value;
     /**
      * Needed for network rules modifier validation.
      */
@@ -674,7 +717,7 @@ interface HintCommentRule extends RuleBase {
     /**
      * Currently only AdGuard supports hints.
      */
-    syntax: AdblockSyntax.Adg;
+    syntax: AdblockSyntax;
     /**
      * List of hints.
      */
@@ -711,7 +754,7 @@ interface Modifier extends Node {
     /**
      * Modifier name
      */
-    modifier: Value;
+    name: Value;
     /**
      * Is this modifier an exception? For example, `~third-party` is an exception
      */
@@ -747,8 +790,8 @@ type DomainListSeparator = CommaSeparator | PipeSeparator;
  * Common interface for a list item of $app, $denyallow, $domain, $method
  * which have similar syntax.
  */
-interface ListItem extends Node {
-    type: ListItemNodeType;
+interface ListItem<T extends ListItemNodeType> extends Node {
+    type: T;
     /**
      * Value of the node.
      */
@@ -764,27 +807,19 @@ interface ListItem extends Node {
 /**
  * Represents an element of the app list — $app.
  */
-interface App extends ListItem {
-    type: ListItemNodeType.App;
-}
+type App = ListItem<ListItemNodeType.App>;
 /**
  * Represents an element of the domain list — $domain, $denyallow.
  */
-interface Domain extends ListItem {
-    type: ListItemNodeType.Domain;
-}
+type Domain = ListItem<ListItemNodeType.Domain>;
 /**
  * Represents an element of the method list — $method.
  */
-interface Method extends ListItem {
-    type: ListItemNodeType.Method;
-}
+type Method = ListItem<ListItemNodeType.Method>;
 /**
  * Represents an element of the stealth option list — $stealth.
  */
-interface StealthOption extends ListItem {
-    type: ListItemNodeType.StealthOption;
-}
+type StealthOption = ListItem<ListItemNodeType.StealthOption>;
 /**
  * Represents a list of domains.
  * Needed for $domain and $denyallow.
@@ -875,17 +910,38 @@ interface StealthOptionList extends Node {
 interface CssInjectionRuleBody extends Node {
     type: 'CssInjectionRuleBody';
     /**
-     * Media query list (if any)
+     * Media query, if any.
+     *
+     * @example
+     *
+     * ```text
+     * @media (max-width: 768px) { ... }
+     *         ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
+     * ```
      */
-    mediaQueryList?: MediaQueryListPlain;
+    mediaQueryList?: Value;
     /**
-     * Selector list
+     * CSS selector list.
+     *
+     * @example
+     * section:has(> .ad) { display: none; }
+     * ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
+     * section:has(> .ad), article > p[advert] { display: none; }
+     * ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
      */
-    selectorList: SelectorListPlain;
+    selectorList: Value;
     /**
-     * Declaration block / remove flag
+     * Declaration list.
+     *
+     * @example
+     * section:has(> .ad) { display: none; }
+     *                      ↑↑↑↑↑↑↑↑↑↑↑↑↑↑
+     * section:has(> .ad), article > p[advert] { display: none; }
+     *                                           ↑↑↑↑↑↑↑↑↑↑↑↑↑↑
+     * div[ad] { padding-top: 10px; padding-bottom: 10px; }
+     *           ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
      */
-    declarationList?: DeclarationListPlain;
+    declarationList?: Value;
     /**
      * Remove flag
      */
@@ -900,7 +956,7 @@ interface ElementHidingRuleBody extends Node {
     /**
      * Element hiding rule selector(s).
      */
-    selectorList: SelectorListPlain;
+    selectorList: Value;
 }
 /**
  * Represents a scriptlet injection rule body.
@@ -920,7 +976,7 @@ interface HtmlFilteringRuleBody extends Node {
     /**
      * HTML rule selector(s).
      */
-    body: SelectorListPlain | FunctionNodePlain;
+    body: Value;
 }
 /**
  * A generic representation of a cosmetic rule.
@@ -1065,7 +1121,7 @@ interface ScriptletInjectionRule extends CosmeticRule {
  */
 interface HtmlFilteringRule extends CosmeticRule {
     type: CosmeticRuleType.HtmlFilteringRule;
-    body: HtmlFilteringRuleBody;
+    body: Value;
 }
 /**
  * Representation of a JS injection rule.
@@ -1082,13 +1138,39 @@ interface JsInjectionRule extends CosmeticRule {
     type: CosmeticRuleType.JsInjectionRule;
     body: Value;
 }
+/**
+ * Represents the different types of network rules.
+ */
+declare enum NetworkRuleType {
+    NetworkRule = "NetworkRule",
+    HostRule = "HostRule"
+}
 /**
  * Represents the common properties of network rules
  */
-interface NetworkRule extends RuleBase {
+interface NetworkRuleBase extends RuleBase {
+    /**
+     * Category of the adblock rule.
+     */
     category: RuleCategory.Network;
-    type: 'NetworkRule';
+    /**
+     * Type of the network rule.
+     */
+    type: NetworkRuleType;
+    /**
+     * Syntax of the adblock rule. If we are not able to determine the syntax of the rule,
+     * we should use `AdblockSyntax.Common` as the value.
+     */
     syntax: AdblockSyntax;
+}
+/**
+ * Represents the common properties of network rules
+ */
+interface NetworkRule extends NetworkRuleBase {
+    /**
+     * Type of the node.
+     */
+    type: NetworkRuleType.NetworkRule;
     /**
      * If the rule is an exception rule. If the rule begins with `@@`, it means that it is an exception rule.
      *
@@ -1134,197 +1216,733 @@ interface NetworkRule extends RuleBase {
      */
     modifiers?: ModifierList;
 }
-
 /**
- * `RuleParser` is responsible for parsing the rules.
+ * Represents a list of hostnames.
+ */
+interface HostnameList extends Node {
+    /**
+     * Type of the node.
+     */
+    type: 'HostnameList';
+    /**
+     * List of hostnames.
+     */
+    children: Value[];
+}
+/**
+ * Represents the common properties of host rules.
  *
- * It automatically determines the category and syntax of the rule, so you can pass any kind of rule to it.
+ * @see https://adguard-dns.io/kb/general/dns-filtering-syntax/#etc-hosts-syntax
  */
-declare class RuleParser {
+interface HostRule extends NetworkRuleBase {
     /**
-     * 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".
+     * Type of the node.
+     */
+    type: NetworkRuleType.HostRule;
+    /**
+     * IP address. It can be an IPv4 or IPv6 address.
      *
-     * But we can determinate the concrete syntax of this rule:
-     * ```adblock
-     * example.org#%#//scriptlet("scriptlet0", "arg0")
+     * @example
+     * ```text
+     * 127.0.0.1 example.com example.org
+     * ↑↑↑↑↑↑↑↑↑
      * ```
-     * 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.
+     * @note If IP is not specified in the rule, it parsed as null IP: `0.0.0.0`.
+     */
+    ip: Value;
+    /**
+     * Hostnames.
      *
-     * @param raw Raw adblock rule
-     * @param tolerant If `true`, then the parser will not throw if the rule is syntactically invalid, instead it will
-     * return an `InvalidRule` object with the error attached to it. Default is `false`.
-     * @param loc Base location of the rule
-     * @returns Adblock rule AST
-     * @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)");
+     * ```text
+     * 127.0.0.1 example.com example.org
+     *           ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
      * ```
      */
-    static parse(raw: string, tolerant?: boolean, loc?: Location): AnyRule;
+    hostnames: HostnameList;
     /**
-     * Converts a rule AST to a string.
+     * Comment (optional).
      *
-     * @param ast - Adblock rule AST
-     * @returns Raw string
      * @example
-     * Take a look at the following example:
-     * ```js
-     * // Parse the rule to the AST
-     * const ast = RuleParser.parse("example.org##.banner");
-     * // Generate the rule from the AST
-     * const raw = RuleParser.generate(ast);
-     * // Print the generated rule
-     * console.log(raw); // "example.org##.banner"
+     * ```text
+     * 127.0.0.1 localhost # This is just a comment
+     *                     ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
      * ```
      */
-    static generate(ast: AnyRule): string;
+    comment?: Value;
 }
 
 /**
- * @file Customized syntax error class for Adblock Filter Parser.
+ * @file Core ByteBuffer implementation for handling binary data in chunks.
  */
-
 /**
- * Customized syntax error class for Adblock Filter Parser,
- * which contains the location range of the error.
+ * Core ByteBuffer implementation for handling binary data in chunks.
+ * This class allows for efficient byte storage and manipulation by organizing data into chunks
+ * and providing methods to read and write bytes.
  */
-declare class AdblockSyntaxError extends SyntaxError {
+declare class ByteBuffer {
     /**
-     * Location range of the error.
+     * The size of each chunk in bytes (32 KB).
      */
-    loc: LocationRange;
+    static readonly CHUNK_SIZE = 32768;
     /**
-     * Constructs a new `AdblockSyntaxError` instance.
+     * An array of Uint8Array chunks that make up the buffer.
+     */
+    protected chunks: Uint8Array[];
+    /**
+     * The total number of chunks in the buffer.
+     */
+    protected chunksLength: number;
+    /**
+     * Constructs a new ByteBuffer instance.
      *
-     * @param message Error message
-     * @param loc Location range of the error
+     * @param chunks Optional array of chunks to initialize the ByteBuffer with.
+     * @param cloneChunks Flag indicating if the chunks should be cloned. For performance reasons,
+     * its default value is `false`. If the original chunks are guaranteed not to change,
+     * leave this flag as `false` to avoid unnecessary copying.
      */
-    constructor(message: string, loc: LocationRange);
-}
-
-/**
- * `AgentParser` is responsible for parsing an Adblock agent rules.
- * 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]
- *    ```
- */
-declare class AgentCommentRuleParser {
+    constructor(chunks?: Uint8Array[], cloneChunks?: boolean);
     /**
-     * Checks if the raw rule is an adblock agent comment.
+     * Ensures that the buffer has enough capacity to accommodate a given position.
+     * This method adjusts the `chunks` array size to ensure it can hold the specified position.
      *
-     * @param raw Raw rule
-     * @returns `true` if the rule is an adblock agent, `false` otherwise
+     * @param position The position to ensure capacity for.
      */
-    static isAgentRule(raw: string): boolean;
+    protected ensureCapacity(position: number): void;
     /**
-     * Parses a raw rule as an adblock agent comment.
+     * Writes a byte to the buffer at the specified position.
+     * If the position is outside of the buffer's current size, the buffer is resized to accommodate it.
      *
-     * @param raw Raw rule
-     * @param loc Base location
-     * @returns Agent rule AST or null (if the raw rule cannot be parsed as an adblock agent comment)
+     * @param position The position at which to write the byte.
+     * @param value The byte value to write (0-255).
      */
-    static parse(raw: string, loc?: Location): AgentCommentRule | null;
+    protected writeByte(position: number, value: number): void;
     /**
-     * Converts an adblock agent AST to a string.
+     * Reads a byte from the specified position in the buffer.
+     * Returns `undefined` if the position is outside of the buffer's current size.
      *
-     * @param ast Agent rule AST
-     * @returns Raw string
+     * @param position The position from which to read the byte.
+     * @returns The read byte value, or `undefined` if the position is out of bounds.
      */
-    static generate(ast: AgentCommentRule): string;
+    protected readByte(position: number): number | undefined;
 }
 
 /**
- * `AgentParser` is responsible for parsing 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
- * `AgentCommentRuleParser`, which uses this class to parse single agents.
+ * @file Represents a storage interface for reading and writing data.
+ */
+/**
+ * Represents a storage interface for reading and writing data.
  */
-declare class AgentParser {
+interface Storage<K = string, V = unknown> {
     /**
-     * Checks if the string is a valid version.
+     * Writes the given data to the storage with the specified key.
      *
-     * @param str String to check
-     * @returns `true` if the string is a valid version, `false` otherwise
+     * @param key The key to identify the data in the storage.
+     * @param chunks The data to write to the storage.
+     * @returns A promise that resolves when the write operation is complete.
      */
-    private static isValidVersion;
+    set(key: K, data: V): Promise<void>;
     /**
-     * Parses a raw rule as an adblock agent comment.
+     * Reads the data from the storage with the specified key.
+     *
+     * @param key The key to identify the data in the storage.
+     * @returns A promise that resolves with the data read from the storage.
+     */
+    get(key: K): Promise<V | undefined>;
+}
+
+/**
+ * @file Input byte buffer for reading binary data.
+ */
+
+/**
+ * Input byte buffer for reading binary data.
+ *
+ * @note Internally, this class uses a {@link ByteBuffer} instance, just providing a convenient API for reading data.
+ */
+declare class InputByteBuffer extends ByteBuffer {
+    /**
+     * Current offset in the buffer for reading.
+     */
+    private offset;
+    /**
+     * Shared native decoder for decoding strings.
+     */
+    private readonly sharedNativeDecoder;
+    /**
+     * Flag indicating if the current environment is Chromium.
+     * This is used for performance optimizations, because Chromium's TextEncoder/TextDecoder has a relatively
+     * large marshalling overhead for small strings.
+     */
+    private readonly isChromium;
+    /**
+     * Constructs a new `InputByteBuffer` instance.
+     *
+     * @param chunks Array of chunks to initialize the ByteBuffer with.
+     * @param cloneChunks Flag indicating if the chunks should be cloned. For performance reasons,
+     * its default value is `false`. If the original chunks are guaranteed not to change,
+     * leave this flag as `false` to avoid unnecessary copying.
+     * @param initialOffset Initial offset in the buffer for reading.
+     *
+     * @throws If the specified chunks array is empty.
+     * @throws If the binary schema version in the buffer is not equal to the expected version.
+     * @throws If the initial offset is out of bounds.
+     */
+    constructor(chunks: Uint8Array[], cloneChunks?: boolean, initialOffset?: number);
+    /**
+     * Creates a new InputByteBuffer instance from a Storage instance by reading chunks from the storage.
+     *
+     * @param storage Storage instance.
+     * @param key Key to read from the storage.
+     * @returns New InputByteBuffer instance.
+     * @note For performance reasons, chunks are passed by reference and not copied.
+     */
+    static createFromStorage(storage: Storage, key: string): Promise<InputByteBuffer>;
+    /**
+     * Reads a 8-bit unsigned integer from the buffer.
+     *
+     * @returns 8-bit unsigned integer from the buffer.
+     */
+    readUint8(): number;
+    /**
+     * Reads a 16-bit unsigned integer from the buffer.
+     *
+     * @returns 16-bit unsigned integer from the buffer.
+     */
+    readUint16(): number;
+    /**
+     * Reads a 32-bit unsigned integer from the buffer at the specified index.
+     *
+     * @param index Index to read the 32-bit unsigned integer from.
+     *
+     * @returns 32-bit unsigned integer from the buffer.
+     */
+    private readUint32FromIndex;
+    /**
+     * Reads a 32-bit unsigned integer from the buffer.
+     *
+     * @returns 32-bit unsigned integer from the buffer.
+     */
+    readUint32(): number;
+    /**
+     * Reads schema version from the buffer.
+     *
+     * @returns 32-bit unsigned integer from the buffer.
+     * @note Schema version is always stored at the beginning of the buffer.
+     */
+    readSchemaVersion(): number;
+    /**
+     * Reads a 32-bit signed integer from the buffer.
+     *
+     * @returns 32-bit signed integer from the buffer.
+     */
+    readInt32(): number;
+    /**
+     * Reads an optimized unsigned integer from the buffer.
+     * 'Optimized' means that the integer is stored in a variable number of bytes, depending on its value,
+     * so that smaller numbers occupy less space.
+     *
+     * @returns Decoded unsigned integer from the buffer.
+     */
+    readOptimizedUint(): number;
+    /**
+     * Reads a string from the buffer.
+     *
+     * @returns Decoded string from the buffer.
+     */
+    readString(): string;
+    /**
+     * Reads a 8-bit unsigned integer from the buffer without advancing the offset.
+     *
+     * @returns 8-bit unsigned integer from the buffer.
+     */
+    peekUint8(): number;
+    /**
+     * Helper method for asserting the next 8-bit unsigned integer in the buffer.
+     *
+     * @param value Expected value.
+     * @throws If the next value in the buffer is not equal to the expected value.
+     */
+    assertUint8(value: number): void;
+    /**
+     * Creates a new `InputByteBuffer` instance with the given initial offset.
+     *
+     * @param initialOffset Initial offset for the new buffer.
+     * @param cloneChunks Flag indicating if the chunks should be cloned. For performance reasons,
+     * its default value is `false`. If the original chunks are guaranteed not to change,
+     * leave this flag as `false` to avoid unnecessary copying.
+     *
+     * @returns New `InputByteBuffer` instance with the given initial offset.
+     *
+     * @note This method is useful if you want to read some data from a specific index.
+     */
+    createCopyWithOffset(initialOffset: number, cloneChunks?: boolean): InputByteBuffer;
+    /**
+     * Gets the current offset in the buffer for reading.
+     *
+     * @returns Current offset in the buffer for reading.
+     */
+    get currentOffset(): number;
+    /**
+     * Gets the capacity of the buffer.
+     *
+     * @returns Capacity of the buffer.
+     */
+    get capacity(): number;
+}
+
+/**
+ * Output byte buffer for writing binary data.
+ *
+ * @note Internally, this class uses a {@link ByteBuffer} instance, just providing a convenient API for reading data.
+ */
+declare class OutputByteBuffer extends ByteBuffer {
+    /**
+     * Current offset in the buffer for writing.
+     */
+    private offset;
+    /**
+     * Size of the shared buffer for encoding strings in bytes.
+     * This is a divisor of ByteBuffer.CHUNK_SIZE and experience shows that this value works optimally.
+     * This is sufficient for most strings that occur in filter lists (we checked average string length in popular
+     * filter lists).
+     */
+    private static readonly ENCODER_BUFFER_SIZE;
+    /**
+     * Length threshold for using a shared buffer for encoding strings.
+     * This temp buffer is needed because we write the short strings in it
+     * (so there is no need to constantly allocate a new buffer).
+     * The reason for dividing ENCODER_BUFFER_SIZE by 4 is to ensure that the encoded string fits in the buffer,
+     * if we also take into account the worst possible case (each character is encoded with 4 bytes).
+     */
+    private static readonly SHORT_STRING_THRESHOLD;
+    /**
+     * Represents the maximum value that can be written as a 'storage optimized' unsigned integer.
+     * 0x1FFFFFFF means 29 bits — 32 bits minus 3 bits — because the last bit in each byte is a flag indicating
+     * if there are more bytes (except for the last byte).
+     */
+    static MAX_OPTIMIZED_UINT: number;
+    /**
+     * Shared buffer for encoding strings.
+     */
+    private readonly sharedBuffer;
+    /**
+     * Shared native encoder for encoding strings.
+     */
+    private readonly sharedNativeEncoder;
+    /**
+     * Flag indicating if the current environment is Chromium.
+     * This is used for performance optimizations, because Chromium's TextEncoder/TextDecoder has a relatively
+     * large marshalling overhead for small strings.
+     */
+    private readonly isChromium;
+    /**
+     * Constructs a new OutputByteBuffer instance.
+     */
+    constructor();
+    /**
+     * Writes a 8-bit unsigned integer to the buffer.
+     *
+     * @param value Value to write.
+     * @returns Number of bytes written to the buffer.
+     */
+    writeUint8(value: number): number;
+    /**
+     * Writes a 16-bit unsigned integer to the buffer.
+     *
+     * @param value Value to write.
+     * @returns Number of bytes written to the buffer.
+     */
+    writeUint16(value: number): number;
+    /**
+     * Writes a 32-bit unsigned integer to the buffer at a specific index.
+     *
+     * @param value Value to write.
+     * @param index Index to write the value to.
+     * @returns Number of bytes written to the buffer.
+     */
+    private writeUint32ToIndex;
+    /**
+     * Writes a 32-bit unsigned integer to the buffer.
+     *
+     * @param value Value to write.
+     * @returns Number of bytes written to the buffer.
+     */
+    writeUint32(value: number): number;
+    /**
+     * Writes a 32-bit signed integer to the buffer.
+     *
+     * @param value Value to write.
+     * @returns Number of bytes written to the buffer.
+     */
+    writeInt32(value: number): number;
+    /**
+     * Writes a Uint8Array to the byte buffer.
+     *
+     * @param buffer Buffer to write.
+     */
+    private writeBuffer;
+    /**
+     * Writes a string to the buffer.
+     *
+     * @param value Value to write.
+     * @returns Number of bytes written to the buffer.
+     */
+    writeString(value: string): number;
+    /**
+     * Writes chunks to the storage.
+     *
+     * @param storage Storage to write the chunks to.
+     * @param key Key to write the chunks to.
+     * @note For performance reasons, chunks are passed by reference and not copied.
+     * @throws If the storage write operation throws.
+     */
+    writeChunksToStorage(storage: Storage, key: string): Promise<void>;
+    /**
+     * Writes an 'optimized' unsigned integer to the buffer.
+     * 'Optimized' means smaller storage usage for smaller numbers.
+     * Except for the last byte, each byte's most significant bit is a flag indicating if there are more bytes.
+     *
+     * @param value Value to write.
+     * @returns Number of bytes written to the buffer.
+     * @throws If the value exceeds the 29-bit limit.
+     */
+    writeOptimizedUint(value: number): number;
+    /**
+     * Gets the current offset in the buffer for writing.
+     *
+     * @returns Current offset in the buffer for writing.
+     */
+    get currentOffset(): number;
+}
+
+/**
+ * Base class for parsers. Each parser should extend this class.
+ */
+declare class ParserBase {
+    /**
+     * Parses the input string and returns the AST node.
+     *
+     * @param input Input string to parse.
+     * @param options Parser options, see {@link ParserOptions}.
+     * @param baseOffset Base offset. Locations in the AST node will be relative to this offset.
+     * @param args Additional, parser-specific arguments, if needed.
+     */
+    static parse(input: string, options: ParserOptions, baseOffset: number, ...args: unknown[]): Node | null;
+    /**
+     * Generates a string from the AST node.
+     *
+     * @param node AST node to generate a string from.
+     */
+    static generate(node: Node): string;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+
+/**
+ * `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.
+ */
+declare class RuleParser extends ParserBase {
+    /**
+     * 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?: ParserOptions, baseOffset?: number): AnyRule;
+    /**
+     * Converts a rule AST to a string.
+     *
+     * @param ast - Adblock rule AST
+     * @returns Raw string
+     * @example
+     * Take a look at the following example:
+     * ```js
+     * // Parse the rule to the AST
+     * const ast = RuleParser.parse("example.org##.banner");
+     * // Generate the rule from the AST
+     * const raw = RuleParser.generate(ast);
+     * // Print the generated rule
+     * console.log(raw); // "example.org##.banner"
+     * ```
+     */
+    static generate(ast: AnyRule): string;
+    /**
+     * Serializes an empty rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serializeEmptyRule(node: EmptyRule, buffer: OutputByteBuffer): void;
+    /**
+     * Deserializes an empty rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserializeEmptyRule(buffer: InputByteBuffer, node: EmptyRule): void;
+    /**
+     * Serializes an invalid rule error node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serializeInvalidRuleErrorNode(node: InvalidRuleError, buffer: OutputByteBuffer): void;
+    /**
+     * Deserializes an invalid rule error node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserializeInvalidRuleErrorNode(buffer: InputByteBuffer, node: Partial<InvalidRuleError>): void;
+    /**
+     * Serializes an invalid rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serializeInvalidRule(node: InvalidRule, buffer: OutputByteBuffer): void;
+    /**
+     * Deserializes an invalid rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserializeInvalidRule(buffer: InputByteBuffer, node: InvalidRule): void;
+    /**
+     * Serializes a rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: AnyRule, buffer: OutputByteBuffer): void;
+    /**
+     * Deserializes a rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer: InputByteBuffer, node: Partial<AnyRule>): void;
+}
+
+/**
+ * @file Customized syntax error class for Adblock Filter Parser.
+ */
+/**
+ * Customized syntax error class for Adblock Filter Parser,
+ * which contains the location range of the error.
+ */
+declare class AdblockSyntaxError extends SyntaxError {
+    /**
+     * Start offset of the error.
+     */
+    start: number;
+    /**
+     * End offset of the error.
+     */
+    end: number;
+    /**
+     * Constructs a new `AdblockSyntaxError` instance.
+     *
+     * @param message Error message.
+     * @param start Start offset of the error.
+     * @param end End offset of the error.
+     */
+    constructor(message: string, start: number, end: number);
+}
+
+/**
+ * `AgentParser` is responsible for parsing an Adblock agent rules.
+ * 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]
+ *    ```
+ */
+declare class AgentCommentRuleParser extends ParserBase {
+    /**
+     * Checks if the raw rule is an adblock agent comment.
      *
      * @param raw Raw rule
-     * @param loc Base location
+     * @returns `true` if the rule is an adblock agent, `false` otherwise
+     */
+    static isAgentRule(raw: string): boolean;
+    /**
+     * Parses a raw rule as an adblock agent comment.
+     *
+     * @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 Agent rule AST or null (if the raw rule cannot be parsed as an adblock agent comment)
+     */
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): AgentCommentRule | null;
+    /**
+     * Converts an adblock agent AST to a string.
+     *
+     * @param ast Agent rule AST
+     * @returns Raw string
+     */
+    static generate(ast: AgentCommentRule): string;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+
+/**
+ * `AgentParser` is responsible for parsing 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
+ * `AgentCommentRuleParser`, which uses this class to parse single agents.
+ */
+declare class AgentParser extends ParserBase {
+    /**
+     * Checks if the string is a valid version.
+     *
+     * @param str String to check
+     * @returns `true` if the string is a valid version, `false` otherwise
+     */
+    private static isValidVersion;
+    /**
+     * Parses a raw rule as an adblock agent comment.
+     *
+     * @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 Agent rule AST
      * @throws {AdblockSyntaxError} If the raw rule cannot be parsed as an adblock agent
      */
-    static parse(raw: string, loc?: Location): Agent;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): Agent;
     /**
-     * Converts an adblock agent AST to a string.
+     * Converts an adblock agent node to a string.
      *
-     * @param ast Agent AST
+     * @param value Agent node
      * @returns Raw string
      */
-    static generate(ast: Agent): string;
+    static generate(value: Agent): string;
+    /**
+     * 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;
+    /**
+     * 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;
 }
 
 /**
@@ -1383,15 +2001,7 @@ declare class AgentParser {
  *        ```
  *      - etc.
  */
-declare class CommentRuleParser {
-    /**
-     * Checks whether a rule is a regular comment. Regular comments are the ones that start with
-     * an exclamation mark (`!`).
-     *
-     * @param raw Raw rule
-     * @returns `true` if the rule is a regular comment, `false` otherwise
-     */
-    static isRegularComment(raw: string): boolean;
+declare class CommentRuleParser extends ParserBase {
     /**
      * Checks whether a rule is a comment.
      *
@@ -1402,32 +2012,43 @@ declare class CommentRuleParser {
     /**
      * Parses a raw rule as comment.
      *
-     * @param raw Raw rule
-     * @param loc Base location
+     * @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 Comment AST or null (if the raw rule cannot be parsed as comment)
      */
-    static parse(raw: string, loc?: Location): AnyCommentRule | null;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): AnyCommentRule | null;
     /**
-     * Converts a comment AST to a string.
+     * Converts a comment rule node to a string.
      *
-     * @param ast Comment AST
+     * @param node Comment rule node
      * @returns Raw string
      */
-    static generate(ast: AnyCommentRule): string;
+    static generate(node: AnyCommentRule): string;
+    /**
+     * 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;
+    /**
+     * 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;
 }
 
-/**
- * @file AGLint configuration comments. Inspired by ESLint inline configuration comments.
- * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
- */
-
 /**
  * `ConfigCommentParser` is responsible for parsing 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}
  */
-declare class ConfigCommentRuleParser {
+declare class ConfigCommentRuleParser extends ParserBase {
     /**
      * Checks if the raw rule is an inline configuration comment rule.
      *
@@ -1438,19 +2059,50 @@ declare class ConfigCommentRuleParser {
     /**
      * Parses a raw rule as an inline configuration comment.
      *
-     * @param raw Raw rule
-     * @param loc Base location
+     * @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
      * Inline configuration comment AST or null (if the raw rule cannot be parsed as configuration comment)
      */
-    static parse(raw: string, loc?: Location): ConfigCommentRule | null;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): ConfigCommentRule | null;
     /**
-     * Converts an inline configuration comment AST to a string.
+     * Converts an inline configuration comment node to a string.
      *
-     * @param ast Inline configuration comment AST
+     * @param node Inline configuration comment node
      * @returns Raw string
      */
-    static generate(ast: ConfigCommentRule): string;
+    static generate(node: ConfigCommentRule): string;
+    /**
+     * Serializes a config node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    private static serializeConfigNode;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
 }
 
 /**
@@ -1467,7 +2119,7 @@ declare class ConfigCommentRuleParser {
  * compatible with the given adblocker. This is a completely natural behavior, meaningful
  * checking of compatibility is not done at the parser level.
  */
-declare class CosmeticRuleParser {
+declare class CosmeticRuleParser extends ParserBase {
     /**
      * Determines whether a rule is a cosmetic rule. The rule is considered cosmetic if it
      * contains a cosmetic rule separator.
@@ -1482,42 +2134,85 @@ declare class CosmeticRuleParser {
      *  - separator
      *  - body
      *
-     * @param raw Raw cosmetic rule
-     * @param loc Location of the rule
+     * @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
      * Parsed cosmetic rule AST or null if it failed to parse based on the known cosmetic rules
      * @throws If the input matches the cosmetic rule pattern but syntactically invalid
      */
-    static parse(raw: string, loc?: Location): AnyCosmeticRule | null;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): AnyCosmeticRule | null;
     /**
      * Generates the rule pattern from the AST.
      *
-     * @param ast Cosmetic rule AST
+     * @param node Cosmetic rule node
      * @returns Raw rule pattern
      * @example
      * - '##.foo' → ''
      * - 'example.com,example.org##.foo' → 'example.com,example.org'
      * - '[$path=/foo/bar]example.com##.foo' → '[$path=/foo/bar]example.com'
      */
-    static generatePattern(ast: AnyCosmeticRule): string;
+    static generatePattern(node: AnyCosmeticRule): string;
     /**
-     * Generates the rule body from the AST.
+     * Generates the rule body from the node.
      *
-     * @param ast Cosmetic rule AST
+     * @param node Cosmetic rule node
      * @returns Raw rule body
      * @example
      * - '##.foo' → '.foo'
      * - 'example.com,example.org##.foo' → '.foo'
      * - 'example.com#%#//scriptlet('foo')' → '//scriptlet('foo')'
      */
-    static generateBody(ast: AnyCosmeticRule): string;
+    static generateBody(node: AnyCosmeticRule): string;
     /**
      * Converts a cosmetic rule AST into a string.
      *
-     * @param ast Cosmetic rule AST
+     * @param node Cosmetic rule AST
      * @returns Raw string
      */
-    static generate(ast: AnyCosmeticRule): string;
+    static generate(node: AnyCosmeticRule): string;
+    /**
+     * Serializes an element hiding rule body node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    private static serializeElementHidingBody;
+    /**
+     * Deserializes an element hiding rule body node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    private static deserializeElementHidingBody;
+    /**
+     * Serializes a CSS injection rule body node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    private static serializeCssInjectionBody;
+    /**
+     * Deserializes CSS injection rule body node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    private static deserializeCssInjectionBody;
+    /**
+     * 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;
+    /**
+     * 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;
 }
 
 /**
@@ -1525,18 +2220,20 @@ declare class CosmeticRuleParser {
  *
  * @see {@link https://adguard.app/kb/general/ad-filtering/create-own-filters/#app-modifier}
  */
-declare class AppListParser {
+declare class AppListParser extends ParserBase {
     /**
      * Parses an app list which items are separated by `|`,
      * e.g. `Example.exe|com.example.osx`.
      *
-     * @param raw Raw app list
-     * @param loc Location of the app list in the rule. If not set, the default location is used.
+     * @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 App list AST.
      * @throws An {@link AdblockSyntaxError} if the app list is syntactically invalid.
+     * @throws An {@link Error} if the options are invalid.
      */
-    static parse(raw: string, loc?: Location): AppList;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): AppList;
 }
 
 /**
@@ -1548,26 +2245,42 @@ declare class AppListParser {
  * This parser is responsible for parsing these domain lists.
  * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_domains}
  */
-declare class DomainListParser {
+declare class DomainListParser extends ParserBase {
     /**
      * Parses a domain list, eg. `example.com,example.org,~example.org`
      *
-     * @param raw Raw domain list.
-     * @param separator Separator character.
-     * @param loc Location of the domain list in the rule. If not set, the default location is used.
+     * @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.
+     * @param separator Separator character (default: comma)
      *
      * @returns Domain list AST.
      * @throws An {@link AdblockSyntaxError} if the domain list is syntactically invalid.
+     * @throws An {@link Error} if the options are invalid.
      */
-    static parse(raw: string, separator?: DomainListSeparator, loc?: Location): DomainList;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number, separator?: string): DomainList;
     /**
-     * Converts a domain list AST to a string.
+     * Converts a domain list node to a string.
      *
-     * @param ast Domain list AST.
+     * @param node Domain list node.
      *
      * @returns Raw string.
      */
-    static generate(ast: DomainList): string;
+    static generate(node: DomainList): string;
+    /**
+     * 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;
+    /**
+     * Deserializes a modifier list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer: InputByteBuffer, node: DomainList): void;
 }
 
 /**
@@ -1575,18 +2288,20 @@ declare class DomainListParser {
  *
  * @see {@link https://adguard.app/kb/general/ad-filtering/create-own-filters/#method-modifier}
  */
-declare class MethodListParser {
+declare class MethodListParser extends ParserBase {
     /**
      * Parses a method list which items are separated by `|`,
      * e.g. `get|post|put`.
      *
-     * @param raw Raw method list
-     * @param loc Location of the method list in the rule. If not set, the default location is used.
+     * @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 Method list AST.
      * @throws An {@link AdblockSyntaxError} if the method list is syntactically invalid.
+     * @throws An {@link Error} if the options are invalid.
      */
-    static parse(raw: string, loc?: Location): MethodList;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): MethodList;
 }
 
 /**
@@ -1594,33 +2309,33 @@ declare class MethodListParser {
  *
  * @see {@link https://adguard.app/kb/general/ad-filtering/create-own-filters/#stealth-modifier}
  */
-declare class StealthOptionListParser {
+declare class StealthOptionListParser extends ParserBase {
     /**
      * Parses a stealth option list which items are separated by `|`,
      * e.g. `dpi|ip`.
      *
-     * @param raw Raw list of stealth options.
-     * @param loc Location of the stealth option list in the rule. If not set, the default location is used.
+     * @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 Stealth option list AST.
      * @throws An {@link AdblockSyntaxError} if the stealth option list is syntactically invalid.
+     * @throws An {@link Error} if the options are invalid.
      */
-    static parse(raw: string, loc?: Location): StealthOptionList;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): StealthOptionList;
 }
 
 /**
  * `FilterListParser` is responsible for parsing a whole adblock filter list (list of rules).
  * It is a wrapper around `RuleParser` which parses each line separately.
  */
-declare class FilterListParser {
+declare class FilterListParser extends ParserBase {
     /**
      * Parses a whole adblock filter list (list of rules).
      *
-     * @param raw Filter list source code (including new lines)
-     * @param tolerant If `true`, then the parser will not throw if the rule is syntactically invalid,
-     * instead it will return an `InvalidRule` object with the error attached to it. Default is `true`.
-     * It is useful for parsing filter lists with invalid rules, because most of the rules are valid,
-     * and some invalid rules can't break the whole filter list parsing.
+     * @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 AST of the source code (list of rules)
      * @example
      * ```js
@@ -1635,7 +2350,7 @@ declare class FilterListParser {
      * ```
      * @throws If one of the rules is syntactically invalid (if `tolerant` is `false`)
      */
-    static parse(raw: string, tolerant?: boolean): FilterList;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): FilterList;
     /**
      * Serializes a whole adblock filter list (list of rules).
      *
@@ -1645,6 +2360,38 @@ declare class FilterListParser {
      * @returns Serialized filter list
      */
     static generate(ast: FilterList, preferRaw?: boolean): string;
+    /**
+     * 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;
+    /**
+     * 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;
 }
 
 /**
@@ -1658,7 +2405,7 @@ declare class FilterListParser {
  * contains two hints: `NOT_OPTIMIZED` and `PLATFORM`.
  * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#hints}
  */
-declare class HintCommentRuleParser {
+declare class HintCommentRuleParser extends ParserBase {
     /**
      * Checks if the raw rule is a hint rule.
      *
@@ -1669,27 +2416,38 @@ declare class HintCommentRuleParser {
     /**
      * Parses a raw rule as a hint comment.
      *
-     * @param raw Raw rule
-     * @param loc Base location
+     * @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 Hint AST or null (if the raw rule cannot be parsed as a hint comment)
      * @throws If the input matches the HINT pattern but syntactically invalid
      * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#hints-1}
      */
-    static parse(raw: string, loc?: Location): HintCommentRule | null;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): HintCommentRule | null;
     /**
-     * Converts a hint rule AST to a raw string.
+     * Converts a hint rule node to a raw string.
      *
-     * @param ast Hint rule AST
+     * @param node Hint rule node
      * @returns Raw string
      */
-    static generate(ast: HintCommentRule): string;
+    static generate(node: HintCommentRule): string;
+    /**
+     * 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;
+    /**
+     * 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;
 }
 
-/**
- * @file AdGuard Hints
- * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#hints}
- */
-
 /**
  * `HintParser` is responsible for parsing AdGuard hints.
  *
@@ -1702,16 +2460,17 @@ declare class HintCommentRuleParser {
  * class is responsible for parsing them. The rule itself is parsed by
  * the `HintRuleParser`, which uses this class to parse single hints.
  */
-declare class HintParser {
+declare class HintParser extends ParserBase {
     /**
      * Parses a raw rule as a hint.
      *
-     * @param raw Raw rule
-     * @param loc Base location
+     * @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 Hint rule AST or null
      * @throws If the syntax is invalid
      */
-    static parse(raw: string, loc?: Location): Hint;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): Hint;
     /**
      * Converts a single hint AST to a string.
      *
@@ -1719,6 +2478,21 @@ declare class HintParser {
      * @returns Hint string
      */
     static generate(hint: Hint): string;
+    /**
+     * 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;
+    /**
+     * 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;
 }
 
 /**
@@ -1731,38 +2505,99 @@ declare class HintParser {
  * ```
  * this parser will parse the expression `(adguard_ext_android_cb || adguard_ext_safari)`.
  */
-declare class LogicalExpressionParser {
+declare class LogicalExpressionParser extends ParserBase {
     /**
      * Split the expression into tokens.
      *
-     * @param raw Source code of the expression
-     * @param loc Location of the expression
-     * @returns Token list
-     * @throws {AdblockSyntaxError} If the expression is invalid
+     * @param raw Source code of the expression
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Token list
+     * @throws {AdblockSyntaxError} If the expression is invalid
+     */
+    private static tokenize;
+    /**
+     * Parses a logical expression.
+     *
+     * @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 Parsed expression
+     * @throws {AdblockSyntaxError} If the expression is invalid
+     */
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): AnyExpressionNode;
+    /**
+     * Generates a string representation of the logical expression (serialization).
+     *
+     * @param node Expression node
+     * @returns String representation of the logical expression
+     */
+    static generate(node: AnyExpressionNode): string;
+    /**
+     * Serializes a variable node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    private static serializeVariableNode;
+    /**
+     * Serializes a parenthesis node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    private static serializeParenthesisNode;
+    /**
+     * Serializes an operator node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    private static serializeOperatorNode;
+    /**
+     * Serializes a logical expression node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: AnyExpressionNode, buffer: OutputByteBuffer): void;
+    /**
+     * Deserializes a variable node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
+     */
+    private static deserializeVariableNode;
+    /**
+     * Deserializes a parenthesis node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
      */
-    private static tokenize;
+    private static deserializeParenthesisNode;
     /**
-     * Parses a logical expression.
+     * Deserializes an operator node from binary format.
      *
-     * @param raw Source code of the expression
-     * @param loc Location of the expression
-     * @returns Parsed expression
-     * @throws {AdblockSyntaxError} If the expression is invalid
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
      */
-    static parse(raw: string, loc?: Location): AnyExpressionNode;
+    private static deserializeOperatorNode;
     /**
-     * Generates a string representation of the logical expression (serialization).
+     * Deserializes a logical expression node from binary format.
      *
-     * @param ast Expression node
-     * @returns String representation of the logical expression
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
      */
-    static generate(ast: AnyExpressionNode): string;
+    static deserialize(buffer: InputByteBuffer, node: Partial<AnyExpressionNode>): void;
 }
 
 /**
- * @file Metadata comments
+ * Known metadata headers.
  */
-
+declare const KNOWN_METADATA_HEADERS: string[];
 /**
  * `MetadataParser` is responsible for parsing metadata comments.
  * Metadata comments are special comments that specify some properties of the list.
@@ -1776,22 +2611,38 @@ declare class LogicalExpressionParser {
  * 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}
  */
-declare class MetadataCommentRuleParser {
+declare class MetadataCommentRuleParser extends ParserBase {
     /**
      * Parses a raw rule as a metadata comment.
      *
-     * @param raw Raw rule
-     * @param loc Base location
+     * @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 Metadata comment AST or null (if the raw rule cannot be parsed as a metadata comment)
      */
-    static parse(raw: string, loc?: Location): MetadataCommentRule | null;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): MetadataCommentRule | null;
     /**
-     * Converts a metadata comment AST to a string.
+     * Converts a metadata comment rule node to a string.
      *
-     * @param ast - Metadata comment AST
-     * @returns Raw string
+     * @param node Metadata comment rule node.
+     * @returns Raw string.
+     */
+    static generate(node: MetadataCommentRule): string;
+    /**
+     * 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;
+    /**
+     * 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 generate(ast: MetadataCommentRule): string;
+    static deserialize(buffer: InputByteBuffer, node: Partial<MetadataCommentRule>): void;
 }
 
 /**
@@ -1802,18 +2653,19 @@ declare class MetadataCommentRuleParser {
  * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#non-basic-rules-modifiers}
  * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#options}
  */
-declare class ModifierListParser {
+declare class ModifierListParser extends ParserBase {
     /**
      * Parses the cosmetic rule modifiers, eg. `third-party,domain=example.com|~example.org`.
      *
      * _Note:_ you should remove `$` separator before passing the raw modifiers to this function,
      *  or it will be parsed in the first modifier.
      *
-     * @param raw Raw modifier list
-     * @param loc Location of the modifier list
+     * @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 Parsed modifiers interface
      */
-    static parse(raw: string, loc?: Location): ModifierList;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): ModifierList;
     /**
      * Converts a modifier list AST to a string.
      *
@@ -1821,6 +2673,20 @@ declare class ModifierListParser {
      * @returns Raw string
      */
     static generate(ast: ModifierList): string;
+    /**
+     * Serializes a modifier list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: ModifierList, buffer: OutputByteBuffer): void;
+    /**
+     * Deserializes a modifier list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer: InputByteBuffer, node: ModifierList): void;
 }
 
 /**
@@ -1829,17 +2695,18 @@ declare class ModifierListParser {
  * @example
  * `match-case`, `~third-party`, `domain=example.com|~example.org`
  */
-declare class ModifierParser {
+declare class ModifierParser extends ParserBase {
     /**
      * Parses a modifier.
      *
-     * @param raw Raw modifier string
-     * @param loc Location of the modifier
+     * @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 Parsed modifier
      * @throws An error if modifier name or value is empty.
      */
-    static parse(raw: string, loc?: Location): Modifier;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): Modifier;
     /**
      * Generates a string from a modifier (serializes it).
      *
@@ -1847,6 +2714,20 @@ declare class ModifierParser {
      * @returns String representation of the modifier
      */
     static generate(modifier: Modifier): string;
+    /**
+     * Serializes a modifier node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: Modifier, buffer: OutputByteBuffer): void;
+    /**
+     * Deserializes a modifier node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer: InputByteBuffer, node: Partial<Modifier>): void;
 }
 
 /**
@@ -1858,15 +2739,18 @@ declare class ModifierParser {
  * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#basic-rules}
  * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#basic}
  */
-declare class NetworkRuleParser {
+declare class NetworkRuleParser extends ParserBase {
     /**
      * Parses a network rule (also known as basic rule).
      *
-     * @param raw Raw rule
-     * @param loc Location of the rule
+     * @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 Network rule AST
+     *
+     * @throws If the rule is syntactically incorrect.
      */
-    static parse(raw: string, loc?: Location): NetworkRule;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): NetworkRule;
     /**
      * Finds the index of the separator character in a network rule.
      *
@@ -1877,10 +2761,24 @@ declare class NetworkRuleParser {
     /**
      * Converts a network rule (basic rule) AST to a string.
      *
-     * @param ast - Network rule AST
+     * @param node Network rule node
      * @returns Raw string
      */
-    static generate(ast: NetworkRule): string;
+    static generate(node: NetworkRule): string;
+    /**
+     * Serializes a network rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: NetworkRule, buffer: OutputByteBuffer): void;
+    /**
+     * Deserializes a modifier node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer: InputByteBuffer, node: Partial<NetworkRule>): void;
 }
 
 /**
@@ -1898,16 +2796,17 @@ declare class NotImplementedError extends Error {
     constructor(message?: string | undefined);
 }
 
-declare class ParameterListParser {
+declare class ParameterListParser extends ParserBase {
     /**
      * Parses a raw parameter list.
      *
-     * @param raw Raw parameter list
+     * @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.
      * @param separator Separator character (default: comma)
-     * @param loc Base location
      * @returns Parameter list AST
      */
-    static parse(raw: string, separator?: string, loc?: Location): ParameterList;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number, separator?: string): ParameterList;
     /**
      * Converts a parameter list AST to a string.
      *
@@ -1916,14 +2815,94 @@ declare class ParameterListParser {
      * @returns String representation of the parameter list
      */
     static generate(params: ParameterList, separator?: string): string;
+    /**
+     * Serializes a parameter list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     * @param frequentValuesMap Optional map of frequent values.
+     * @param toLower Whether to lowercase the value before the frequent value match (defaults to `false`).
+     */
+    static serialize(node: ParameterList, buffer: OutputByteBuffer, frequentValuesMap?: Map<string, number>, toLower?: boolean): void;
+    /**
+     * Deserializes a parameter list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @param frequentValuesMap Optional map of frequent values.
+     * @throws If the binary data is malformed.
+     */
+    static deserialize(buffer: InputByteBuffer, node: ParameterList, frequentValuesMap?: Map<number, string>): void;
 }
 
 /**
- * Pre-processor directives
+ * `HostRuleParser` is responsible for parsing hosts-like rules.
  *
- * @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}
+ * HostRule is a structure for simple host-level rules (i.e. /etc/hosts syntax).
+ * It also supports "just domain" syntax. In this case, the IP will be set to 0.0.0.0.
+ *
+ * Rules syntax looks like this:
+ * ```text
+ * IP_address canonical_hostname [aliases...]
+ * ```
+ *
+ * @example
+ * `192.168.1.13 bar.mydomain.org bar` -- ipv4
+ * `ff02::1 ip6-allnodes` -- ipv6
+ * `::1 localhost ip6-localhost ip6-loopback` -- ipv6 aliases
+ * `example.org` -- "just domain" syntax
+ * @see {@link http://man7.org/linux/man-pages/man5/hosts.5.html}
  */
+declare class HostRuleParser extends ParserBase {
+    static readonly NULL_IP = "0.0.0.0";
+    static readonly COMMENT_MARKER = "#";
+    /**
+     * Parses an etc/hosts-like rule.
+     *
+     * @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 node.
+     *
+     * @throws If the input contains invalid data.
+     */
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): HostRule;
+    /**
+     * Converts a host rule node to a raw string.
+     *
+     * @param node Host rule node.
+     * @returns Raw string.
+     */
+    static generate(node: HostRule): string;
+    /**
+     * Serializes a hostname list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    private static serializeHostnameList;
+    /**
+     * Deserializes a hostname list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    private static deserializeHostnameList;
+    /**
+     * Serializes a host rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node: HostRule, buffer: OutputByteBuffer): void;
+    /**
+     * Deserializes a modifier node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer: InputByteBuffer, node: Partial<HostRule>): void;
+}
 
 /**
  * `PreProcessorParser` is responsible for parsing preprocessor rules.
@@ -1941,7 +2920,7 @@ declare class ParameterListParser {
  * @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}
  */
-declare class PreProcessorCommentRuleParser {
+declare class PreProcessorCommentRuleParser extends ParserBase {
     /**
      * Determines whether the rule is a pre-processor rule.
      *
@@ -1952,19 +2931,35 @@ declare class PreProcessorCommentRuleParser {
     /**
      * Parses a raw rule as a pre-processor comment.
      *
-     * @param raw Raw rule
-     * @param loc Base location
+     * @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
      * Pre-processor comment AST or null (if the raw rule cannot be parsed as a pre-processor comment)
      */
-    static parse(raw: string, loc?: Location): PreProcessorCommentRule | null;
+    static parse(raw: string, options?: ParserOptions, baseOffset?: number): PreProcessorCommentRule | null;
     /**
-     * Converts a pre-processor comment AST to a string.
+     * Converts a pre-processor comment node to a string.
      *
-     * @param ast - Pre-processor comment AST
+     * @param node Pre-processor comment node
      * @returns Raw string
      */
-    static generate(ast: PreProcessorCommentRule): string;
+    static generate(node: PreProcessorCommentRule): string;
+    /**
+     * 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;
+    /**
+     * 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;
 }
 
 /**
@@ -1982,6 +2977,30 @@ declare class RuleConversionError extends Error {
     constructor(message: string);
 }
 
+/**
+ * @file Customized error for binary schema mismatch.
+ */
+/**
+ * Customized error for binary schema mismatch.
+ */
+declare class BinarySchemaMismatchError extends Error {
+    /**
+     * Expected schema version.
+     */
+    expectedVersion: number;
+    /**
+     * Actual schema version.
+     */
+    actualVersion: number;
+    /**
+     * Constructs a new `BinarySchemaMismatchError` instance.
+     *
+     * @param expectedVersion Expected schema version.
+     * @param actualVersion Actual schema version.
+     */
+    constructor(expectedVersion: number, actualVersion: number);
+}
+
 /**
  * Result of modifier validation:
  * - `{ valid: true }` for valid and _fully supported_ modifier;
@@ -2003,17 +3022,6 @@ type ValidationResult = {
  * Modifier validator class.
  */
 declare class ModifierValidator {
-    /**
-     * Map of all modifiers data parsed from yaml files.
-     */
-    private modifiersData;
-    /**
-     * List of all modifier names for any adblocker.
-     *
-     * Please note that **deprecated** modifiers are **included** as well.
-     */
-    private allModifierNames;
-    constructor();
     /**
      * Simply checks whether the modifier exists in any adblocker.
      *
@@ -2039,30 +3047,6 @@ declare class ModifierValidator {
      * @returns Result of modifier validation.
      */
     validate: (syntax: AdblockSyntax, rawModifier: Modifier, isException?: boolean) => ValidationResult;
-    /**
-     * Returns AdGuard documentation URL for given modifier.
-     *
-     * @param modifier Parsed modifier AST node.
-     *
-     * @returns AdGuard documentation URL or `null` if not found.
-     */
-    getAdgDocumentationLink: (modifier: Modifier) => string | null;
-    /**
-     * Returns Ublock Origin documentation URL for given modifier.
-     *
-     * @param modifier Parsed modifier AST node.
-     *
-     * @returns Ublock Origin documentation URL or `null` if not found.
-     */
-    getUboDocumentationLink: (modifier: Modifier) => string | null;
-    /**
-     * Returns AdBlock Plus documentation URL for given modifier.
-     *
-     * @param modifier Parsed modifier AST node.
-     *
-     * @returns AdBlock Plus documentation URL or `null` if not found.
-     */
-    getAbpDocumentationLink: (modifier: Modifier) => string | null;
 }
 declare const modifierValidator: ModifierValidator;
 
@@ -2290,8 +3274,28 @@ declare class RuleConverter extends RuleConverterBase {
      * @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>;
 }
 
+/**
+ * @file Binary schema version.
+ */
+/**
+ * Binary schema version.
+ * This version number is used to ensure that the binary format is compatible with the current library version.
+ * We increment this number if the serialized format changes in a way that is not backwards-compatible.
+ */
+declare const BINARY_SCHEMA_VERSION = 1;
+
 /**
  * @file Cosmetic rule separator finder and categorizer
  */
@@ -2313,370 +3317,29 @@ interface CosmeticRuleSeparatorFinderResult {
 /**
  * Utility class for cosmetic rule separators.
  */
-declare class CosmeticRuleSeparatorUtils {
-    /**
-     * Checks whether the specified separator is an exception.
-     *
-     * @param separator Separator to check
-     * @returns `true` if the separator is an exception, `false` otherwise
-     */
-    static isException(separator: CosmeticRuleSeparator): boolean;
-    /**
-     * Checks whether the specified separator is marks an Extended CSS cosmetic rule.
-     *
-     * @param separator Separator to check
-     * @returns `true` if the separator is marks an Extended CSS cosmetic rule, `false` otherwise
-     */
-    static isExtendedCssMarker(separator: CosmeticRuleSeparator): boolean;
-    /**
-     * Looks for the cosmetic rule separator in the rule. This is a simplified version that
-     * masks the recursive function.
-     *
-     * @param rule Raw rule
-     * @returns Separator result or null if no separator was found
-     */
-    static find(rule: string): CosmeticRuleSeparatorFinderResult | null;
-}
-
-/**
- * @file Helper file for CSSTree to provide better compatibility with TypeScript.
- * @see {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/62536}
- */
-/**
- * CSSTree node types.
- *
- * @see {@link https://github.com/csstree/csstree/blob/master/docs/ast.md#node-types}
- */
-declare const enum CssTreeNodeType {
-    AnPlusB = "AnPlusB",
-    Atrule = "Atrule",
-    AtrulePrelude = "AtrulePrelude",
-    AttributeSelector = "AttributeSelector",
-    Block = "Block",
-    Brackets = "Brackets",
-    CDC = "CDC",
-    CDO = "CDO",
-    ClassSelector = "ClassSelector",
-    Combinator = "Combinator",
-    Comment = "Comment",
-    Declaration = "Declaration",
-    DeclarationList = "DeclarationList",
-    Dimension = "Dimension",
-    Function = "Function",
-    Hash = "Hash",
-    Identifier = "Identifier",
-    IdSelector = "IdSelector",
-    MediaFeature = "MediaFeature",
-    MediaQuery = "MediaQuery",
-    MediaQueryList = "MediaQueryList",
-    NestingSelector = "NestingSelector",
-    Nth = "Nth",
-    Number = "Number",
-    Operator = "Operator",
-    Parentheses = "Parentheses",
-    Percentage = "Percentage",
-    PseudoClassSelector = "PseudoClassSelector",
-    PseudoElementSelector = "PseudoElementSelector",
-    Ratio = "Ratio",
-    Raw = "Raw",
-    Rule = "Rule",
-    Selector = "Selector",
-    SelectorList = "SelectorList",
-    String = "String",
-    StyleSheet = "StyleSheet",
-    TypeSelector = "TypeSelector",
-    UnicodeRange = "UnicodeRange",
-    Url = "Url",
-    Value = "Value",
-    WhiteSpace = "WhiteSpace"
-}
-/**
- * Parser context for CSSTree.
- *
- * @see {@link https://github.com/csstree/csstree/blob/master/docs/parsing.md#context}
- */
-declare const enum CssTreeParserContext {
-    /**
-     * Regular stylesheet, should be suitable in most cases (default)
-     */
-    stylesheet = "stylesheet",
-    /**
-     * at-rule (e.g. `@media screen`, `print { ... }`)
-     */
-    atrule = "atrule",
-    /**
-     * at-rule prelude (screen, print for example above)
-     */
-    atrulePrelude = "atrulePrelude",
-    /**
-     * used to parse comma separated media query list
-     */
-    mediaQueryList = "mediaQueryList",
-    /**
-     * used to parse media query
-     */
-    mediaQuery = "mediaQuery",
-    /**
-     * rule (e.g. `.foo`, `.bar:hover { color: red; border: 1px solid black; }`)
-     */
-    rule = "rule",
-    /**
-     * selector group (`.foo`, `.bar:hover` for rule example)
-     */
-    selectorList = "selectorList",
-    /**
-     * selector (`.foo` or `.bar:hover` for rule example)
-     */
-    selector = "selector",
-    /**
-     * block with curly braces ({ color: red; border: 1px solid black; } for rule example)
-     */
-    block = "block",
-    /**
-     * block content w/o curly braces (`color: red; border: 1px solid black;` for rule example),
-     * useful for parsing HTML style attribute value
-     */
-    declarationList = "declarationList",
-    /**
-     * declaration (`color: red` or `border: 1px solid black` for rule example)
-     */
-    declaration = "declaration",
-    /**
-     * declaration value (`red` or `1px solid black` for rule example)
-     */
-    value = "value"
-}
-
-/**
- * Additional / helper functions for CSSTree.
- */
-declare class CssTree {
-    /**
-     * Shifts location of the CSSTree node. Temporary workaround for CSSTree issue:
-     * https://github.com/csstree/csstree/issues/251
-     *
-     * @param root Root CSSTree node
-     * @param loc Location to shift
-     * @returns Root CSSTree node with shifted location
-     */
-    static shiftNodePosition(root: CssNode, loc?: Location): CssNode;
-    /**
-     * Helper function for parsing CSS parts.
-     *
-     * @param raw Raw CSS input
-     * @param context CSSTree context for parsing
-     * @param tolerant If `true`, then the parser will not throw an error on parsing fallbacks. Default is `false`
-     * @param loc Base location for the parsed node
-     * @returns CSSTree node (AST)
-     */
-    static parse(raw: string, context: CssTreeParserContext, tolerant?: boolean, loc?: Location): CssNode;
-    /**
-     * Helper function for parsing CSS parts.
-     *
-     * @param raw Raw CSS input
-     * @param context CSSTree context
-     * @param tolerant If `true`, then the parser will not throw an error on parsing fallbacks. Default is `false`
-     * @param loc Base location for the parsed node
-     * @returns CSSTree node (AST)
-     */
-    static parsePlain(raw: string, context: CssTreeParserContext, tolerant?: boolean, loc?: Location): CssNodePlain;
-    /**
-     * Checks if the CSSTree node is an ExtendedCSS node.
-     *
-     * @param node Node to check
-     * @param pseudoClasses List of the names of the pseudo classes to check
-     * @param attributeSelectors List of the names of the attribute selectors to check
-     * @returns `true` if the node is an ExtendedCSS node, otherwise `false`
-     */
-    static isExtendedCssNode(node: CssNode | CssNodePlain, pseudoClasses: Set<string>, attributeSelectors: Set<string>): boolean;
-    /**
-     * Walks through the CSSTree node and returns all ExtendedCSS nodes.
-     *
-     * @param selectorList Selector list (can be a string or a CSSTree node)
-     * @param pseudoClasses List of the names of the pseudo classes to check
-     * @param attributeSelectors List of the names of the attribute selectors to check
-     * @returns Extended CSS nodes (pseudos and attributes)
-     * @see {@link https://github.com/csstree/csstree/blob/master/docs/ast.md#selectorlist}
-     */
-    static getSelectorExtendedCssNodes(selectorList: string | SelectorList | SelectorListPlain, pseudoClasses?: Set<string>, attributeSelectors?: Set<string>): CssNode[];
-    /**
-     * Checks if the selector contains any ExtendedCSS nodes. It is a faster alternative to
-     * `getSelectorExtendedCssNodes` if you only need to know if the selector contains any ExtendedCSS nodes,
-     * because it stops the search on the first ExtendedCSS node instead of going through the whole selector
-     * and collecting all ExtendedCSS nodes.
-     *
-     * @param selectorList Selector list (can be a string or a CSSTree node)
-     * @param pseudoClasses List of the names of the pseudo classes to check
-     * @param attributeSelectors List of the names of the attribute selectors to check
-     * @returns `true` if the selector contains any ExtendedCSS nodes
-     * @see {@link https://github.com/csstree/csstree/blob/master/docs/ast.md#selectorlist}
-     * @see {@link https://github.com/csstree/csstree/blob/master/docs/traversal.md#findast-fn}
-     */
-    static hasAnySelectorExtendedCssNode(selectorList: string | SelectorList | SelectorListPlain, pseudoClasses?: Set<string>, attributeSelectors?: Set<string>): boolean;
-    /**
-     * Checks if the node is a forbidden function (unsafe resource loading). Typically it is used to check
-     * if the node is a `url()` function, which is a security risk when using filter lists from untrusted
-     * sources.
-     *
-     * @param node Node to check
-     * @param forbiddenFunctions Set of the names of the functions to check
-     * @returns `true` if the node is a forbidden function
-     */
-    static isForbiddenFunction(node: CssNode | CssNodePlain, forbiddenFunctions?: Set<string>): boolean;
-    /**
-     * Gets the list of the forbidden function nodes in the declaration block. Typically it is used to get
-     * the list of the functions that can be used to load external resources, which is a security risk
-     * when using filter lists from untrusted sources.
-     *
-     * @param declarationList Declaration list to check (can be a string or a CSSTree node)
-     * @param forbiddenFunctions Set of the names of the functions to check
-     * @returns List of the forbidden function nodes in the declaration block (can be empty)
-     */
-    static getForbiddenFunctionNodes(declarationList: string | DeclarationList | DeclarationListPlain, forbiddenFunctions?: Set<string>): CssNode[];
-    /**
-     * Checks if the declaration block contains any forbidden functions. Typically it is used to check
-     * if the declaration block contains any functions that can be used to load external resources,
-     * which is a security risk when using filter lists from untrusted sources.
-     *
-     * @param declarationList Declaration list to check (can be a string or a CSSTree node)
-     * @param forbiddenFunctions Set of the names of the functions to check
-     * @returns `true` if the declaration block contains any forbidden functions
-     * @throws If you pass a string, but it is not a valid CSS
-     * @throws If you pass an invalid CSSTree node / AST
-     * @see {@link https://github.com/csstree/csstree/blob/master/docs/ast.md#declarationlist}
-     * @see {@link https://github.com/AdguardTeam/AdguardBrowserExtension/issues/1196}
-     * @see {@link https://github.com/AdguardTeam/AdguardBrowserExtension/issues/1920}
-     */
-    static hasAnyForbiddenFunction(declarationList: string | DeclarationList | DeclarationListPlain, forbiddenFunctions?: Set<string>): boolean;
-    /**
-     * Generates string representation of the media query list.
-     *
-     * @param ast Media query list AST
-     * @returns String representation of the media query list
-     */
-    static generateMediaQueryList(ast: MediaQueryList): string;
-    /**
-     * Generates string representation of the media query.
-     *
-     * @param ast Media query AST
-     * @returns String representation of the media query
-     */
-    static generateMediaQuery(ast: MediaQuery): string;
-    /**
-     * Generates string representation of the selector list.
-     *
-     * @param ast SelectorList AST
-     * @returns String representation of the selector list
-     */
-    static generateSelectorList(ast: SelectorList): string;
-    /**
-     * Selector generation based on CSSTree's AST. This is necessary because CSSTree
-     * only adds spaces in some edge cases.
-     *
-     * @param ast CSS Tree AST
-     * @returns CSS selector as string
-     */
-    static generateSelector(ast: Selector): string;
-    /**
-     * Generates string representation of the selector list.
-     *
-     * @param ast SelectorList AST
-     * @returns String representation of the selector list
-     */
-    static generateSelectorListPlain(ast: SelectorListPlain): string;
-    /**
-     * Selector generation based on CSSTree's AST. This is necessary because CSSTree
-     * only adds spaces in some edge cases.
-     *
-     * @param ast CSS Tree AST
-     * @returns CSS selector as string
-     */
-    static generateSelectorPlain(ast: SelectorPlain): string;
-    /**
-     * Block generation based on CSSTree's AST. This is necessary because CSSTree only adds spaces in some edge cases.
-     *
-     * @param ast CSS Tree AST
-     * @returns CSS selector as string
-     */
-    static generateDeclarationList(ast: DeclarationList): string;
-    /**
-     * Helper method to assert that the attribute selector has a value
-     *
-     * @param node Attribute selector node
-     */
-    static assertAttributeSelectorHasStringValue(node: AttributeSelector): asserts node is AttributeSelector & {
-        value: {
-            type: 'String';
-        };
-    };
-    /**
-     * Helper method to assert that the pseudo-class selector has at least one argument
-     *
-     * @param node Pseudo-class selector node
-     */
-    static assertPseudoClassHasAnyArgument(node: PseudoClassSelectorPlain): asserts node is PseudoClassSelectorPlain & {
-        children: CssNodePlain[];
-    };
-    /**
-     * Helper method to parse an attribute selector value as a number
-     *
-     * @param node Attribute selector node
-     * @returns Parsed attribute selector value as a number
-     * @throws If the attribute selector hasn't a string value or the string value is can't be parsed as a number
-     */
-    static parseAttributeSelectorValueAsNumber(node: AttributeSelector): number;
-    /**
-     * Helper method to parse a pseudo-class argument as a number
-     *
-     * @param node Pseudo-class selector node to parse
-     * @returns Parsed pseudo-class argument as a number
-     */
-    static parsePseudoClassArgumentAsNumber(node: PseudoClassSelectorPlain): number;
-    /**
-     * Helper method to create an attribute selector node
-     *
-     * @param name Name of the attribute
-     * @param value Value of the attribute
-     * @param matcher Matcher of the attribute
-     * @param flags Flags of the attribute
-     * @returns Attribute selector node
-     * @see {@link https://github.com/csstree/csstree/blob/master/docs/ast.md#attributeselector}
-     */
-    static createAttributeSelectorNode(name: string, value: string, matcher?: string, flags?: string | null): AttributeSelector;
-    /**
-     * Helper function to rename a CSSTree pseudo-class node
-     *
-     * @param node Node to rename
-     * @param name New name
-     */
-    static renamePseudoClass(node: PseudoClassSelector, name: string): void;
+declare class CosmeticRuleSeparatorUtils {
     /**
-     * Helper function to generate a raw string from a pseudo-class
-     * selector's children
+     * Checks whether the specified separator is an exception.
      *
-     * @param node Pseudo-class selector node
-     * @returns Generated pseudo-class value
-     * @example
-     * - `:nth-child(2n+1)` -> `2n+1`
-     * - `:matches-path(/foo/bar)` -> `/foo/bar`
+     * @param separator Separator to check
+     * @returns `true` if the separator is an exception, `false` otherwise
      */
-    static generatePseudoClassValue(node: PseudoClassSelector): string;
+    static isException(separator: CosmeticRuleSeparator): boolean;
     /**
-     * Helper function to generate a raw string from a function selector's children
+     * Checks whether the specified separator is marks an Extended CSS cosmetic rule.
      *
-     * @param node Function node
-     * @returns Generated function value
-     * @example `responseheader(name)` -> `name`
+     * @param separator Separator to check
+     * @returns `true` if the separator is marks an Extended CSS cosmetic rule, `false` otherwise
      */
-    static generateFunctionValue(node: FunctionNode): string;
+    static isExtendedCssMarker(separator: CosmeticRuleSeparator): boolean;
     /**
-     * Helper function to generate a raw string from a function selector's children
+     * Looks for the cosmetic rule separator in the rule. This is a simplified version that
+     * masks the recursive function.
      *
-     * @param node Function node
-     * @returns Generated function value
-     * @example `responseheader(name)` -> `name`
+     * @param rule Raw rule
+     * @returns Separator result or null if no separator was found
      */
-    static generateFunctionPlainValue(node: FunctionNodePlain): string;
+    static find(rule: string): CosmeticRuleSeparatorFinderResult | null;
 }
 
 declare class DomainUtils {
@@ -2690,7 +3353,7 @@ declare class DomainUtils {
 }
 
 /**
- * @file Utility functions for logical expression AST.
+ * @file Utility functions for logical expression node.
  */
 
 /**
@@ -2700,24 +3363,24 @@ type VariableTable = {
     [key: string]: boolean;
 };
 /**
- * Utility functions for logical expression AST.
+ * Utility functions for logical expression node.
  */
 declare class LogicalExpressionUtils {
     /**
      * Get all variables in the expression.
      *
-     * @param ast Logical expression AST
+     * @param node Logical expression node
      * @returns List of variables in the expression (nodes)
      * @example
      * If the expression is `a && b || c`, the returned list will be
      * nodes for `a`, `b`, and `c`.
      */
-    static getVariables(ast: AnyExpressionNode): ExpressionVariableNode[];
+    static getVariables(node: AnyExpressionNode): ExpressionVariableNode[];
     /**
      * Evaluate the parsed logical expression. You'll need to provide a
      * variable table.
      *
-     * @param ast Logical expression AST
+     * @param node Logical expression node
      * @param table Variable table (key: variable name, value: boolean)
      * @returns Evaluation result
      * @example
@@ -2732,34 +3395,9 @@ declare class LogicalExpressionUtils {
      * );
      * ```
      */
-    static evaluate(ast: AnyExpressionNode, table: VariableTable): boolean;
+    static evaluate(node: AnyExpressionNode, table: VariableTable): boolean;
 }
 
-/**
- * @file Utility functions for location and location range management.
- */
-
-/**
- * Shifts the specified location by the specified offset.
- *
- * @param loc Location to shift
- * @param offset Offset to shift by
- * @returns Location shifted by the specified offset
- */
-declare function shiftLoc(loc: Location, offset: number): Location;
-/**
- * Calculates a location range from the specified base location and offsets.
- *
- * Since every adblock rule is a single line, the start and end locations
- * of the range will have the same line, no need to calculate it here.
- *
- * @param loc Base location
- * @param startOffset Start offset
- * @param endOffset End offset
- * @returns Calculated location range
- */
-declare function locRange(loc: Location, startOffset: number, endOffset: number): LocationRange;
-
 declare const ADBLOCK_URL_START: string;
 declare const ADBLOCK_URL_START_REGEX = "^(http|https|ws|wss)://([a-z0-9-_.]+\\.)?";
 declare const ADBLOCK_URL_SEPARATOR = "^";
@@ -2866,6 +3504,14 @@ declare class QuoteUtils {
      * @returns String without quotes
      */
     static removeQuotes(string: string): string;
+    /**
+     * Removes bounding quotes from a string, if any, and unescapes the escaped quotes,
+     * like transforming `'abc\'def'` to `abc'def`.
+     *
+     * @param string Input string
+     * @returns String without quotes
+     */
+    static removeQuotesAndUnescape(string: string): string;
     /**
      * Wraps given `strings` with `quote` (defaults to single quote `'`)
      * and joins them with `separator` (defaults to comma+space `, `).
@@ -2883,12 +3529,104 @@ declare class QuoteUtils {
 }
 
 /**
- * Known metadata headers
+ * @file Position provider class.
+ */
+/**
+ * Represents a position in the source code.
+ */
+interface Position {
+    /**
+     * 1-based line number
+     */
+    line: number;
+    /**
+     * 1-based column number
+     */
+    column: number;
+}
+/**
+ * Class responsible for converting a character offset in source code into a line and column position.
+ * This conversion is particularly needed in linters and VSCode extensions,
+ * where line and column numbers are more human-friendly and intuitive than character offsets.
+ * Moreover, the VSCode diagnostics API does not directly support character offsets,
+ * it also requires line and column numbers.
+ */
+declare class PositionProvider {
+    /**
+     * Maps a character offset to a line number.
+     */
+    private offsetToLine;
+    /**
+     * Maps a line number to the starting character offset of that line.
+     */
+    private lineStartOffsets;
+    /**
+     * Constructs a new PositionProvider instance.
+     *
+     * @param sourceCode The source code as a string.
+     */
+    constructor(sourceCode: string);
+    /**
+     * Converts a character offset to a line and column position.
+     *
+     * @param offset The zero-based character offset in the source code.
+     * @returns A Position object containing the 1-based line and column number, or null if the offset is out of range.
+     */
+    convertOffsetToPosition(offset: number): Position | null;
+}
+
+/**
+ * @file Utility for encoding strings to byte sequences.
+ */
+interface TextEncoderPolyfillResult {
+    readonly written: number;
+    readonly read: number;
+}
+/**
+ * Encodes an UTF-8 string into a byte sequence according to the WHATWG spec.
+ *
+ * @param str String to encode.
+ * @param buffer Buffer to write the encoded bytes to.
+ * @returns Number of bytes written to the buffer.
+ * @see {@link https://encoding.spec.whatwg.org/#utf-8-encoder}
+ * @note Bytes written maybe larger than the string length, but never smaller.
+ * For example, the string '你好' has a length of 2, but its byte representation has a length of 6.
+ */
+declare const encodeIntoPolyfill: (str: string, buffer: Uint8Array) => TextEncoderPolyfillResult;
+
+/**
+ * @file Optimized utility for decoding strings from byte sequences.
+ */
+/**
+ * Decodes a byte sequence into an UTF-8 string according to the WHATWG spec.
+ * Optimized for performance.
+ *
+ * @param buffer Buffer to read the bytes from.
+ * @param start Start offset in the buffer.
+ * @param end End offset in the buffer.
+ * @returns Decoded string.
+ * @see {@link https://encoding.spec.whatwg.org/#utf-8-decoder}
+ */
+declare const decodeTextPolyfill: (buffer: Uint8Array, start?: number, end?: number) => string;
+
+/**
+ * Utility functions for categorizing rules.
  */
-declare const METADATA_HEADERS: string[];
+declare class RuleCategorizer {
+    /**
+     * Determines the type of a given raw cosmetic rule.
+     *
+     * @param rawRule Raw rule to check.
+     *
+     * @returns Type of the cosmetic rule or `null` if the rule is cannot be parsed as a cosmetic rule.
+     */
+    static getCosmeticRuleType(rawRule: string): CosmeticRuleType | null;
+}
 
 /**
- * Known Extended CSS pseudo-classes. Please, keep this list sorted.
+ * _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.
  */
 declare const EXT_CSS_PSEUDO_CLASSES: Set<string>;
 /**
@@ -2905,9 +3643,456 @@ declare const EXT_CSS_LEGACY_ATTRIBUTES: Set<string>;
  */
 declare const FORBIDDEN_CSS_FUNCTIONS: Set<string>;
 
+/**
+ * @file Base compatibility data schema, which is commonly used in compatibility tables.
+ */
+
+/**
+ * Zod schema for base compatibility data with camelCase properties.
+ */
+declare const baseCompatibilityDataSchemaCamelCase: zod.ZodEffects<zod.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    aliases: string[] | null;
+    docs: string | null;
+    versionAdded: string | null;
+    versionRemoved: string | null;
+    deprecated: boolean;
+    deprecationMessage: string | null;
+    removed: boolean;
+    removalMessage: string | null;
+}, any>;
+/**
+ * Type of the base compatibility data schema.
+ */
+type BaseCompatibilityDataSchema = zod.infer<typeof baseCompatibilityDataSchemaCamelCase>;
+
+/**
+ * @file Schema for modifier data.
+ */
+
+/**
+ * Zod schema for modifier data.
+ */
+declare const modifierDataSchema: zod.ZodEffects<zod.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    aliases: string[] | null;
+    docs: string | null;
+    versionAdded: string | null;
+    versionRemoved: string | null;
+    deprecated: boolean;
+    deprecationMessage: string | null;
+    removed: boolean;
+    removalMessage: string | null;
+    conflicts: string[] | null;
+    inverseConflicts: boolean;
+    assignable: boolean;
+    negatable: boolean;
+    blockOnly: boolean;
+    exceptionOnly: boolean;
+    valueOptional: boolean;
+    valueFormat: string | null;
+}, any>;
+/**
+ * Type of the modifier data schema.
+ */
+type ModifierDataSchema = zod.infer<typeof modifierDataSchema>;
+
+/**
+ * @file Schema for redirect data.
+ */
+
+/**
+ * Zod schema for redirect data.
+ */
+declare const redirectDataSchema: zod.ZodEffects<zod.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    aliases: string[] | null;
+    docs: string | null;
+    versionAdded: string | null;
+    versionRemoved: string | null;
+    deprecated: boolean;
+    deprecationMessage: string | null;
+    removed: boolean;
+    removalMessage: string | null;
+    isBlocking: boolean;
+}, any>;
+/**
+ * Type of the redirect data schema.
+ */
+type RedirectDataSchema = zod.infer<typeof redirectDataSchema>;
+
+/**
+ * @file Schema for scriptlet data.
+ */
+
+/**
+ * Zod schema for scriptlet data.
+ */
+declare const scriptletDataSchema: zod.ZodEffects<zod.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    aliases: string[] | null;
+    docs: string | null;
+    versionAdded: string | null;
+    versionRemoved: string | null;
+    deprecated: boolean;
+    deprecationMessage: string | null;
+    removed: boolean;
+    removalMessage: string | null;
+    parameters?: {
+        name: string;
+        debug: boolean;
+        pattern: string | null;
+        description: string | null;
+        default: string | null;
+        required: boolean;
+    }[] | undefined;
+}, any>;
+/**
+ * Type of the scriptlet data schema.
+ */
+type ScriptletDataSchema = zod.infer<typeof scriptletDataSchema>;
+
+/**
+ * @file Platform schema.
+ */
+
+/**
+ * Parses a raw platform string into a platform bitmask.
+ *
+ * @param rawPlatforms Raw platform string, e.g. 'adg_safari_any|adg_os_any'.
+ *
+ * @returns Platform bitmask.
+ */
+declare const parseRawPlatforms: (rawPlatforms: string) => number;
+
+/**
+ * @file Provides platform enums.
+ * The difference between specific and generic platforms is that specific platforms are individual platforms
+ * (e.g. AdGuard for Windows, AdGuard for Android, etc.),
+ * while generic platforms are groups of specific platforms
+ * (e.g. AdGuard for any OS, AdGuard for any Chromium-based extension, etc.).
+ */
+/**
+ * List of specific platforms.
+ */
+declare enum SpecificPlatform {
+    AdgOsWindows = 1,
+    AdgOsMac = 2,
+    AdgOsAndroid = 4,
+    AdgExtChrome = 8,
+    AdgExtOpera = 16,
+    AdgExtEdge = 32,
+    AdgExtFirefox = 64,
+    AdgCbAndroid = 128,
+    AdgCbIos = 256,
+    AdgCbSafari = 512,
+    UboExtChrome = 1024,
+    UboExtOpera = 2048,
+    UboExtEdge = 4096,
+    UboExtFirefox = 8192,
+    AbpExtChrome = 16384,
+    AbpExtOpera = 32768,
+    AbpExtEdge = 65536,
+    AbpExtFirefox = 131072
+}
+/**
+ * List of generic platforms (combinations of specific platforms).
+ */
+declare enum GenericPlatform {
+    AdgOsAny = 7,
+    AdgSafariAny = 768,
+    AdgExtChromium = 56,
+    AdgExtAny = 120,
+    AdgAny = 1023,
+    UboExtChromium = 7168,
+    UboExtAny = 15360,
+    UboAny = 15360,
+    AbpExtChromium = 114688,
+    AbpExtAny = 245760,
+    AbpAny = 245760,
+    Any = 262143
+}
+
+/**
+ * @file Compatibility tables types.
+ */
+/**
+ * Map with shared storage.
+ * The idea is to avoid storing the same value multiple times in the map,
+ * so the value is stored in the `shared` array and the map refers to the index in the `shared` array.
+ *
+ * @template K Type of the map keys.
+ * @template V Type of the map values.
+ */
+interface MapWithSharedStorage<K extends string | number | symbol, V> {
+    /**
+     * Shared storage.
+     */
+    shared: V[];
+    /**
+     * Map of the values where the value is a pointer to the shared storage (refers to the index in the `shared` array).
+     */
+    map: Record<K, number>;
+}
+/**
+ * Compatibility table row.
+ *
+ * @template T Type of the compatibility data.
+ */
+type CompatibilityTableRow<T> = MapWithSharedStorage<number, T>;
+/**
+ * Compatibility table.
+ *
+ * @template T Type of the compatibility data.
+ */
+type CompatibilityTable<T> = MapWithSharedStorage<string, CompatibilityTableRow<T>>;
+
+/**
+ * @file Provides common compatibility table methods.
+ */
+
+/**
+ * Lists all supported entity records by a product.
+ *
+ * Keys are compatibility flags, values are compatibility data records.
+ *
+ * @template T Compatibility data schema.
+ */
+type ProductRecords<T> = {
+    [key: string]: T;
+};
+/**
+ * Defines a compatibility table row by product.
+ *
+ * Keys are Adblock syntaxes, values are product records.
+ *
+ * @template T Compatibility data schema.
+ */
+type RowByProduct<T> = {
+    [AdblockSyntax.Adg]: ProductRecords<T>;
+    [AdblockSyntax.Ubo]: ProductRecords<T>;
+    [AdblockSyntax.Abp]: ProductRecords<T>;
+};
+/**
+ * Defines multiple compatibility table rows by product.
+ *
+ * @template T Compatibility data schema.
+ */
+type RowsByProduct<T> = RowByProduct<T>[];
+/**
+ * Single platform records type.
+ *
+ * Keys are platform enums values, values are compatibility data records.
+ *
+ * @template T Compatibility data schema.
+ */
+type SinglePlatformRecords<T> = {
+    [key: string]: T;
+};
+/**
+ * Name transformer function type. This function is used to normalize compatibility data names before processing them,
+ * e.g. converting to lowercase, remove unnecessary prefixes, etc.
+ *
+ * @param name Compatibility data name.
+ *
+ * @returns Normalized name.
+ */
+type NameTransformer = (name: string) => string;
+/**
+ * Base compatibility table class which provides common methods to work with compatibility data.
+ *
+ * @template T Compatibility data schema.
+ */
+declare abstract class CompatibilityTableBase<T extends BaseCompatibilityDataSchema> {
+    /**
+     * Compatibility table data.
+     */
+    private data;
+    /**
+     * Optional name transformer function. If provided,
+     * it will be called in all methods before processing compatibility data names.
+     */
+    private readonly nameTransformer;
+    /**
+     * Creates a new instance of the common compatibility table.
+     *
+     * @param data Compatibility table data.
+     * @param nameTransformer Optional name transformer function.
+     */
+    constructor(data: CompatibilityTable<T>, nameTransformer?: NameTransformer | null);
+    /**
+     * Helper method to get a 'row' from the compatibility table data by name.
+     *
+     * @param name Compatibility data name.
+     * @returns Compatibility table row storage or `null` if not found.
+     */
+    private getRowStorage;
+    /**
+     * Checks whether a compatibility data `name` exists for any platform.
+     *
+     * @note Technically, do the same as `exists()` method with generic platform _any_
+     * but it is faster because it does not apply complex logic.
+     *
+     * @param name Compatibility data name.
+     *
+     * @returns True if the compatibility data exists, false otherwise.
+     */
+    existsAny(name: string): boolean;
+    /**
+     * Checks whether a compatibility data `name` exists for a specified platform.
+     *
+     * @param name Compatibility data name.
+     * @param platform Specific or generic platform.
+     *
+     * @returns True if the compatibility data exists, false otherwise.
+     */
+    exists(name: string, platform: SpecificPlatform | GenericPlatform): boolean;
+    /**
+     * Returns a compatibility data by name and specific platform.
+     *
+     * @param name The name of the compatibility data.
+     * @param platform The specific platform.
+     *
+     * @returns A single compatibility data or `null` if not found.
+     */
+    getSingle(name: string, platform: SpecificPlatform): T | null;
+    /**
+     * Returns all compatibility data records for name and specified platform.
+     *
+     * @param name Compatibility data name.
+     * @param platform Specific or generic platform.
+     *
+     * @returns Multiple records grouped by platforms.
+     * Technically, it is an object where keys are platform enums values and values are compatibility data records.
+     *
+     * @note Platform enum values can be converted to string names using {@link getSpecificPlatformName} on demand.
+     */
+    getMultiple(name: string, platform: SpecificPlatform | GenericPlatform): SinglePlatformRecords<T> | null;
+    /**
+     * Returns all compatibility data records for the specified platform.
+     *
+     * @param platform Specific or generic platform.
+     *
+     * @returns Array of multiple records grouped by platforms.
+     */
+    getAllMultiple(platform: SpecificPlatform | GenericPlatform): SinglePlatformRecords<T>[];
+    /**
+     * Returns the first compatibility data record for name and specified platform.
+     *
+     * @param name Compatibility data name.
+     * @param platform Specific or generic platform.
+     *
+     * @returns First found compatibility data record or `null` if not found.
+     */
+    getFirst(name: string, platform: SpecificPlatform | GenericPlatform): T | null;
+    /**
+     * Returns all compatibility data records for the specified name.
+     *
+     * @param name Compatibility data name.
+     *
+     * @returns Array of multiple records grouped by platforms.
+     */
+    getRow(name: string): T[];
+    /**
+     * Returns all compatibility data grouped by products.
+     *
+     * @returns Array of multiple records grouped by products.
+     */
+    getRowsByProduct(): RowsByProduct<T>;
+}
+
+/**
+ * @file Compatibility tables for modifiers.
+ */
+
+/**
+ * Compatibility table for modifiers.
+ */
+declare class ModifiersCompatibilityTable extends CompatibilityTableBase<ModifierDataSchema> {
+    /**
+     * Creates a new instance of the compatibility table for modifiers.
+     *
+     * @param data Compatibility table data.
+     */
+    constructor(data: CompatibilityTable<ModifierDataSchema>);
+}
+/**
+ * Compatibility table instance for modifiers.
+ */
+declare const modifiersCompatibilityTable: ModifiersCompatibilityTable;
+
+/**
+ * @file Compatibility tables for redirects.
+ */
+
+/**
+ * Compatibility table for redirects.
+ */
+declare class RedirectsCompatibilityTable extends CompatibilityTableBase<RedirectDataSchema> {
+    /**
+     * Creates a new instance of the compatibility table for redirects.
+     *
+     * @param data Compatibility table data.
+     */
+    constructor(data: CompatibilityTable<RedirectDataSchema>);
+}
+/**
+ * Compatibility table instance for redirects.
+ */
+declare const redirectsCompatibilityTable: RedirectsCompatibilityTable;
+
+/**
+ * @file Compatibility tables for scriptlets.
+ */
+
+/**
+ * Compatibility table for scriptlets.
+ */
+declare class ScriptletsCompatibilityTable extends CompatibilityTableBase<ScriptletDataSchema> {
+}
+/**
+ * Compatibility table instance for scriptlets.
+ */
+declare const scriptletsCompatibilityTable: ScriptletsCompatibilityTable;
+
+/**
+ * @file Provides platform mapping and helper functions.
+ */
+
+/**
+ * Check if the platform is a generic platform.
+ *
+ * @param platform Platform to check.
+ *
+ * @returns True if the platform is a generic platform, false otherwise.
+ */
+declare const isGenericPlatform: (platform: number) => boolean;
+/**
+ * Returns the platform enum value for the given platform string name.
+ *
+ * @param platform Platform string name, e.g., 'adg_os_windows'.
+ *
+ * @returns Specific or generic platform enum value.
+ * @throws Error if the platform is unknown.
+ */
+declare const getPlatformId: (platform: string) => SpecificPlatform | GenericPlatform;
+/**
+ * Returns the specific platform string name for the given platform enum value.
+ *
+ * @param platform Specific platform enum value.
+ *
+ * @returns Specific platform string name, e.g., 'adg_os_windows'.
+ * @throws Error if the platform is unknown.
+ */
+declare const getSpecificPlatformName: (platform: SpecificPlatform) => string;
+
 /**
  * @file AGTree version
  */
-declare const version: string;
+declare const AGTREE_VERSION: string;
 
-export { ADBLOCK_URL_SEPARATOR, ADBLOCK_URL_SEPARATOR_REGEX, ADBLOCK_URL_START, ADBLOCK_URL_START_REGEX, ADBLOCK_WILDCARD, ADBLOCK_WILDCARD_REGEX, ADG_SCRIPTLET_MASK, AGLINT_COMMAND_PREFIX, AdblockSyntax, AdblockSyntaxError, Agent, AgentCommentRule, AgentCommentRuleParser, AgentParser, AnyCommentRule, AnyCosmeticRule, AnyExpressionNode, AnyOperator, AnyRule, AppListParser, COMMA_DOMAIN_LIST_SEPARATOR, CommentBase, CommentMarker, CommentRule, CommentRuleParser, CommentRuleType, ConfigCommentRule, ConfigCommentRuleParser, CosmeticRule, CosmeticRuleParser, CosmeticRuleSeparator, CosmeticRuleSeparatorFinderResult, CosmeticRuleSeparatorUtils, CosmeticRuleType, CssInjectionRule, CssInjectionRuleBody, CssTree, CssTreeNodeType, CssTreeParserContext, Domain, DomainList, DomainListParser, DomainListSeparator, DomainUtils, EXT_CSS_LEGACY_ATTRIBUTES, EXT_CSS_PSEUDO_CLASSES, ElementHidingRule, ElementHidingRuleBody, EmptyRule, ExpressionOperatorNode, ExpressionParenthesisNode, ExpressionVariableNode, FORBIDDEN_CSS_FUNCTIONS, FilterList, FilterListConverter, FilterListParser, HINT_MARKER, Hint, HintCommentRule, HintCommentRuleParser, HintParser, HtmlFilteringRule, HtmlFilteringRuleBody, IF, INCLUDE, JsInjectionRule, Location, LocationRange, LogicalExpressionParser, LogicalExpressionUtils, METADATA_HEADERS, MODIFIERS_SEPARATOR, MODIFIER_ASSIGN_OPERATOR, MetadataCommentRule, MetadataCommentRuleParser, MethodListParser, Modifier, ModifierList, ModifierListParser, ModifierParser, NEGATION_MARKER, NETWORK_RULE_EXCEPTION_MARKER, NETWORK_RULE_SEPARATOR, NetworkRule, NetworkRuleParser, Node, NotImplementedError, PIPE_MODIFIER_SEPARATOR, PREPROCESSOR_MARKER, Parameter, ParameterList, ParameterListParser, PreProcessorCommentRule, PreProcessorCommentRuleParser, QuoteType, QuoteUtils, RawFilterListConverter, RawRuleConverter, RegExpUtils, RuleBase, RuleCategory, RuleConversionError, RuleConverter, RuleParser, SAFARI_CB_AFFINITY, SPECIAL_REGEX_SYMBOLS, ScriptletInjectionRule, ScriptletInjectionRuleBody, StealthOptionListParser, UBO_SCRIPTLET_MASK, Value, VariableTable, locRange, modifierValidator, shiftLoc, version };
+export { ADBLOCK_URL_SEPARATOR, ADBLOCK_URL_SEPARATOR_REGEX, ADBLOCK_URL_START, ADBLOCK_URL_START_REGEX, ADBLOCK_WILDCARD, ADBLOCK_WILDCARD_REGEX, ADG_SCRIPTLET_MASK, AGLINT_COMMAND_PREFIX, AGTREE_VERSION, AdblockSyntax, AdblockSyntaxError, Agent, AgentCommentRule, AgentCommentRuleParser, AgentParser, AnyCommentRule, AnyCosmeticRule, AnyExpressionNode, AnyNetworkRule, AnyRule, AppListParser, BINARY_SCHEMA_VERSION, BinarySchemaMismatchError, ByteBuffer, COMMA_DOMAIN_LIST_SEPARATOR, CommentBase, CommentMarker, CommentRule, CommentRuleParser, CommentRuleType, CompatibilityTable, CompatibilityTableRow, ConfigCommentRule, ConfigCommentRuleParser, CosmeticRule, CosmeticRuleParser, CosmeticRuleSeparator, CosmeticRuleSeparatorFinderResult, CosmeticRuleSeparatorUtils, CosmeticRuleType, CssInjectionRule, CssInjectionRuleBody, Domain, DomainList, DomainListParser, DomainListSeparator, DomainUtils, EXT_CSS_LEGACY_ATTRIBUTES, EXT_CSS_PSEUDO_CLASSES, ElementHidingRule, ElementHidingRuleBody, EmptyRule, ExpressionOperatorNode, ExpressionParenthesisNode, ExpressionVariableNode, FORBIDDEN_CSS_FUNCTIONS, FilterList, FilterListConverter, FilterListParser, GenericPlatform, HINT_MARKER, Hint, HintCommentRule, HintCommentRuleParser, HintParser, HostRule, HostRuleParser, HostnameList, HtmlFilteringRule, HtmlFilteringRuleBody, IF, INCLUDE, InputByteBuffer, JsInjectionRule, KNOWN_METADATA_HEADERS, Location, LocationRange, LogicalExpressionParser, LogicalExpressionUtils, MODIFIERS_SEPARATOR, MODIFIER_ASSIGN_OPERATOR, MetadataCommentRule, MetadataCommentRuleParser, MethodListParser, Modifier, ModifierList, ModifierListParser, ModifierParser, NEGATION_MARKER, NETWORK_RULE_EXCEPTION_MARKER, NETWORK_RULE_SEPARATOR, NetworkRule, NetworkRuleParser, NetworkRuleType, Node, NotImplementedError, OutputByteBuffer, PIPE_MODIFIER_SEPARATOR, PREPROCESSOR_MARKER, ParameterList, ParameterListParser, ParserOptions, Position, PositionProvider, PreProcessorCommentRule, PreProcessorCommentRuleParser, ProductRecords, QuoteType, QuoteUtils, RawFilterListConverter, RawRuleConverter, RegExpUtils, RowByProduct, RowsByProduct, RuleBase, RuleCategorizer, RuleCategory, RuleConversionError, RuleConverter, RuleParser, SAFARI_CB_AFFINITY, SPECIAL_REGEX_SYMBOLS, ScriptletInjectionRule, ScriptletInjectionRuleBody, SpecificPlatform, StealthOptionListParser, TextEncoderPolyfillResult, UBO_SCRIPTLET_MASK, Value, VariableTable, decodeTextPolyfill, defaultParserOptions, encodeIntoPolyfill, getPlatformId, getSpecificPlatformName, isGenericPlatform, modifierValidator, modifiersCompatibilityTable, parseRawPlatforms, redirectsCompatibilityTable, scriptletsCompatibilityTable };