@adguard/agtree 1.0.1 → 1.1.1

package/dist/agtree.d.ts

@@ -1,10 +1,12 @@
 /*
- * AGTree v1.0.1 (build date: Wed, 24 May 2023 17:09:26 GMT)
+ * AGTree v1.1.1 (build date: Fri, 11 Aug 2023 13:11:01 GMT)
  * (c) 2023 AdGuard Software Ltd.
  * Released under the MIT license
- * https://github.com/AdguardTeam/AGTree#readme
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
  */
-import { MediaQueryListPlain, SelectorListPlain, DeclarationListPlain, FunctionNodePlain } from '@adguard/ecss-tree';
+import { MediaQueryListPlain, SelectorListPlain, DeclarationListPlain, FunctionNodePlain, CssNode, CssNodePlain, SelectorList, DeclarationList, MediaQueryList, MediaQuery, Selector, AttributeSelector, PseudoClassSelectorPlain, PseudoClassSelector, FunctionNode } from '@adguard/ecss-tree';
+import * as ecssTree from '@adguard/ecss-tree';
+export { ecssTree as ECSSTree };
 
 /**
  * @file Possible adblock syntaxes are listed here.
@@ -12,7 +14,7 @@ import { MediaQueryListPlain, SelectorListPlain, DeclarationListPlain, FunctionN
 /**
  * Possible adblock syntaxes (supported by this library)
  */
