@adguard/agtree 1.0.1 → 1.1.1

package/dist/agtree.esm.js

@@ -1,13 +1,17 @@
 /*
- * 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 valid from 'semver/functions/valid.js';
 import coerce from 'semver/functions/coerce.js';
 import JSON5 from 'json5';
-import { walk, parse, toPlainObject, generate, fromPlainObject, List } from '@adguard/ecss-tree';
+import { walk, parse, toPlainObject, find, generate, fromPlainObject, List } from '@adguard/ecss-tree';
+import * as ecssTree from '@adguard/ecss-tree';
+export { ecssTree as ECSSTree };
+import cloneDeep from 'clone-deep';
+import { redirects } from '@adguard/scriptlets';
 import { parse as parse$1 } from 'tldts';
 
 /**
@@ -74,10 +78,15 @@ const SEMICOLON = ';';
 const AMPERSAND = '&';
 const ASTERISK = '*';
 const AT_SIGN = '@';
+const CARET = '^';
 const DOLLAR_SIGN = '$';
+const EQUALS = '=';
 const EXCLAMATION_MARK = '!';
 const HASHMARK = '#';
 const PIPE = '|';
+const PLUS = '+';
+const QUESTION_MARK = '?';
+const SLASH = '/';
 const UNDERSCORE = '_';
 // Escape characters
 const BACKSLASH = '\\';
@@ -87,6 +96,8 @@ const CR = '\r';
 const FF = '\f';
 const LF = '\n';
 const CRLF = CR + LF;
+const DOUBLE_QUOTE = '"';
+const SINGLE_QUOTE = '\'';
 // Brackets
 const OPEN_PARENTHESIS = '(';
 const CLOSE_PARENTHESIS = ')';
@@ -103,6 +114,7 @@ const CAPITAL_LETTER_Z = 'Z';
 // Numbers as strings
 const NUMBER_0 = '0';
 const NUMBER_9 = '9';
+const REGEX_MARKER = '/';
 const ADG_SCRIPTLET_MASK = '//scriptlet';
 const UBO_SCRIPTLET_MASK = 'js';
 // Modifiers are separated by ",". For example: "script,domain=example.com"
@@ -120,6 +132,16 @@ const DOMAIN_EXCEPTION_MARKER = '~';
  * ```
  */
 const CLASSIC_DOMAIN_SEPARATOR = ',';
+/**
+ * Modifier domain separator.
+ *
+ * @example
+ * ```adblock
+ * ! Domains are separated by "|":
+ * ads.js^$script,domains=example.com|~example.org
+ * ```
+ */
+const MODIFIER_DOMAIN_SEPARATOR = '|';
 const DOMAIN_LIST_TYPE = 'DomainList';
 const CSS_IMPORTANT = '!important';
 const HINT_MARKER = '!+';
@@ -176,7 +198,6 @@ function locRange(loc, startOffset, endOffset) {
  */
 const SINGLE_QUOTE_MARKER = "'";
 const DOUBLE_QUOTE_MARKER = '"';
-const REGEX_MARKER = '/';
 class StringUtils {
     /**
      * Finds the first occurrence of a character that:
@@ -523,21 +544,6 @@ class StringUtils {
         }
         return pattern.length;
     }
-    /**
-     * Checks whether a string is a RegExp pattern.
-     *
-     * @param pattern - Pattern to check
-     * @returns `true` if the string is a RegExp pattern, `false` otherwise
-     */
-    static isRegexPattern(pattern) {
-        const trimmedPattern = pattern.trim();
-        const lastIndex = trimmedPattern.length - 1;
-        if (trimmedPattern.length > 2 && trimmedPattern[0] === REGEX_MARKER) {
-            const last = StringUtils.findNextUnescapedCharacter(trimmedPattern, REGEX_MARKER, 1);
-            return last === lastIndex;
-        }
-        return false;
-    }
     /**
      * Escapes a specified character in the string.
      *
@@ -568,7 +574,7 @@ class StringUtils {
         while (i < pattern.length && StringUtils.isWhitespace(pattern[i])) {
             i += 1;
         }
-        return i;
+        return Math.min(i, pattern.length);
     }
     /**
      * Searches for the previous non-whitespace character in the source pattern.
@@ -582,22 +588,7 @@ class StringUtils {
         while (i >= 0 && StringUtils.isWhitespace(pattern[i])) {
             i -= 1;
         }
-        return i;
-    }
-    /**
-     * Finds the next EOL character in the pattern (CR, LF, FF) or the end of the pattern.
-     *
-     * @param pattern Pattern to search
-     * @param start Start index
-     * @returns Index of the next EOL character or the length of the pattern
-     */
-    static findNextEOL(pattern, start = 0) {
-        for (let i = start; i < pattern.length; i += 1) {
-            if (StringUtils.isEOL(pattern[i])) {
-                return i;
-            }
-        }
-        return pattern.length;
+        return Math.max(i, -1);
     }
     /**
      * Checks if the given character is a new line character.
@@ -687,6 +678,46 @@ class StringUtils {
         }
         return result;
     }
+    /**
+     * Helper method to parse a raw string as a number
+     *
+     * @param raw Raw string to parse
+     * @returns Parsed number
+     * @throws If the raw string can't be parsed as a number
+     */
+    static parseNumber(raw) {
+        const result = parseInt(raw, 10);
+        if (Number.isNaN(result)) {
+            throw new Error('Expected a number');
+        }
+        return result;
+    }
+    /**
+     * Checks if the given value is a string.
+     *
+     * @param value Value to check
+     * @returns `true` if the value is a string, `false` otherwise
+     */
+    static isString(value) {
+        return typeof value === 'string';
+    }
+    /**
+     * Escapes the given characters in the input string.
+     *
+     * @param input Input string
+     * @param characters Characters to escape (by default, no characters are escaped)
+     * @returns Escaped string
+     */
+    static escapeCharacters(input, characters = new Set()) {
+        let result = EMPTY;
+        for (let i = 0; i < input.length; i += 1) {
+            if (characters.has(input[i])) {
+                result += ESCAPE_CHARACTER;
+            }
+            result += input[i];
+        }
+        return result;
+    }
 }
 
 /**
@@ -767,7 +798,89 @@ var CosmeticRuleType;
     CosmeticRuleType["HtmlFilteringRule"] = "HtmlFilteringRule";
     CosmeticRuleType["JsInjectionRule"] = "JsInjectionRule";
 })(CosmeticRuleType || (CosmeticRuleType = {}));
+/**
+ * Represents possible cosmetic rule separators.
+ */
+var CosmeticRuleSeparator;
+(function (CosmeticRuleSeparator) {
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    CosmeticRuleSeparator["ElementHiding"] = "##";
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    CosmeticRuleSeparator["ElementHidingException"] = "#@#";
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    CosmeticRuleSeparator["ExtendedElementHiding"] = "#?#";
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    CosmeticRuleSeparator["ExtendedElementHidingException"] = "#@?#";
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    CosmeticRuleSeparator["AbpSnippet"] = "#$#";
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    CosmeticRuleSeparator["AbpSnippetException"] = "#@$#";
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    CosmeticRuleSeparator["AdgCssInjection"] = "#$#";
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    CosmeticRuleSeparator["AdgCssInjectionException"] = "#@$#";
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    CosmeticRuleSeparator["AdgExtendedCssInjection"] = "#$?#";
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    CosmeticRuleSeparator["AdgExtendedCssInjectionException"] = "#@$?#";
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
+     */
+    CosmeticRuleSeparator["AdgJsInjection"] = "#%#";
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
+     */
+    CosmeticRuleSeparator["AdgJsInjectionException"] = "#@%#";
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#html-filtering-rules}
+     */
+    CosmeticRuleSeparator["AdgHtmlFiltering"] = "$$";
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#html-filtering-rules}
+     */
+    CosmeticRuleSeparator["AdgHtmlFilteringException"] = "$@$";
+    /**
+     * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#scriptlet-injection}
+     */
+    CosmeticRuleSeparator["UboScriptletInjection"] = "##+";
+    /**
+     * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#scriptlet-injection}
+     */
+    CosmeticRuleSeparator["UboScriptletInjectionException"] = "#@#+";
+    /**
+     * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#html-filters}
+     */
+    CosmeticRuleSeparator["UboHtmlFiltering"] = "##^";
+    /**
+     * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#html-filters}
+     */
+    CosmeticRuleSeparator["UboHtmlFilteringException"] = "#@#^";
+})(CosmeticRuleSeparator || (CosmeticRuleSeparator = {}));
 
+/**
+ * @file Customized syntax error class for Adblock Filter Parser.
+ */
+const ERROR_NAME$2 = 'AdblockSyntaxError';
 /**
  * Customized syntax error class for Adblock Filter Parser,
  * which contains the location range of the error.
@@ -785,11 +898,48 @@ class AdblockSyntaxError extends SyntaxError {
      */
     constructor(message, loc) {
         super(message);
-        this.name = 'AdblockSyntaxError';
+        this.name = ERROR_NAME$2;
         this.loc = loc;
     }
 }
 
+const ADG_NAME_MARKERS = new Set([
+    'adguard',
+    'adg',
+]);
+const UBO_NAME_MARKERS = new Set([
+    'ublock',
+    'ublock origin',
+    'ubo',
+]);
+const ABP_NAME_MARKERS = new Set([
+    'adblock',
+    'adblock plus',
+    'adblockplus',
+    'abp',
+]);
+/**
+ * Returns the adblock syntax based on the adblock name
+ * parsed from the agent type comment.
+ * Needed for modifiers validation of network rules by AGLint.
+ *
+ * @param name Adblock name.
+ *
+ * @returns Adblock syntax.
+ */
+const getAdblockSyntax = (name) => {
+    let syntax = AdblockSyntax.Common;
+    if (ADG_NAME_MARKERS.has(name.toLowerCase())) {
+        syntax = AdblockSyntax.Adg;
+    }
+    else if (UBO_NAME_MARKERS.has(name.toLowerCase())) {
+        syntax = AdblockSyntax.Ubo;
+    }
+    else if (ABP_NAME_MARKERS.has(name.toLowerCase())) {
+        syntax = AdblockSyntax.Abp;
+    }
+    return syntax;
+};
 /**
  * `AgentParser` is responsible for parsing single adblock agent elements.
  *
@@ -828,6 +978,8 @@ class AgentParser {
         // Prepare variables for name and version
         let name = null;
         let version = null;
+        // default value for the syntax
+        let syntax = AdblockSyntax.Common;
         // Get agent parts by splitting it by spaces. The last part may be a version.
         // Example: "Adblock Plus 2.0"
         while (offset < raw.length) {
@@ -840,11 +992,12 @@ class AgentParser {
                 if (version !== null) {
                     throw new AdblockSyntaxError('Duplicated versions are not allowed', locRange(loc, offset, partEnd));
                 }
+                const parsedNamePart = raw.substring(nameStartIndex, nameEndIndex);
                 // Save name
                 name = {
                     type: 'Value',
                     loc: locRange(loc, nameStartIndex, nameEndIndex),
-                    value: raw.substring(nameStartIndex, nameEndIndex),
+                    value: parsedNamePart,
                 };
                 // Save version
                 version = {
@@ -852,6 +1005,8 @@ class AgentParser {
                     loc: locRange(loc, offset, partEnd),
                     value: part,
                 };
+                // Save syntax
+                syntax = getAdblockSyntax(parsedNamePart);
             }
             else {
                 nameEndIndex = partEnd;
@@ -861,11 +1016,13 @@ class AgentParser {
         }
         // If we didn't find a version, the whole string is the name
         if (name === null) {
+            const parsedNamePart = raw.substring(nameStartIndex, nameEndIndex);
             name = {
                 type: 'Value',
                 loc: locRange(loc, nameStartIndex, nameEndIndex),
-                value: raw.substring(nameStartIndex, nameEndIndex),
+                value: parsedNamePart,
             };
+            syntax = getAdblockSyntax(parsedNamePart);
         }
         // Agent name cannot be empty
         if (name.value.length === 0) {
@@ -876,6 +1033,7 @@ class AgentParser {
             loc: locRange(loc, 0, raw.length),
             adblock: name,
             version,
+            syntax,
         };
     }
     /**
@@ -915,6 +1073,18 @@ class CosmeticRuleSeparatorUtils {
         // Simply check the second character
         return separator[1] === AT_SIGN;
     }
+    /**
+     * 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) {
+        return (separator === CosmeticRuleSeparator.ExtendedElementHiding
+            || separator === CosmeticRuleSeparator.ExtendedElementHidingException
+            || separator === CosmeticRuleSeparator.AdgExtendedCssInjection
+            || separator === CosmeticRuleSeparator.AdgExtendedCssInjectionException);
+    }
     /**
      * Looks for the cosmetic rule separator in the rule. This is a simplified version that
      * masks the recursive function.
@@ -942,64 +1112,80 @@ class CosmeticRuleSeparatorUtils {
             if (rule[i] === '#') {
                 if (rule[i + 1] === '#') {
                     if (rule[i + 2] === '+') {
-                        return createResult(i, '##+');
+                        // ##+
+                        return createResult(i, CosmeticRuleSeparator.UboScriptletInjection);
                     }
                     if (rule[i + 2] === '^') {
-                        return createResult(i, '##^');
+                        // ##^
+                        return createResult(i, CosmeticRuleSeparator.UboHtmlFiltering);
                     }
                     if (rule[i - 1] !== SPACE) {
-                        return createResult(i, '##');
+                        // ##
+                        return createResult(i, CosmeticRuleSeparator.ElementHiding);
                     }
                 }
                 if (rule[i + 1] === '?' && rule[i + 2] === '#') {
-                    return createResult(i, '#?#');
+                    // #?#
+                    return createResult(i, CosmeticRuleSeparator.ExtendedElementHiding);
                 }
                 if (rule[i + 1] === '%' && rule[i + 2] === '#') {
-                    return createResult(i, '#%#');
+                    // #%#
+                    return createResult(i, CosmeticRuleSeparator.AdgJsInjection);
                 }
                 if (rule[i + 1] === '$') {
                     if (rule[i + 2] === '#') {
-                        return createResult(i, '#$#');
+                        // #$#
+                        return createResult(i, CosmeticRuleSeparator.AdgCssInjection);
                     }
                     if (rule[i + 2] === '?' && rule[i + 3] === '#') {
-                        return createResult(i, '#$?#');
+                        // #$?#
+                        return createResult(i, CosmeticRuleSeparator.AdgExtendedCssInjection);
                     }
                 }
                 // Exceptions
                 if (rule[i + 1] === '@') {
                     if (rule[i + 2] === '#') {
                         if (rule[i + 3] === '+') {
-                            return createResult(i, '#@#+');
+                            // #@#+
+                            return createResult(i, CosmeticRuleSeparator.UboScriptletInjectionException);
                         }
                         if (rule[i + 3] === '^') {
-                            return createResult(i, '#@#^');
+                            // #@#^
+                            return createResult(i, CosmeticRuleSeparator.UboHtmlFilteringException);
                         }
                         if (rule[i - 1] !== SPACE) {
-                            return createResult(i, '#@#');
+                            // #@#
+                            return createResult(i, CosmeticRuleSeparator.ElementHidingException);
                         }
                     }
                     if (rule[i + 2] === '?' && rule[i + 3] === '#') {
-                        return createResult(i, '#@?#');
+                        // #@?#
+                        return createResult(i, CosmeticRuleSeparator.ExtendedElementHidingException);
                     }
                     if (rule[i + 2] === '%' && rule[i + 3] === '#') {
-                        return createResult(i, '#@%#');
+                        // #@%#
+                        return createResult(i, CosmeticRuleSeparator.AdgJsInjectionException);
                     }
                     if (rule[i + 2] === '$') {
                         if (rule[i + 3] === '#') {
-                            return createResult(i, '#@$#');
+                            // #@$#
+                            return createResult(i, CosmeticRuleSeparator.AdgCssInjectionException);
                         }
                         if (rule[i + 3] === '?' && rule[i + 4] === '#') {
-                            return createResult(i, '#@$?#');
+                            // #@$?#
+                            return createResult(i, CosmeticRuleSeparator.AdgExtendedCssInjectionException);
                         }
                     }
                 }
             }
             if (rule[i] === '$') {
                 if (rule[i + 1] === '$') {
-                    return createResult(i, '$$');
+                    // $$
+                    return createResult(i, CosmeticRuleSeparator.AdgHtmlFiltering);
                 }
                 if (rule[i + 1] === '@' && rule[i + 2] === '$') {
-                    return createResult(i, '$@$');
+                    // $@$
+                    return createResult(i, CosmeticRuleSeparator.AdgHtmlFilteringException);
                 }
             }
         }
@@ -1798,6 +1984,9 @@ class LogicalExpressionParser {
             if (!token) {
                 throw new AdblockSyntaxError(`Expected token of type "${type}", but reached end of input`, locRange(loc, 0, raw.length));
             }
+            // We only use this function internally, so we can safely ignore this
+            // from the coverage report
+            // istanbul ignore next
             if (token.type !== type) {
                 throw new AdblockSyntaxError(`Expected token of type "${type}", but got "${token.type}"`, 
                 // Token location is always shifted, no need locRange
@@ -2448,7 +2637,9 @@ class ModifierParser {
      *
      * @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, loc = defaultLocation) {
         let offset = 0;
@@ -2469,7 +2660,7 @@ class ModifierParser {
         // Find assignment operator
         const assignmentIndex = StringUtils.findNextUnescapedCharacter(raw, MODIFIER_ASSIGN_OPERATOR);
         // Find the end of the modifier
-        const modifierEnd = StringUtils.skipWSBack(raw) + 1;
+        const modifierEnd = Math.max(StringUtils.skipWSBack(raw) + 1, modifierNameStart);
         // Modifier name can't be empty
         if (modifierNameStart === modifierEnd) {
             throw new AdblockSyntaxError('Modifier name can\'t be empty', locRange(loc, 0, raw.length));
@@ -2559,24 +2750,28 @@ class ModifierListParser {
             loc: locRange(loc, 0, raw.length),
             children: [],
         };
-        let offset = 0;
-        // Skip whitespace before the modifier list
-        offset = StringUtils.skipWS(raw, offset);
+        let offset = StringUtils.skipWS(raw);
+        let separatorIndex = -1;
         // Split modifiers by unescaped commas
         while (offset < raw.length) {
             // Skip whitespace before the modifier
             offset = StringUtils.skipWS(raw, offset);
             const modifierStart = offset;
-            // Find the index of the first unescaped "," character
-            const separatorStartIndex = StringUtils.findNextUnescapedCharacter(raw, MODIFIERS_SEPARATOR, offset);
-            const modifierEnd = separatorStartIndex === -1
-                ? StringUtils.skipWSBack(raw) + 1
-                : StringUtils.skipWSBack(raw, separatorStartIndex - 1) + 1;
+            // Find the index of the first unescaped comma
+            separatorIndex = StringUtils.findNextUnescapedCharacter(raw, MODIFIERS_SEPARATOR, offset);
+            const modifierEnd = separatorIndex === -1
+                ? raw.length
+                : StringUtils.skipWSBack(raw, separatorIndex - 1) + 1;
             // Parse the modifier
             const modifier = ModifierParser.parse(raw.substring(modifierStart, modifierEnd), shiftLoc(loc, modifierStart));
             result.children.push(modifier);
             // Increment the offset to the next modifier (or the end of the string)
-            offset = separatorStartIndex === -1 ? raw.length : separatorStartIndex + 1;
+            offset = separatorIndex === -1 ? raw.length : separatorIndex + 1;
+        }
+        // Check if there are any modifiers after the last separator
+        if (separatorIndex !== -1) {
+            const modifierStart = StringUtils.skipWS(raw, separatorIndex + 1);
+            result.children.push(ModifierParser.parse(raw.substring(modifierStart, raw.length), shiftLoc(loc, modifierStart)));
         }
         return result;
     }
@@ -2594,63 +2789,6 @@ class ModifierListParser {
     }
 }
 
-/**
- * Known ExtendedCSS elements
- */
-const EXTCSS_PSEUDO_CLASSES = [
-    // AdGuard
-    // https://github.com/AdguardTeam/ExtendedCss
-    'has',
-    'if-not',
-    'contains',
-    'matches-css',
-    'matches-attr',
-    'matches-property',
-    'xpath',
-    'nth-ancestor',
-    'upward',
-    'remove',
-    'is',
-    // uBlock Origin
-    // https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#procedural-cosmetic-filters
-    'has-text',
-    'matches-css-before',
-    'matches-css-after',
-    'matches-path',
-    'min-text-length',
-    'watch-attr',
-    // Adblock Plus
-    // https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide-emulation
-    '-abp-has',
-    '-abp-contains',
-    '-abp-properties',
-];
-const EXTCSS_ATTRIBUTES = [
-    // AdGuard
-    '-ext-has',
-    '-ext-if-not',
-    '-ext-contains',
-    '-ext-matches-css',
-    '-ext-matches-attr',
-    '-ext-matches-property',
-    '-ext-xpath',
-    '-ext-nth-ancestor',
-    '-ext-upward',
-    '-ext-remove',
-    '-ext-is',
-    // uBlock Origin
-    '-ext-has-text',
-    '-ext-matches-css-before',
-    '-ext-matches-css-after',
-    '-ext-matches-path',
-    '-ext-min-text-length',
-    '-ext-watch-attr',
-    // Adblock Plus
-    '-ext-abp-has',
-    '-ext-abp-contains',
-    '-ext-abp-properties',
-];
-
 /**
  * @file Helper file for CSSTree to provide better compatibility with TypeScript.
  * @see {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/62536}
@@ -2762,6 +2900,91 @@ var CssTreeParserContext;
     CssTreeParserContext["value"] = "value";
 })(CssTreeParserContext || (CssTreeParserContext = {}));
 
+/**
+ * @file Known CSS elements and attributes.
+ * TODO: Implement a compatibility table for Extended CSS
+ */
+const LEGACY_EXT_CSS_ATTRIBUTE_PREFIX = '-ext-';
+/**
+ * Known Extended CSS pseudo-classes. Please, keep this list sorted.
+ */
+const EXT_CSS_PSEUDO_CLASSES = new Set([
+    // AdGuard
+    // https://github.com/AdguardTeam/ExtendedCss
+    'contains',
+    'has',
+    'if-not',
+    'is',
+    'matches-attr',
+    'matches-css',
+    'matches-property',
+    'nth-ancestor',
+    'remove',
+    'upward',
+    'xpath',
+    // uBlock Origin
+    // https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#procedural-cosmetic-filters
+    'has-text',
+    'matches-css-after',
+    'matches-css-before',
+    'matches-path',
+    'min-text-length',
+    'watch-attr',
+    // Adblock Plus
+    // https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide-emulation
+    '-abp-contains',
+    '-abp-has',
+    '-abp-properties',
+]);
+/**
+ * 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.
+ */
+const EXT_CSS_LEGACY_ATTRIBUTES = new Set([
+    // AdGuard
+    '-ext-contains',
+    '-ext-has',
+    '-ext-if-not',
+    '-ext-is',
+    '-ext-matches-attr',
+    '-ext-matches-css',
+    '-ext-matches-property',
+    '-ext-nth-ancestor',
+    '-ext-remove',
+    '-ext-upward',
+    '-ext-xpath',
+    // uBlock Origin
+    '-ext-has-text',
+    '-ext-matches-css-after',
+    '-ext-matches-css-before',
+    '-ext-matches-path',
+    '-ext-min-text-length',
+    '-ext-watch-attr',
+    // Adblock Plus
+    '-ext-abp-contains',
+    '-ext-abp-has',
+    '-ext-abp-properties',
+]);
+/**
+ * Known CSS functions that aren't allowed in CSS injection rules, because they
+ * able to load external resources. Please, keep this list sorted.
+ */
+const FORBIDDEN_CSS_FUNCTIONS = new Set([
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/cross-fade
+    '-webkit-cross-fade',
+    'cross-fade',
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/image
+    'image',
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/image-set
+    '-webkit-image-set',
+    'image-set',
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/url
+    'url',
+]);
+
 /**
  * @file Additional / helper functions for ECSSTree / CSSTree.
  */