-declare enum AdblockSyntax {
+declare const enum AdblockSyntax {
     /**
      * Common syntax, which is supported by more than one adblocker (or by all adblockers).
      *
@@ -55,6 +57,12 @@ declare enum AdblockSyntax {
     Adg = "AdGuard"
 }
 
+declare const ADG_SCRIPTLET_MASK = "//scriptlet";
+declare const UBO_SCRIPTLET_MASK = "js";
+declare const MODIFIERS_SEPARATOR = ",";
+declare const MODIFIER_EXCEPTION_MARKER = "~";
+declare const MODIFIER_ASSIGN_OPERATOR = "=";
+declare const DOMAIN_EXCEPTION_MARKER = "~";
 /**
  * Classic domain separator.
  *
@@ -75,6 +83,14 @@ declare const CLASSIC_DOMAIN_SEPARATOR = ",";
  * ```
  */
 declare const MODIFIER_DOMAIN_SEPARATOR = "|";
+declare const HINT_MARKER = "!+";
+declare const NETWORK_RULE_EXCEPTION_MARKER = "@@";
+declare const NETWORK_RULE_SEPARATOR = "$";
+declare const AGLINT_COMMAND_PREFIX = "aglint";
+declare const PREPROCESSOR_MARKER = "!#";
+declare const SAFARI_CB_AFFINITY = "safari_cb_affinity";
+declare const IF = "if";
+declare const INCLUDE = "include";
 
 /**
  * Represents possible logical expression operators.
@@ -107,7 +123,7 @@ type AnyCosmeticRule = CssInjectionRule | ElementHidingRule | ScriptletInjection
  * - 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 `#`.
  */
-declare enum CommentMarker {
+declare const enum CommentMarker {
     /**
      * Regular comment marker. It is supported by all ad blockers.
      */
@@ -122,7 +138,7 @@ declare enum CommentMarker {
  * Represents the main categories that an adblock rule can belong to.
  * Of course, these include additional subcategories.
  */
-declare enum RuleCategory {
+declare const enum RuleCategory {
     /**
      * Empty "rules" that are only containing whitespaces. These rules are handled just for convenience.
      */
@@ -148,7 +164,7 @@ declare enum RuleCategory {
 /**
  * Represents possible comment types.
  */
-declare enum CommentRuleType {
+declare const enum CommentRuleType {
     AgentCommentRule = "AgentCommentRule",
     CommentRule = "CommentRule",
     ConfigCommentRule = "ConfigCommentRule",
@@ -159,7 +175,7 @@ declare enum CommentRuleType {
 /**
  * Represents possible cosmetic rule types.
  */
-declare enum CosmeticRuleType {
+declare const enum CosmeticRuleType {
     ElementHidingRule = "ElementHidingRule",
     CssInjectionRule = "CssInjectionRule",
     ScriptletInjectionRule = "ScriptletInjectionRule",
@@ -169,7 +185,80 @@ declare enum CosmeticRuleType {
 /**
  * Represents possible cosmetic rule separators.
  */
-type CosmeticRuleSeparator = '##' | '#@#' | '#?#' | '#@?#' | '#$#' | '#@$#' | '#$?#' | '#@$?#' | '##+' | '#@#+' | '#%#' | '#@%#' | '##^' | '#@#^' | '$$' | '$@$';
+declare const enum CosmeticRuleSeparator {
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    ElementHiding = "##",
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    ElementHidingException = "#@#",
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    ExtendedElementHiding = "#?#",
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    ExtendedElementHidingException = "#@?#",
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    AbpSnippet = "#$#",
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    AbpSnippetException = "#@$#",
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    AdgCssInjection = "#$#",
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    AdgCssInjectionException = "#@$#",
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    AdgExtendedCssInjection = "#$?#",
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    AdgExtendedCssInjectionException = "#@$?#",
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
+     */
+    AdgJsInjection = "#%#",
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
+     */
+    AdgJsInjectionException = "#@%#",
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#html-filtering-rules}
+     */
+    AdgHtmlFiltering = "$$",
+    /**
+     * @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 = "#@#^"
+}
 /**
  * Represents a basic node in the AST.
  */
@@ -182,6 +271,10 @@ interface Node {
      * 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.
@@ -495,6 +588,10 @@ interface Agent extends Node {
      * Adblock version (if specified).
      */
     version: Value | null;
+    /**
+     * Needed for network rules modifier validation.
+     */
+    syntax: AdblockSyntax;
 }
 /**
  * Represents an agent comment rule.
@@ -1001,6 +1098,28 @@ declare class RuleParser {
     static generate(ast: AnyRule): string;
 }
 
+/**
+ * @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 {
+    /**
+     * Location range of the error.
+     */
+    loc: LocationRange;
+    /**
+     * Constructs a new `AdblockSyntaxError` instance.
+     *
+     * @param message Error message
+     * @param loc Location range of the error
+     */
+    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
@@ -1087,145 +1206,568 @@ declare class AgentParser {
 }
 
 /**
- * @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.
+ * `CommentParser` is responsible for parsing any comment-like adblock rules.
  *
  * @example
- * If the hint rule is
- * ```adblock
- * !+ NOT_OPTIMIZED PLATFORM(windows)
- * ```
- * then the hints are `NOT_OPTIMIZED` and `PLATFORM(windows)`, and this
- * class is responsible for parsing them. The rule itself is parsed by
- * the `HintRuleParser`, which uses this class to parse single hints.
+ * Example rules:
+ *  - Adblock agent rules:
+ *      - ```adblock
+ *        [AdGuard]
+ *        ```
+ *      - ```adblock
+ *        [Adblock Plus 2.0]
+ *        ```
+ *      - etc.
+ *  - AdGuard hint rules:
+ *      - ```adblock
+ *        !+ NOT_OPTIMIZED
+ *        ```
+ *      - ```adblock
+ *        !+ NOT_OPTIMIZED PLATFORM(windows)
+ *        ```
+ *      - etc.
+ *  - Pre-processor rules:
+ *      - ```adblock
+ *        !#if (adguard)
+ *        ```
+ *      - ```adblock
+ *        !#endif
+ *        ```
+ *      - etc.
+ *  - Metadata rules:
+ *      - ```adblock
+ *        ! Title: My List
+ *        ```
+ *      - ```adblock
+ *        ! Version: 2.0.150
+ *        ```
+ *      - etc.
+ *  - AGLint inline config rules:
+ *      - ```adblock
+ *        ! aglint-enable some-rule
+ *        ```
+ *      - ```adblock
+ *        ! aglint-disable some-rule
+ *        ```
+ *      - etc.
+ *  - Simple comments:
+ *      - Regular version:
+ *        ```adblock
+ *        ! This is just a comment
+ *        ```
+ *      - uBlock Origin / "hostlist" version:
+ *        ```adblock
+ *        # This is just a comment
+ *        ```
+ *      - etc.
  */
-declare class HintParser {
+declare class CommentRuleParser {
     /**
-     * Parses a raw rule as a hint.
+     * Checks whether a rule is a regular comment. Regular comments are the ones that start with
+     * an exclamation mark (`!`).
      *
      * @param raw Raw rule
-     * @param loc Base location
-     * @returns Hint rule AST or null
-     * @throws If the syntax is invalid
-     */
-    static parse(raw: string, loc?: Location): Hint;
-    /**
-     * Converts a single hint AST to a string.
-     *
-     * @param hint Hint AST
-     * @returns Hint string
+     * @returns `true` if the rule is a regular comment, `false` otherwise
      */
-    static generate(hint: Hint): string;
-}
-
-/**
- * `HintRuleParser` is responsible for parsing AdGuard hint rules.
- *
- * @example
- * The following hint rule
- * ```adblock
- * !+ NOT_OPTIMIZED PLATFORM(windows)
- * ```
- * contains two hints: `NOT_OPTIMIZED` and `PLATFORM`.
- * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#hints}
- */
-declare class HintCommentRuleParser {
+    static isRegularComment(raw: string): boolean;
     /**
-     * Checks if the raw rule is a hint rule.
+     * Checks whether a rule is a comment.
      *
      * @param raw Raw rule
-     * @returns `true` if the rule is a hint rule, `false` otherwise
+     * @returns `true` if the rule is a comment, `false` otherwise
      */
-    static isHintRule(raw: string): boolean;
+    static isCommentRule(raw: string): boolean;
     /**
-     * Parses a raw rule as a hint comment.
+     * Parses a raw rule as comment.
      *
      * @param raw Raw rule
      * @param loc Base location
-     * @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}
+     * @returns Comment AST or null (if the raw rule cannot be parsed as comment)
      */
-    static parse(raw: string, loc?: Location): HintCommentRule | null;
+    static parse(raw: string, loc?: Location): AnyCommentRule | null;
     /**
-     * Converts a hint rule AST to a raw string.
+     * Converts a comment AST to a string.
      *
-     * @param ast Hint rule AST
+     * @param ast Comment AST
      * @returns Raw string
      */
-    static generate(ast: HintCommentRule): string;
+    static generate(ast: AnyCommentRule): string;
 }
 
 /**
- * @file Metadata comments
+ * @file AGLint configuration comments. Inspired by ESLint inline configuration comments.
+ * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
  */
 
 /**
- * `MetadataParser` is responsible for parsing metadata comments.
- * Metadata comments are special comments that specify some properties of the list.
+ * `ConfigCommentParser` is responsible for parsing inline AGLint configuration rules.
+ * Generally, the idea is inspired by ESLint inline configuration comments.
  *
- * @example
- * For example, in the case of
- * ```adblock
- * ! Title: My List
- * ```
- * the name of the header is `Title`, and the value is `My List`, which means that
- * the list title is `My List`, and it can be used in the adblocker UI.
- * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#special-comments}
+ * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
  */
-declare class MetadataCommentRuleParser {
+declare class ConfigCommentRuleParser {
     /**
-     * Parses a raw rule as a metadata comment.
+     * Checks if the raw rule is an inline configuration comment rule.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is an inline configuration comment rule, otherwise `false`.
+     */
+    static isConfigComment(raw: string): boolean;
+    /**
+     * Parses a raw rule as an inline configuration comment.
      *
      * @param raw Raw rule
      * @param loc Base location
-     * @returns Metadata comment AST or null (if the raw rule cannot be parsed as a metadata comment)
+     * @returns
+     * Inline configuration comment AST or null (if the raw rule cannot be parsed as configuration comment)
      */
-    static parse(raw: string, loc?: Location): MetadataCommentRule | null;
+    static parse(raw: string, loc?: Location): ConfigCommentRule | null;
     /**
-     * Converts a metadata comment AST to a string.
+     * Converts an inline configuration comment AST to a string.
      *
-     * @param ast - Metadata comment AST
+     * @param ast Inline configuration comment AST
      * @returns Raw string
      */
-    static generate(ast: MetadataCommentRule): string;
+    static generate(ast: ConfigCommentRule): string;
 }
 
 /**
- * Pre-processor directives
+ * `CosmeticRuleParser` is responsible for parsing cosmetic 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}
- */
-
-/**
- * `PreProcessorParser` is responsible for parsing preprocessor rules.
- * Pre-processor comments are special comments that are used to control the behavior of the filter list processor.
- * Please note that this parser only handles general syntax for now, and does not validate the parameters at
- * the parsing stage.
+ * Where possible, it automatically detects the difference between supported syntaxes:
+ *  - AdGuard
+ *  - uBlock Origin
+ *  - Adblock Plus
  *
- * @example
- * If your rule is
- * ```adblock
- * !#if (adguard)
- * ```
- * then the directive's name is `if` and its value is `(adguard)`, but the parameter list
- * is not parsed / validated further.
- * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#pre-processor-directives}
- * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#pre-parsing-directives}
+ * If the syntax is common / cannot be determined, the parser gives `Common` syntax.
+ *
+ * Please note that syntactically correct rules are parsed even if they are not actually
+ * compatible with the given adblocker. This is a completely natural behavior, meaningful
+ * checking of compatibility is not done at the parser level.
  */
-declare class PreProcessorCommentRuleParser {
+declare class CosmeticRuleParser {
     /**
-     * Determines whether the rule is a pre-processor rule.
+     * Determines whether a rule is a cosmetic rule. The rule is considered cosmetic if it
+     * contains a cosmetic rule separator.
      *
      * @param raw Raw rule
-     * @returns `true` if the rule is a pre-processor rule, `false` otherwise
+     * @returns `true` if the rule is a cosmetic rule, `false` otherwise
      */
-    static isPreProcessorRule(raw: string): boolean;
+    static isCosmeticRule(raw: string): boolean;
+    /**
+     * Parses a cosmetic rule. The structure of the cosmetic rules:
+     *  - pattern (AdGuard pattern can have modifiers, other syntaxes don't)
+     *  - separator
+     *  - body
+     *
+     * @param raw Raw cosmetic rule
+     * @param loc Location of the rule
+     * @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;
+    /**
+     * Generates the rule pattern from the AST.
+     *
+     * @param ast Cosmetic rule AST
+     * @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;
+    /**
+     * Generates the rule body from the AST.
+     *
+     * @param ast Cosmetic rule AST
+     * @returns Raw rule body
+     * @example
+     * - '##.foo' → '.foo'
+     * - 'example.com,example.org##.foo' → '.foo'
+     * - 'example.com#%#//scriptlet('foo')' → '//scriptlet('foo')'
+     */
+    static generateBody(ast: AnyCosmeticRule): string;
+    /**
+     * Converts a cosmetic rule AST into a string.
+     *
+     * @param ast Cosmetic rule AST
+     * @returns Raw string
+     */
+    static generate(ast: AnyCosmeticRule): string;
+}
+
+/**
+ * `DomainListParser` is responsible for parsing a domain list.
+ *
+ * @example
+ * - If the rule is `example.com,~example.net##.ads`, the domain list is `example.com,~example.net`.
+ * - If the rule is `ads.js^$script,domains=example.com|~example.org`, the domain list is `example.com|~example.org`.
+ * This parser is responsible for parsing these domain lists.
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_domains}
+ */
+declare class DomainListParser {
+    /**
+     * 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
+     * @returns Domain list AST
+     * @throws If the domain list is syntactically invalid
+     */
+    static parse(raw: string, separator?: DomainListSeparator, loc?: Location): DomainList;
+    /**
+     * Converts a domain list AST to a string.
+     *
+     * @param ast Domain list AST
+     * @returns Raw string
+     */
+    static generate(ast: DomainList): string;
+}
+
+/**
+ * `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 {
+    /**
+     * 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.
+     * @returns AST of the source code (list of rules)
+     * @example
+     * ```js
+     * import { readFileSync } from 'fs';
+     * import { FilterListParser } from '@adguard/agtree';
+     *
+     * // Read filter list content from file
+     * const content = readFileSync('your-adblock-filter-list.txt', 'utf-8');
+     *
+     * // Parse the filter list content, then do something with the AST
+     * const ast = FilterListParser.parse(content);
+     * ```
+     * @throws If one of the rules is syntactically invalid (if `tolerant` is `false`)
+     */
+    static parse(raw: string, tolerant?: boolean): FilterList;
+    /**
+     * Serializes a whole adblock filter list (list of rules).
+     *
+     * @param ast AST to generate
+     * @param preferRaw If `true`, then the parser will use `raws.text` property of each rule
+     * if it is available. Default is `false`.
+     * @returns Serialized filter list
+     */
+    static generate(ast: FilterList, preferRaw?: boolean): string;
+}
+
+/**
+ * `HintRuleParser` is responsible for parsing AdGuard hint rules.
+ *
+ * @example
+ * The following hint rule
+ * ```adblock
+ * !+ NOT_OPTIMIZED PLATFORM(windows)
+ * ```
+ * contains two hints: `NOT_OPTIMIZED` and `PLATFORM`.
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#hints}
+ */
+declare class HintCommentRuleParser {
+    /**
+     * Checks if the raw rule is a hint rule.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is a hint rule, `false` otherwise
+     */
+    static isHintRule(raw: string): boolean;
+    /**
+     * Parses a raw rule as a hint comment.
+     *
+     * @param raw Raw rule
+     * @param loc Base location
+     * @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;
+    /**
+     * Converts a hint rule AST to a raw string.
+     *
+     * @param ast Hint rule AST
+     * @returns Raw string
+     */
+    static generate(ast: HintCommentRule): string;
+}
+
+/**
+ * @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.
+ *
+ * @example
+ * If the hint rule is
+ * ```adblock
+ * !+ NOT_OPTIMIZED PLATFORM(windows)
+ * ```
+ * then the hints are `NOT_OPTIMIZED` and `PLATFORM(windows)`, and this
+ * class is responsible for parsing them. The rule itself is parsed by
+ * the `HintRuleParser`, which uses this class to parse single hints.
+ */
+declare class HintParser {
+    /**
+     * Parses a raw rule as a hint.
+     *
+     * @param raw Raw rule
+     * @param loc Base location
+     * @returns Hint rule AST or null
+     * @throws If the syntax is invalid
+     */
+    static parse(raw: string, loc?: Location): Hint;
+    /**
+     * Converts a single hint AST to a string.
+     *
+     * @param hint Hint AST
+     * @returns Hint string
+     */
+    static generate(hint: Hint): string;
+}
+
+/**
+ * `LogicalExpressionParser` is responsible for parsing logical expressions.
+ *
+ * @example
+ * From the following rule:
+ * ```adblock
+ * !#if (adguard_ext_android_cb || adguard_ext_safari)
+ * ```
+ * this parser will parse the expression `(adguard_ext_android_cb || adguard_ext_safari)`.
+ */
+declare class LogicalExpressionParser {
+    /**
+     * 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
+     */
+    private static tokenize;
+    /**
+     * Parses a logical expression.
+     *
+     * @param raw Source code of the expression
+     * @param loc Location of the expression
+     * @returns Parsed expression
+     * @throws {AdblockSyntaxError} If the expression is invalid
+     */
+    static parse(raw: string, loc?: Location): AnyExpressionNode;
+    /**
+     * Generates a string representation of the logical expression (serialization).
+     *
+     * @param ast Expression node
+     * @returns String representation of the logical expression
+     */
+    static generate(ast: AnyExpressionNode): string;
+}
+
+/**
+ * @file Metadata comments
+ */
+
+/**
+ * `MetadataParser` is responsible for parsing metadata comments.
+ * Metadata comments are special comments that specify some properties of the list.
+ *
+ * @example
+ * For example, in the case of
+ * ```adblock
+ * ! Title: My List
+ * ```
+ * the name of the header is `Title`, and the value is `My List`, which means that
+ * the list title is `My List`, and it can be used in the adblocker UI.
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#special-comments}
+ */
+declare class MetadataCommentRuleParser {
+    /**
+     * Parses a raw rule as a metadata comment.
+     *
+     * @param raw Raw rule
+     * @param loc Base location
+     * @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;
+    /**
+     * Converts a metadata comment AST to a string.
+     *
+     * @param ast - Metadata comment AST
+     * @returns Raw string
+     */
+    static generate(ast: MetadataCommentRule): string;
+}
+
+/**
+ * `ModifierListParser` is responsible for parsing modifier lists. Please note that the name is not
+ * uniform, "modifiers" are also known as "options".
+ *
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#basic-rules-modifiers}
+ * @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 {
+    /**
+     * 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
+     * @returns Parsed modifiers interface
+     */
+    static parse(raw: string, loc?: Location): ModifierList;
+    /**
+     * Converts a modifier list AST to a string.
+     *
+     * @param ast Modifier list AST
+     * @returns Raw string
+     */
+    static generate(ast: ModifierList): string;
+}
+
+/**
+ * `ModifierParser` is responsible for parsing modifiers.
+ *
+ * @example
+ * `match-case`, `~third-party`, `domain=example.com|~example.org`
+ */
+declare class ModifierParser {
+    /**
+     * Parses a modifier.
+     *
+     * @param raw Raw modifier string
+     * @param loc Location of the modifier
+     *
+     * @returns Parsed modifier
+     * @throws An error if modifier name or value is empty.
+     */
+    static parse(raw: string, loc?: Location): Modifier;
+    /**
+     * Generates a string from a modifier (serializes it).
+     *
+     * @param modifier Modifier to generate string from
+     * @returns String representation of the modifier
+     */
+    static generate(modifier: Modifier): string;
+}
+
+/**
+ * `NetworkRuleParser` is responsible for parsing network rules.
+ *
+ * Please note that this will parse all syntactically correct network rules.
+ * Modifier compatibility is not checked at the parser level.
+ *
+ * @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 {
+    /**
+     * Parses a network rule (also known as basic rule).
+     *
+     * @param raw Raw rule
+     * @param loc Location of the rule
+     * @returns Network rule AST
+     */
+    static parse(raw: string, loc?: Location): NetworkRule;
+    /**
+     * Finds the index of the separator character in a network rule.
+     *
+     * @param rule Network rule to check
+     * @returns The index of the separator character, or -1 if there is no separator
+     */
+    private static findNetworkRuleSeparatorIndex;
+    /**
+     * Converts a network rule (basic rule) AST to a string.
+     *
+     * @param ast - Network rule AST
+     * @returns Raw string
+     */
+    static generate(ast: NetworkRule): string;
+}
+
+/**
+ * @file Customized error class for not implemented features.
+ */
+/**
+ * Customized error class for not implemented features.
+ */
+declare class NotImplementedError extends Error {
+    /**
+     * Constructs a new `NotImplementedError` instance.
+     *
+     * @param message Additional error message (optional)
+     */
+    constructor(message?: string | undefined);
+}
+
+declare class ParameterListParser {
+    /**
+     * Parses a raw parameter list.
+     *
+     * @param raw Raw parameter list
+     * @param separator Separator character (default: comma)
+     * @param loc Base location
+     * @returns Parameter list AST
+     */
+    static parse(raw: string, separator?: string, loc?: Location): ParameterList;
+    /**
+     * Converts a parameter list AST to a string.
+     *
+     * @param params Parameter list AST
+     * @param separator Separator character (default: comma)
+     * @returns String representation of the parameter list
+     */
+    static generate(params: ParameterList, separator?: string): string;
+}
+
+/**
+ * Pre-processor directives
+ *
+ * @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}
+ */
+
+/**
+ * `PreProcessorParser` is responsible for parsing preprocessor rules.
+ * Pre-processor comments are special comments that are used to control the behavior of the filter list processor.
+ * Please note that this parser only handles general syntax for now, and does not validate the parameters at
+ * the parsing stage.
+ *
+ * @example
+ * If your rule is
+ * ```adblock
+ * !#if (adguard)
+ * ```
+ * then the directive's name is `if` and its value is `(adguard)`, but the parameter list
+ * is not parsed / validated further.
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#pre-processor-directives}
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#pre-parsing-directives}
+ */
+declare class PreProcessorCommentRuleParser {
+    /**
+     * Determines whether the rule is a pre-processor rule.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is a pre-processor rule, `false` otherwise
+     */
+    static isPreProcessorRule(raw: string): boolean;
     /**
      * Parses a raw rule as a pre-processor comment.
      *
@@ -1245,409 +1787,587 @@ declare class PreProcessorCommentRuleParser {
 }
 
 /**
- * @file AGLint configuration comments. Inspired by ESLint inline configuration comments.
- * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
+ * @file Customized error class for conversion errors.
+ */
+/**
+ * Customized error class for conversion errors.
+ */
+declare class RuleConversionError extends Error {
+    /**
+     * Constructs a new `RuleConversionError` instance.
+     *
+     * @param message Error message
+     */
+    constructor(message: string);
+}
+
+/**
+ * @file Validator for modifiers.
  */
 
 /**
- * `ConfigCommentParser` is responsible for parsing inline AGLint configuration rules.
- * Generally, the idea is inspired by ESLint inline configuration comments.
+ * Result of modifier validation:
+ * - `{ ok: true }` for valid and _fully supported_ modifier;
+ * - `{ ok: true, warn: <deprecation notice> }` for valid
+ *   and _still supported but deprecated_ modifier;
+ * - otherwise `{ ok: true, error: <invalidity reason> }`
+ */
+type ValidationResult = {
+    ok: boolean;
+    error?: string;
+    warn?: string;
+};
+/**
+ * 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.
+     *
+     * **Deprecated** and **removed** modifiers are considered as **existent**.
+     *
+     * @param modifier Already parsed modifier AST node.
+     *
+     * @returns True if modifier exists, false otherwise.
+     */
+    exists: (modifier: Modifier) => boolean;
+    /**
+     * Checks whether the given `modifier` is valid for specified `syntax`.
+     *
+     * For `Common` syntax it simply checks whether the modifier exists.
+     * For specific syntax the validation is more complex —
+     * deprecated, assignable, negatable and other requirements are checked.
+     *
+     * @param syntax Adblock syntax to check the modifier for.
+     * @param rawModifier Modifier AST node.
+     * @param isException Whether the modifier is used in exception rule, default to false.
+     * Needed to check whether the modifier is allowed only in blocking or exception rules.
+     *
+     * @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;
+
+/**
+ * @file Base class for converters
  *
- * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
+ * TS doesn't support abstract static methods, so we should use
+ * a workaround and extend this class instead of implementing it
  */
-declare class ConfigCommentRuleParser {
+/**
+ * Basic class for rule converters
+ */
+declare class ConverterBase {
     /**
-     * Checks if the raw rule is an inline configuration comment rule.
+     * Converts some data to AdGuard format
      *
-     * @param raw Raw rule
-     * @returns `true` if the rule is an inline configuration comment rule, otherwise `false`.
+     * @param data Data to convert
+     * @returns Converted data
+     * @throws If the data is invalid or incompatible
      */
-    static isConfigComment(raw: string): boolean;
+    static convertToAdg(data: unknown): unknown;
     /**
-     * Parses a raw rule as an inline configuration comment.
+     * Converts some data to Adblock Plus format
      *
-     * @param raw Raw rule
-     * @param loc Base location
-     * @returns
-     * Inline configuration comment AST or null (if the raw rule cannot be parsed as configuration comment)
+     * @param data Data to convert
+     * @returns Converted data
+     * @throws If the data is invalid or incompatible
      */
-    static parse(raw: string, loc?: Location): ConfigCommentRule | null;
+    static convertToAbp(data: unknown): unknown;
     /**
-     * Converts an inline configuration comment AST to a string.
+     * Converts some data to uBlock Origin format
      *
-     * @param ast Inline configuration comment AST
-     * @returns Raw string
+     * @param data Data to convert
+     * @returns Converted data
+     * @throws If the data is invalid or incompatible
      */
-    static generate(ast: ConfigCommentRule): string;
+    static convertToUbo(data: unknown): unknown;
 }
 
 /**
- * `CommentParser` is responsible for parsing any comment-like adblock rules.
+ * @file Base class for rule converters
  *
- * @example
- * Example rules:
- *  - Adblock agent rules:
- *      - ```adblock
- *        [AdGuard]
- *        ```
- *      - ```adblock
- *        [Adblock Plus 2.0]
- *        ```
- *      - etc.
- *  - AdGuard hint rules:
- *      - ```adblock
- *        !+ NOT_OPTIMIZED
- *        ```
- *      - ```adblock
- *        !+ NOT_OPTIMIZED PLATFORM(windows)
- *        ```
- *      - etc.
- *  - Pre-processor rules:
- *      - ```adblock
- *        !#if (adguard)
- *        ```
- *      - ```adblock
- *        !#endif
- *        ```
- *      - etc.
- *  - Metadata rules:
- *      - ```adblock
- *        ! Title: My List
- *        ```
- *      - ```adblock
- *        ! Version: 2.0.150
- *        ```
- *      - etc.
- *  - AGLint inline config rules:
- *      - ```adblock
- *        ! aglint-enable some-rule
- *        ```
- *      - ```adblock
- *        ! aglint-disable some-rule
- *        ```
- *      - etc.
- *  - Simple comments:
- *      - Regular version:
- *        ```adblock
- *        ! This is just a comment
- *        ```
- *      - uBlock Origin / "hostlist" version:
- *        ```adblock
- *        # This is just a comment
- *        ```
- *      - etc.
+ * TS doesn't support abstract static methods, so we should use
+ * a workaround and extend this class instead of implementing it
  */
-declare class CommentRuleParser {
+
+/**
+ * Basic class for rule converters
+ */
+declare class RuleConverterBase extends ConverterBase {
     /**
-     * Checks whether a rule is a regular comment. Regular comments are the ones that start with
-     * an exclamation mark (`!`).
+     * Converts an adblock filtering rule to AdGuard format, if possible.
      *
-     * @param raw Raw rule
-     * @returns `true` if the rule is a regular comment, `false` otherwise
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
      */
-    static isRegularComment(raw: string): boolean;
+    static convertToAdg(rule: Node): Node[];
     /**
-     * Checks whether a rule is a comment.
+     * Converts an adblock filtering rule to Adblock Plus format, if possible.
      *
-     * @param raw Raw rule
-     * @returns `true` if the rule is a comment, `false` otherwise
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
      */
-    static isCommentRule(raw: string): boolean;
+    static convertToAbp(rule: Node): Node[];
     /**
-     * Parses a raw rule as comment.
+     * Converts an adblock filtering rule to uBlock Origin format, if possible.
      *
-     * @param raw Raw rule
-     * @param loc Base location
-     * @returns Comment AST or null (if the raw rule cannot be parsed as comment)
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
      */
-    static parse(raw: string, loc?: Location): AnyCommentRule | null;
+    static convertToUbo(rule: Node): Node[];
+}
+
+/**
+ * @file Adblock rule converter
+ *
+ * This file is the entry point for all rule converters
+ * which automatically detects the rule type and calls
+ * the corresponding "sub-converter".
+ */
+
+/**
+ * Adblock filtering rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+declare class RuleConverter extends RuleConverterBase {
     /**
-     * Converts a comment AST to a string.
+     * Converts an adblock filtering rule to AdGuard format, if possible.
      *
-     * @param ast Comment AST
-     * @returns Raw string
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
      */
-    static generate(ast: AnyCommentRule): string;
+    static convertToAdg(rule: AnyRule): AnyRule[];
 }
 
 /**
- * `NetworkRuleParser` is responsible for parsing network rules.
+ * @file Adblock filter list converter
+ */
+
+/**
+ * Adblock filter list converter class
  *
- * Please note that this will parse all syntactically correct network rules.
- * Modifier compatibility is not checked at the parser level.
+ * This class just provides an extra layer on top of the {@link RuleConverter}
+ * and can be used to convert entire filter lists.
  *
- * @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}
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ * @todo Implement tolerant mode, which will allow to convert a filter list
+ * even if some of its rules are invalid
  */
-declare class NetworkRuleParser {
+declare class FilterListConverter extends ConverterBase {
     /**
-     * Parses a network rule (also known as basic rule).
+     * Converts an adblock filter list to AdGuard format, if possible.
      *
-     * @param raw Raw rule
-     * @param loc Location of the rule
-     * @returns Network rule AST
+     * @param filterListNode Filter list node to convert
+     * @returns Converted filter list node
+     * @throws If the filter list is invalid or cannot be converted
      */
-    static parse(raw: string, loc?: Location): NetworkRule;
+    static convertToAdg(filterListNode: FilterList): FilterList;
+}
+
+/**
+ * @file Cosmetic rule separator finder and categorizer
+ */
+
+interface CosmeticRuleSeparatorFinderResult {
     /**
-     * Finds the index of the separator character in a network rule.
+     * Separator type
+     */
+    separator: CosmeticRuleSeparator;
+    /**
+     * Separator start position
+     */
+    start: number;
+    /**
+     * Separator end position
+     */
+    end: number;
+}
+/**
+ * Utility class for cosmetic rule separators.
+ */
+declare class CosmeticRuleSeparatorUtils {
+    /**
+     * Checks whether the specified separator is an exception.
      *
-     * @param rule Network rule to check
-     * @returns The index of the separator character, or -1 if there is no separator
+     * @param separator Separator to check
+     * @returns `true` if the separator is an exception, `false` otherwise
      */
-    private static findNetworkRuleSeparatorIndex;
+    static isException(separator: CosmeticRuleSeparator): boolean;
     /**
-     * Converts a network rule (basic rule) AST to a string.
+     * Checks whether the specified separator is marks an Extended CSS cosmetic rule.
      *
-     * @param ast - Network rule AST
-     * @returns Raw string
+     * @param separator Separator to check
+     * @returns `true` if the separator is marks an Extended CSS cosmetic rule, `false` otherwise
      */
-    static generate(ast: NetworkRule): string;
+    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;
 }
 
 /**
- * `CosmeticRuleParser` is responsible for parsing cosmetic rules.
- *
- * Where possible, it automatically detects the difference between supported syntaxes:
- *  - AdGuard
- *  - uBlock Origin
- *  - Adblock Plus
+ * @file Helper file for CSSTree to provide better compatibility with TypeScript.
+ * @see {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/62536}
+ */
+/**
+ * CSSTree node types.
  *
- * If the syntax is common / cannot be determined, the parser gives `Common` syntax.
+ * @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.
  *
- * Please note that syntactically correct rules are parsed even if they are not actually
- * compatible with the given adblocker. This is a completely natural behavior, meaningful
- * checking of compatibility is not done at the parser level.
+ * @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 CosmeticRuleParser {
+declare class CssTree {
     /**
-     * Determines whether a rule is a cosmetic rule. The rule is considered cosmetic if it
-     * contains a cosmetic rule separator.
+     * Shifts location of the CSSTree node. Temporary workaround for CSSTree issue:
+     * https://github.com/csstree/csstree/issues/251
      *
-     * @param raw Raw rule
-     * @returns `true` if the rule is a cosmetic rule, `false` otherwise
+     * @param root Root CSSTree node
+     * @param loc Location to shift
+     * @returns Root CSSTree node with shifted location
      */
-    static isCosmeticRule(raw: string): boolean;
+    static shiftNodePosition(root: CssNode, loc?: Location): CssNode;
     /**
-     * Parses a cosmetic rule. The structure of the cosmetic rules:
-     *  - pattern (AdGuard pattern can have modifiers, other syntaxes don't)
-     *  - separator
-     *  - body
+     * Helper function for parsing CSS parts.
      *
-     * @param raw Raw cosmetic rule
-     * @param loc Location of the rule
-     * @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
+     * @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, loc?: Location): AnyCosmeticRule | null;
+    static parse(raw: string, context: CssTreeParserContext, tolerant?: boolean, loc?: Location): CssNode;
     /**
-     * Converts a cosmetic rule AST into a string.
+     * Helper function for parsing CSS parts.
      *
-     * @param ast Cosmetic rule AST
-     * @returns Raw string
+     * @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 generate(ast: AnyCosmeticRule): string;
-}
-
-/**
- * `LogicalExpressionParser` is responsible for parsing logical expressions.
- *
- * @example
- * From the following rule:
- * ```adblock
- * !#if (adguard_ext_android_cb || adguard_ext_safari)
- * ```
- * this parser will parse the expression `(adguard_ext_android_cb || adguard_ext_safari)`.
- */
-declare class LogicalExpressionParser {
+    static parsePlain(raw: string, context: CssTreeParserContext, tolerant?: boolean, loc?: Location): CssNodePlain;
     /**
-     * Split the expression into tokens.
+     * Checks if the CSSTree node is an ExtendedCSS node.
      *
-     * @param raw Source code of the expression
-     * @param loc Location of the expression
-     * @returns Token list
-     * @throws {AdblockSyntaxError} If the expression is invalid
+     * @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`
      */
-    private static tokenize;
+    static isExtendedCssNode(node: CssNode | CssNodePlain, pseudoClasses: Set<string>, attributeSelectors: Set<string>): boolean;
     /**
-     * Parses a logical expression.
+     * Walks through the CSSTree node and returns all ExtendedCSS nodes.
      *
-     * @param raw Source code of the expression
-     * @param loc Location of the expression
-     * @returns Parsed expression
-     * @throws {AdblockSyntaxError} If the expression is invalid
+     * @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 parse(raw: string, loc?: Location): AnyExpressionNode;
+    static getSelectorExtendedCssNodes(selectorList: string | SelectorList | SelectorListPlain, pseudoClasses?: Set<string>, attributeSelectors?: Set<string>): CssNode[];
     /**
-     * Generates a string representation of the logical expression (serialization).
+     * 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 ast Expression node
-     * @returns String representation of the logical expression
+     * @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 generate(ast: AnyExpressionNode): string;
-}
-
-/**
- * `DomainListParser` is responsible for parsing a domain list.
- *
- * @example
- * - If the rule is `example.com,~example.net##.ads`, the domain list is `example.com,~example.net`.
- * - If the rule is `ads.js^$script,domains=example.com|~example.org`, the domain list is `example.com|~example.org`.
- * This parser is responsible for parsing these domain lists.
- * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_domains}
- */
-declare class DomainListParser {
+    static hasAnySelectorExtendedCssNode(selectorList: string | SelectorList | SelectorListPlain, pseudoClasses?: Set<string>, attributeSelectors?: Set<string>): boolean;
     /**
-     * Parses a domain list, eg. `example.com,example.org,~example.org`
+     * 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 raw Raw domain list
-     * @param separator Separator character
-     * @param loc Location of the domain list
-     * @returns Domain list AST
-     * @throws If the domain list is syntactically invalid
+     * @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 parse(raw: string, separator?: DomainListSeparator, loc?: Location): DomainList;
+    static isForbiddenFunction(node: CssNode | CssNodePlain, forbiddenFunctions?: Set<string>): boolean;
     /**
-     * Converts a domain list AST to a string.
+     * 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 ast Domain list AST
-     * @returns Raw string
+     * @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 generate(ast: DomainList): string;
-}
-
-/**
- * `ModifierListParser` is responsible for parsing modifier lists. Please note that the name is not
- * uniform, "modifiers" are also known as "options".
- *
- * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#basic-rules-modifiers}
- * @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 {
+    static getForbiddenFunctionNodes(declarationList: string | DeclarationList | DeclarationListPlain, forbiddenFunctions?: Set<string>): CssNode[];
     /**
-     * Parses the cosmetic rule modifiers, eg. `third-party,domain=example.com|~example.org`.
+     * 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.
      *
-     * _Note:_ you should remove `$` separator before passing the raw modifiers to this function,
-     *  or it will be parsed in the first modifier.
+     * @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 raw Raw modifier list
-     * @param loc Location of the modifier list
-     * @returns Parsed modifiers interface
+     * @param ast Media query list AST
+     * @returns String representation of the media query list
      */
-    static parse(raw: string, loc?: Location): ModifierList;
+    static generateMediaQueryList(ast: MediaQueryList): string;
     /**
-     * Converts a modifier list AST to a string.
+     * Generates string representation of the media query.
      *
-     * @param ast Modifier list AST
-     * @returns Raw string
+     * @param ast Media query AST
+     * @returns String representation of the media query
      */
-    static generate(ast: ModifierList): string;
-}
-
-/**
- * `ModifierParser` is responsible for parsing modifiers.
- *
- * @example
- * `match-case`, `~third-party`, `domain=example.com|~example.org`
- */
-declare class ModifierParser {
+    static generateMediaQuery(ast: MediaQuery): string;
     /**
-     * Parses a modifier.
+     * Generates string representation of the selector list.
      *
-     * @param raw Raw modifier string
-     * @param loc Location of the modifier
-     * @returns Parsed modifier
+     * @param ast SelectorList AST
+     * @returns String representation of the selector list
      */
-    static parse(raw: string, loc?: Location): Modifier;
+    static generateSelectorList(ast: SelectorList): string;
     /**
-     * Generates a string from a modifier (serializes it).
+     * Selector generation based on CSSTree's AST. This is necessary because CSSTree
+     * only adds spaces in some edge cases.
      *
-     * @param modifier Modifier to generate string from
-     * @returns String representation of the modifier
+     * @param ast CSS Tree AST
+     * @returns CSS selector as string
      */
-    static generate(modifier: Modifier): string;
-}
-
-declare class ParameterListParser {
+    static generateSelector(ast: Selector): string;
     /**
-     * Parses a raw parameter list.
+     * Block generation based on CSSTree's AST. This is necessary because CSSTree only adds spaces in some edge cases.
      *
-     * @param raw Raw parameter list
-     * @param separator Separator character (default: comma)
-     * @param loc Base location
-     * @returns Parameter list AST
+     * @param ast CSS Tree AST
+     * @returns CSS selector as string
      */
-    static parse(raw: string, separator?: string, loc?: Location): ParameterList;
+    static generateDeclarationList(ast: DeclarationList): string;
     /**
-     * Converts a parameter list AST to a string.
+     * Helper method to assert that the attribute selector has a value
      *
-     * @param params Parameter list AST
-     * @param separator Separator character (default: comma)
-     * @returns String representation of the parameter list
+     * @param node Attribute selector node
      */
-    static generate(params: ParameterList, separator?: string): string;
-}
-
-/**
- * @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 {
+    static assertAttributeSelectorHasStringValue(node: AttributeSelector): asserts node is AttributeSelector & {
+        value: {
+            type: 'String';
+        };
+    };
     /**
-     * Location range of the error.
+     * Helper method to assert that the pseudo-class selector has at least one argument
+     *
+     * @param node Pseudo-class selector node
      */
-    loc: LocationRange;
+    static assertPseudoClassHasAnyArgument(node: PseudoClassSelectorPlain): asserts node is PseudoClassSelectorPlain & {
+        children: CssNodePlain[];
+    };
     /**
-     * Constructs a new `AdblockSyntaxError` instance.
+     * Helper method to parse an attribute selector value as a number
      *
-     * @param message Error message
-     * @param loc Location range of the error
+     * @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
      */
-    constructor(message: string, loc: LocationRange);
-}
-
-/**
- * `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 {
+    static parseAttributeSelectorValueAsNumber(node: AttributeSelector): number;
     /**
-     * Parses a whole adblock filter list (list of rules).
+     * Helper method to parse a pseudo-class argument as a number
      *
-     * @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.
-     * @returns AST of the source code (list of rules)
-     * @example
-     * ```js
-     * import { readFileSync } from 'fs';
-     * import { FilterListParser } from '@adguard/agtree';
+     * @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
      *
-     * // Read filter list content from file
-     * const content = readFileSync('your-adblock-filter-list.txt', 'utf-8');
+     * @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
      *
-     * // Parse the filter list content, then do something with the AST
-     * const ast = FilterListParser.parse(content);
-     * ```
-     * @throws If one of the rules is syntactically invalid (if `tolerant` is `false`)
+     * @param node Node to rename
+     * @param name New name
      */
-    static parse(raw: string, tolerant?: boolean): FilterList;
+    static renamePseudoClass(node: PseudoClassSelector, name: string): void;
     /**
-     * Serializes a whole adblock filter list (list of rules).
+     * Helper function to generate a raw string from a pseudo-class
+     * selector's children
      *
-     * @param ast AST to generate
-     * @param preferRaw If `true`, then the parser will use `raws.text` property of each rule
-     * if it is available. Default is `false`.
-     * @returns Serialized filter list
+     * @param node Pseudo-class selector node
+     * @returns Generated pseudo-class value
+     * @example
+     * - `:nth-child(2n+1)` -> `2n+1`
+     * - `:matches-path(/foo/bar)` -> `/foo/bar`
      */
-    static generate(ast: FilterList, preferRaw?: boolean): string;
+    static generatePseudoClassValue(node: PseudoClassSelector): string;
+    /**
+     * Helper function to generate a raw string from a function selector's children
+     *
+     * @param node Function node
+     * @returns Generated function value
+     * @example `responseheader(name)` -> `name`
+     */
+    static generateFunctionValue(node: FunctionNode): string;
 }
 
 /**
@@ -1709,9 +2429,165 @@ declare class LogicalExpressionUtils {
     static evaluate(ast: 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 = "^";
+declare const ADBLOCK_URL_SEPARATOR_REGEX = "([^ a-zA-Z0-9.%_-]|$)";
+declare const ADBLOCK_WILDCARD = "*";
+declare const ADBLOCK_WILDCARD_REGEX: string;
+/**
+ * Special RegExp symbols
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#special-escape
+ */
+declare const SPECIAL_REGEX_SYMBOLS: Set<string>;
+/**
+ * Utility functions for working with RegExp patterns
+ */
+declare class RegExpUtils {
+    /**
+     * Checks whether a string is a RegExp pattern.
+     * Flags are not supported.
+     *
+     * @param pattern - Pattern to check
+     * @returns `true` if the string is a RegExp pattern, `false` otherwise
+     */
+    static isRegexPattern(pattern: string): boolean;
+    /**
+     * Negates a RegExp pattern. Technically, this method wraps the pattern in `^((?!` and `).)*$`.
+     *
+     * RegExp modifiers are not supported.
+     *
+     * @param pattern Pattern to negate (can be wrapped in slashes or not)
+     * @returns Negated RegExp pattern
+     */
+    static negateRegexPattern(pattern: string): string;
+    /**
+     * Converts a basic adblock rule pattern to a RegExp pattern. Based on
+     * https://github.com/AdguardTeam/tsurlfilter/blob/9b26e0b4a0e30b87690bc60f7cf377d112c3085c/packages/tsurlfilter/src/rules/simple-regex.ts#L219
+     *
+     * @param pattern Pattern to convert
+     * @returns RegExp equivalent of the pattern
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#basic-rules}
+     */
+    static patternToRegexp(pattern: string): string;
+}
+
+/**
+ * @file Utility functions for working with quotes
+ */
+/**
+ * Possible quote types for scriptlet parameters
+ */
+declare enum QuoteType {
+    /**
+     * No quotes at all
+     */
+    None = "none",
+    /**
+     * Single quotes (`'`)
+     */
+    Single = "single",
+    /**
+     * Double quotes (`"`)
+     */
+    Double = "double"
+}
+/**
+ * Utility functions for working with quotes
+ */
+declare class QuoteUtils {
+    /**
+     * Escape all unescaped occurrences of the character
+     *
+     * @param string String to escape
+     * @param char Character to escape
+     * @returns Escaped string
+     */
+    static escapeUnescapedOccurrences(string: string, char: string): string;
+    /**
+     * Unescape all single escaped occurrences of the character
+     *
+     * @param string String to unescape
+     * @param char Character to unescape
+     * @returns Unescaped string
+     */
+    static unescapeSingleEscapedOccurrences(string: string, char: string): string;
+    /**
+     * Get quote type of the string
+     *
+     * @param string String to check
+     * @returns Quote type of the string
+     */
+    static getStringQuoteType(string: string): QuoteType;
+    /**
+     * Set quote type of the string
+     *
+     * @param string String to set quote type of
+     * @param quoteType Quote type to set
+     * @returns String with the specified quote type
+     */
+    static setStringQuoteType(string: string, quoteType: QuoteType): string;
+    /**
+     * Removes bounding quotes from a string, if any
+     *
+     * @param string Input string
+     * @returns String without quotes
+     */
+    static removeQuotes(string: string): string;
+}
+
+/**
+ * Known metadata headers
+ */
+declare const METADATA_HEADERS: string[];
+
+/**
+ * Known Extended CSS pseudo-classes. Please, keep this list sorted.
+ */
+declare const EXT_CSS_PSEUDO_CLASSES: Set<string>;
+/**
+ * Known legacy Extended CSS attributes. These attributes are deprecated and
+ * should be replaced with the corresponding pseudo-classes. In a long term,
+ * these attributes will be COMPLETELY removed from the Extended CSS syntax.
+ *
+ * Please, keep this list sorted.
+ */
+declare const EXT_CSS_LEGACY_ATTRIBUTES: Set<string>;
+/**
+ * Known CSS functions that aren't allowed in CSS injection rules, because they
+ * able to load external resources. Please, keep this list sorted.
+ */
+declare const FORBIDDEN_CSS_FUNCTIONS: Set<string>;
+
 /**
  * @file AGTree version
  */
 declare const version: string;
 
-export { AdblockSyntaxError, Agent, AgentCommentRule, AgentCommentRuleParser, AgentParser, AnyCommentRule, AnyCosmeticRule, AnyExpressionNode, AnyOperator, AnyRule, CommentBase, CommentMarker, CommentRule, CommentRuleParser, CommentRuleType, ConfigCommentRule, ConfigCommentRuleParser, CosmeticRule, CosmeticRuleParser, CosmeticRuleSeparator, CosmeticRuleType, CssInjectionRule, CssInjectionRuleBody, Domain, DomainList, DomainListParser, DomainListSeparator, DomainUtils, ElementHidingRule, ElementHidingRuleBody, EmptyRule, ExpressionOperatorNode, ExpressionParenthesisNode, ExpressionVariableNode, FilterList, FilterListParser, Hint, HintCommentRule, HintCommentRuleParser, HintParser, HtmlFilteringRule, HtmlFilteringRuleBody, JsInjectionRule, Location, LocationRange, LogicalExpressionParser, LogicalExpressionUtils, MetadataCommentRule, MetadataCommentRuleParser, Modifier, ModifierList, ModifierListParser, ModifierParser, NetworkRule, NetworkRuleParser, Node, Parameter, ParameterList, ParameterListParser, PreProcessorCommentRule, PreProcessorCommentRuleParser, RuleBase, RuleCategory, RuleParser, ScriptletInjectionRule, ScriptletInjectionRuleBody, Value, VariableTable, 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, AdblockSyntax, AdblockSyntaxError, Agent, AgentCommentRule, AgentCommentRuleParser, AgentParser, AnyCommentRule, AnyCosmeticRule, AnyExpressionNode, AnyOperator, AnyRule, CLASSIC_DOMAIN_SEPARATOR, CommentBase, CommentMarker, CommentRule, CommentRuleParser, CommentRuleType, ConfigCommentRule, ConfigCommentRuleParser, CosmeticRule, CosmeticRuleParser, CosmeticRuleSeparator, CosmeticRuleSeparatorFinderResult, CosmeticRuleSeparatorUtils, CosmeticRuleType, CssInjectionRule, CssInjectionRuleBody, CssTree, CssTreeNodeType, CssTreeParserContext, DOMAIN_EXCEPTION_MARKER, 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, MODIFIER_DOMAIN_SEPARATOR, MODIFIER_EXCEPTION_MARKER, MetadataCommentRule, MetadataCommentRuleParser, Modifier, ModifierList, ModifierListParser, ModifierParser, NETWORK_RULE_EXCEPTION_MARKER, NETWORK_RULE_SEPARATOR, NetworkRule, NetworkRuleParser, Node, NotImplementedError, PREPROCESSOR_MARKER, Parameter, ParameterList, ParameterListParser, PreProcessorCommentRule, PreProcessorCommentRuleParser, QuoteType, QuoteUtils, RegExpUtils, RuleBase, RuleCategory, RuleConversionError, RuleConverter, RuleParser, SAFARI_CB_AFFINITY, SPECIAL_REGEX_SYMBOLS, ScriptletInjectionRule, ScriptletInjectionRuleBody, UBO_SCRIPTLET_MASK, Value, VariableTable, locRange, modifierValidator, shiftLoc, version };