@@ -2775,6 +2998,7 @@ const commonCssTreeOptions = {
     parseCustomProperty: true,
     positions: true,
 };
+const URL_FUNCTION = 'url';
 /**
  * Additional / helper functions for CSSTree.
  */
@@ -2845,11 +3069,14 @@ class CssTree {
                     errorLoc = locRange(loc, error.offset, raw.length);
                 }
                 else {
+                    // istanbul ignore next
                     errorLoc = locRange(loc, 0, raw.length);
                 }
                 throw new AdblockSyntaxError(`ECSSTree parsing error: '${error.message}'`, errorLoc);
             }
-            // Pass through
+            // Pass through any other error just in case, but theoretically it should never happen,
+            // so it is ok to ignore it from the coverage
+            // istanbul ignore next
             throw error;
         }
     }
@@ -2862,64 +3089,186 @@ class CssTree {
      * @param loc Base location for the parsed node
      * @returns CSSTree node (AST)
      */
+    // istanbul ignore next
     // eslint-disable-next-line max-len
     static parsePlain(raw, context, tolerant = false, loc = defaultLocation) {
         return toPlainObject(CssTree.parse(raw, context, tolerant, loc));
     }
     /**
-     * Walks through the CSSTree node and returns all ExtendedCSS nodes.
+     * Checks if the CSSTree node is an ExtendedCSS node.
      *
-     * @param selectorAst CSSTree selector AST
-     * @returns Extended CSS nodes (pseudos and attributes)
+     * @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 getSelectorExtendedCssNodes(selectorAst) {
-        const pseudos = [];
-        const attributes = [];
-        walk(selectorAst, (node) => {
-            // Pseudo classes
-            if (node.type === CssTreeNodeType.PseudoClassSelector) {
-                // Check if it's a known ExtendedCSS pseudo class
-                if (EXTCSS_PSEUDO_CLASSES.includes(node.name)) {
-                    pseudos.push(node);
-                }
-            }
-            else if (node.type === CssTreeNodeType.AttributeSelector) {
-                // Check if it's a known ExtendedCSS attribute
-                if (EXTCSS_ATTRIBUTES.includes(node.name.name)) {
-                    attributes.push(node);
-                }
-            }
-        });
-        return {
-            pseudos,
-            attributes,
-        };
+    static isExtendedCssNode(node, pseudoClasses, attributeSelectors) {
+        return ((node.type === CssTreeNodeType.PseudoClassSelector && pseudoClasses.has(node.name))
+            || (node.type === CssTreeNodeType.AttributeSelector && attributeSelectors.has(node.name.name)));
     }
     /**
-     * Generates string representation of the media query list.
+     * Walks through the CSSTree node and returns all ExtendedCSS nodes.
      *
-     * @param ast Media query list AST
-     * @returns String representation of the media query list
+     * @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 generateMediaQueryList(ast) {
-        let result = EMPTY;
-        if (!ast.children || ast.children.size === 0) {
-            throw new Error('Media query list cannot be empty');
+    static getSelectorExtendedCssNodes(selectorList, pseudoClasses = EXT_CSS_PSEUDO_CLASSES, attributeSelectors = EXT_CSS_LEGACY_ATTRIBUTES) {
+        // Parse the block if string is passed
+        let ast;
+        if (StringUtils.isString(selectorList)) {
+            ast = CssTree.parse(selectorList, CssTreeParserContext.selectorList);
         }
-        ast.children.forEach((mediaQuery, listItem) => {
-            if (mediaQuery.type !== CssTreeNodeType.MediaQuery) {
-                throw new Error(`Unexpected node type: ${mediaQuery.type}`);
-            }
-            result += this.generateMediaQuery(mediaQuery);
-            if (listItem.next !== null) {
-                result += COMMA;
-                result += SPACE;
+        else {
+            ast = cloneDeep(selectorList);
+        }
+        const nodes = [];
+        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        walk(ast, (node) => {
+            if (CssTree.isExtendedCssNode(node, pseudoClasses, attributeSelectors)) {
+                nodes.push(node);
             }
         });
-        return result;
+        return nodes;
     }
     /**
-     * Generates string representation of the media query.
+     * 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, pseudoClasses = EXT_CSS_PSEUDO_CLASSES, attributeSelectors = EXT_CSS_LEGACY_ATTRIBUTES) {
+        // Parse the block if string is passed
+        let ast;
+        if (StringUtils.isString(selectorList)) {
+            ast = CssTree.parse(selectorList, CssTreeParserContext.selectorList);
+        }
+        else {
+            ast = cloneDeep(selectorList);
+        }
+        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return find(ast, (node) => CssTree.isExtendedCssNode(node, pseudoClasses, attributeSelectors)) !== null;
+    }
+    /**
+     * 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, forbiddenFunctions = FORBIDDEN_CSS_FUNCTIONS) {
+        return (
+        // General case: check if it's a forbidden function
+        (node.type === CssTreeNodeType.Function && forbiddenFunctions.has(node.name))
+            // Special case: CSSTree handles `url()` function in a separate node type,
+            // and we also should check if the `url()` are marked as a forbidden function
+            || (node.type === CssTreeNodeType.Url && forbiddenFunctions.has(URL_FUNCTION)));
+    }
+    /**
+     * 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, forbiddenFunctions = FORBIDDEN_CSS_FUNCTIONS) {
+        // Parse the block if string is passed
+        let ast;
+        if (StringUtils.isString(declarationList)) {
+            ast = CssTree.parse(declarationList, CssTreeParserContext.declarationList);
+        }
+        else {
+            ast = cloneDeep(declarationList);
+        }
+        const nodes = [];
+        // While walking the AST we should skip the nested functions,
+        // for example skip url()s in cross-fade(url(), url()), since
+        // cross-fade() itself is already a forbidden function
+        let inForbiddenFunction = false;
+        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        walk(ast, {
+            enter: (node) => {
+                if (!inForbiddenFunction && CssTree.isForbiddenFunction(node, forbiddenFunctions)) {
+                    nodes.push(node);
+                    inForbiddenFunction = true;
+                }
+            },
+            leave: (node) => {
+                if (inForbiddenFunction && CssTree.isForbiddenFunction(node, forbiddenFunctions)) {
+                    inForbiddenFunction = false;
+                }
+            },
+        });
+        return nodes;
+    }
+    /**
+     * 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, forbiddenFunctions = FORBIDDEN_CSS_FUNCTIONS) {
+        // Parse the block if string is passed
+        let ast;
+        if (StringUtils.isString(declarationList)) {
+            ast = CssTree.parse(declarationList, CssTreeParserContext.declarationList);
+        }
+        else {
+            ast = cloneDeep(declarationList);
+        }
+        // TODO: CSSTree types should be improved, as a workaround we use `any` here
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return find(ast, (node) => CssTree.isForbiddenFunction(node, forbiddenFunctions)) !== null;
+    }
+    /**
+     * 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) {
+        let result = EMPTY;
+        if (!ast.children || ast.children.size === 0) {
+            throw new Error('Media query list cannot be empty');
+        }
+        ast.children.forEach((mediaQuery, listItem) => {
+            if (mediaQuery.type !== CssTreeNodeType.MediaQuery) {
+                throw new Error(`Unexpected node type: ${mediaQuery.type}`);
+            }
+            result += this.generateMediaQuery(mediaQuery);
+            if (listItem.next !== null) {
+                result += COMMA;
+                result += SPACE;
+            }
+        });
+        return result;
+    }
+    /**
+     * Generates string representation of the media query.
      *
      * @param ast Media query AST
      * @returns String representation of the media query
@@ -3162,6 +3511,150 @@ class CssTree {
         });
         return result.trim();
     }
+    /**
+     * Helper method to assert that the attribute selector has a value
+     *
+     * @param node Attribute selector node
+     */
+    static assertAttributeSelectorHasStringValue(node) {
+        if (!node.value || node.value.type !== CssTreeNodeType.String) {
+            throw new Error(`Invalid argument '${node.value}' for '${node.name.name}', expected a string, but got '${node.value
+                ? node.value.type
+                : 'undefined'}'`);
+        }
+    }
+    /**
+     * Helper method to assert that the pseudo-class selector has at least one argument
+     *
+     * @param node Pseudo-class selector node
+     */
+    static assertPseudoClassHasAnyArgument(node) {
+        if (!node.children || node.children.length === 0) {
+            throw new Error(`Pseudo class '${node.name}' has no argument`);
+        }
+    }
+    /**
+     * 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) {
+        CssTree.assertAttributeSelectorHasStringValue(node);
+        return StringUtils.parseNumber(node.value.value);
+    }
+    /**
+     * 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) {
+        // Check if the pseudo-class has at least one child
+        CssTree.assertPseudoClassHasAnyArgument(node);
+        // Check if the pseudo-class has only one child
+        if (node.children.length > 1) {
+            throw new Error(`Invalid argument '${node.name}', expected a number, but got multiple arguments`);
+        }
+        // Check if the pseudo-class argument is a string / number / raw
+        const argument = node.children[0];
+        if (argument.type !== CssTreeNodeType.String
+            && argument.type !== CssTreeNodeType.Number
+            && argument.type !== CssTreeNodeType.Raw) {
+            throw new Error(`Invalid argument '${node.name}', expected a ${CssTreeNodeType.String} or ${CssTreeNodeType.Number} or ${CssTreeNodeType.Raw}, but got '${argument.type}'`);
+        }
+        // Parse the argument as a number
+        return StringUtils.parseNumber(argument.value);
+    }
+    /**
+     * 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, value, matcher = EQUALS, flags = null) {
+        return {
+            type: CssTreeNodeType.AttributeSelector,
+            name: {
+                type: CssTreeNodeType.Identifier,
+                name,
+            },
+            value: {
+                type: CssTreeNodeType.String,
+                value,
+            },
+            matcher,
+            flags,
+        };
+    }
+    /**
+     * Helper function to rename a CSSTree pseudo-class node
+     *
+     * @param node Node to rename
+     * @param name New name
+     */
+    static renamePseudoClass(node, name) {
+        Object.assign(node, {
+            ...node,
+            name,
+        });
+    }
+    /**
+     * Helper function to generate a raw string from a pseudo-class
+     * selector's children
+     *
+     * @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 generatePseudoClassValue(node) {
+        let result = EMPTY;
+        node.children?.forEach((child) => {
+            switch (child.type) {
+                case CssTreeNodeType.Selector:
+                    result += CssTree.generateSelector(child);
+                    break;
+                case CssTreeNodeType.SelectorList:
+                    result += CssTree.generateSelectorList(child);
+                    break;
+                case CssTreeNodeType.Raw:
+                    result += child.value;
+                    break;
+                default:
+                    // Fallback to CSSTree's default generate function
+                    result += generate(child);
+            }
+        });
+        return result;
+    }
+    /**
+     * 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) {
+        let result = EMPTY;
+        node.children?.forEach((child) => {
+            switch (child.type) {
+                case CssTreeNodeType.Raw:
+                    result += child.value;
+                    break;
+                default:
+                    // Fallback to CSSTree's default generate function
+                    result += generate(child);
+            }
+        });
+        return result;
+    }
 }
 
 /**
@@ -3817,13 +4310,14 @@ class ScriptletInjectionBodyParser {
         const openingParenthesesIndex = offset;
         // Find closing parentheses
         // eslint-disable-next-line max-len
-        const closingParenthesesIndex = StringUtils.skipWSBack(raw);
-        if (raw[closingParenthesesIndex] !== CLOSE_PARENTHESIS) {
+        const closingParenthesesIndex = StringUtils.findUnescapedNonStringNonRegexChar(raw, CLOSE_PARENTHESIS, openingParenthesesIndex + 1);
+        // Closing parentheses should be present
+        if (closingParenthesesIndex === -1) {
             throw new AdblockSyntaxError(
             // eslint-disable-next-line max-len
             `Invalid AdGuard/uBlock scriptlet call, no closing parentheses '${CLOSE_PARENTHESIS}' found`, locRange(loc, offset, raw.length));
         }
-        // No unexpected characters after the closing parentheses
+        // Shouldn't have any characters after the closing parentheses
         if (StringUtils.skipWSBack(raw) !== closingParenthesesIndex) {
             throw new AdblockSyntaxError(
             // eslint-disable-next-line max-len
@@ -3875,17 +4369,8 @@ class ScriptletInjectionBodyParser {
             if (semicolonIndex === -1) {
                 semicolonIndex = raw.length;
             }
-            const scriptletCallEnd = StringUtils.skipWSBack(raw, semicolonIndex - 1) + 1;
-            if (scriptletCallEnd <= scriptletCallStart) {
-                break;
-            }
+            const scriptletCallEnd = Math.max(StringUtils.skipWSBack(raw, semicolonIndex - 1) + 1, scriptletCallStart);
             const params = ParameterListParser.parse(raw.substring(scriptletCallStart, scriptletCallEnd), SPACE, shiftLoc(loc, scriptletCallStart));
-            // Check if the scriptlet name is specified
-            if (params.children.length === 0) {
-                throw new AdblockSyntaxError(
-                // eslint-disable-next-line max-len
-                'Invalid ABP snippet call, no scriptlet name specified', locRange(loc, offset, raw.length));
-            }
             // Parse the scriptlet call
             result.children.push(params);
             // Skip the semicolon
@@ -3928,8 +4413,11 @@ class ScriptletInjectionBodyParser {
      * @throws If the rule body is not supported by the specified syntax
      * @throws If the AST is invalid
      */
-    static generate(ast, syntax = AdblockSyntax.Adg) {
+    static generate(ast, syntax) {
         let result = EMPTY;
+        if (ast.children.length === 0) {
+            throw new Error('Invalid AST, no scriptlet calls specified');
+        }
         // AdGuard and uBlock doesn't support multiple scriptlet calls in one rule
         if (syntax === AdblockSyntax.Adg || syntax === AdblockSyntax.Ubo) {
             if (ast.children.length > 1) {
@@ -4104,6 +4592,266 @@ class HtmlFilteringBodyParser {
     }
 }
 
+/**
+ * Checks whether the given value is undefined.
+ *
+ * @param value Value to check.
+ *
+ * @returns True if the value type is not 'undefined'.
+ */
+const isUndefined = (value) => {
+    return typeof value === 'undefined';
+};
+
+/**
+ * @file Utility functions for working with modifier nodes
+ */
+/**
+ * Creates a modifier node
+ *
+ * @param name Name of the modifier
+ * @param value Value of the modifier
+ * @param exception Whether the modifier is an exception
+ * @returns Modifier node
+ */
+function createModifierNode(name, value = undefined, exception = false) {
+    const result = {
+        type: 'Modifier',
+        exception,
+        modifier: {
+            type: 'Value',
+            value: name,
+        },
+    };
+    if (!isUndefined(value)) {
+        result.value = {
+            type: 'Value',
+            value,
+        };
+    }
+    return result;
+}
+/**
+ * Creates a modifier list node
+ *
+ * @param modifiers Modifiers to put in the list (optional, defaults to an empty list)
+ * @returns Modifier list node
+ */
+function createModifierListNode(modifiers = []) {
+    const result = {
+        type: 'ModifierList',
+        // We need to clone the modifiers to avoid side effects
+        children: cloneDeep(modifiers),
+    };
+    return result;
+}
+
+/**
+ * @file Utility to extract UBO rule modifiers from a selector list
+ *
+ * uBO rule modifiers are special pseudo-classes that are used to specify
+ * the rule's behavior, for example, if you want to apply the rule only
+ * to a specific path, you can use the `:matches-path(...)` pseudo-class.
+ */
+const UBO_MODIFIERS_INDICATOR = ':matches-';
+const MATCHES_PATH_OPERATOR = 'matches-path';
+const NOT_OPERATOR = 'not';
+/**
+ * List of supported UBO rule modifiers
+ */
+// TODO: Add support for other modifiers, if needed
+const SUPPORTED_UBO_RULE_MODIFIERS = new Set([
+    MATCHES_PATH_OPERATOR,
+]);
+/**
+ * Fast check to determine if the selector list contains UBO rule modifiers.
+ * This function helps to avoid unnecessary walk through the selector list.
+ *
+ * @param rawSelectorList Raw selector list to check
+ * @returns `true` if the selector list contains UBO rule modifiers, `false` otherwise
+ */
+function hasUboModifierIndicator(rawSelectorList) {
+    return rawSelectorList.includes(UBO_MODIFIERS_INDICATOR);
+}
+/**
+ * Helper function that always returns the linked list version of the
+ * selector node.
+ *
+ * @param selector Selector to process
+ * @returns Linked list based selector
+ */
+function convertSelectorToLinkedList(selector) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return fromPlainObject(cloneDeep(selector));
+}
+/**
+ * Helper function that always returns the linked list version of the
+ * selector list node.
+ *
+ * @param selectorList Selector list to process
+ * @returns Linked list based selector list
+ */
+function convertSelectorListToLinkedList(selectorList) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return fromPlainObject(cloneDeep(selectorList));
+}
+/**
+ * Helper function for checking and removing bounding combinators
+ *
+ * @param ref Reference to the CSSTree node
+ * @param name Name to error message
+ */
+function handleBoundingCombinators(ref, name) {
+    // Check preceding combinator
+    if (ref.item.prev?.data.type === CssTreeNodeType.Combinator) {
+        // Special case is space combinator, it's allowed, but should be removed
+        if (ref.item.prev.data.name === SPACE) {
+            // Remove the combinator
+            ref.list?.remove(ref.item.prev);
+        }
+        else {
+            // Throw an error for other combinator types
+            throw new Error(`Unexpected combinator before '${name}'`);
+        }
+    }
+    // Check following combinator
+    if (ref.item.next?.data.type === CssTreeNodeType.Combinator) {
+        // Special case is space combinator, it's allowed, but should be removed
+        if (ref.item.next.data.name === SPACE) {
+            // Remove the combinator
+            ref.list?.remove(ref.item.next);
+        }
+        else {
+            // Throw an error for other combinator types
+            throw new Error(`Unexpected combinator after '${name}'`);
+        }
+    }
+}
+/**
+ * Extract UBO rule modifiers from the selector and clean the selector AST from them.
+ *
+ * @param selector Selector to process (can be linked list or array based)
+ * @returns Extracted UBO rule modifiers and cleaned selector list
+ */
+function extractUboModifiersFromSelector(selector) {
+    // We need a linked list based AST here
+    const cleaned = convertSelectorToLinkedList(selector);
+    // Prepare the modifiers list, we should add the modifiers to it
+    const modifiers = {
+        type: 'ModifierList',
+        children: [],
+    };
+    let depth = 0;
+    let notRef;
+    // Walk through the selector nodes
+    walk(cleaned, {
+        enter: (node, item, list) => {
+            // Don't take into account selectors and selector lists
+            if (node.type === CssTreeNodeType.Selector || node.type === CssTreeNodeType.SelectorList) {
+                return;
+            }
+            // Set the :not() reference if we are on the top level
+            if (node.type === CssTreeNodeType.PseudoClassSelector && node.name === NOT_OPERATOR && depth === 0) {
+                notRef = {
+                    node,
+                    item,
+                    list,
+                };
+            }
+            depth += 1;
+        },
+        leave: (node, item, list) => {
+            // Don't take into account selectors and selector lists
+            if (node.type === CssTreeNodeType.Selector || node.type === CssTreeNodeType.SelectorList) {
+                return;
+            }
+            if (node.type === CssTreeNodeType.PseudoClassSelector) {
+                if (SUPPORTED_UBO_RULE_MODIFIERS.has(node.name)) {
+                    // depth should be 1 for :matches-path(...) and 2 for :not(:matches-path(...))
+                    if (depth !== (notRef ? 2 : 1)) {
+                        throw new Error(`Unexpected depth for ':${node.name}(...)'`);
+                    }
+                    // uBO modifier can't be preceded nor followed by a combinator
+                    handleBoundingCombinators({ node, item, list }, `:${node.name}(...)`);
+                    // if we have :not() ref, then we should check if the uBO modifier is the only child of :not()
+                    if (notRef && list.size !== 1) {
+                        throw new Error(`Unexpected nodes inside ':not(:${node.name}(...))'`);
+                    }
+                    // Add the modifier to the modifiers list node
+                    modifiers.children.push(createModifierNode(node.name, CssTree.generatePseudoClassValue(node), 
+                    // :not(:matches-path(...)) should be an exception modifier
+                    !isUndefined(notRef)));
+                    if (notRef) {
+                        // If we have :not() ref, then we should remove the :not() node
+                        // (which also removes the uBO modifier node, since it's the parent
+                        // of the uBO modifier node).
+                        // But before removing the :not() node, we should check
+                        // :not() isn't preceded nor followed by a combinator.
+                        handleBoundingCombinators(notRef, `:not(:${node.name}(...))`);
+                        notRef.list?.remove(notRef.item);
+                    }
+                    else {
+                        // Otherwise just remove the uBO modifier node
+                        list?.remove(item);
+                    }
+                }
+            }
+            depth -= 1;
+            // Reset the :not() ref if we're leaving the :not() node at the top level
+            if (node.type === CssTreeNodeType.PseudoClassSelector && node.name === NOT_OPERATOR && depth === 0) {
+                notRef = undefined;
+            }
+        },
+    });
+    return {
+        modifiers,
+        cleaned: toPlainObject(cleaned),
+    };
+}
+/**
+ * Extract UBO rule modifiers from the selector list and clean the selector
+ * list AST from them.
+ *
+ * @param selectorList Selector list to process (can be linked list or array based)
+ * @returns Extracted UBO rule modifiers and cleaned selector list
+ * @example
+ * If you have the following adblock rule:
+ * ```adblock
+ * ##:matches-path(/path) .foo > .bar:has(.baz)
+ * ```
+ * Then this function extracts the `:matches-path(/path)` pseudo-class as
+ * a rule modifier with key `matches-path` and value `/path` and and returns
+ * the following selector list:
+ * ```css
+ * .foo > .bar:has(.baz)
+ * ```
+ * (this is the 'cleaned' selector list - a selector list without the
+ * special uBO pseudo-classes)
+ */
+function extractUboModifiersFromSelectorList(selectorList) {
+    // We need a linked list based AST here
+    const cleaned = convertSelectorListToLinkedList(selectorList);
+    // Prepare the modifiers list, we should add the modifiers to it
+    const modifiers = {
+        type: 'ModifierList',
+        children: [],
+    };
+    // Walk through the selector list nodes
+    cleaned.children.forEach((child) => {
+        if (child.type === CssTreeNodeType.Selector) {
+            const result = extractUboModifiersFromSelector(child);
+            // Add the modifiers to the modifiers list
+            modifiers.children.push(...result.modifiers.children);
+            // Replace the selector with the cleaned one
+            Object.assign(child, result.cleaned);
+        }
+    });
+    return {
+        modifiers,
+        cleaned: toPlainObject(cleaned),
+    };
+}
+
 /**
  * `CosmeticRuleParser` is responsible for parsing cosmetic rules.
  *
@@ -4118,6 +4866,7 @@ class HtmlFilteringBodyParser {
  * compatible with the given adblocker. This is a completely natural behavior, meaningful
  * checking of compatibility is not done at the parser level.
  */
+// TODO: Make raw body parsing optional
 class CosmeticRuleParser {
     /**
      * Determines whether a rule is a cosmetic rule. The rule is considered cosmetic if it
@@ -4205,7 +4954,7 @@ class CosmeticRuleParser {
                     if (syntax === AdblockSyntax.Adg) {
                         throw new AdblockSyntaxError('AdGuard modifier list is not supported in uBO CSS injection rules', locRange(loc, patternStart, patternEnd));
                     }
-                    return {
+                    const uboCssInjectionRuleNode = {
                         category: RuleCategory.Cosmetic,
                         type: CosmeticRuleType.CssInjectionRule,
                         loc: locRange(loc, 0, raw.length),
@@ -4217,10 +4966,29 @@ class CosmeticRuleParser {
                         modifiers,
                         domains,
                         separator,
-                        body: CssInjectionBodyParser.parse(rawBody, shiftLoc(loc, bodyStart)),
+                        body: {
+                            ...CssInjectionBodyParser.parse(rawBody, shiftLoc(loc, bodyStart)),
+                            raw: rawBody,
+                        },
                     };
+                    if (hasUboModifierIndicator(rawBody)) {
+                        const extractedUboModifiers = extractUboModifiersFromSelectorList(uboCssInjectionRuleNode.body.selectorList);
+                        if (extractedUboModifiers.modifiers.children.length > 0) {
+                            if (!uboCssInjectionRuleNode.modifiers) {
+                                uboCssInjectionRuleNode.modifiers = {
+                                    type: 'ModifierList',
+                                    children: [],
+                                };
+                            }
+                            uboCssInjectionRuleNode.modifiers.children.push(...extractedUboModifiers.modifiers.children);
+                            uboCssInjectionRuleNode.body.selectorList = extractedUboModifiers.cleaned;
+                            uboCssInjectionRuleNode.syntax = AdblockSyntax.Ubo;
+                        }
+                    }
+                    return uboCssInjectionRuleNode;
                 }
-                return {
+                // eslint-disable-next-line no-case-declarations
+                const elementHidingRuleNode = {
                     category: RuleCategory.Cosmetic,
                     type: CosmeticRuleType.ElementHidingRule,
                     loc: locRange(loc, 0, raw.length),
@@ -4232,8 +5000,26 @@ class CosmeticRuleParser {
                     modifiers,
                     domains,
                     separator,
-                    body: ElementHidingBodyParser.parse(rawBody, shiftLoc(loc, bodyStart)),
+                    body: {
+                        ...ElementHidingBodyParser.parse(rawBody, shiftLoc(loc, bodyStart)),
+                        raw: rawBody,
+                    },
                 };
+                if (hasUboModifierIndicator(rawBody)) {
+                    const extractedUboModifiers = extractUboModifiersFromSelectorList(elementHidingRuleNode.body.selectorList);
+                    if (extractedUboModifiers.modifiers.children.length > 0) {
+                        if (!elementHidingRuleNode.modifiers) {
+                            elementHidingRuleNode.modifiers = {
+                                type: 'ModifierList',
+                                children: [],
+                            };
+                        }
+                        elementHidingRuleNode.modifiers.children.push(...extractedUboModifiers.modifiers.children);
+                        elementHidingRuleNode.body.selectorList = extractedUboModifiers.cleaned;
+                        elementHidingRuleNode.syntax = AdblockSyntax.Ubo;
+                    }
+                }
+                return elementHidingRuleNode;
             // ADG CSS injection / ABP snippet injection
             case '#$#':
             case '#@$#':
@@ -4253,7 +5039,10 @@ class CosmeticRuleParser {
                         modifiers,
                         domains,
                         separator,
-                        body: CssInjectionBodyParser.parse(rawBody, shiftLoc(loc, bodyStart)),
+                        body: {
+                            ...CssInjectionBodyParser.parse(rawBody, shiftLoc(loc, bodyStart)),
+                            raw: rawBody,
+                        },
                     };
                 }
                 // ABP snippet injection
@@ -4273,7 +5062,10 @@ class CosmeticRuleParser {
                         modifiers,
                         domains,
                         separator,
-                        body: ScriptletInjectionBodyParser.parse(rawBody, AdblockSyntax.Abp, shiftLoc(loc, bodyStart)),
+                        body: {
+                            ...ScriptletInjectionBodyParser.parse(rawBody, AdblockSyntax.Abp, shiftLoc(loc, bodyStart)),
+                            raw: rawBody,
+                        },
                     };
                 }
                 // ABP snippet injection is not supported for #$?# and #@$?#
@@ -4297,7 +5089,10 @@ class CosmeticRuleParser {
                     modifiers,
                     domains,
                     separator,
-                    body: ScriptletInjectionBodyParser.parse(rawBody, AdblockSyntax.Ubo, shiftLoc(loc, bodyStart)),
+                    body: {
+                        ...ScriptletInjectionBodyParser.parse(rawBody, AdblockSyntax.Ubo, shiftLoc(loc, bodyStart)),
+                        raw: rawBody,
+                    },
                 };
             // ADG JS / scriptlet injection
             case '#%#':
@@ -4317,7 +5112,10 @@ class CosmeticRuleParser {
                         modifiers,
                         domains,
                         separator,
-                        body: ScriptletInjectionBodyParser.parse(rawBody, AdblockSyntax.Ubo, shiftLoc(loc, bodyStart)),
+                        body: {
+                            ...ScriptletInjectionBodyParser.parse(rawBody, AdblockSyntax.Ubo, shiftLoc(loc, bodyStart)),
+                            raw: rawBody,
+                        },
                     };
                 }
                 // Don't allow empty body
@@ -4341,6 +5139,7 @@ class CosmeticRuleParser {
                         type: 'Value',
                         loc: locRange(loc, bodyStart, bodyEnd),
                         value: rawBody,
+                        raw: rawBody,
                     },
                 };
             // uBO HTML filtering
@@ -4349,7 +5148,8 @@ class CosmeticRuleParser {
                 if (syntax === AdblockSyntax.Adg) {
                     throw new AdblockSyntaxError('AdGuard modifier list is not supported in uBO HTML filtering rules', locRange(loc, patternStart, patternEnd));
                 }
-                return {
+                // eslint-disable-next-line no-case-declarations
+                const uboHtmlRuleNode = {
                     category: RuleCategory.Cosmetic,
                     type: CosmeticRuleType.HtmlFilteringRule,
                     loc: locRange(loc, 0, raw.length),
@@ -4361,12 +5161,33 @@ class CosmeticRuleParser {
                     modifiers,
                     domains,
                     separator,
-                    body: HtmlFilteringBodyParser.parse(rawBody, shiftLoc(loc, bodyStart)),
+                    body: {
+                        ...HtmlFilteringBodyParser.parse(rawBody, shiftLoc(loc, bodyStart)),
+                        raw: rawBody,
+                    },
                 };
+                if (hasUboModifierIndicator(rawBody)
+                    && uboHtmlRuleNode.body.body.type === CssTreeNodeType.SelectorList) {
+                    // eslint-disable-next-line max-len
+                    const extractedUboModifiers = extractUboModifiersFromSelectorList(uboHtmlRuleNode.body.body);
+                    if (extractedUboModifiers.modifiers.children.length > 0) {
+                        if (!uboHtmlRuleNode.modifiers) {
+                            uboHtmlRuleNode.modifiers = {
+                                type: 'ModifierList',
+                                children: [],
+                            };
+                        }
+                        uboHtmlRuleNode.modifiers.children.push(...extractedUboModifiers.modifiers.children);
+                        uboHtmlRuleNode.body.body = extractedUboModifiers.cleaned;
+                        uboHtmlRuleNode.syntax = AdblockSyntax.Ubo;
+                    }
+                }
+                return uboHtmlRuleNode;
             // ADG HTML filtering
             case '$$':
             case '$@$':
                 body = HtmlFilteringBodyParser.parse(rawBody, shiftLoc(loc, bodyStart));
+                body.raw = rawBody;
                 if (body.body.type === 'Function') {
                     throw new AdblockSyntaxError('Functions are not supported in ADG HTML filtering rules', locRange(loc, bodyStart, bodyEnd));
                 }
@@ -4389,12 +5210,16 @@ class CosmeticRuleParser {
         }
     }
     /**
-     * Converts a cosmetic rule AST into a string.
+     * Generates the rule pattern from the AST.
      *
      * @param ast Cosmetic rule AST
-     * @returns Raw string
+     * @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 generate(ast) {
+    static generatePattern(ast) {
         let result = EMPTY;
         // AdGuard modifiers (if any)
         if (ast.syntax === AdblockSyntax.Adg && ast.modifiers && ast.modifiers.children.length > 0) {
@@ -4405,49 +5230,93 @@ class CosmeticRuleParser {
         }
         // Domain list (if any)
         result += DomainListParser.generate(ast.domains);
-        // Separator
-        result += ast.separator.value;
+        return result;
+    }
+    /**
+     * 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) {
+        let result = EMPTY;
         // Body
         switch (ast.type) {
             case CosmeticRuleType.ElementHidingRule:
-                result += ElementHidingBodyParser.generate(ast.body);
+                result = ElementHidingBodyParser.generate(ast.body);
                 break;
             case CosmeticRuleType.CssInjectionRule:
-                result += CssInjectionBodyParser.generate(ast.body, ast.syntax);
+                result = CssInjectionBodyParser.generate(ast.body, ast.syntax);
                 break;
             case CosmeticRuleType.HtmlFilteringRule:
-                result += HtmlFilteringBodyParser.generate(ast.body, ast.syntax);
+                result = HtmlFilteringBodyParser.generate(ast.body, ast.syntax);
                 break;
             case CosmeticRuleType.JsInjectionRule:
                 // Native JS code
-                result += ast.body.value;
+                result = ast.body.value;
                 break;
             case CosmeticRuleType.ScriptletInjectionRule:
-                result += ScriptletInjectionBodyParser.generate(ast.body, ast.syntax);
+                result = ScriptletInjectionBodyParser.generate(ast.body, ast.syntax);
                 break;
             default:
                 throw new Error('Unknown cosmetic rule type');
         }
         return result;
     }
-}
-
-/**
- * `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}
- */
-class NetworkRuleParser {
     /**
-     * Parses a network rule (also known as basic rule).
+     * Converts a cosmetic rule AST into a string.
      *
-     * @param raw Raw rule
-     * @param loc Location of the rule
-     * @returns Network rule AST
+     * @param ast Cosmetic rule AST
+     * @returns Raw string
+     */
+    static generate(ast) {
+        let result = EMPTY;
+        // Pattern
+        result += CosmeticRuleParser.generatePattern(ast);
+        // Separator
+        result += ast.separator.value;
+        // uBO rule modifiers
+        if (ast.syntax === AdblockSyntax.Ubo && ast.modifiers) {
+            ast.modifiers.children.forEach((modifier) => {
+                result += COLON;
+                result += modifier.modifier.value;
+                if (modifier.value) {
+                    result += OPEN_PARENTHESIS;
+                    result += modifier.value.value;
+                    result += CLOSE_PARENTHESIS;
+                }
+            });
+            // If there are at least one modifier, add a space
+            if (ast.modifiers.children.length) {
+                result += SPACE;
+            }
+        }
+        // Body
+        result += CosmeticRuleParser.generateBody(ast);
+        return result;
+    }
+}
+
+/**
+ * `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}
+ */
+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, loc = defaultLocation) {
         let offset = 0;
@@ -4836,6 +5705,3063 @@ class FilterListParser {
     }
 }
 
+/**
+ * @file Customized error class for not implemented features.
+ */
+const ERROR_NAME$1 = 'NotImplementedError';
+const BASE_MESSAGE = 'Not implemented';
+/**
+ * Customized error class for not implemented features.
+ */
+class NotImplementedError extends Error {
+    /**
+     * Constructs a new `NotImplementedError` instance.
+     *
+     * @param message Additional error message (optional)
+     */
+    constructor(message = undefined) {
+        // Prepare the full error message
+        const fullMessage = message
+            ? `${BASE_MESSAGE}: ${message}`
+            : BASE_MESSAGE;
+        super(fullMessage);
+        this.name = ERROR_NAME$1;
+    }
+}
+
+/**
+ * @file Customized error class for conversion errors.
+ */
+const ERROR_NAME = 'RuleConversionError';
+/**
+ * Customized error class for conversion errors.
+ */
+class RuleConversionError extends Error {
+    /**
+     * Constructs a new `RuleConversionError` instance.
+     *
+     * @param message Error message
+     */
+    constructor(message) {
+        super(message);
+        this.name = ERROR_NAME;
+    }
+}
+
+var data$T = { adg_os_any:{ name:"all",
+    description:"$all modifier is made of $document, $popup, and all content-type modifiers combined.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#all-modifier",
+    negatable:false,
+    block_only:true },
+  adg_ext_any:{ name:"all",
+    description:"$all modifier is made of $document, $popup, and all content-type modifiers combined.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#all-modifier",
+    negatable:false,
+    block_only:true },
+  adg_cb_ios:{ name:"all",
+    description:"The `$all` modifier is made of `$document`, `$popup`, and all content-type modifiers combined.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#all-modifier",
+    negatable:false,
+    block_only:true },
+  adg_cb_safari:{ name:"all",
+    description:"The `$all` modifier is made of `$document`, `$popup`, and all content-type modifiers combined.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#all-modifier",
+    negatable:false,
+    block_only:true },
+  ubo_ext_any:{ name:"all",
+    description:"The `all` option is equivalent to specifying all network-based types\n+ `popup`, `document`, `inline-font` and `inline-script`.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#all",
+    negatable:false,
+    block_only:false } };
+
+var data$S = { adg_os_any:{ name:"app",
+    description:"The `$app` modifier lets you narrow the rule coverage down to a specific application or a list of applications.\nThe modifier's behavior and syntax perfectly match the corresponding basic rules `$app` modifier.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#app-modifier",
+    assignable:true,
+    negatable:false } };
+
+var data$R = { adg_os_any:{ name:"badfilter",
+    description:"The rules with the `$badfilter` modifier disable other basic rules to which they refer. It means that\nthe text of the disabled rule should match the text of the `$badfilter` rule (without the `$badfilter` modifier).",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#badfilter-modifier",
+    negatable:false },
+  adg_ext_any:{ name:"badfilter",
+    description:"The rules with the `$badfilter` modifier disable other basic rules to which they refer. It means that\nthe text of the disabled rule should match the text of the `$badfilter` rule (without the `$badfilter` modifier).",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#badfilter-modifier",
+    negatable:false },
+  adg_cb_ios:{ name:"badfilter",
+    description:"The rules with the `$badfilter` modifier disable other basic rules to which they refer. It means that\nthe text of the disabled rule should match the text of the `$badfilter` rule (without the `$badfilter` modifier).",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#badfilter-modifier",
+    negatable:false },
+  adg_cb_safari:{ name:"badfilter",
+    description:"The rules with the `$badfilter` modifier disable other basic rules to which they refer. It means that\nthe text of the disabled rule should match the text of the `$badfilter` rule (without the `$badfilter` modifier).",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#badfilter-modifier",
+    negatable:false },
+  ubo_ext_any:{ name:"badfilter",
+    description:"The rules with the `$badfilter` modifier disable other basic rules to which they refer. It means that\nthe text of the disabled rule should match the text of the `$badfilter` rule (without the `$badfilter` modifier).",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#badfilter",
+    negatable:false } };
+
+var data$Q = { ubo_ext_any:{ name:"cname",
+    description:"When used in an exception filter,\nit will bypass blocking CNAME uncloaked requests for the current (specified) document.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#cname",
+    negatable:false,
+    exception_only:true } };
+
+var data$P = { adg_os_any:{ name:"content",
+    description:"Disables HTML filtering and `$replace` rules on the pages that match the rule.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#content-modifier",
+    negatable:false,
+    exception_only:true } };
+
+var data$O = { adg_os_any:{ name:"cookie",
+    description:"The `$cookie` modifier completely changes rule behavior.\nInstead of blocking a request, this modifier makes us suppress or modify the Cookie and Set-Cookie headers.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#cookie-modifier",
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"^([^;=\\s]*?)((?:;(maxAge=\\d+;?)?|(sameSite=(lax|none|strict);?)?){1,3})(?<!;)$" },
+  adg_ext_any:{ name:"cookie",
+    description:"The `$cookie` modifier completely changes rule behavior.\nInstead of blocking a request, this modifier makes us suppress or modify the Cookie and Set-Cookie headers.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#cookie-modifier",
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"^([^;=\\s]*?)((?:;(maxAge=\\d+;?)?|(sameSite=(lax|none|strict);?)?){1,3})(?<!;)$" } };
+
+var data$N = { adg_os_any:{ name:"csp",
+    description:"This modifier completely changes the rule behavior.\nIf it is applied to a rule, it will not block the matching request.\nThe response headers are going to be modified instead.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#csp-modifier",
+    conflicts:[ "domain",
+      "important",
+      "subdocument",
+      "badfilter" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"/[^,$]+/" },
+  adg_ext_any:{ name:"csp",
+    description:"This modifier completely changes the rule behavior.\nIf it is applied to a rule, it will not block the matching request.\nThe response headers are going to be modified instead.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#csp-modifier",
+    conflicts:[ "domain",
+      "important",
+      "subdocument",
+      "badfilter" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"/[^,$]+/" },
+  abp_ext_any:{ name:"csp",
+    description:"This modifier completely changes the rule behavior.\nIf it is applied to a rule, it will not block the matching request.\nThe response headers are going to be modified instead.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#content-security-policies",
+    conflicts:[ "domain",
+      "subdocument" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"/[^,$]+/" },
+  ubo_ext_any:{ name:"csp",
+    description:"This modifier completely changes the rule behavior.\nIf it is applied to a rule, it will not block the matching request.\nThe response headers are going to be modified instead.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#csp",
+    conflicts:[ "1p",
+      "3p",
+      "domain",
+      "badfilter" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"/[^,$]+/" } };
+
+var data$M = { adg_os_any:{ name:"denyallow",
+    description:"The `$denyallow` modifier allows to avoid creating additional rules\nwhen it is needed to disable a certain rule for specific domains.\n`$denyallow` matches only target domains and not referrer domains.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#denyallow-modifier",
+    conflicts:[ "to" ],
+    assignable:true,
+    negatable:false,
+    value_format:"pipe_separated_domains" },
+  adg_ext_any:{ name:"denyallow",
+    description:"The `$denyallow` modifier allows to avoid creating additional rules\nwhen it is needed to disable a certain rule for specific domains.\n`$denyallow` matches only target domains and not referrer domains.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#denyallow-modifier",
+    conflicts:[ "to" ],
+    assignable:true,
+    negatable:false,
+    value_format:"pipe_separated_domains" },
+  adg_cb_ios:{ name:"denyallow",
+    description:"The `$denyallow` modifier allows to avoid creating additional rules\nwhen it is needed to disable a certain rule for specific domains.\n`$denyallow` matches only target domains and not referrer domains.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#denyallow-modifier",
+    conflicts:[ "to" ],
+    assignable:true,
+    negatable:false,
+    value_format:"pipe_separated_domains" },
+  adg_cb_safari:{ name:"denyallow",
+    description:"The `$denyallow` modifier allows to avoid creating additional rules\nwhen it is needed to disable a certain rule for specific domains.\n`$denyallow` matches only target domains and not referrer domains.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#denyallow-modifier",
+    conflicts:[ "to" ],
+    assignable:true,
+    negatable:false,
+    value_format:"pipe_separated_domains" },
+  ubo_ext_any:{ name:"denyallow",
+    description:"The `$denyallow` modifier allows to avoid creating additional rules\nwhen it is needed to disable a certain rule for specific domains.\n`$denyallow` matches only target domains and not referrer domains.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#denyallow",
+    conflicts:[ "to" ],
+    assignable:true,
+    negatable:false,
+    value_format:"pipe_separated_domains" } };
+
+var data$L = { adg_os_any:{ name:"document",
+    description:"The rule corresponds to the main frame document requests,\ni.e. HTML documents that are loaded in the browser tab.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#document-modifier",
+    negatable:false },
+  adg_ext_any:{ name:"document",
+    description:"The rule corresponds to the main frame document requests,\ni.e. HTML documents that are loaded in the browser tab.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#document-modifier",
+    negatable:false },
+  adg_cb_ios:{ name:"document",
+    description:"The rule corresponds to the main frame document requests,\ni.e. HTML documents that are loaded in the browser tab.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#document-modifier",
+    negatable:false },
+  adg_cb_safari:{ name:"document",
+    description:"The rule corresponds to the main frame document requests,\ni.e. HTML documents that are loaded in the browser tab.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#document-modifier",
+    negatable:false },
+  abp_ext_any:{ name:"document",
+    description:"The rule corresponds to the main frame document requests,\ni.e. HTML documents that are loaded in the browser tab.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#allowlist",
+    negatable:false },
+  ubo_ext_any:{ name:"document",
+    aliases:[ "doc" ],
+    description:"The rule corresponds to the main frame document requests,\ni.e. HTML documents that are loaded in the browser tab.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#document",
+    negatable:false } };
+
+var data$K = { adg_any:{ name:"domain",
+    aliases:[ "from" ],
+    description:"The `$domain` modifier limits the rule application area to a list of domains and their subdomains.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#domain-modifier",
+    assignable:true,
+    negatable:false,
+    value_format:"pipe_separated_domains" },
+  abp_any:{ name:"domain",
+    description:"The `$domain` modifier limits the rule application area to a list of domains and their subdomains.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#domain-restrictions",
+    assignable:true,
+    negatable:false,
+    value_format:"pipe_separated_domains" },
+  ubo_any:{ name:"domain",
+    aliases:[ "from" ],
+    description:"The `$domain` modifier limits the rule application area to a list of domains and their subdomains.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#from",
+    assignable:true,
+    negatable:false,
+    value_format:"pipe_separated_domains" } };
+
+var data$J = { adg_any:{ name:"elemhide",
+    aliases:[ "ehide" ],
+    description:"Disables any cosmetic rules on the pages matching the rule.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#elemhide-modifier",
+    negatable:false,
+    exception_only:true },
+  abp_any:{ name:"elemhide",
+    aliases:[ "ehide" ],
+    description:"Disables any cosmetic rules on the pages matching the rule.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options",
+    negatable:false,
+    exception_only:true },
+  ubo_any:{ name:"elemhide",
+    aliases:[ "ehide" ],
+    negatable:false,
+    exception_only:true,
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#elemhide-1",
+    description:"Disables any cosmetic rules on the pages matching the rule." } };
+
+var data$I = { adg_os_any:{ name:"empty",
+    description:"This modifier is deprecated in favor of the $redirect modifier.\nRules with `$empty` are still supported and being converted into `$redirect=nooptext` now\nbut the support shall be removed in the future.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#empty-modifier",
+    deprecated:true,
+    deprecation_message:"Rules with `$empty` are still supported and being converted into `$redirect=nooptext` now\nbut the support shall be removed in the future.",
+    negatable:false },
+  adg_ext_any:{ name:"empty",
+    description:"This modifier is deprecated in favor of the $redirect modifier.\nRules with `$empty` are still supported and being converted into `$redirect=nooptext` now\nbut the support shall be removed in the future.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#empty-modifier",
+    deprecated:true,
+    deprecation_message:"Rules with `$empty` are still supported and being converted into `$redirect=nooptext` now\nbut the support shall be removed in the future.",
+    negatable:false },
+  ubo_ext_any:{ name:"empty",
+    description:"This modifier is deprecated in favor of the $redirect modifier.\nRules with `$empty` are supported and being converted into `$redirect=nooptext`.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#empty",
+    negatable:false } };
+
+var data$H = { adg_any:{ name:"first-party",
+    aliases:[ "1p",
+      "~third-party" ],
+    description:"A restriction of first-party requests. Equal to `~third-party`.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#third-party-modifier",
+    negatable:false },
+  ubo_any:{ name:"first-party",
+    aliases:[ "1p",
+      "~third-party" ],
+    description:"A restriction of first-party requests. Equal to `~third-party`.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#1p",
+    negatable:false } };
+
+var data$G = { adg_os_any:{ name:"extension",
+    description:"Disables all userscripts on the pages matching this rule.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#extension-modifier",
+    conflicts:[ "domain",
+      "specifichide",
+      "generichide",
+      "elemhide",
+      "genericblock",
+      "urlblock",
+      "jsinject",
+      "content",
+      "xmlhttprequest",
+      "badfilter" ],
+    inverse_conflicts:true,
+    exception_only:true } };
+
+var data$F = { adg_any:{ name:"font",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#font-modifier",
+    description:"The rule corresponds to requests for fonts, e.g. `.woff` filename extension." },
+  abp_any:{ name:"font",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#options",
+    description:"The rule corresponds to requests for fonts, e.g. `.woff` filename extension." },
+  ubo_any:{ name:"font",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#options",
+    description:"The rule corresponds to requests for fonts, e.g. `.woff` filename extension." } };
+
+var data$E = { adg_os_any:{ name:"genericblock",
+    description:"Disables generic basic rules on pages that correspond to exception rule.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#genericblock-modifier",
+    conflicts:[ "domain",
+      "specifichide",
+      "generichide",
+      "elemhide",
+      "extension",
+      "jsinject",
+      "content",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true },
+  adg_ext_any:{ name:"genericblock",
+    description:"Disables generic basic rules on pages that correspond to exception rule.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#genericblock-modifier",
+    conflicts:[ "domain",
+      "specifichide",
+      "generichide",
+      "elemhide",
+      "jsinject",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true },
+  adg_cb_ios:{ name:"genericblock",
+    description:"Disables generic basic rules on pages that correspond to exception rule.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#genericblock-modifier",
+    conflicts:[ "domain",
+      "specifichide",
+      "generichide",
+      "elemhide",
+      "jsinject",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true },
+  adg_cb_safari:{ name:"genericblock",
+    description:"Disables generic basic rules on pages that correspond to exception rule.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#genericblock-modifier",
+    conflicts:[ "domain",
+      "specifichide",
+      "generichide",
+      "elemhide",
+      "jsinject",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true },
+  abp_ext_any:{ name:"genericblock",
+    description:"Disables generic basic rules on pages that correspond to exception rule.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options",
+    negatable:false,
+    exception_only:true } };
+
+var data$D = { adg_any:{ name:"generichide",
+    aliases:[ "ghide" ],
+    description:"Disables all generic cosmetic rules.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#generichide-modifier",
+    conflicts:[ "domain",
+      "genericblock",
+      "urlblock",
+      "extension",
+      "jsinject",
+      "content",
+      "xmlhttprequest",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true },
+  ubo_any:{ name:"generichide",
+    aliases:[ "ghide" ],
+    description:"Disables all generic cosmetic rules.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#generichide",
+    conflicts:[ "domain",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true },
+  abp_any:{ name:"generichide",
+    description:"Disables all generic cosmetic rules.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options",
+    conflicts:[ "domain" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true } };
+
+var data$C = { adg_os_any:{ name:"header",
+    description:"The `$header` modifier allows matching the HTTP response\nhaving a specific header with (optionally) a specific value.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#header-modifier",
+    assignable:true,
+    value_format:"/^[A-z0-9-]+(:.+|)$/" },
+  adg_ext_any:{ name:"header",
+    description:"The `$header` modifier allows matching the HTTP response\nhaving a specific header with (optionally) a specific value.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#header-modifier",
+    assignable:true,
+    value_format:"/^[A-z0-9-]+(:.+|)$/" },
+  ubo_ext_any:{ name:"header",
+    description:"The `$header` modifier allows matching the HTTP response\nhaving a specific header with (optionally) a specific value.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#header",
+    assignable:true,
+    value_format:"/^[A-z0-9-]+(:.+|)$/" } };
+
+var data$B = { adg_os_any:{ name:"hls",
+    description:"The `$hls` rules modify the response of a matching request.\nThey are intended as a convenient way to remove segments from HLS playlists (RFC 8216).",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#hls-modifier",
+    version_added:"CoreLibs 1.10",
+    conflicts:[ "domain",
+      "third-party",
+      "app",
+      "important",
+      "match-case",
+      "xmlhttprequest" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_format:"/^(?!.*([^\\\\](,|\\$|\\/))).*$/" } };
+
+var data$A = { adg_any:{ name:"image",
+    description:"The rule corresponds to images requests.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#image-modifier" },
+  abp_any:{ name:"image",
+    description:"The rule corresponds to images requests.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#options" },
+  ubo_any:{ name:"image",
+    description:"The rule corresponds to images requests.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#options" } };
+
+var data$z = { adg_any:{ name:"important",
+    description:"The `$important` modifier applied to a rule increases its priority\nover any other rule without `$important` modifier. Even over basic exception rules.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#important-modifier",
+    negatable:false },
+  ubo_any:{ name:"important",
+    description:"The `$important` modifier applied to a rule increases its priority\nover any other rule without `$important` modifier. Even over basic exception rules.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#important",
+    negatable:false } };
+
+var data$y = { adg_os_any:{ name:"inline-font",
+    description:"The `$inline-font` modifier is a sort of a shortcut for $csp modifier with specific value.\nE.g. `||example.org^$inline-font` is converting into:\n```adblock\n||example.org^$csp=font-src 'self' 'unsafe-eval' http: https: data: blob: mediastream: filesystem:\n```",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#inline-font-modifier" },
+  adg_ext_any:{ name:"inline-font",
+    description:"The `$inline-font` modifier is a sort of a shortcut for $csp modifier with specific value.\nE.g. `||example.org^$inline-font` is converting into:\n```adblock\n||example.org^$csp=font-src 'self' 'unsafe-eval' http: https: data: blob: mediastream: filesystem:\n```",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#inline-font-modifier" },
+  ubo_ext_any:{ name:"inline-font",
+    description:"The `$inline-font` modifier is a sort of a shortcut for $csp modifier with specific value.\nE.g. `||example.org^$inline-font` is converting into:\n```adblock\n||example.org^$csp=font-src 'self' 'unsafe-eval' http: https: data: blob: mediastream: filesystem:\n```",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#inline-font" } };
+
+var data$x = { adg_os_any:{ name:"inline-script",
+    description:"The `$inline-script` modifier is a sort of a shortcut for $csp modifier with specific value.\nE.g. `||example.org^$inline-script` is converting into:\n```adblock\n||example.org^$csp=script-src 'self' 'unsafe-eval' http: https: data: blob: mediastream: filesystem:\n```",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#inline-script-modifier" },
+  adg_ext_any:{ name:"inline-script",
+    description:"The `$inline-script` modifier is a sort of a shortcut for $csp modifier with specific value.\nE.g. `||example.org^$inline-script` is converting into:\n```adblock\n||example.org^$csp=script-src 'self' 'unsafe-eval' http: https: data: blob: mediastream: filesystem:\n```",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#inline-script-modifier" },
+  ubo_ext_any:{ name:"inline-script",
+    description:"The `$inline-script` modifier is a sort of a shortcut for $csp modifier with specific value.\nE.g. `||example.org^$inline-script` is converting into:\n```adblock\n||example.org^$csp=script-src 'self' 'unsafe-eval' http: https: data: blob: mediastream: filesystem:\n```",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#inline-script" } };
+
+var data$w = { adg_os_any:{ name:"jsinject",
+    description:"Forbids adding of javascript code to the page.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#jsinject-modifier",
+    conflicts:[ "domain",
+      "specifichide",
+      "generichide",
+      "elemhide",
+      "genericblock",
+      "urlblock",
+      "extension",
+      "content",
+      "xmlhttprequest",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true },
+  adg_ext_any:{ name:"jsinject",
+    description:"Forbids adding of javascript code to the page.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#jsinject-modifier",
+    conflicts:[ "domain",
+      "specifichide",
+      "generichide",
+      "elemhide",
+      "genericblock",
+      "urlblock",
+      "xmlhttprequest",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true },
+  adg_cb_ios:{ name:"jsinject",
+    description:"Forbids adding of javascript code to the page.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#jsinject-modifier",
+    conflicts:[ "domain",
+      "specifichide",
+      "generichide",
+      "elemhide",
+      "genericblock",
+      "urlblock",
+      "xmlhttprequest",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true },
+  adg_cb_safari:{ name:"jsinject",
+    description:"Forbids adding of javascript code to the page.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#jsinject-modifier",
+    conflicts:[ "domain",
+      "specifichide",
+      "generichide",
+      "elemhide",
+      "genericblock",
+      "urlblock",
+      "xmlhttprequest",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true } };
+
+var data$v = { adg_os_any:{ name:"jsonprune",
+    description:"The `$jsonprune` rules modify the response to a matching request\nby removing JSON items that match a modified JSONPath expression.\nThey do not modify responses which are not valid JSON documents.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#jsonprune-modifier",
+    assignable:true,
+    negatable:false,
+    value_format:"/^\\\\\\$\\.(?!.*([^\\\\](,|\\$|\\/))).*$/" } };
+
+var data$u = { adg_any:{ name:"match-case",
+    description:"This modifier defines a rule which applies only to addresses that match the case.\nDefault rules are case-insensitive.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#match-case-modifier" },
+  abp_any:{ name:"match-case",
+    description:"This modifier defines a rule which applies only to addresses that match the case.\nDefault rules are case-insensitive.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" },
+  ubo_any:{ name:"match-case",
+    description:"This modifier defines a rule which applies only to addresses that match the case.\nDefault rules are case-insensitive.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#match-case" } };
+
+var data$t = { adg_any:{ name:"media",
+    description:"A restriction of third-party and own requests.\nA third-party request is a request from a different domain.\nFor example, a request to `example.org` from `domain.com` is a third-party request.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#media-modifier" },
+  abp_any:{ name:"media",
+    description:"A restriction of third-party and own requests.\nA third-party request is a request from a different domain.\nFor example, a request to `example.org` from `domain.com` is a third-party request.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#options" },
+  ubo_any:{ name:"media",
+    description:"A restriction of third-party and own requests.\nA third-party request is a request from a different domain.\nFor example, a request to `example.org` from `domain.com` is a third-party request.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#options" } };
+
+var data$s = { adg_os_any:{ name:"method",
+    description:"This modifier limits the rule scope to requests that use the specified set of HTTP methods.\nNegated methods are allowed.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#method-modifier",
+    negatable:false,
+    assignable:true,
+    value_format:"(?xi)\n  ^(?!\\|)(?:\\b(\n    get|\n    head|\n    post|\n    put|\n    delete|\n    connect|\n    options|\n    trace|\n    patch\n  )\\b|(\\|?|~?))+(?<!\\|)$" },
+  adg_ext_any:{ name:"method",
+    description:"This modifier limits the rule scope to requests that use the specified set of HTTP methods.\nNegated methods are allowed.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#method-modifier",
+    negatable:false,
+    assignable:true,
+    value_format:"(?xi)\n  ^(?!\\|)(?:\\b(\n    get|\n    head|\n    post|\n    put|\n    delete|\n    connect|\n    options|\n    trace|\n    patch\n  )\\b|(\\|?|~?))+(?<!\\|)$" },
+  ubo_ext_any:{ name:"method",
+    description:"This modifier limits the rule scope to requests that use the specified set of HTTP methods.\nNegated methods are allowed.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#method",
+    negatable:false,
+    assignable:true,
+    value_format:"(?xi)\n  ^(?!\\|)(?:\\b(\n    get|\n    head|\n    post|\n    put|\n    delete|\n    connect|\n    options|\n    trace|\n    patch\n  )\\b|(\\|?|~?))+(?<!\\|)$" } };
+
+var data$r = { adg_os_any:{ name:"mp4",
+    description:"As a response to blocked request AdGuard returns a short video placeholder.\nRules with `$mp4` are still supported and being converted into `$redirect=noopmp4-1s` now\nbut the support shall be removed in the future.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#mp4-modifier",
+    deprecated:true,
+    deprecation_message:"Rules with `$mp4` are still supported and being converted into `$redirect=noopmp4-1s` now\nbut the support shall be removed in the future.",
+    negatable:false },
+  adg_ext_any:{ name:"mp4",
+    description:"As a response to blocked request AdGuard returns a short video placeholder.\nRules with `$mp4` are still supported and being converted into `$redirect=noopmp4-1s` now\nbut the support shall be removed in the future.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#mp4-modifier",
+    deprecated:true,
+    deprecation_message:"Rules with `$mp4` are still supported and being converted into `$redirect=noopmp4-1s` now\nbut the support shall be removed in the future.",
+    negatable:false },
+  ubo_ext_any:{ name:"mp4",
+    description:"As a response to blocked request a short video placeholder is returned.\nRules with `$mp4` are supported and being converted into `$redirect=noopmp4-1s`.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#mp4",
+    negatable:false } };
+
+var data$q = { adg_os_any:{ name:"network",
+    description:"This is basically a Firewall-kind of rules allowing to fully block\nor unblock access to a specified remote address.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#network-modifier",
+    conflicts:[ "app",
+      "important" ],
+    inverse_conflicts:true,
+    negatable:false } };
+
+var data$p = { adg_os_any:{ name:"_",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#noop-modifier",
+    description:"The noop modifier does nothing and can be used solely to increase rules' readability.\nIt consists of a sequence of underscore characters (_) of any length\nand can appear in a rule as many times as needed.",
+    negatable:false },
+  adg_ext_any:{ name:"_",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#noop-modifier",
+    description:"The noop modifier does nothing and can be used solely to increase rules' readability.\nIt consists of a sequence of underscore characters (_) of any length\nand can appear in a rule as many times as needed.",
+    negatable:false },
+  adg_cb_ios:{ name:"_",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#noop-modifier",
+    description:"The noop modifier does nothing and can be used solely to increase rules' readability.\nIt consists of a sequence of underscore characters (_) of any length\nand can appear in a rule as many times as needed.",
+    negatable:false },
+  adg_cb_safari:{ name:"_",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#noop-modifier",
+    description:"The noop modifier does nothing and can be used solely to increase rules' readability.\nIt consists of a sequence of underscore characters (_) of any length\nand can appear in a rule as many times as needed.",
+    negatable:false },
+  ubo_ext_any:{ name:"_",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#_-aka-noop",
+    description:"The noop modifier does nothing and can be used solely to increase rules' readability.\nIt consists of a sequence of underscore characters (_) of any length\nand can appear in a rule as many times as needed.",
+    negatable:false } };
+
+var data$o = { adg_any:{ name:"object-subrequest",
+    description:"The `$object-subrequest` modifier is removed and is no longer supported.\nRules with it are considered as invalid.\nThe rule corresponds to requests by browser plugins (it is usually Flash).",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#object-subrequest-modifier",
+    removed:true,
+    removal_message:"The `$object-subrequest` modifier is removed and is no longer supported.\nRules with it are considered as invalid." } };
+
+var data$n = { adg_any:{ name:"object",
+    description:"The rule corresponds to browser plugins resources, e.g. Java or Flash",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#object-modifier" },
+  abp_any:{ name:"object",
+    description:"The rule corresponds to browser plugins resources, e.g. Java or Flash.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" },
+  ubo_any:{ name:"object",
+    description:"The rule corresponds to browser plugins resources, e.g. Java or Flash.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" } };
+
+var data$m = { adg_any:{ name:"other",
+    description:"The rule applies to requests for which the type has not been determined\nor does not match the types listed above.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#other-modifier" },
+  abp_any:{ name:"other",
+    description:"The rule applies to requests for which the type has not been determined\nor does not match the types listed above.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" },
+  ubo_any:{ name:"other",
+    description:"The rule applies to requests for which the type has not been determined\nor does not match the types listed above.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" } };
+
+var data$l = { adg_os_any:{ name:"permissions",
+    description:"For the requests matching a `$permissions` rule, ad blocker strengthens response's feature policy\nby adding additional feature policy equal to the `$permissions` modifier contents.\n`$permissions` rules are applied independently from any other rule type.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#permissions-modifier",
+    version_added:"CoreLibs 1.11",
+    conflicts:[ "domain",
+      "important",
+      "subdocument" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_format:"(?x)\n^(?:(\n  accelerometer|\n  ambient-light-sensor|\n  autoplay|\n  battery|\n  camera|\n  display-capture|\n  document-domain|\n  encrypted-media|\n  execution-while-not-rendered|\n  execution-while-out-of-viewport|\n  fullscreen|\n  gamepad|\n  geolocation|\n  gyroscope|\n  hid|\n  identity-credentials-get|\n  idle-detection|\n  local-fonts|\n  magnetometer|\n  microphone|\n  midi|\n  payment|\n  picture-in-picture|\n  publickey-credentials-create|\n  publickey-credentials-get|\n  screen-wake-lock|\n  serial|\n  speaker-selection|\n  storage-access|\n  usb|\n  web-share|\n  xr-spatial-tracking\n  )=\\(\\)(\\\\, )?)+(?<!,)$" } };
+
+var data$k = { adg_any:{ name:"ping",
+    description:"The rule corresponds to requests caused by either navigator.sendBeacon() or the ping attribute on links.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#ping-modifier" },
+  abp_any:{ name:"ping",
+    description:"The rule corresponds to requests caused by either navigator.sendBeacon() or the ping attribute on links.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" },
+  ubo_any:{ name:"ping",
+    description:"The rule corresponds to requests caused by either navigator.sendBeacon() or the ping attribute on links.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" } };
+
+var data$j = { ubo_ext_any:{ name:"popunder",
+    description:"To block \"popunders\" windows/tabs where the original page redirects to an advertisement\nand the desired content loads in the newly created one.\nTo be used in the same manner as the popup filter option, except that it will block popunders.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#popunder",
+    negatable:false,
+    block_only:true } };
+
+var data$i = { adg_any:{ name:"popup",
+    description:"Pages opened in a new tab or window.\nNote: Filters will not block pop-ups by default, only if the `$popup`  type option is specified.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#popup-modifier",
+    negatable:false },
+  abp_any:{ name:"popup",
+    description:"Pages opened in a new tab or window.\nNote: Filters will not block pop-ups by default, only if the `$popup`  type option is specified.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options",
+    negatable:false },
+  ubo_any:{ name:"popup",
+    description:"Pages opened in a new tab or window.\nNote: Filters will not block pop-ups by default, only if the `$popup`  type option is specified.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options",
+    negatable:false } };
+
+var data$h = { adg_os_any:{ name:"redirect-rule",
+    description:"This is basically an alias to `$redirect`\nsince it has the same \"redirection\" values and the logic is almost similar.\nThe difference is that `$redirect-rule` is applied only in the case\nwhen the target request is blocked by a different basic rule.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#redirect-rule-modifier",
+    conflicts:[ "domain",
+      "to",
+      "third-party",
+      "popup",
+      "match-case",
+      "header",
+      "first-party",
+      "document",
+      "image",
+      "stylesheet",
+      "script",
+      "object",
+      "font",
+      "media",
+      "subdocument",
+      "ping",
+      "xmlhttprequest",
+      "websocket",
+      "other",
+      "webrtc",
+      "important",
+      "badfilter",
+      "app" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"(?x)\n  ^(\n    1x1-transparent\\.gif|\n    2x2-transparent\\.png|\n    3x2-transparent\\.png|\n    32x32-transparent\\.png|\n    noopframe|\n    noopcss|\n    noopjs|\n    noopjson|\n    nooptext|\n    empty|\n    noopvmap-1\\.0|\n    noopvast-2\\.0|\n    noopvast-3\\.0|\n    noopvast-4\\.0|\n    noopmp3-0\\.1s|\n    noopmp4-1s|\n    amazon-apstag|\n    ati-smarttag|\n    didomi-loader|\n    fingerprintjs2|\n    fingerprintjs3|\n    gemius|\n    google-analytics-ga|\n    google-analytics|\n    google-ima3|\n    googlesyndication-adsbygoogle|\n    googletagservices-gpt|\n    matomo|\n    metrika-yandex-tag|\n    metrika-yandex-watch|\n    naver-wcslog|\n    noeval|\n    pardot-1\\.0|\n    prebid-ads|\n    prebid|\n    prevent-bab|\n    prevent-bab2|\n    prevent-fab-3\\.2\\.0|\n    prevent-popads-net|\n    scorecardresearch-beacon|\n    set-popads-dummy|\n    click2load\\.html|\n  )?$" },
+  adg_ext_any:{ name:"redirect-rule",
+    description:"This is basically an alias to `$redirect`\nsince it has the same \"redirection\" values and the logic is almost similar.\nThe difference is that `$redirect-rule` is applied only in the case\nwhen the target request is blocked by a different basic rule.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#redirect-rule-modifier",
+    conflicts:[ "domain",
+      "to",
+      "third-party",
+      "popup",
+      "match-case",
+      "header",
+      "first-party",
+      "document",
+      "image",
+      "stylesheet",
+      "script",
+      "object",
+      "font",
+      "media",
+      "subdocument",
+      "ping",
+      "xmlhttprequest",
+      "websocket",
+      "other",
+      "webrtc",
+      "important",
+      "badfilter" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"(?x)\n  ^(\n    1x1-transparent\\.gif|\n    2x2-transparent\\.png|\n    3x2-transparent\\.png|\n    32x32-transparent\\.png|\n    noopframe|\n    noopcss|\n    noopjs|\n    noopjson|\n    nooptext|\n    empty|\n    noopvmap-1\\.0|\n    noopvast-2\\.0|\n    noopvast-3\\.0|\n    noopvast-4\\.0|\n    noopmp3-0\\.1s|\n    noopmp4-1s|\n    amazon-apstag|\n    ati-smarttag|\n    didomi-loader|\n    fingerprintjs2|\n    fingerprintjs3|\n    gemius|\n    google-analytics-ga|\n    google-analytics|\n    google-ima3|\n    googlesyndication-adsbygoogle|\n    googletagservices-gpt|\n    matomo|\n    metrika-yandex-tag|\n    metrika-yandex-watch|\n    naver-wcslog|\n    noeval|\n    pardot-1\\.0|\n    prebid-ads|\n    prebid|\n    prevent-bab|\n    prevent-bab2|\n    prevent-fab-3\\.2\\.0|\n    prevent-popads-net|\n    scorecardresearch-beacon|\n    set-popads-dummy|\n    click2load\\.html|\n  )?$" },
+  ubo_ext_any:{ name:"redirect-rule",
+    description:"This is basically an alias to `$redirect`\nsince it has the same \"redirection\" values and the logic is almost similar.\nThe difference is that `$redirect-rule` is applied only in the case\nwhen the target request is blocked by a different basic rule.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#redirect-rule",
+    conflicts:[ "domain",
+      "to",
+      "third-party",
+      "popup",
+      "match-case",
+      "header",
+      "first-party",
+      "document",
+      "image",
+      "stylesheet",
+      "script",
+      "object",
+      "font",
+      "media",
+      "subdocument",
+      "ping",
+      "xmlhttprequest",
+      "websocket",
+      "other",
+      "webrtc",
+      "important",
+      "badfilter" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_format:"(?x)\n  ^(\n    1x1\\.gif|\n    2x2\\.png|\n    3x2\\.png|\n    32x32\\.png|\n    noop\\.css|\n    noop\\.html|\n    noopframe|\n    noop\\.js|\n    noop\\.txt|\n    noop-0\\.1s\\.mp3|\n    noop-0\\.5s\\.mp3|\n    noop-1s\\.mp4|\n    none|\n    click2load\\.html|\n    addthis_widget\\.js|\n    amazon_ads\\.js|\n    amazon_apstag\\.js|\n    monkeybroker\\.js|\n    doubleclick_instream_ad_status|\n    google-analytics_ga\\.js|\n    google-analytics_analytics\\.js|\n    google-analytics_inpage_linkid\\.js|\n    google-analytics_cx_api\\.js|\n    google-ima\\.js|\n    googletagservices_gpt\\.js|\n    googletagmanager_gtm\\.js|\n    googlesyndication_adsbygoogle\\.js|\n    scorecardresearch_beacon\\.js|\n    outbrain-widget\\.js|\n    hd-main\\.js\n  )\n  (:[0-9]+)?$" } };
+
+var data$g = { adg_os_any:{ name:"redirect",
+    description:"Used to redirect web requests to a local \"resource\".",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#redirect-modifier",
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"(?x)\n  ^(\n    1x1-transparent\\.gif|\n    2x2-transparent\\.png|\n    3x2-transparent\\.png|\n    32x32-transparent\\.png|\n    noopframe|\n    noopcss|\n    noopjs|\n    noopjson|\n    nooptext|\n    empty|\n    noopvmap-1\\.0|\n    noopvast-2\\.0|\n    noopvast-3\\.0|\n    noopvast-4\\.0|\n    noopmp3-0\\.1s|\n    noopmp4-1s|\n    amazon-apstag|\n    ati-smarttag|\n    didomi-loader|\n    fingerprintjs2|\n    fingerprintjs3|\n    gemius|\n    google-analytics-ga|\n    google-analytics|\n    google-ima3|\n    googlesyndication-adsbygoogle|\n    googletagservices-gpt|\n    matomo|\n    metrika-yandex-tag|\n    metrika-yandex-watch|\n    naver-wcslog|\n    noeval|\n    pardot-1\\.0|\n    prebid-ads|\n    prebid|\n    prevent-bab|\n    prevent-bab2|\n    prevent-fab-3\\.2\\.0|\n    prevent-popads-net|\n    scorecardresearch-beacon|\n    set-popads-dummy|\n    click2load\\.html\n  )?$" },
+  adg_ext_any:{ name:"redirect",
+    description:"Used to redirect web requests to a local \"resource\".",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#redirect-modifier",
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"(?x)\n  ^(\n    1x1-transparent\\.gif|\n    2x2-transparent\\.png|\n    3x2-transparent\\.png|\n    32x32-transparent\\.png|\n    noopframe|\n    noopcss|\n    noopjs|\n    noopjson|\n    nooptext|\n    empty|\n    noopvmap-1\\.0|\n    noopvast-2\\.0|\n    noopvast-3\\.0|\n    noopvast-4\\.0|\n    noopmp3-0\\.1s|\n    noopmp4-1s|\n    amazon-apstag|\n    ati-smarttag|\n    didomi-loader|\n    fingerprintjs2|\n    fingerprintjs3|\n    gemius|\n    google-analytics-ga|\n    google-analytics|\n    google-ima3|\n    googlesyndication-adsbygoogle|\n    googletagservices-gpt|\n    matomo|\n    metrika-yandex-tag|\n    metrika-yandex-watch|\n    naver-wcslog|\n    noeval|\n    pardot-1\\.0|\n    prebid-ads|\n    prebid|\n    prevent-bab|\n    prevent-bab2|\n    prevent-fab-3\\.2\\.0|\n    prevent-popads-net|\n    scorecardresearch-beacon|\n    set-popads-dummy|\n    click2load\\.html\n  )?$" },
+  ubo_ext_any:{ name:"redirect",
+    description:"Used to redirect web requests to a local \"resource\".",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#redirect",
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"(?x)\n  ^(\n    1x1\\.gif|\n    2x2\\.png|\n    3x2\\.png|\n    32x32\\.png|\n    noop\\.css|\n    noop\\.html|\n    noopframe|\n    noop\\.js|\n    noop\\.txt|\n    noop-0\\.1s\\.mp3|\n    noop-0\\.5s\\.mp3|\n    noop-1s\\.mp4|\n    none|\n    click2load\\.html|\n    addthis_widget\\.js|\n    amazon_ads\\.js|\n    amazon_apstag\\.js|\n    monkeybroker\\.js|\n    doubleclick_instream_ad_status|\n    google-analytics_ga\\.js|\n    google-analytics_analytics\\.js|\n    google-analytics_inpage_linkid\\.js|\n    google-analytics_cx_api\\.js|\n    google-ima\\.js|\n    googletagservices_gpt\\.js|\n    googletagmanager_gtm\\.js|\n    googlesyndication_adsbygoogle\\.js|\n    scorecardresearch_beacon\\.js|\n    outbrain-widget\\.js|\n    hd-main\\.js\n  )\n  (:[0-9]+)?$" } };
+
+var data$f = { adg_os_any:{ name:"removeheader",
+    description:"Rules with the `$removeheader` modifier are intended to remove headers from HTTP requests and responses.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#removeheader-modifier",
+    conflicts:[ "domain",
+      "third-party",
+      "first-party",
+      "app",
+      "important",
+      "match-case",
+      "document",
+      "image",
+      "stylesheet",
+      "script",
+      "object",
+      "font",
+      "media",
+      "subdocument",
+      "ping",
+      "xmlhttpreqeust",
+      "websocket",
+      "other",
+      "webrtc" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"(?xi)\n  ^\n    # Value may start with \"request:\"\n    (request:)?\n\n    # Forbidden header names\n    (?!\n      (\n        access-control-allow-origin|\n        access-control-allow-credentials|\n        access-control-allow-headers|\n        access-control-allow-methods|\n        access-control-expose-headers|\n        access-control-max-age|\n        access-control-request-headers|\n        access-control-request-method|\n        origin|\n        timing-allow-origin|\n        allow|\n        cross-origin-embedder-policy|\n        cross-origin-opener-policy|\n        cross-origin-resource-policy|\n        content-security-policy|\n        content-security-policy-report-only|\n        expect-ct|\n        feature-policy|\n        origin-isolation|\n        strict-transport-security|\n        upgrade-insecure-requests|\n        x-content-type-options|\n        x-download-options|\n        x-frame-options|\n        x-permitted-cross-domain-policies|\n        x-powered-by|\n        x-xss-protection|\n        public-key-pins|\n        public-key-pins-report-only|\n        sec-websocket-key|\n        sec-websocket-extensions|\n        sec-websocket-accept|\n        sec-websocket-protocol|\n        sec-websocket-version|\n        p3p|\n        sec-fetch-mode|\n        sec-fetch-dest|\n        sec-fetch-site|\n        sec-fetch-user|\n        referrer-policy|\n        content-type|\n        content-length|\n        accept|\n        accept-encoding|\n        host|\n        connection|\n        transfer-encoding|\n        upgrade\n      )\n    $)\n\n    # Any other header name is allowed, if it matches the following regex\n    [A-z0-9-]+\n  $" },
+  adg_ext_any:{ name:"removeheader",
+    description:"Rules with the `$removeheader` modifier are intended to remove headers from HTTP requests and responses.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#removeheader-modifier",
+    conflicts:[ "domain",
+      "third-party",
+      "first-party",
+      "app",
+      "important",
+      "match-case",
+      "document",
+      "image",
+      "stylesheet",
+      "script",
+      "object",
+      "font",
+      "media",
+      "subdocument",
+      "ping",
+      "xmlhttpreqeust",
+      "websocket",
+      "other",
+      "webrtc" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"(?xi)\n  ^\n    # Value may start with \"request:\"\n    (request:)?\n\n    # Forbidden header names\n    (?!\n      (\n        access-control-allow-origin|\n        access-control-allow-credentials|\n        access-control-allow-headers|\n        access-control-allow-methods|\n        access-control-expose-headers|\n        access-control-max-age|\n        access-control-request-headers|\n        access-control-request-method|\n        origin|\n        timing-allow-origin|\n        allow|\n        cross-origin-embedder-policy|\n        cross-origin-opener-policy|\n        cross-origin-resource-policy|\n        content-security-policy|\n        content-security-policy-report-only|\n        expect-ct|\n        feature-policy|\n        origin-isolation|\n        strict-transport-security|\n        upgrade-insecure-requests|\n        x-content-type-options|\n        x-download-options|\n        x-frame-options|\n        x-permitted-cross-domain-policies|\n        x-powered-by|\n        x-xss-protection|\n        public-key-pins|\n        public-key-pins-report-only|\n        sec-websocket-key|\n        sec-websocket-extensions|\n        sec-websocket-accept|\n        sec-websocket-protocol|\n        sec-websocket-version|\n        p3p|\n        sec-fetch-mode|\n        sec-fetch-dest|\n        sec-fetch-site|\n        sec-fetch-user|\n        referrer-policy|\n        content-type|\n        content-length|\n        accept|\n        accept-encoding|\n        host|\n        connection|\n        transfer-encoding|\n        upgrade\n      )\n    $)\n\n    # Any other header name is allowed, if it matches the following regex\n    [A-z0-9-]+\n  $" } };
+
+var data$e = { adg_os_any:{ name:"removeparam",
+    description:"Rules with the `$removeparam` modifier are intended to strip query parameters from requests' URLs.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#removeparam-modifier",
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"/^(?!.*([^\\\\](,|\\$|\\/))).*$/" },
+  adg_ext_any:{ name:"removeparam",
+    description:"Rules with the `$removeparam` modifier are intended to strip query parameters from requests' URLs.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#removeparam-modifier",
+    assignable:true,
+    negatable:false,
+    value_optional:true,
+    value_format:"/^(?!.*([^\\\\](,|\\$|\\/))).*$/" },
+  ubo_ext_any:{ name:"removeparam",
+    description:"Rules with the `$removeparam` modifier are intended to strip query parameters from requests' URLs.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#removeparam",
+    assignable:true,
+    negatable:false,
+    value_format:"/^(?!.*([^\\\\](,|\\$|\\/))).*$/" } };
+
+var data$d = { adg_os_any:{ name:"replace",
+    description:"This modifier completely changes the rule behavior.\nIf it is applied, the rule will not block the request. The response is going to be modified instead.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#replace-modifier",
+    conflicts:[ "app",
+      "domain",
+      "document",
+      "subdocument",
+      "script",
+      "stylesheet",
+      "other",
+      "xmlhttprequest",
+      "first-party",
+      "third-party",
+      "important",
+      "badfilter" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_format:"/^\\/.+\\/.*\\/$/" },
+  adg_ext_firefox:{ name:"replace",
+    description:"This modifier completely changes the rule behavior.\nIf it is applied, the rule will not block the request. The response is going to be modified instead.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#replace-modifier",
+    conflicts:[ "domain",
+      "document",
+      "subdocument",
+      "script",
+      "stylesheet",
+      "other",
+      "xmlhttprequest",
+      "first-party",
+      "third-party",
+      "important",
+      "badfilter" ],
+    inverse_conflicts:true,
+    assignable:true,
+    negatable:false,
+    value_format:"/^\\/.+\\/.*\\/$/" } };
+
+var data$c = { adg_any:{ name:"script",
+    description:"The rule corresponds to script requests, e.g. javascript, vbscript.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#script-modifier" },
+  abp_any:{ name:"script",
+    description:"The rule corresponds to script requests, e.g. javascript, vbscript.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" },
+  ubo_any:{ name:"script",
+    description:"The rule corresponds to script requests, e.g. javascript, vbscript.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#options" } };
+
+var data$b = { adg_any:{ name:"specifichide",
+    aliases:[ "shide" ],
+    description:"Disables all specific element hiding and CSS rules, but not general ones.\nHas an opposite effect to `$generichide`.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#specifichide-modifier",
+    conflicts:[ "domain",
+      "genericblock",
+      "urlblock",
+      "extension",
+      "jsinject",
+      "content",
+      "xmlhttprequest",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true },
+  ubo_any:{ name:"specifichide",
+    aliases:[ "shide" ],
+    description:"Disables all specific element hiding and CSS rules, but not general ones.\nHas an opposite effect to `$generichide`.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#specifichide",
+    conflicts:[ "domain",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true } };
+
+var data$a = { adg_os_any:{ name:"stealth",
+    description:"Disables the Stealth Mode module for all corresponding pages and requests.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#stealth-modifier",
+    assignable:true,
+    negatable:false,
+    exception_only:true,
+    value_optional:true,
+    value_format:"(?x)\n  ^(?!\\|)\\b(?:(\n    searchqueries|\n    donottrack|\n    3p-cookie|\n    1p-cookie|\n    3p-cache|\n    3p-auth|\n    webrtc|\n    push|\n    location|\n    flash|\n    java|\n    referrer|\n    useragent|\n    ip|\n    xclientdata|\n    dpi|\n    \\|?\n  )\\b)+(?<!\\|)$" },
+  adg_ext_chrome:{ name:"stealth",
+    description:"Disables the Stealth Mode module for all corresponding pages and requests.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#stealth-modifier",
+    assignable:true,
+    negatable:false,
+    exception_only:true,
+    value_optional:true,
+    value_format:"(?x)\n  ^(?!\\|)\\b(?:(\n    searchqueries|\n    donottrack|\n    3p-cookie|\n    1p-cookie|\n    webrtc|\n    referrer|\n    xclientdata\n    |\\|?\n  )\\b)+(?<!\\|)$" },
+  adg_ext_firefox:{ name:"stealth",
+    description:"Disables the Stealth Mode module for all corresponding pages and requests.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#stealth-modifier",
+    assignable:true,
+    negatable:false,
+    exception_only:true,
+    value_optional:true,
+    value_format:"(?x)\n  ^(?!\\|)\\b(?:(\n    searchqueries|\n    donottrack|\n    3p-cookie|\n    1p-cookie|\n    webrtc|\n    referrer|\n    |\\|?\n  )\\b)+(?<!\\|)$" },
+  adg_ext_opera:{ name:"stealth",
+    description:"Disables the Stealth Mode module for all corresponding pages and requests.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#stealth-modifier",
+    assignable:true,
+    negatable:false,
+    exception_only:true,
+    value_optional:true,
+    value_format:"(?x)\n  ^(?!\\|)\\b(?:(\n    searchqueries|\n    donottrack|\n    3p-cookie|\n    1p-cookie|\n    webrtc|\n    referrer|\n    |\\|?\n  )\\b)+(?<!\\|)$" },
+  adg_ext_edge:{ name:"stealth",
+    description:"Disables the Stealth Mode module for all corresponding pages and requests.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#stealth-modifier",
+    assignable:true,
+    negatable:false,
+    exception_only:true,
+    value_optional:true,
+    value_format:"(?x)\n  ^(?!\\|)\\b(?:(\n    searchqueries|\n    donottrack|\n    3p-cookie|\n    1p-cookie|\n    webrtc|\n    referrer|\n    |\\|?\n  )\\b)+(?<!\\|)$" } };
+
+var data$9 = { ubo_any:{ name:"strict1p",
+    description:"This new `strict1p` option can check for strict partyness.\nFor example, a network request qualifies as 1st-party if both the context and the request share the same hostname.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#strict1p" } };
+
+var data$8 = { ubo_any:{ name:"strict3p",
+    description:"This new `strict3p` option can check for strict partyness.\nFor example, a network request qualifies as 3rd-party if the context and the request hostnames are different.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#strict3p" } };
+
+var data$7 = { adg_any:{ name:"stylesheet",
+    description:"The rule corresponds to CSS files requests.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#stylesheet-modifier" },
+  abp_any:{ name:"stylesheet",
+    description:"The rule corresponds to CSS files requests.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" },
+  ubo_any:{ name:"stylesheet",
+    aliases:[ "css" ],
+    description:"The rule corresponds to CSS files requests.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#css" } };
+
+var data$6 = { adg_any:{ name:"subdocument",
+    description:"The rule corresponds to requests for built-in pages — HTML tags frame and iframe.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#subdocument-modifier" },
+  abp_any:{ name:"subdocument",
+    description:"The rule corresponds to requests for built-in pages — HTML tags frame and iframe.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" },
+  ubo_any:{ name:"subdocument",
+    aliases:[ "frame" ],
+    description:"The rule corresponds to requests for built-in pages — HTML tags frame and iframe.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#frame" } };
+
+var data$5 = { adg_any:{ name:"third-party",
+    aliases:[ "3p" ],
+    description:"A restriction of third-party and own requests.\nA third-party request is a request from a different domain.\nFor example, a request to `example.org` from `domain.com` is a third-party request.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#third-party-modifier" },
+  ubo_any:{ name:"3p",
+    aliases:[ "third-party" ],
+    description:"A restriction of third-party and own requests.\nA third-party request is a request from a different domain.\nFor example, a request to `example.org` from `domain.com` is a third-party request.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#3p" },
+  abp_any:{ name:"third-party",
+    description:"A restriction of third-party and own requests.\nA third-party request is a request from a different domain.\nFor example, a request to `example.org` from `domain.com` is a third-party request.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293#party-requests" } };
+
+var data$4 = { ubo_ext_any:{ name:"to",
+    description:"The main motivation of this option is\nto give static network filtering engine an equivalent of DNR's `requestDomains` and `excludedRequestDomains`.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#to",
+    assignable:true,
+    negatable:false,
+    value_format:"pipe_separated_domains" } };
+
+var data$3 = { adg_any:{ name:"urlblock",
+    description:"Disables blocking of all requests sent from the pages matching the rule.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#urlblock-modifier",
+    conflicts:[ "domain",
+      "specifichide",
+      "generichide",
+      "elemhide",
+      "extension",
+      "jsinject",
+      "content",
+      "badfilter" ],
+    inverse_conflicts:true,
+    negatable:false,
+    exception_only:true } };
+
+var data$2 = { adg_any:{ name:"webrtc",
+    description:"The rule applies only to WebRTC connections.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#webrtc-modifier",
+    removed:true,
+    removal_message:"This modifier is removed and is no longer supported.\nRules with it are considered as invalid. If you need to suppress WebRTC, consider using\nthe [nowebrtc scriptlet](https://github.com/AdguardTeam/Scriptlets/blob/master/wiki/about-scriptlets.md#nowebrtc)." },
+  ubo_any:{ name:"webrtc",
+    description:"The rule applies only to WebRTC connections.",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax",
+    removed:true,
+    removal_message:"This modifier is removed and is no longer supported.\nIf you need to suppress WebRTC, consider using\nthe [nowebrtc scriptlet](https://github.com/gorhill/uBlock/wiki/Resources-Library#nowebrtcjs-)." },
+  abp_any:{ name:"webrtc",
+    description:"The rule applies only to WebRTC connections.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options",
+    version_added:"1.13.3" } };
+
+var data$1 = { adg_os_any:{ name:"websocket",
+    description:"The rule applies only to WebSocket connections.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#websocket-modifier" },
+  adg_ext_any:{ name:"websocket",
+    description:"The rule applies only to WebSocket connections.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#websocket-modifier" },
+  adg_cb_ios:{ name:"websocket",
+    description:"The rule applies only to WebSocket connections.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#websocket-modifier" },
+  adg_cb_safari:{ name:"websocket",
+    description:"The rule applies only to WebSocket connections.",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#websocket-modifier" },
+  abp_ext_any:{ name:"websocket",
+    description:"The rule applies only to WebSocket connections.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" },
+  ubo_ext_any:{ name:"websocket",
+    description:"The rule applies only to WebSocket connections.",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" } };
+
+var data = { adg_any:{ name:"xmlhttprequest",
+    aliases:[ "xhr" ],
+    description:"The rule applies only to ajax requests (requests sent via javascript object XMLHttpRequest).",
+    docs:"https://adguard.app/kb/general/ad-filtering/create-own-filters/#xmlhttprequest-modifier" },
+  abp_any:{ name:"xmlhttprequest",
+    description:"The rule applies only to ajax requests (requests sent via javascript object XMLHttpRequest).",
+    docs:"https://help.adblockplus.org/hc/en-us/articles/360062733293-How-to-write-filters#type-options" },
+  ubo_any:{ name:"xhr",
+    aliases:[ "xmlhttprequest" ],
+    description:"The rule applies only to ajax requests (requests sent via javascript object XMLHttpRequest).",
+    docs:"https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#xhr" } };
+
+/**
+ * @file Raw compatibility tables data reexport from yaml files.
+ *
+ * '@ts-nocheck' is used here once instead of adding @ts-ignore for each import.
+ */
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+// Please keep imports and exports in alphabetical order
+const rawModifiersData = {
+    all: data$T,
+    app: data$S,
+    badfilter: data$R,
+    cname: data$Q,
+    content: data$P,
+    cookie: data$O,
+    csp: data$N,
+    denyallow: data$M,
+    document: data$L,
+    domain: data$K,
+    elemhide: data$J,
+    empty: data$I,
+    firstParty: data$H,
+    extension: data$G,
+    font: data$F,
+    genericblock: data$E,
+    generichide: data$D,
+    header: data$C,
+    hls: data$B,
+    image: data$A,
+    important: data$z,
+    inlineFont: data$y,
+    inlineScript: data$x,
+    jsinject: data$w,
+    jsonprune: data$v,
+    matchCase: data$u,
+    media: data$t,
+    method: data$s,
+    mp4: data$r,
+    network: data$q,
+    noop: data$p,
+    objectSubrequest: data$o,
+    object: data$n,
+    other: data$m,
+    permissions: data$l,
+    ping: data$k,
+    popunder: data$j,
+    popup: data$i,
+    redirectRule: data$h,
+    redirect: data$g,
+    removeheader: data$f,
+    removeparam: data$e,
+    replace: data$d,
+    script: data$c,
+    specifichide: data$b,
+    stealth: data$a,
+    strict1p: data$9,
+    strict3p: data$8,
+    stylesheet: data$7,
+    subdocument: data$6,
+    thirdParty: data$5,
+    to: data$4,
+    urlblock: data$3,
+    webrtc: data$2,
+    websocket: data$1,
+    xmlhttprequest: data,
+};
+
+/**
+ * @file Compatibility tables types.
+ */
+/**
+ * List of properties names for modifier data.
+ *
+ * @see {@link https://github.com/AdguardTeam/tsurlfilter/blob/master/packages/agtree/src/compatibility-tables/modifiers/README.md#file-structure}
+ */
+var SpecificKey;
+(function (SpecificKey) {
+    SpecificKey["Name"] = "name";
+    SpecificKey["Aliases"] = "aliases";
+    SpecificKey["Description"] = "description";
+    SpecificKey["Docs"] = "docs";
+    SpecificKey["Deprecated"] = "deprecated";
+    SpecificKey["DeprecationMessage"] = "deprecation_message";
+    SpecificKey["Removed"] = "removed";
+    SpecificKey["RemovalMessage"] = "removal_message";
+    SpecificKey["Conflicts"] = "conflicts";
+    SpecificKey["InverseConflicts"] = "inverse_conflicts";
+    SpecificKey["Assignable"] = "assignable";
+    SpecificKey["Negatable"] = "negatable";
+    SpecificKey["BlockOnly"] = "block_only";
+    SpecificKey["ExceptionOnly"] = "exception_only";
+    // TODO: consider removing this field
+    // and handle whether the value is optional by `value_format`. AG-24028
+    SpecificKey["ValueOptional"] = "value_optional";
+    SpecificKey["ValueFormat"] = "value_format";
+    // TODO: following fields should be handled later
+    // VersionAdded = 'version_added',
+    // VersionRemoved = 'version_removed',
+})(SpecificKey || (SpecificKey = {}));
+
+/**
+ * Prepares specific platform modifier data from raw modifiers data —
+ * sets [default values] to properties that are not defined in raw data.
+ *
+ * [default values]: ./modifiers/README.md "Check File structure table for default values."
+ *
+ * @param blockerId Key in ModifierData, i.e. 'adg_os_any', 'ubo_ext_any', etc.
+ * @param rawModifierData Specific platform modifier data from raw modifiers data.
+ *
+ * @returns Prepared specific platform modifier data where properties cannot be undefined.
+ */
+const prepareBlockerData = (blockerId, rawModifierData) => {
+    const rawData = rawModifierData[blockerId];
+    const blockerData = {
+        [SpecificKey.Name]: rawData[SpecificKey.Name],
+        [SpecificKey.Aliases]: rawData[SpecificKey.Aliases] || null,
+        [SpecificKey.Description]: rawData[SpecificKey.Description] || null,
+        [SpecificKey.Docs]: rawData[SpecificKey.Docs] || null,
+        [SpecificKey.Deprecated]: rawData[SpecificKey.Deprecated] || false,
+        [SpecificKey.DeprecationMessage]: rawData[SpecificKey.DeprecationMessage] || null,
+        [SpecificKey.Removed]: rawData[SpecificKey.Removed] || false,
+        [SpecificKey.RemovalMessage]: rawData[SpecificKey.RemovalMessage] || null,
+        [SpecificKey.Conflicts]: rawData[SpecificKey.Conflicts] || null,
+        [SpecificKey.InverseConflicts]: rawData[SpecificKey.InverseConflicts] || false,
+        [SpecificKey.Assignable]: rawData[SpecificKey.Assignable] || false,
+        // 'negatable' should be checked whether it is undefined or not
+        // because if it is 'false', default value 'true' will override it
+        [SpecificKey.Negatable]: isUndefined(rawData[SpecificKey.Negatable])
+            ? true
+            : rawData[SpecificKey.Negatable],
+        [SpecificKey.BlockOnly]: rawData[SpecificKey.BlockOnly] || false,
+        [SpecificKey.ExceptionOnly]: rawData[SpecificKey.ExceptionOnly] || false,
+        [SpecificKey.ValueOptional]: rawData[SpecificKey.ValueOptional] || false,
+        [SpecificKey.ValueFormat]: rawData[SpecificKey.ValueFormat] || null,
+    };
+    return blockerData;
+};
+/**
+ * Prepares raw modifiers data into a data map with default values for properties
+ * that are not defined in raw data.
+ *
+ * @returns Map of parsed and prepared modifiers data.
+ */
+const getModifiersData = () => {
+    const dataMap = new Map();
+    Object.keys(rawModifiersData).forEach((modifierId) => {
+        const rawModifierData = rawModifiersData[modifierId];
+        const modifierData = {};
+        Object.keys(rawModifierData).forEach((blockerId) => {
+            modifierData[blockerId] = prepareBlockerData(blockerId, rawModifierData);
+        });
+        dataMap.set(modifierId, modifierData);
+    });
+    return dataMap;
+};
+
+const INVALID_ERROR_PREFIX = {
+    NOT_EXISTENT: 'Not existent modifier',
+    NOT_SUPPORTED: 'The adblocker does not support the modifier',
+    REMOVED: 'Removed and no longer supported modifier',
+    BLOCK_ONLY: 'Only blocking rules may contain the modifier',
+    EXCEPTION_ONLY: 'Only exception rules may contain the modifier',
+    NOT_NEGATABLE: 'Not negatable modifier',
+    VALUE_REQUIRED: 'Value is required for the modifier',
+    VALUE_FORBIDDEN: 'Value is not allowed for the modifier',
+    INVALID_NOOP: 'Invalid noop modifier',
+};
+
+/**
+ * @file Validator for modifiers.
+ */
+const BLOCKER_PREFIX = {
+    [AdblockSyntax.Adg]: 'adg_',
+    [AdblockSyntax.Ubo]: 'ubo_',
+    [AdblockSyntax.Abp]: 'abp_',
+};
+/**
+ * Collects names and aliases for all supported modifiers.
+ * Deprecated and removed modifiers are included because they are known and existent
+ * and they should be validated properly.
+ *
+ * @param dataMap Parsed all modifiers data.
+ *
+ * @returns Set of all modifier names (and their aliases).
+ */
+const getAllModifierNames = (dataMap) => {
+    const names = new Set();
+    dataMap.forEach((modifierData) => {
+        Object.keys(modifierData).forEach((blockerId) => {
+            const blockerData = modifierData[blockerId];
+            names.add(blockerData.name);
+            if (!blockerData.aliases) {
+                return;
+            }
+            blockerData.aliases.forEach((alias) => names.add(alias));
+        });
+    });
+    return names;
+};
+/**
+ * Returns modifier data for given modifier name and adblocker.
+ *
+ * @param modifiersData Parsed all modifiers data map.
+ * @param blockerPrefix Prefix of the adblocker, e.g. 'adg_', 'ubo_', or 'abp_'.
+ * @param modifierName Modifier name.
+ *
+ * @returns Modifier data or `null` if not found.
+ */
+const getSpecificBlockerData = (modifiersData, blockerPrefix, modifierName) => {
+    let specificBlockerData = null;
+    modifiersData.forEach((modifierData) => {
+        Object.keys(modifierData).forEach((blockerId) => {
+            const blockerData = modifierData[blockerId];
+            if (blockerData.name === modifierName
+                || (blockerData.aliases && blockerData.aliases.includes(modifierName))) {
+                // modifier is found by name or alias
+                // so its support by specific adblocker should be checked
+                if (blockerId.startsWith(blockerPrefix)) {
+                    // so maybe other data objects should be checked as well (not sure)
+                    specificBlockerData = blockerData;
+                }
+            }
+        });
+    });
+    return specificBlockerData;
+};
+/**
+ * Returns invalid validation result with given error message.
+ *
+ * @param error Error message.
+ *
+ * @returns Validation result `{ ok: false, error }`.
+ */
+const getInvalidValidationResult = (error) => {
+    return {
+        ok: false,
+        error,
+    };
+};
+/**
+ * Fully checks whether the given `modifier` valid for given blocker `syntax`:
+ * is it supported by the blocker, deprecated, assignable, negatable, etc.
+ *
+ * @param modifiersData Parsed all modifiers data map.
+ * @param syntax Adblock syntax to check the modifier for.
+ * 'Common' is not supported, it should be specific — 'AdGuard', 'uBlockOrigin', or 'AdblockPlus'.
+ * @param modifier Parsed modifier AST node.
+ * @param isException Whether the modifier is used in exception rule.
+ * Needed to check whether the modifier is allowed only in blocking or exception rules.
+ *
+ * @returns Result of modifier validation.
+ */
+const validateForSpecificSyntax = (modifiersData, syntax, modifier, isException) => {
+    if (syntax === AdblockSyntax.Common) {
+        throw new Error(`Syntax should be specific, '${AdblockSyntax.Common}' is not supported`);
+    }
+    const modifierName = modifier.modifier.value;
+    const blockerPrefix = BLOCKER_PREFIX[syntax];
+    if (!blockerPrefix) {
+        throw new Error(`Unknown syntax: ${syntax}`);
+    }
+    // needed for validation of negation, assignment, etc.
+    const specificBlockerData = getSpecificBlockerData(modifiersData, blockerPrefix, modifierName);
+    // if no specific blocker data is found
+    if (!specificBlockerData) {
+        return getInvalidValidationResult(`${INVALID_ERROR_PREFIX.NOT_SUPPORTED}: '${modifierName}'`);
+    }
+    // e.g. 'object-subrequest'
+    if (specificBlockerData.removed) {
+        return getInvalidValidationResult(`${INVALID_ERROR_PREFIX.REMOVED}: '${modifierName}'`);
+    }
+    if (specificBlockerData.deprecated) {
+        if (!specificBlockerData.deprecation_message) {
+            throw new Error('Deprecation notice is required for deprecated modifier');
+        }
+        return {
+            ok: true,
+            warn: specificBlockerData.deprecation_message,
+        };
+    }
+    if (specificBlockerData.block_only && isException) {
+        return getInvalidValidationResult(`${INVALID_ERROR_PREFIX.BLOCK_ONLY}: '${modifierName}'`);
+    }
+    if (specificBlockerData.exception_only && !isException) {
+        return getInvalidValidationResult(`${INVALID_ERROR_PREFIX.EXCEPTION_ONLY}: '${modifierName}'`);
+    }
+    // e.g. '~domain=example.com'
+    if (!specificBlockerData.negatable && modifier.exception) {
+        return getInvalidValidationResult(`${INVALID_ERROR_PREFIX.NOT_NEGATABLE}: '${modifierName}'`);
+    }
+    // e.g. 'domain'
+    if (specificBlockerData.assignable) {
+        /**
+         * Some assignable modifiers can be used without a value,
+         * e.g. '@@||example.com^$cookie'.
+         */
+        if (!modifier.value
+            // value should be specified if it is not optional
+            && !specificBlockerData.value_optional) {
+            return getInvalidValidationResult(`${INVALID_ERROR_PREFIX.VALUE_REQUIRED}: '${modifierName}'`);
+        }
+        /**
+         * TODO: consider to return `{ ok: true, warn: 'Modifier value may be specified' }` (???)
+         * for $stealth modifier without a value
+         * but only after the extension will support value for $stealth:
+         * https://github.com/AdguardTeam/AdguardBrowserExtension/issues/2107
+         */
+    }
+    else if (modifier?.value) {
+        return getInvalidValidationResult(`${INVALID_ERROR_PREFIX.VALUE_FORBIDDEN}: '${modifierName}'`);
+    }
+    return { ok: true };
+};
+/**
+ * Returns documentation URL for given modifier and adblocker.
+ *
+ * @param modifiersData Parsed all modifiers data map.
+ * @param blockerPrefix Prefix of the adblocker, e.g. 'adg_', 'ubo_', or 'abp_'.
+ * @param modifier Parsed modifier AST node.
+ *
+ * @returns Documentation URL or `null` if not found.
+ */
+const getBlockerDocumentationLink = (modifiersData, blockerPrefix, modifier) => {
+    const specificBlockerData = getSpecificBlockerData(modifiersData, blockerPrefix, modifier.modifier.value);
+    return specificBlockerData?.docs || null;
+};
+/**
+ * Validates the noop modifier (i.e. only underscores).
+ *
+ * @param value Value of the modifier.
+ *
+ * @returns True if the modifier is valid, false otherwise.
+ */
+const isValidNoopModifier = (value) => {
+    return value.split('').every((char) => char === UNDERSCORE);
+};
+/**
+ * Modifier validator class.
+ */
+class ModifierValidator {
+    /**
+     * Map of all modifiers data parsed from yaml files.
+     */
+    modifiersData;
+    /**
+     * List of all modifier names for any adblocker.
+     *
+     * Please note that **deprecated** modifiers are **included** as well.
+     */
+    allModifierNames;
+    constructor() {
+        // data map based on yaml files
+        this.modifiersData = getModifiersData();
+        this.allModifierNames = getAllModifierNames(this.modifiersData);
+    }
+    /**
+     * 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) => {
+        return this.allModifierNames.has(modifier.modifier.value);
+    };
+    /**
+     * 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, rawModifier, isException = false) => {
+        const modifier = cloneDeep(rawModifier);
+        // special case: handle noop modifier which may be used as multiple underscores (not just one)
+        // https://adguard.com/kb/general/ad-filtering/create-own-filters/#noop-modifier
+        if (modifier.modifier.value.startsWith(UNDERSCORE)) {
+            // check whether the modifier value contains something else besides underscores
+            if (!isValidNoopModifier(modifier.modifier.value)) {
+                return getInvalidValidationResult(`${INVALID_ERROR_PREFIX.INVALID_NOOP}: '${modifier.modifier.value}'`);
+            }
+            // otherwise, replace the modifier value with single underscore.
+            // it is needed to check whether the modifier is supported by specific adblocker due to the syntax
+            modifier.modifier.value = UNDERSCORE;
+        }
+        if (!this.exists(modifier)) {
+            return getInvalidValidationResult(`${INVALID_ERROR_PREFIX.NOT_EXISTENT}: '${modifier.modifier.value}'`);
+        }
+        // for 'Common' syntax we cannot check something more
+        if (syntax === AdblockSyntax.Common) {
+            return { ok: true };
+        }
+        return validateForSpecificSyntax(this.modifiersData, syntax, modifier, isException);
+    };
+    /**
+     * Returns AdGuard documentation URL for given modifier.
+     *
+     * @param modifier Parsed modifier AST node.
+     *
+     * @returns AdGuard documentation URL or `null` if not found.
+     */
+    getAdgDocumentationLink = (modifier) => {
+        if (!this.exists(modifier)) {
+            return null;
+        }
+        return getBlockerDocumentationLink(this.modifiersData, BLOCKER_PREFIX[AdblockSyntax.Adg], modifier);
+    };
+    /**
+     * 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) => {
+        if (!this.exists(modifier)) {
+            return null;
+        }
+        return getBlockerDocumentationLink(this.modifiersData, BLOCKER_PREFIX[AdblockSyntax.Ubo], modifier);
+    };
+    /**
+     * 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) => {
+        if (!this.exists(modifier)) {
+            return null;
+        }
+        return getBlockerDocumentationLink(this.modifiersData, BLOCKER_PREFIX[AdblockSyntax.Abp], modifier);
+    };
+}
+const modifierValidator = new ModifierValidator();
+
+/**
+ * @file Base class for converters
+ *
+ * TS doesn't support abstract static methods, so we should use
+ * a workaround and extend this class instead of implementing it
+ */
+/* eslint-disable jsdoc/require-returns-check */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Basic class for rule converters
+ */
+class ConverterBase {
+    /**
+     * Converts some data to AdGuard format
+     *
+     * @param data Data to convert
+     * @returns Converted data
+     * @throws If the data is invalid or incompatible
+     */
+    static convertToAdg(data) {
+        throw new NotImplementedError();
+    }
+    /**
+     * Converts some data to Adblock Plus format
+     *
+     * @param data Data to convert
+     * @returns Converted data
+     * @throws If the data is invalid or incompatible
+     */
+    static convertToAbp(data) {
+        throw new NotImplementedError();
+    }
+    /**
+     * Converts some data to uBlock Origin format
+     *
+     * @param data Data to convert
+     * @returns Converted data
+     * @throws If the data is invalid or incompatible
+     */
+    static convertToUbo(data) {
+        throw new NotImplementedError();
+    }
+}
+
+/**
+ * @file Base class for rule converters
+ *
+ * TS doesn't support abstract static methods, so we should use
+ * a workaround and extend this class instead of implementing it
+ */
+/* eslint-disable jsdoc/require-returns-check */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Basic class for rule converters
+ */
+class RuleConverterBase extends ConverterBase {
+    /**
+     * Converts an adblock filtering rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        throw new NotImplementedError();
+    }
+    /**
+     * Converts an adblock filtering rule to Adblock Plus format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAbp(rule) {
+        throw new NotImplementedError();
+    }
+    /**
+     * Converts an adblock filtering rule to uBlock Origin format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToUbo(rule) {
+        throw new NotImplementedError();
+    }
+}
+
+/**
+ * @file Comment rule converter
+ */
+/**
+ * Comment rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class CommentRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a comment rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Clone the provided AST node to avoid side effects
+        const ruleNode = cloneDeep(rule);
+        // TODO: Add support for other comment types, if needed
+        // Main task is # -> ! conversion
+        switch (ruleNode.type) {
+            case CommentRuleType.CommentRule:
+                // 'Comment' uBO style comments
+                if (ruleNode.type === CommentRuleType.CommentRule
+                    && ruleNode.marker.value === CommentMarker.Hashmark) {
+                    ruleNode.marker.value = CommentMarker.Regular;
+                    // Add the hashmark to the beginning of the comment
+                    ruleNode.text.value = `${SPACE}${CommentMarker.Hashmark}${ruleNode.text.value}`;
+                }
+                return [ruleNode];
+            // Leave any other comment rule as is
+            default:
+                return [ruleNode];
+        }
+    }
+}
+
+/**
+ * @file Regular expression utilities
+ */
+// Special RegExp constants
+const REGEX_START = CARET; // '^'
+const REGEX_END = DOLLAR_SIGN; // '$'
+const REGEX_ANY_CHARACTERS = DOT + ASTERISK; // '.*'
+// Special adblock pattern symbols and their RegExp equivalents
+const ADBLOCK_URL_START = PIPE + PIPE; // '||'
+const ADBLOCK_URL_START_REGEX = '^(http|https|ws|wss)://([a-z0-9-_.]+\\.)?';
+const ADBLOCK_URL_SEPARATOR = CARET; // '^'
+const ADBLOCK_URL_SEPARATOR_REGEX = '([^ a-zA-Z0-9.%_-]|$)';
+const ADBLOCK_WILDCARD = ASTERISK; // '*'
+const ADBLOCK_WILDCARD_REGEX = REGEX_ANY_CHARACTERS;
+// Negation wrapper for RegExp patterns
+const REGEX_NEGATION_PREFIX = '^((?!';
+const REGEX_NEGATION_SUFFIX = ').)*$';
+/**
+ * Special RegExp symbols
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#special-escape
+ */
+const SPECIAL_REGEX_SYMBOLS = new Set([
+    ASTERISK,
+    CARET,
+    CLOSE_CURLY_BRACKET,
+    CLOSE_PARENTHESIS,
+    CLOSE_SQUARE_BRACKET,
+    DOLLAR_SIGN,
+    DOT,
+    ESCAPE_CHARACTER,
+    OPEN_CURLY_BRACKET,
+    OPEN_PARENTHESIS,
+    OPEN_SQUARE_BRACKET,
+    PIPE,
+    PLUS,
+    QUESTION_MARK,
+    SLASH,
+]);
+/**
+ * Utility functions for working with RegExp patterns
+ */
+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) {
+        const trimmedPattern = pattern.trim();
+        // Avoid false positives
+        if (trimmedPattern.length > REGEX_MARKER.length * 2 && trimmedPattern.startsWith(REGEX_MARKER)) {
+            const last = StringUtils.findNextUnescapedCharacter(trimmedPattern, REGEX_MARKER, REGEX_MARKER.length);
+            return last === trimmedPattern.length - 1;
+        }
+        return false;
+    }
+    /**
+     * 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) {
+        let result = pattern.trim();
+        let slashes = false;
+        // Remove the leading and trailing slashes (/)
+        if (RegExpUtils.isRegexPattern(result)) {
+            result = result.substring(REGEX_MARKER.length, result.length - REGEX_MARKER.length);
+            slashes = true;
+        }
+        // Only negate the pattern if it's not already negated
+        if (!(result.startsWith(REGEX_NEGATION_PREFIX) && result.endsWith(REGEX_NEGATION_SUFFIX))) {
+            // Remove leading caret (^)
+            if (result.startsWith(REGEX_START)) {
+                result = result.substring(REGEX_START.length);
+            }
+            // Remove trailing dollar sign ($)
+            if (result.endsWith(REGEX_END)) {
+                result = result.substring(0, result.length - REGEX_END.length);
+            }
+            // Wrap the pattern in the negation
+            result = `${REGEX_NEGATION_PREFIX}${result}${REGEX_NEGATION_SUFFIX}`;
+        }
+        // Add the leading and trailing slashes back if they were there
+        if (slashes) {
+            result = `${REGEX_MARKER}${result}${REGEX_MARKER}`;
+        }
+        return result;
+    }
+    /**
+     * 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) {
+        const trimmed = pattern.trim();
+        // Return regex for any character sequence if the pattern is just |, ||, * or empty
+        if (trimmed === ADBLOCK_URL_START
+            || trimmed === PIPE
+            || trimmed === ADBLOCK_WILDCARD
+            || trimmed === EMPTY) {
+            return REGEX_ANY_CHARACTERS;
+        }
+        // If the pattern is already a RegExp, just return it, but remove the leading and trailing slashes
+        if (RegExpUtils.isRegexPattern(pattern)) {
+            return pattern.substring(REGEX_MARKER.length, pattern.length - REGEX_MARKER.length);
+        }
+        let result = EMPTY;
+        let offset = 0;
+        let len = trimmed.length;
+        // Handle leading pipes
+        if (trimmed[0] === PIPE) {
+            if (trimmed[1] === PIPE) {
+                // Replace adblock url start (||) with its RegExp equivalent
+                result += ADBLOCK_URL_START_REGEX;
+                offset = ADBLOCK_URL_START.length;
+            }
+            else {
+                // Replace single pipe (|) with the RegExp start symbol (^)
+                result += REGEX_START;
+                offset = REGEX_START.length;
+            }
+        }
+        // Handle trailing pipes
+        let trailingPipe = false;
+        if (trimmed.endsWith(PIPE)) {
+            trailingPipe = true;
+            len -= PIPE.length;
+        }
+        // Handle the rest of the pattern, if any
+        for (; offset < len; offset += 1) {
+            if (trimmed[offset] === ADBLOCK_WILDCARD) {
+                // Replace adblock wildcard (*) with its RegExp equivalent
+                result += ADBLOCK_WILDCARD_REGEX;
+            }
+            else if (trimmed[offset] === ADBLOCK_URL_SEPARATOR) {
+                // Replace adblock url separator (^) with its RegExp equivalent
+                result += ADBLOCK_URL_SEPARATOR_REGEX;
+            }
+            else if (SPECIAL_REGEX_SYMBOLS.has(trimmed[offset])) {
+                // Escape special RegExp symbols (we handled pipe (|) and asterisk (*) already)
+                result += ESCAPE_CHARACTER + trimmed[offset];
+            }
+            else {
+                // Just add any other character
+                result += trimmed[offset];
+            }
+        }
+        // Handle trailing pipes
+        if (trailingPipe) {
+            // Replace trailing pipe (|) with the RegExp end symbol ($)
+            result += REGEX_END;
+        }
+        return result;
+    }
+}
+
+/**
+ * @file HTML filtering rule converter
+ */
+/**
+ * From the AdGuard docs:
+ * Specifies the maximum length for content of HTML element. If this parameter is
+ * set and the content length exceeds the value, a rule does not apply to the element.
+ * If this parameter is not specified, the max-length is considered to be 8192 (8 KB).
+ * When converting from other formats, we set the max-length to 262144 (256 KB).
+ *
+ * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#html-filtering-rules}
+ */
+const ADGUARD_HTML_DEFAULT_MAX_LENGTH = 8192;
+const ADGUARD_HTML_CONVERSION_MAX_LENGTH = ADGUARD_HTML_DEFAULT_MAX_LENGTH * 32;
+const NOT_SPECIFIED = -1;
+const CONTAINS$1 = 'contains';
+const HAS_TEXT$1 = 'has-text';
+const MAX_LENGTH = 'max-length';
+const MIN_LENGTH = 'min-length';
+const MIN_TEXT_LENGTH = 'min-text-length';
+const TAG_CONTENT = 'tag-content';
+const WILDCARD$1 = 'wildcard';
+/**
+ * HTML filtering rule converter class
+ *
+ * @todo Implement `convertToUbo` (ABP currently doesn't support HTML filtering rules)
+ */
+class HtmlRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a HTML rule to AdGuard syntax, if possible. Also can be used to convert
+     * AdGuard rules to AdGuard syntax to validate them.
+     *
+     * _Note:_ uBlock Origin supports multiple selectors within a single rule, but AdGuard doesn't,
+     * so the following rule
+     * ```
+     * example.com##^div[attr1="value1"][attr2="value2"], script:has-text(value)
+     * ```
+     * will be converted to multiple AdGuard rules:
+     * ```
+     * example.com$$div[attr1="value1"][attr2="value2"][max-length="262144"]
+     * example.com$$script[tag-content="value"][max-length="262144"]
+     * ```
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Clone the provided AST node to avoid side effects
+        const ruleNode = cloneDeep(rule);
+        // Prepare the conversion result
+        const conversionResult = [];
+        // Iterate over selector list
+        for (const selector of ruleNode.body.body.children) {
+            // Check selector, just in case
+            if (selector.type !== CssTreeNodeType.Selector) {
+                throw new RuleConversionError(`Expected selector, got '${selector.type}'`);
+            }
+            // At least one child is required, and first child may be a tag selector
+            if (selector.children.length === 0) {
+                throw new RuleConversionError('Invalid selector, no children are present');
+            }
+            // Prepare bounds
+            let minLength = NOT_SPECIFIED;
+            let maxLength = NOT_SPECIFIED;
+            // Prepare the converted selector
+            const convertedSelector = {
+                type: CssTreeNodeType.Selector,
+                children: [],
+            };
+            for (let i = 0; i < selector.children.length; i += 1) {
+                // Current node within the current selector
+                const node = selector.children[i];
+                switch (node.type) {
+                    case CssTreeNodeType.TypeSelector:
+                        // First child in the selector may be a tag selector
+                        if (i !== 0) {
+                            throw new RuleConversionError('Tag selector should be the first child, if present');
+                        }
+                        // Simply store the tag selector
+                        convertedSelector.children.push(cloneDeep(node));
+                        break;
+                    case CssTreeNodeType.AttributeSelector:
+                        // Check if the attribute selector is a special AdGuard attribute
+                        switch (node.name.name) {
+                            case MIN_LENGTH:
+                                minLength = CssTree.parseAttributeSelectorValueAsNumber(node);
+                                break;
+                            case MAX_LENGTH:
+                                maxLength = CssTree.parseAttributeSelectorValueAsNumber(node);
+                                break;
+                            case TAG_CONTENT:
+                            case WILDCARD$1:
+                                CssTree.assertAttributeSelectorHasStringValue(node);
+                                convertedSelector.children.push(cloneDeep(node));
+                                break;
+                            default:
+                                convertedSelector.children.push(cloneDeep(node));
+                        }
+                        break;
+                    case CssTreeNodeType.PseudoClassSelector:
+                        CssTree.assertPseudoClassHasAnyArgument(node);
+                        // eslint-disable-next-line no-case-declarations
+                        const arg = node.children[0];
+                        if (arg.type !== CssTreeNodeType.String
+                            && arg.type !== CssTreeNodeType.Raw
+                            && arg.type !== CssTreeNodeType.Number) {
+                            throw new RuleConversionError(`Unsupported argument type '${arg.type}' for pseudo class '${node.name}'`);
+                        }
+                        // Process the pseudo class based on its name
+                        switch (node.name) {
+                            case HAS_TEXT$1:
+                            case CONTAINS$1:
+                                // Check if the argument is a RegExp
+                                if (RegExpUtils.isRegexPattern(arg.value)) {
+                                    // TODO: Add some support for RegExp patterns later
+                                    // Need to find a way to convert some RegExp patterns to glob patterns
+                                    throw new RuleConversionError('Conversion of RegExp patterns is not yet supported');
+                                }
+                                convertedSelector.children.push(CssTree.createAttributeSelectorNode(TAG_CONTENT, arg.value));
+                                break;
+                            // https://github.com/gorhill/uBlock/wiki/Procedural-cosmetic-filters#subjectmin-text-lengthn
+                            case MIN_TEXT_LENGTH:
+                                minLength = CssTree.parsePseudoClassArgumentAsNumber(node);
+                                break;
+                            default:
+                                throw new RuleConversionError(`Unsupported pseudo class '${node.name}'`);
+                        }
+                        break;
+                    default:
+                        throw new RuleConversionError(`Unsupported node type '${node.type}'`);
+                }
+            }
+            if (minLength !== NOT_SPECIFIED) {
+                convertedSelector.children.push(CssTree.createAttributeSelectorNode(MIN_LENGTH, String(minLength)));
+            }
+            convertedSelector.children.push(CssTree.createAttributeSelectorNode(MAX_LENGTH, String(maxLength === NOT_SPECIFIED
+                ? ADGUARD_HTML_CONVERSION_MAX_LENGTH
+                : maxLength)));
+            // Create the converted rule
+            conversionResult.push({
+                category: RuleCategory.Cosmetic,
+                type: CosmeticRuleType.HtmlFilteringRule,
+                syntax: AdblockSyntax.Adg,
+                // Convert the separator based on the exception status
+                separator: {
+                    type: 'Value',
+                    value: ruleNode.exception
+                        ? CosmeticRuleSeparator.AdgHtmlFilteringException
+                        : CosmeticRuleSeparator.AdgHtmlFiltering,
+                },
+                // Create the body based on the converted selector
+                body: {
+                    type: 'HtmlFilteringRuleBody',
+                    body: {
+                        type: CssTreeNodeType.SelectorList,
+                        children: [{
+                                type: CssTreeNodeType.Selector,
+                                children: [convertedSelector],
+                            }],
+                    },
+                },
+                exception: ruleNode.exception,
+                domains: ruleNode.domains,
+            });
+        }
+        return conversionResult;
+    }
+}
+
+/**
+ * @file Utility functions for working with quotes
+ */
+/**
+ * Possible quote types for scriptlet parameters
+ */
+var QuoteType;
+(function (QuoteType) {
+    /**
+     * No quotes at all
+     */
+    QuoteType["None"] = "none";
+    /**
+     * Single quotes (`'`)
+     */
+    QuoteType["Single"] = "single";
+    /**
+     * Double quotes (`"`)
+     */
+    QuoteType["Double"] = "double";
+})(QuoteType || (QuoteType = {}));
+/**
+ * Utility functions for working with quotes
+ */
+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, char) {
+        let result = EMPTY;
+        for (let i = 0; i < string.length; i += 1) {
+            if (string[i] === char && (i === 0 || string[i - 1] !== ESCAPE_CHARACTER)) {
+                result += ESCAPE_CHARACTER;
+            }
+            result += string[i];
+        }
+        return result;
+    }
+    /**
+     * Unescape all single escaped occurrences of the character
+     *
+     * @param string String to unescape
+     * @param char Character to unescape
+     * @returns Unescaped string
+     */
+    static unescapeSingleEscapedOccurrences(string, char) {
+        let result = EMPTY;
+        for (let i = 0; i < string.length; i += 1) {
+            if (string[i] === char
+                && string[i - 1] === ESCAPE_CHARACTER
+                && (i === 1 || string[i - 2] !== ESCAPE_CHARACTER)) {
+                result = result.slice(0, -1);
+            }
+            result += string[i];
+        }
+        return result;
+    }
+    /**
+     * Get quote type of the string
+     *
+     * @param string String to check
+     * @returns Quote type of the string
+     */
+    static getStringQuoteType(string) {
+        // Don't check 1-character strings to avoid false positives
+        if (string.length > 1) {
+            if (string.startsWith(SINGLE_QUOTE) && string.endsWith(SINGLE_QUOTE)) {
+                return QuoteType.Single;
+            }
+            if (string.startsWith(DOUBLE_QUOTE) && string.endsWith(DOUBLE_QUOTE)) {
+                return QuoteType.Double;
+            }
+        }
+        return QuoteType.None;
+    }
+    /**
+     * 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, quoteType) {
+        const actualQuoteType = QuoteUtils.getStringQuoteType(string);
+        switch (quoteType) {
+            case QuoteType.None:
+                if (actualQuoteType === QuoteType.Single) {
+                    return QuoteUtils.escapeUnescapedOccurrences(string.slice(1, -1), SINGLE_QUOTE);
+                }
+                if (actualQuoteType === QuoteType.Double) {
+                    return QuoteUtils.escapeUnescapedOccurrences(string.slice(1, -1), DOUBLE_QUOTE);
+                }
+                return string;
+            case QuoteType.Single:
+                if (actualQuoteType === QuoteType.None) {
+                    return SINGLE_QUOTE + QuoteUtils.escapeUnescapedOccurrences(string, SINGLE_QUOTE) + SINGLE_QUOTE;
+                }
+                if (actualQuoteType === QuoteType.Double) {
+                    return SINGLE_QUOTE
+                        + QuoteUtils.escapeUnescapedOccurrences(QuoteUtils.unescapeSingleEscapedOccurrences(string.slice(1, -1), DOUBLE_QUOTE), SINGLE_QUOTE) + SINGLE_QUOTE;
+                }
+                return string;
+            case QuoteType.Double:
+                if (actualQuoteType === QuoteType.None) {
+                    return DOUBLE_QUOTE + QuoteUtils.escapeUnescapedOccurrences(string, DOUBLE_QUOTE) + DOUBLE_QUOTE;
+                }
+                if (actualQuoteType !== QuoteType.Double) {
+                    // eslint-disable-next-line max-len
+                    return DOUBLE_QUOTE
+                        + QuoteUtils.escapeUnescapedOccurrences(QuoteUtils.unescapeSingleEscapedOccurrences(string.slice(1, -1), SINGLE_QUOTE), DOUBLE_QUOTE) + DOUBLE_QUOTE;
+                }
+                return string;
+            default:
+                return string;
+        }
+    }
+    /**
+     * Removes bounding quotes from a string, if any
+     *
+     * @param string Input string
+     * @returns String without quotes
+     */
+    static removeQuotes(string) {
+        if (
+        // We should check for string length to avoid false positives
+        string.length > 1
+            && (string[0] === SINGLE_QUOTE || string[0] === DOUBLE_QUOTE)
+            && string[0] === string[string.length - 1]) {
+            return string.slice(1, -1);
+        }
+        return string;
+    }
+}
+
+/**
+ * @file Utility functions for working with scriptlet nodes
+ */
+/**
+ * Get name of the scriptlet from the scriptlet node
+ *
+ * @param scriptletNode Scriptlet node to get name of
+ * @returns Name of the scriptlet
+ * @throws If the scriptlet is empty
+ */
+function getScriptletName(scriptletNode) {
+    if (scriptletNode.children.length === 0) {
+        throw new Error('Empty scriptlet');
+    }
+    return scriptletNode.children[0].value;
+}
+/**
+ * Set name of the scriptlet
+ *
+ * @param scriptletNode Scriptlet node to set name of
+ * @param name Name to set
+ * @returns Scriptlet node with the specified name
+ * @throws If the scriptlet is empty
+ */
+function setScriptletName(scriptletNode, name) {
+    if (scriptletNode.children.length === 0) {
+        throw new Error('Empty scriptlet');
+    }
+    const scriptletNodeClone = cloneDeep(scriptletNode);
+    scriptletNodeClone.children[0].value = name;
+    return scriptletNodeClone;
+}
+/**
+ * Set quote type of the scriptlet parameters
+ *
+ * @param scriptletNode Scriptlet node to set quote type of
+ * @param quoteType Preferred quote type
+ * @returns Scriptlet node with the specified quote type
+ */
+function setScriptletQuoteType(scriptletNode, quoteType) {
+    if (scriptletNode.children.length === 0) {
+        throw new Error('Empty scriptlet');
+    }
+    const scriptletNodeClone = cloneDeep(scriptletNode);
+    for (let i = 0; i < scriptletNodeClone.children.length; i += 1) {
+        scriptletNodeClone.children[i].value = QuoteUtils.setStringQuoteType(scriptletNodeClone.children[i].value, quoteType);
+    }
+    return scriptletNodeClone;
+}
+
+/**
+ * @file Scriptlet conversions from ABP and uBO to ADG
+ */
+const ABP_SCRIPTLET_PREFIX = 'abp-';
+const UBO_SCRIPTLET_PREFIX = 'ubo-';
+/**
+ * Helper class for converting scriptlets from ABP and uBO to ADG
+ */
+class AdgScriptletConverter {
+    /**
+     * Helper function to convert scriptlets to ADG. We implement the core
+     * logic here to avoid code duplication.
+     *
+     * @param scriptletNode Scriptlet parameter list node to convert
+     * @param prefix Prefix to add to the scriptlet name
+     * @returns Converted scriptlet parameter list node
+     */
+    static convertToAdg(scriptletNode, prefix) {
+        // Remove possible quotes just to make it easier to work with the scriptlet name
+        const scriptletName = QuoteUtils.setStringQuoteType(getScriptletName(scriptletNode), QuoteType.None);
+        // Clone the node to avoid any side effects
+        let result = cloneDeep(scriptletNode);
+        // Only add prefix if it's not already there
+        if (!scriptletName.startsWith(prefix)) {
+            result = setScriptletName(scriptletNode, `${prefix}${scriptletName}`);
+        }
+        // ADG scriptlet parameters should be quoted, and single quoted are preferred
+        result = setScriptletQuoteType(result, QuoteType.Single);
+        return result;
+    }
+    /**
+     * Converts an ABP snippet node to ADG scriptlet node, if possible.
+     *
+     * @param scriptletNode Scriptlet node to convert
+     * @returns Converted scriptlet node
+     * @throws If the scriptlet isn't supported by ADG or is invalid
+     * @see {@link https://help.adblockplus.org/hc/en-us/articles/1500002338501#snippets-ref}
+     */
+    static convertFromAbp = (scriptletNode) => {
+        return AdgScriptletConverter.convertToAdg(scriptletNode, ABP_SCRIPTLET_PREFIX);
+    };
+    /**
+     * Convert a uBO scriptlet node to ADG scriptlet node, if possible.
+     *
+     * @param scriptletNode Scriptlet node to convert
+     * @returns Converted scriptlet node
+     * @throws If the scriptlet isn't supported by ADG or is invalid
+     * @see {@link https://github.com/gorhill/uBlock/wiki/Resources-Library#available-general-purpose-scriptlets}
+     */
+    static convertFromUbo = (scriptletNode) => {
+        return AdgScriptletConverter.convertToAdg(scriptletNode, UBO_SCRIPTLET_PREFIX);
+    };
+}
+
+/**
+ * @file Scriptlet injection rule converter
+ */
+/**
+ * Scriptlet injection rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class ScriptletRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a scriptlet injection rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Clone the provided AST node to avoid side effects
+        const ruleNode = cloneDeep(rule);
+        const convertedScriptlets = [];
+        for (const scriptlet of ruleNode.body.children) {
+            if (ruleNode.syntax === AdblockSyntax.Abp) {
+                convertedScriptlets.push(AdgScriptletConverter.convertFromAbp(scriptlet));
+            }
+            else if (ruleNode.syntax === AdblockSyntax.Ubo) {
+                convertedScriptlets.push(AdgScriptletConverter.convertFromUbo(scriptlet));
+            }
+            else if (ruleNode.syntax === AdblockSyntax.Adg) {
+                convertedScriptlets.push(scriptlet);
+            }
+        }
+        ruleNode.separator.value = ruleNode.exception
+            ? CosmeticRuleSeparator.AdgJsInjectionException
+            : CosmeticRuleSeparator.AdgJsInjection;
+        // ADG doesn't support multiple scriptlets in one rule, so we should split them
+        return convertedScriptlets.map((scriptlet) => {
+            return {
+                ...ruleNode,
+                syntax: AdblockSyntax.Adg,
+                body: {
+                    ...ruleNode.body,
+                    children: [scriptlet],
+                },
+            };
+        });
+    }
+}
+
+/**
+ * @file Cosmetic rule modifier converter from uBO to ADG
+ */
+const UBO_MATCHES_PATH_OPERATOR = 'matches-path';
+const ADG_PATH_MODIFIER = 'path';
+/**
+ * Special characters in modifier regexps that should be escaped
+ */
+const SPECIAL_MODIFIER_REGEX_CHARS = new Set([
+    OPEN_SQUARE_BRACKET,
+    CLOSE_SQUARE_BRACKET,
+    COMMA,
+    ESCAPE_CHARACTER,
+]);
+/**
+ * Helper class for converting cosmetic rule modifiers from uBO to ADG
+ */
+class AdgCosmeticRuleModifierConverter {
+    /**
+     * Converts a uBO cosmetic rule modifier list to ADG, if possible.
+     *
+     * @param modifierList Cosmetic rule modifier list node to convert
+     * @returns Converted cosmetic rule modifier list node
+     * @throws If the modifier list cannot be converted
+     * @see {@link https://github.com/gorhill/uBlock/wiki/Procedural-cosmetic-filters#cosmetic-filter-operators}
+     */
+    static convertFromUbo = (modifierList) => {
+        const convertedModifierList = createModifierListNode();
+        for (const modifier of modifierList.children) {
+            let modifierValue;
+            switch (modifier.modifier.value) {
+                case UBO_MATCHES_PATH_OPERATOR:
+                    // :matches-path() should have a value
+                    if (!modifier.value) {
+                        throw new RuleConversionError('Missing value for :matches-path(...)');
+                    }
+                    modifierValue = RegExpUtils.isRegexPattern(modifier.value.value)
+                        ? StringUtils.escapeCharacters(modifier.value.value, SPECIAL_MODIFIER_REGEX_CHARS)
+                        : modifier.value.value;
+                    // Convert uBO's `:matches-path(...)` operator to ADG's `$path=...` modifier
+                    convertedModifierList.children.push(createModifierNode(ADG_PATH_MODIFIER, 
+                    // We should negate the regexp if the modifier is an exception
+                    modifier.exception
+                        // eslint-disable-next-line max-len
+                        ? `${REGEX_MARKER}${RegExpUtils.negateRegexPattern(RegExpUtils.patternToRegexp(modifierValue))}${REGEX_MARKER}`
+                        : modifierValue));
+                    break;
+                default:
+                    // Leave the modifier as-is
+                    convertedModifierList.children.push(modifier);
+            }
+        }
+        return convertedModifierList;
+    };
+}
+
+// Constants for pseudo-classes (please keep them sorted alphabetically)
+const ABP_CONTAINS = '-abp-contains';
+const ABP_HAS = '-abp-has';
+const CONTAINS = 'contains';
+const HAS = 'has';
+const HAS_TEXT = 'has-text';
+const MATCHES_CSS = 'matches-css';
+const MATCHES_CSS_AFTER = 'matches-css-after';
+const MATCHES_CSS_BEFORE = 'matches-css-before';
+const NOT = 'not';
+// Constants for pseudo-elements (please keep them sorted alphabetically)
+const AFTER = 'after';
+const BEFORE = 'before';
+/**
+ * Converts some pseudo-classes to pseudo-elements. For example:
+ * - `:before` → `::before`
+ *
+ * @param selectorList Selector list to convert
+ * @returns Converted selector list
+ */
+function convertToPseudoElements(selectorList) {
+    // Prepare conversion result
+    const selectorListClone = cloneDeep(selectorList);
+    walk(selectorListClone, {
+        leave: (node) => {
+            if (node.type === CssTreeNodeType.PseudoClassSelector) {
+                // :after  → ::after
+                // :before → ::before
+                if (node.name === AFTER || node.name === BEFORE) {
+                    Object.assign(node, {
+                        ...node,
+                        type: CssTreeNodeType.PseudoElementSelector,
+                    });
+                }
+            }
+        },
+    });
+    return selectorListClone;
+}
+/**
+ * Converts legacy Extended CSS `matches-css-before` and `matches-css-after`
+ * pseudo-classes to the new 'matches-css' pseudo-class:
+ * - `:matches-css-before(...)` → `:matches-css(before, ...)`
+ * - `:matches-css-after(...)`  → `:matches-css(after, ...)`
+ *
+ * @param node Node to convert
+ * @throws If the node is invalid
+ */
+function convertLegacyMatchesCss(node) {
+    const nodeClone = cloneDeep(node);
+    if (nodeClone.type === CssTreeNodeType.PseudoClassSelector
+        && [MATCHES_CSS_BEFORE, MATCHES_CSS_AFTER].includes(nodeClone.name)) {
+        if (!nodeClone.children || nodeClone.children.size < 1) {
+            throw new Error(`Invalid ${nodeClone.name} pseudo-class: missing argument`);
+        }
+        // Remove the 'matches-css-' prefix to get the direction
+        const direction = nodeClone.name.substring(MATCHES_CSS.length + 1);
+        // Rename the pseudo-class
+        nodeClone.name = MATCHES_CSS;
+        // Add the direction to the first raw argument
+        const arg = nodeClone.children.first;
+        // Check argument
+        if (!arg) {
+            throw new Error(`Invalid ${nodeClone.name} pseudo-class: argument shouldn't be null`);
+        }
+        if (arg.type !== CssTreeNodeType.Raw) {
+            throw new Error(`Invalid ${nodeClone.name} pseudo-class: unexpected argument type`);
+        }
+        // Add the direction as the first argument
+        arg.value = `${direction},${arg.value}`;
+        // Replace the original node with the converted one
+        Object.assign(node, nodeClone);
+    }
+}
+/**
+ * Converts legacy Extended CSS selectors to the modern Extended CSS syntax.
+ * For example:
+ * - `[-ext-has=...]` → `:has(...)`
+ * - `[-ext-contains=...]` → `:contains(...)`
+ * - `[-ext-matches-css-before=...]` → `:matches-css(before, ...)`
+ *
+ * @param selectorList Selector list AST to convert
+ * @returns Converted selector list
+ */
+function convertFromLegacyExtendedCss(selectorList) {
+    // Prepare conversion result
+    const selectorListClone = cloneDeep(selectorList);
+    walk(selectorListClone, {
+        leave: (node) => {
+            // :matches-css-before(arg) → :matches-css(before,arg)
+            // :matches-css-after(arg)  → :matches-css(after,arg)
+            convertLegacyMatchesCss(node);
+            // [-ext-name=...]   → :name(...)
+            // [-ext-name='...'] → :name(...)
+            // [-ext-name="..."] → :name(...)
+            if (node.type === CssTreeNodeType.AttributeSelector
+                && node.name.name.startsWith(LEGACY_EXT_CSS_ATTRIBUTE_PREFIX)
+                && node.matcher === EQUALS) {
+                // Node value should be exist
+                if (!node.value) {
+                    throw new Error(`Invalid ${node.name} attribute selector: missing value`);
+                }
+                // Remove the '-ext-' prefix to get the pseudo-class name
+                const name = node.name.name.substring(LEGACY_EXT_CSS_ATTRIBUTE_PREFIX.length);
+                // Prepare the children list for the pseudo-class node
+                const children = new List();
+                // TODO: Change String node to Raw node to drop the quotes.
+                // The structure of the node is the same, just the type
+                // is different and generate() will generate the quotes
+                // for String node. See:
+                //  - https://github.com/csstree/csstree/blob/master/docs/ast.md#string
+                //  - https://github.com/csstree/csstree/blob/master/docs/ast.md#raw
+                // if (node.value.type === "String") {
+                //     node.value.type = "Raw";
+                // }
+                // For example, if the input is [-ext-has="> .selector"], then
+                // we need to parse "> .selector" as a selector instead of string
+                // it as a raw value
+                if ([HAS, NOT].includes(name)) {
+                    // Get the value of the attribute selector
+                    const { value } = node;
+                    // If the value is an identifier, then simply push it to the
+                    // children list, otherwise parse it as a selector list before
+                    if (value.type === CssTreeNodeType.Identifier) {
+                        children.push(value);
+                    }
+                    else if (value.type === CssTreeNodeType.String) {
+                        // Parse the value as a selector
+                        const parsedChildren = CssTree.parse(value.value, CssTreeParserContext.selectorList);
+                        // Don't forget convert the parsed AST again, because
+                        // it was a raw string before
+                        children.push(convertFromLegacyExtendedCss(parsedChildren));
+                    }
+                }
+                else {
+                    let value = EMPTY;
+                    if (node.value.type === CssTreeNodeType.String) {
+                        // If the value is a string, then use its value
+                        value = node.value.value;
+                    }
+                    else if (node.value.type === CssTreeNodeType.Identifier) {
+                        // If the value is an identifier, then use its name
+                        value = node.value.name;
+                    }
+                    // In other cases, convert value to raw
+                    children.push({
+                        type: CssTreeNodeType.Raw,
+                        value,
+                    });
+                }
+                // Create a pseudo-class node with the data from the attribute
+                // selector
+                const pseudoNode = {
+                    type: CssTreeNodeType.PseudoClassSelector,
+                    name,
+                    children,
+                };
+                // Handle this case: [-ext-matches-css-before=...] → :matches-css(before,...)
+                convertLegacyMatchesCss(pseudoNode);
+                // Convert attribute selector to pseudo-class selector, but
+                // keep the reference to the original node
+                Object.assign(node, pseudoNode);
+            }
+        },
+    });
+    return selectorListClone;
+}
+/**
+ * CSS selector converter
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class CssSelectorConverter extends ConverterBase {
+    /**
+     * Converts Extended CSS elements to AdGuard-compatible ones
+     *
+     * @param selectorList Selector list to convert
+     * @returns Converted selector list
+     * @throws If the rule is invalid or incompatible
+     */
+    static convertToAdg(selectorList) {
+        // First, convert
+        //  - legacy Extended CSS selectors to the modern Extended CSS syntax and
+        //  - some pseudo-classes to pseudo-elements
+        const selectorListClone = convertToPseudoElements(convertFromLegacyExtendedCss(cloneDeep(selectorList)));
+        // Then, convert some Extended CSS pseudo-classes to AdGuard-compatible ones
+        walk(selectorListClone, {
+            leave: (node) => {
+                if (node.type === CssTreeNodeType.PseudoClassSelector) {
+                    // :-abp-contains(...) → :contains(...)
+                    // :has-text(...)      → :contains(...)
+                    if (node.name === ABP_CONTAINS || node.name === HAS_TEXT) {
+                        CssTree.renamePseudoClass(node, CONTAINS);
+                    }
+                    // :-abp-has(...) → :has(...)
+                    if (node.name === ABP_HAS) {
+                        CssTree.renamePseudoClass(node, HAS);
+                    }
+                    // TODO: check uBO's `:others()` and `:watch-attr()` pseudo-classes
+                }
+            },
+        });
+        return selectorListClone;
+    }
+}
+
+/**
+ * @file CSS injection rule converter
+ */
+/**
+ * CSS injection rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class CssInjectionRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a CSS injection rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Clone the provided AST node to avoid side effects
+        const ruleNode = cloneDeep(rule);
+        // Change the separator if the rule contains ExtendedCSS selectors
+        if (CssTree.hasAnySelectorExtendedCssNode(ruleNode.body.selectorList) || ruleNode.body.remove) {
+            ruleNode.separator.value = ruleNode.exception
+                ? CosmeticRuleSeparator.AdgExtendedCssInjectionException
+                : CosmeticRuleSeparator.AdgExtendedCssInjection;
+        }
+        else {
+            ruleNode.separator.value = ruleNode.exception
+                ? CosmeticRuleSeparator.AdgCssInjectionException
+                : CosmeticRuleSeparator.AdgCssInjection;
+        }
+        // Convert CSS selector list
+        Object.assign(ruleNode.body.selectorList, CssSelectorConverter.convertToAdg(fromPlainObject(ruleNode.body.selectorList)));
+        ruleNode.syntax = AdblockSyntax.Adg;
+        return [ruleNode];
+    }
+}
+
+/**
+ * @file Element hiding rule converter
+ */
+/**
+ * Element hiding rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class ElementHidingRuleConverter extends RuleConverterBase {
+    /**
+     * Converts an element hiding rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Clone the provided AST node to avoid side effects
+        const ruleNode = cloneDeep(rule);
+        // Change the separator if the rule contains ExtendedCSS selectors
+        if (CssTree.hasAnySelectorExtendedCssNode(ruleNode.body.selectorList)) {
+            ruleNode.separator.value = ruleNode.exception
+                ? CosmeticRuleSeparator.ExtendedElementHidingException
+                : CosmeticRuleSeparator.ExtendedElementHiding;
+        }
+        else {
+            ruleNode.separator.value = ruleNode.exception
+                ? CosmeticRuleSeparator.ElementHidingException
+                : CosmeticRuleSeparator.ElementHiding;
+        }
+        // Convert CSS selector list
+        Object.assign(ruleNode.body.selectorList, CssSelectorConverter.convertToAdg(fromPlainObject(ruleNode.body.selectorList)));
+        ruleNode.syntax = AdblockSyntax.Adg;
+        return [ruleNode];
+    }
+}
+
+/**
+ * @file Utility functions for working with network rule nodes
+ */
+/**
+ * Creates a network rule node
+ *
+ * @param pattern Rule pattern
+ * @param modifiers Rule modifiers (optional, default: undefined)
+ * @param exception Exception rule flag (optional, default: false)
+ * @param syntax Adblock syntax (optional, default: Common)
+ * @returns Network rule node
+ */
+function createNetworkRuleNode(pattern, modifiers = undefined, exception = false, syntax = AdblockSyntax.Common) {
+    const result = {
+        category: RuleCategory.Network,
+        type: 'NetworkRule',
+        syntax,
+        exception,
+        pattern: {
+            type: 'Value',
+            value: pattern,
+        },
+    };
+    if (!isUndefined(modifiers)) {
+        result.modifiers = cloneDeep(modifiers);
+    }
+    return result;
+}
+
+/**
+ * @file Converter for request header removal rules
+ */
+const UBO_RESPONSEHEADER_MARKER = 'responseheader';
+const ADG_REMOVEHEADER_MODIFIER = 'removeheader';
+/**
+ * Converter for request header removal rules
+ *
+ * @todo Implement `convertToUbo` (ABP currently doesn't support header removal rules)
+ */
+class HeaderRemovalRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a header removal rule to AdGuard syntax, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Clone the provided AST node to avoid side effects
+        const ruleNode = cloneDeep(rule);
+        // TODO: Add support for ABP syntax once it starts supporting header removal rules
+        // Check the input rule
+        if (ruleNode.category !== RuleCategory.Cosmetic
+            || ruleNode.type !== CosmeticRuleType.HtmlFilteringRule
+            || ruleNode.body.body.type !== CssTreeNodeType.Function
+            || ruleNode.body.body.name !== UBO_RESPONSEHEADER_MARKER) {
+            throw new RuleConversionError('Not a response header rule');
+        }
+        // Prepare network rule pattern
+        let pattern = EMPTY;
+        if (ruleNode.domains.children.length === 1) {
+            // If the rule has only one domain, we can use a simple network rule pattern:
+            // ||single-domain-from-the-rule^
+            pattern = [
+                ADBLOCK_URL_START,
+                ruleNode.domains.children[0].value,
+                ADBLOCK_URL_SEPARATOR,
+            ].join(EMPTY);
+        }
+        else if (ruleNode.domains.children.length > 1) {
+            // TODO: Add support for multiple domains, for example:
+            // example.com,example.org,example.net##^responseheader(header-name)
+            // We should consider allowing $domain with $removeheader modifier,
+            // for example:
+            // $removeheader=header-name,domain=example.com|example.org|example.net
+            throw new RuleConversionError('Multiple domains are not supported yet');
+        }
+        // Prepare network rule modifiers
+        const modifiers = createModifierListNode();
+        modifiers.children.push(createModifierNode(ADG_REMOVEHEADER_MODIFIER, CssTree.generateFunctionValue(fromPlainObject(ruleNode.body.body))));
+        // Construct the network rule
+        return [
+            createNetworkRuleNode(pattern, modifiers, 
+            // Copy the exception flag
+            ruleNode.exception, AdblockSyntax.Adg),
+        ];
+    }
+}
+
+/**
+ * @file Cosmetic rule converter
+ */
+/**
+ * Cosmetic rule converter class (also known as "non-basic rule converter")
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class CosmeticRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a cosmetic rule to AdGuard syntax, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Clone the provided AST node to avoid side effects
+        const ruleNode = cloneDeep(rule);
+        // Convert cosmetic rule modifiers
+        if (ruleNode.modifiers) {
+            if (ruleNode.syntax === AdblockSyntax.Ubo) {
+                // uBO doesn't support this rule:
+                // example.com##+js(set-constant.js, foo, bar):matches-path(/baz)
+                if (ruleNode.type === CosmeticRuleType.ScriptletInjectionRule) {
+                    throw new RuleConversionError('uBO scriptlet injection rules don\'t support cosmetic rule modifiers');
+                }
+                ruleNode.modifiers = AdgCosmeticRuleModifierConverter.convertFromUbo(ruleNode.modifiers);
+            }
+            else if (ruleNode.syntax === AdblockSyntax.Abp) {
+                // TODO: Implement once ABP starts supporting cosmetic rule modifiers
+                throw new RuleConversionError('ABP don\'t support cosmetic rule modifiers');
+            }
+        }
+        // Convert cosmetic rule based on its type
+        switch (ruleNode.type) {
+            case CosmeticRuleType.ElementHidingRule:
+                return ElementHidingRuleConverter.convertToAdg(ruleNode);
+            case CosmeticRuleType.ScriptletInjectionRule:
+                return ScriptletRuleConverter.convertToAdg(ruleNode);
+            case CosmeticRuleType.CssInjectionRule:
+                return CssInjectionRuleConverter.convertToAdg(ruleNode);
+            case CosmeticRuleType.HtmlFilteringRule:
+                // Handle special case: uBO response header filtering rule
+                if (ruleNode.body.body.type === CssTreeNodeType.Function
+                    && ruleNode.body.body.name === UBO_RESPONSEHEADER_MARKER) {
+                    return HeaderRemovalRuleConverter.convertToAdg(ruleNode);
+                }
+                return HtmlRuleConverter.convertToAdg(ruleNode);
+            // Note: Currently, only ADG supports JS injection rules
+            case CosmeticRuleType.JsInjectionRule:
+                return [ruleNode];
+            default:
+                throw new RuleConversionError('Unsupported cosmetic rule type');
+        }
+    }
+}
+
+/**
+ * @file Network rule modifier list converter.
+ */
+/**
+ * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#csp-modifier}
+ */
+const CSP_MODIFIER = 'csp';
+const CSP_SEPARATOR = SEMICOLON + SPACE;
+/**
+ * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#csp-modifier}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy}
+ */
+const COMMON_CSP_PARAMS = '\'self\' \'unsafe-eval\' http: https: data: blob: mediastream: filesystem:';
+/**
+ * @see {@link https://help.adblockplus.org/hc/en-us/articles/360062733293#rewrite}
+ */
+const ABP_REWRITE_MODIFIER = 'rewrite';
+/**
+ * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#redirect-modifier}
+ */
+const REDIRECT_MODIFIER = 'redirect';
+/**
+ * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#redirect-rule-modifier}
+ */
+const REDIRECT_RULE_MODIFIER = 'redirect-rule';
+/**
+ * Redirect-related modifiers.
+ */
+const REDIRECT_MODIFIERS = new Set([
+    ABP_REWRITE_MODIFIER,
+    REDIRECT_MODIFIER,
+    REDIRECT_RULE_MODIFIER,
+]);
+/**
+ * Conversion map for ADG network rule modifiers.
+ */
+const ADG_CONVERSION_MAP = new Map([
+    ['1p', [{ name: () => 'third-party', exception: (actual) => !actual }]],
+    ['3p', [{ name: () => 'third-party' }]],
+    ['css', [{ name: () => 'stylesheet' }]],
+    ['doc', [{ name: () => 'document' }]],
+    ['ehide', [{ name: () => 'elemhide' }]],
+    ['empty', [{ name: () => 'redirect', value: () => 'nooptext' }]],
+    ['first-party', [{ name: () => 'third-party', exception: (actual) => !actual }]],
+    ['frame', [{ name: () => 'subdocument' }]],
+    ['ghide', [{ name: () => 'generichide' }]],
+    ['inline-font', [{ name: () => CSP_MODIFIER, value: () => `font-src ${COMMON_CSP_PARAMS}` }]],
+    ['inline-script', [{ name: () => CSP_MODIFIER, value: () => `script-src ${COMMON_CSP_PARAMS}` }]],
+    ['mp4', [{ name: () => 'redirect', value: () => 'noopmp4-1s' }, { name: () => 'media', value: () => undefined }]],
+    ['queryprune', [{ name: () => 'removeparam' }]],
+    ['shide', [{ name: () => 'specifichide' }]],
+    ['xhr', [{ name: () => 'xmlhttprequest' }]],
+]);
+/**
+ * Helper class for converting network rule modifier lists.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class NetworkRuleModifierListConverter extends ConverterBase {
+    /**
+     * Converts a network rule modifier list to AdGuard format, if possible.
+     *
+     * @param modifierList Network rule modifier list node to convert
+     * @returns Converted modifier list node
+     * @throws If the conversion is not possible
+     */
+    static convertToAdg(modifierList) {
+        // Clone the provided AST node to avoid side effects
+        const modifierListNode = cloneDeep(modifierList);
+        const convertedModifierList = createModifierListNode();
+        // We should merge $csp modifiers into one
+        const cspValues = [];
+        modifierListNode.children.forEach((modifierNode) => {
+            // Handle regular modifiers conversion and $csp modifiers collection
+            const modifierConversions = ADG_CONVERSION_MAP.get(modifierNode.modifier.value);
+            if (modifierConversions) {
+                for (const modifierConversion of modifierConversions) {
+                    const name = modifierConversion.name(modifierNode.modifier.value);
+                    const exception = modifierConversion.exception
+                        // If the exception value is undefined in the original modifier, it
+                        // means that the modifier isn't negated
+                        ? modifierConversion.exception(modifierNode.exception || false)
+                        : modifierNode.exception;
+                    const value = modifierConversion.value
+                        ? modifierConversion.value(modifierNode.value?.value)
+                        : modifierNode.value?.value;
+                    if (name === CSP_MODIFIER && value) {
+                        // Special case: collect $csp values
+                        cspValues.push(value);
+                    }
+                    else {
+                        // Regular case: collect the converted modifiers, if the modifier list
+                        // not already contains the same modifier
+                        const existingModifier = convertedModifierList.children.find((m) => m.modifier.value === name && m.exception === exception && m.value?.value === value);
+                        if (!existingModifier) {
+                            convertedModifierList.children.push(createModifierNode(name, value, exception));
+                        }
+                    }
+                }
+                return;
+            }
+            // Handle special case: resource redirection modifiers
+            if (REDIRECT_MODIFIERS.has(modifierNode.modifier.value)) {
+                // Redirect modifiers can't be negated
+                if (modifierNode.exception === true) {
+                    throw new RuleConversionError(`Modifier '${modifierNode.modifier.value}' cannot be negated`);
+                }
+                // Convert the redirect resource name to ADG format
+                const redirectResource = modifierNode.value?.value;
+                if (!redirectResource) {
+                    throw new RuleConversionError(`No redirect resource specified for '${modifierNode.modifier.value}' modifier`);
+                }
+                // Leave $redirect and $redirect-rule modifiers as is, but convert $rewrite to $redirect
+                const modifierName = modifierNode.modifier.value === ABP_REWRITE_MODIFIER
+                    ? REDIRECT_MODIFIER
+                    : modifierNode.modifier.value;
+                // Try to convert the redirect resource name to ADG format
+                // This function returns undefined if the resource name is unknown
+                const convertedRedirectResource = redirects.convertRedirectNameToAdg(redirectResource);
+                convertedModifierList.children.push(createModifierNode(modifierName, 
+                // If the redirect resource name is unknown, fall back to the original one
+                // Later, the validator will throw an error if the resource name is invalid
+                convertedRedirectResource || redirectResource, modifierNode.exception));
+                return;
+            }
+            // In all other cases, just copy the modifier as is, if the modifier list
+            // not already contains the same modifier
+            const existingModifier = convertedModifierList.children.find((m) => m.modifier.value === modifierNode.modifier.value
+                && m.exception === modifierNode.exception
+                && m.value?.value === modifierNode.value?.value);
+            if (!existingModifier) {
+                convertedModifierList.children.push(modifierNode);
+            }
+        });
+        // Merge $csp modifiers into one, then add it to the converted modifier list
+        if (cspValues.length > 0) {
+            convertedModifierList.children.push(createModifierNode(CSP_MODIFIER, cspValues.join(CSP_SEPARATOR)));
+        }
+        return convertedModifierList;
+    }
+}
+
+/**
+ * @file Network rule converter
+ */
+/**
+ * Network rule converter class (also known as "basic rule converter")
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class NetworkRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a network rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Clone the provided AST node to avoid side effects
+        const ruleNode = cloneDeep(rule);
+        // Convert modifiers
+        if (ruleNode.modifiers) {
+            Object.assign(ruleNode.modifiers, NetworkRuleModifierListConverter.convertToAdg(ruleNode.modifiers));
+        }
+        return [ruleNode];
+    }
+}
+
+/**
+ * @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`
+ */
+class RuleConverter extends RuleConverterBase {
+    /**
+     * Converts an adblock filtering rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns Array of converted rule nodes
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Clone the provided AST node to avoid side effects
+        const ruleNode = cloneDeep(rule);
+        // Delegate conversion to the corresponding sub-converter
+        // based on the rule category
+        switch (ruleNode.category) {
+            case RuleCategory.Comment:
+                return CommentRuleConverter.convertToAdg(ruleNode);
+            case RuleCategory.Cosmetic:
+                return CosmeticRuleConverter.convertToAdg(ruleNode);
+            case RuleCategory.Network:
+                return NetworkRuleConverter.convertToAdg(ruleNode);
+            default:
+                throw new RuleConversionError(`Unknown rule category: ${ruleNode.category}`);
+        }
+    }
+}
+
+/**
+ * @file Utility functions for working with filter list nodes
+ */
+/**
+ * Creates a filter list node
+ *
+ * @param rules Rules to put in the list (optional, defaults to an empty list)
+ * @returns Filter list node
+ */
+function createFilterListNode(rules = []) {
+    const result = {
+        type: 'FilterList',
+        children: [],
+    };
+    // We need to clone the rules to avoid side effects
+    if (rules.length > 0) {
+        result.children = cloneDeep(rules);
+    }
+    return result;
+}
+
+/**
+ * @file Adblock filter list converter
+ */
+/**
+ * Adblock filter list converter class
+ *
+ * This class just provides an extra layer on top of the {@link RuleConverter}
+ * and can be used to convert entire filter lists.
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ * @todo Implement tolerant mode, which will allow to convert a filter list
+ * even if some of its rules are invalid
+ */
+class FilterListConverter extends ConverterBase {
+    /**
+     * Converts an adblock filter list to AdGuard format, if possible.
+     *
+     * @param filterListNode Filter list node to convert
+     * @returns Converted filter list node
+     * @throws If the filter list is invalid or cannot be converted
+     */
+    static convertToAdg(filterListNode) {
+        const result = createFilterListNode();
+        // Iterate over the filtering rules and convert them one by one,
+        // then add them to the result (one conversion may result in multiple rules)
+        for (const ruleNode of filterListNode.children) {
+            const convertedRules = RuleConverter.convertToAdg(ruleNode);
+            result.children.push(...convertedRules);
+        }
+        return result;
+    }
+}
+
 /**
  * @file Utility functions for domain and hostname validation.
  */
@@ -4949,7 +8875,7 @@ class LogicalExpressionUtils {
     }
 }
 
-const version$1 = "1.0.1";
+const version$1 = "1.1.1";
 
 /**
  * @file AGTree version
@@ -4960,4 +8886,4 @@ const version$1 = "1.0.1";
 // with wrong relative path to `package.json`. So we need this little "hack"
 const version = version$1;
 
-export { AdblockSyntaxError, AgentCommentRuleParser, AgentParser, CommentMarker, CommentRuleParser, CommentRuleType, ConfigCommentRuleParser, CosmeticRuleParser, CosmeticRuleType, DomainListParser, DomainUtils, FilterListParser, HintCommentRuleParser, HintParser, LogicalExpressionParser, LogicalExpressionUtils, MetadataCommentRuleParser, ModifierListParser, ModifierParser, NetworkRuleParser, ParameterListParser, PreProcessorCommentRuleParser, RuleCategory, RuleParser, 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, AgentCommentRuleParser, AgentParser, CLASSIC_DOMAIN_SEPARATOR, CommentMarker, CommentRuleParser, CommentRuleType, ConfigCommentRuleParser, CosmeticRuleParser, CosmeticRuleSeparator, CosmeticRuleSeparatorUtils, CosmeticRuleType, CssTree, CssTreeNodeType, CssTreeParserContext, DOMAIN_EXCEPTION_MARKER, DomainListParser, DomainUtils, EXT_CSS_LEGACY_ATTRIBUTES, EXT_CSS_PSEUDO_CLASSES, FORBIDDEN_CSS_FUNCTIONS, FilterListConverter, FilterListParser, HINT_MARKER, HintCommentRuleParser, HintParser, IF, INCLUDE, LogicalExpressionParser, LogicalExpressionUtils, METADATA_HEADERS, MODIFIERS_SEPARATOR, MODIFIER_ASSIGN_OPERATOR, MODIFIER_DOMAIN_SEPARATOR, MODIFIER_EXCEPTION_MARKER, MetadataCommentRuleParser, ModifierListParser, ModifierParser, NETWORK_RULE_EXCEPTION_MARKER, NETWORK_RULE_SEPARATOR, NetworkRuleParser, NotImplementedError, PREPROCESSOR_MARKER, ParameterListParser, PreProcessorCommentRuleParser, QuoteType, QuoteUtils, RegExpUtils, RuleCategory, RuleConversionError, RuleConverter, RuleParser, SAFARI_CB_AFFINITY, SPECIAL_REGEX_SYMBOLS, UBO_SCRIPTLET_MASK, locRange, modifierValidator, shiftLoc, version };