@adguard/agtree 2.1.3 → 3.0.0

package/dist/esm/parser/cosmetic/cosmetic-rule-parser.mjs

@@ -0,0 +1,453 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { sprintf } from 'sprintf-js';
+import { CosmeticRuleSeparatorUtils } from '../../utils/cosmetic-rule-separator.mjs';
+import { AdblockSyntax } from '../../utils/adblockers.mjs';
+import { DomainListParser } from '../misc/domain-list-parser.mjs';
+import { ModifierListParser } from '../misc/modifier-list.mjs';
+import { OPEN_SQUARE_BRACKET, DOLLAR_SIGN, CLOSE_SQUARE_BRACKET, UBO_SCRIPTLET_MASK, UBO_SCRIPTLET_MASK_LEGACY, ADG_SCRIPTLET_MASK, UBO_HTML_MASK } from '../../utils/constants.mjs';
+import { RuleCategory, CosmeticRuleType } from '../../nodes/index.mjs';
+import { AdblockSyntaxError } from '../../errors/adblock-syntax-error.mjs';
+import { StringUtils } from '../../utils/string.mjs';
+import { CommentParser } from '../comment/comment-parser.mjs';
+import { defaultParserOptions } from '../options.mjs';
+import { UboSelectorParser } from '../css/ubo-selector-parser.mjs';
+import { AdgCssInjectionParser } from '../css/adg-css-injection-parser.mjs';
+import { AbpSnippetInjectionBodyParser } from './body/abp-snippet-injection-body-parser.mjs';
+import { UboScriptletInjectionBodyParser } from './body/ubo-scriptlet-injection-body-parser.mjs';
+import { AdgScriptletInjectionBodyParser } from './body/adg-scriptlet-injection-body-parser.mjs';
+import { BaseParser } from '../base-parser.mjs';
+import { UboPseudoName } from '../../common/ubo-selector-common.mjs';
+
+/**
+ * Possible error messages for uBO selectors. Formatted with {@link sprintf}.
+ */
+const ERROR_MESSAGES = {
+    EMPTY_RULE_BODY: 'Empty rule body',
+    INVALID_BODY_FOR_SEPARATOR: "Body '%s' is not valid for the '%s' cosmetic rule separator",
+    MISSING_ADGUARD_MODIFIER_LIST_END: "Missing '%s' at the end of the AdGuard modifier list in pattern '%s'",
+    MISSING_ADGUARD_MODIFIER_LIST_MARKER: "Missing '%s' at the beginning of the AdGuard modifier list in pattern '%s'",
+    SYNTAXES_CANNOT_BE_MIXED: "'%s' syntax cannot be mixed with '%s' syntax",
+    SYNTAX_DISABLED: "Parsing '%s' syntax is disabled, but the rule uses it",
+};
+const ADG_CSS_INJECTION_PATTERN = /^(?:.+){(?:.+)}$/;
+/**
+ * `CosmeticRuleParser` is responsible for parsing cosmetic rules.
+ *
+ * Where possible, it automatically detects the difference between supported syntaxes:
+ *  - AdGuard
+ *  - uBlock Origin
+ *  - Adblock Plus
+ *
+ * If the syntax is common / cannot be determined, the parser gives `Common` syntax.
+ *
+ * Please note that syntactically correct rules are parsed even if they are not actually
+ * compatible with the given adblocker. This is a completely natural behavior, meaningful
+ * checking of compatibility is not done at the parser level.
+ */
+// TODO: Make raw body parsing optional
+// TODO: Split into smaller sections
+class CosmeticRuleParser extends BaseParser {
+    /**
+     * Determines whether a rule is a cosmetic rule. The rule is considered cosmetic if it
+     * contains a cosmetic rule separator.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is a cosmetic rule, `false` otherwise
+     */
+    static isCosmeticRule(raw) {
+        const trimmed = raw.trim();
+        if (CommentParser.isCommentRule(trimmed)) {
+            return false;
+        }
+        return CosmeticRuleSeparatorUtils.find(trimmed) !== null;
+    }
+    /**
+     * Parses a cosmetic rule. The structure of the cosmetic rules:
+     *  - pattern (AdGuard pattern can have modifiers, other syntaxes don't)
+     *  - separator
+     *  - body
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns
+     * Parsed cosmetic rule AST or null if it failed to parse based on the known cosmetic rules
+     * @throws If the input matches the cosmetic rule pattern but syntactically invalid
+     */
+    // TODO: Split to smaller functions
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        // Find cosmetic rule separator - each cosmetic rule must have it, otherwise it is not a cosmetic rule
+        const separatorResult = CosmeticRuleSeparatorUtils.find(raw);
+        if (!separatorResult) {
+            return null;
+        }
+        let syntax = AdblockSyntax.Common;
+        let modifiers;
+        const patternStart = StringUtils.skipWS(raw);
+        const patternEnd = StringUtils.skipWSBack(raw, separatorResult.start - 1) + 1;
+        const bodyStart = StringUtils.skipWS(raw, separatorResult.end);
+        const bodyEnd = StringUtils.skipWSBack(raw) + 1;
+        // Note we use '<=' instead of '===' because we have bidirectional trim
+        if (bodyEnd <= bodyStart) {
+            throw new AdblockSyntaxError(ERROR_MESSAGES.EMPTY_RULE_BODY, baseOffset, baseOffset + raw.length);
+        }
+        // Step 1. Parse the pattern: it can be a domain list or a domain list with modifiers (AdGuard)
+        const rawPattern = raw.slice(patternStart, patternEnd);
+        let patternOffset = patternStart;
+        if (rawPattern[patternOffset] === OPEN_SQUARE_BRACKET) {
+            // Save offset to the beginning of the modifier list for later
+            const modifierListStart = patternOffset;
+            // Consume opening square bracket
+            patternOffset += 1;
+            // Skip whitespace after opening square bracket
+            patternOffset = StringUtils.skipWS(rawPattern, patternOffset);
+            // Open square bracket should be followed by a modifier separator: [$
+            if (rawPattern[patternOffset] !== DOLLAR_SIGN) {
+                throw new AdblockSyntaxError(sprintf(ERROR_MESSAGES.MISSING_ADGUARD_MODIFIER_LIST_MARKER, DOLLAR_SIGN, rawPattern), baseOffset + patternOffset, baseOffset + rawPattern.length);
+            }
+            // Consume modifier separator
+            patternOffset += 1;
+            // Skip whitespace after modifier separator
+            patternOffset = StringUtils.skipWS(rawPattern, patternOffset);
+            // Modifier list ends with the last unescaped square bracket
+            // We search for the last unescaped square bracket, because some modifiers can contain square brackets,
+            // e.g. [$domain=/example[0-9]\.(com|org)/]##.ad
+            const modifierListEnd = StringUtils.findLastUnescapedCharacter(rawPattern, CLOSE_SQUARE_BRACKET);
+            if (modifierListEnd === -1) {
+                throw new AdblockSyntaxError(sprintf(ERROR_MESSAGES.MISSING_ADGUARD_MODIFIER_LIST_END, CLOSE_SQUARE_BRACKET, rawPattern), baseOffset + patternOffset, baseOffset + rawPattern.length);
+            }
+            // Parse modifier list
+            modifiers = ModifierListParser.parse(raw.slice(patternOffset, modifierListEnd), options, baseOffset + patternOffset);
+            // Expand modifier list location to include the opening and closing square brackets
+            if (options.isLocIncluded) {
+                modifiers.start = baseOffset + modifierListStart;
+                modifiers.end = baseOffset + modifierListEnd + 1;
+            }
+            // Consume modifier list
+            patternOffset = modifierListEnd + 1;
+            // Change the syntax to ADG
+            syntax = AdblockSyntax.Adg;
+        }
+        // Skip whitespace after modifier list
+        patternOffset = StringUtils.skipWS(rawPattern, patternOffset);
+        // Parse domains
+        const domains = DomainListParser.parse(rawPattern.slice(patternOffset), options, baseOffset + patternOffset);
+        // Step 2. Parse the separator
+        const separator = {
+            type: 'Value',
+            value: separatorResult.separator,
+        };
+        if (options.isLocIncluded) {
+            separator.start = baseOffset + separatorResult.start;
+            separator.end = baseOffset + separatorResult.end;
+        }
+        const exception = CosmeticRuleSeparatorUtils.isException(separatorResult.separator);
+        // Step 3. Parse the rule body
+        let rawBody = raw.slice(bodyStart, bodyEnd);
+        /**
+         * Ensures that the rule syntax is common or the expected one. This function is used to prevent mixing
+         * different syntaxes in the same rule.
+         *
+         * @example
+         * The following rule mixes AdGuard and uBO syntaxes, because it uses AdGuard modifier list and uBO
+         * CSS injection:
+         * ```adblock
+         * [$path=/something]example.com##.foo:style(color: red)
+         * ```
+         * In this case, parser sets syntax to AdGuard, because it detects the AdGuard modifier list, but
+         * when parsing the rule body, it detects uBO CSS injection, which is not compatible with AdGuard.
+         *
+         * @param expectedSyntax Expected syntax
+         * @throws If the rule syntax is not common or the expected one
+         */
+        const expectCommonOrSpecificSyntax = (expectedSyntax) => {
+            if (syntax !== AdblockSyntax.Common && syntax !== expectedSyntax) {
+                throw new AdblockSyntaxError(sprintf(ERROR_MESSAGES.SYNTAXES_CANNOT_BE_MIXED, expectedSyntax, syntax), baseOffset + patternStart, baseOffset + bodyEnd);
+            }
+        };
+        let uboSelector;
+        // Parse UBO rule modifiers
+        if (options.parseUboSpecificRules) {
+            uboSelector = UboSelectorParser.parse(rawBody, options, baseOffset + bodyStart);
+            rawBody = uboSelector.selector.value;
+            // Do not allow ADG modifiers and UBO modifiers in the same rule
+            if (uboSelector.modifiers && uboSelector.modifiers.children.length > 0) {
+                // If modifiers are present, that means that the ADG modifier list was parsed
+                expectCommonOrSpecificSyntax(AdblockSyntax.Ubo);
+                // Change the syntax to uBO
+                syntax = AdblockSyntax.Ubo;
+                // Store the rule modifiers
+                // Please note that not each special uBO modifier is a rule modifier, some of them are
+                // used for CSS injection, for example `:style()` and `:remove()`
+                for (const modifier of uboSelector.modifiers.children) {
+                    // TODO: Add support for matches-media and element hiding rules
+                    // TODO: Improve this condition if new uBO modifiers are added
+                    if (modifier.name.value === UboPseudoName.MatchesPath) {
+                        // Prepare the modifier list if it does not exist yet
+                        if (!modifiers) {
+                            modifiers = {
+                                type: 'ModifierList',
+                                children: [],
+                            };
+                            if (options.isLocIncluded) {
+                                modifiers.start = baseOffset + bodyStart;
+                                modifiers.end = baseOffset + bodyEnd;
+                            }
+                        }
+                        modifiers.children.push(modifier);
+                    }
+                }
+            }
+        }
+        const raws = {
+            text: raw,
+        };
+        const baseRule = {
+            category: RuleCategory.Cosmetic,
+            exception,
+            modifiers,
+            domains,
+            separator,
+        };
+        if (options.includeRaws) {
+            baseRule.raws = raws;
+        }
+        if (options.isLocIncluded) {
+            baseRule.start = baseOffset;
+            baseRule.end = baseOffset + raw.length;
+        }
+        const parseUboCssInjection = () => {
+            if (!uboSelector || !uboSelector.modifiers || uboSelector.modifiers.children?.length < 1) {
+                return null;
+            }
+            expectCommonOrSpecificSyntax(AdblockSyntax.Ubo);
+            const selectorList = uboSelector.selector;
+            let declarationList;
+            let mediaQueryList;
+            let remove = false;
+            for (const modifier of uboSelector.modifiers.children) {
+                switch (modifier.name.value) {
+                    case UboPseudoName.Style:
+                        declarationList = modifier.value;
+                        break;
+                    case UboPseudoName.Remove:
+                        declarationList = {
+                            type: 'Value',
+                            value: '',
+                        };
+                        remove = true;
+                        break;
+                    case UboPseudoName.MatchesMedia:
+                        mediaQueryList = modifier.value;
+                        break;
+                }
+            }
+            // If neither `:style()` nor `:remove()` is present
+            if (!declarationList) {
+                return null;
+            }
+            const body = {
+                type: 'CssInjectionRuleBody',
+                selectorList,
+                declarationList,
+                mediaQueryList,
+                remove,
+            };
+            if (options.isLocIncluded) {
+                body.start = baseOffset + bodyStart;
+                body.end = baseOffset + bodyEnd;
+            }
+            return {
+                syntax: AdblockSyntax.Ubo,
+                type: CosmeticRuleType.CssInjectionRule,
+                body,
+            };
+        };
+        const parseElementHiding = () => {
+            const selectorList = {
+                type: 'Value',
+                value: rawBody,
+            };
+            if (options.isLocIncluded) {
+                selectorList.start = baseOffset + bodyStart;
+                selectorList.end = baseOffset + bodyEnd;
+            }
+            const body = {
+                type: 'ElementHidingRuleBody',
+                selectorList,
+            };
+            if (options.isLocIncluded) {
+                body.start = baseOffset + bodyStart;
+                body.end = baseOffset + bodyEnd;
+            }
+            return {
+                syntax,
+                type: CosmeticRuleType.ElementHidingRule,
+                body,
+            };
+        };
+        const parseAdgCssInjection = () => {
+            // TODO: Improve this detection. Need to cover the following cases:
+            // #$#body { color: red;
+            // #$#@media (min-width: 100px) { body { color: red; }
+            // ADG CSS injection
+            if (!ADG_CSS_INJECTION_PATTERN.test(rawBody)) {
+                return null;
+            }
+            expectCommonOrSpecificSyntax(AdblockSyntax.Adg);
+            return {
+                syntax: AdblockSyntax.Adg,
+                type: CosmeticRuleType.CssInjectionRule,
+                body: AdgCssInjectionParser.parse(rawBody, options, baseOffset + bodyStart),
+            };
+        };
+        const parseAbpSnippetInjection = () => {
+            if (!options.parseAbpSpecificRules) {
+                throw new AdblockSyntaxError(sprintf(ERROR_MESSAGES.SYNTAX_DISABLED, AdblockSyntax.Abp), baseOffset + bodyStart, baseOffset + bodyEnd);
+            }
+            expectCommonOrSpecificSyntax(AdblockSyntax.Abp);
+            const body = AbpSnippetInjectionBodyParser.parse(rawBody, options, baseOffset + bodyStart);
+            if (options.isLocIncluded) {
+                body.start = baseOffset + bodyStart;
+                body.end = baseOffset + bodyEnd;
+            }
+            return {
+                syntax: AdblockSyntax.Abp,
+                type: CosmeticRuleType.ScriptletInjectionRule,
+                body,
+            };
+        };
+        const parseUboScriptletInjection = () => {
+            if (!rawBody.startsWith(UBO_SCRIPTLET_MASK) && !rawBody.startsWith(UBO_SCRIPTLET_MASK_LEGACY)) {
+                return null;
+            }
+            if (!options.parseUboSpecificRules) {
+                throw new AdblockSyntaxError(sprintf(ERROR_MESSAGES.SYNTAX_DISABLED, AdblockSyntax.Ubo), baseOffset + bodyStart, baseOffset + bodyEnd);
+            }
+            expectCommonOrSpecificSyntax(AdblockSyntax.Ubo);
+            const body = UboScriptletInjectionBodyParser.parse(rawBody, options, baseOffset + bodyStart);
+            if (options.isLocIncluded) {
+                body.start = baseOffset + bodyStart;
+                body.end = baseOffset + bodyEnd;
+            }
+            return {
+                syntax: AdblockSyntax.Ubo,
+                type: CosmeticRuleType.ScriptletInjectionRule,
+                body,
+            };
+        };
+        const parseAdgScriptletInjection = () => {
+            // ADG scriptlet injection
+            if (!rawBody.startsWith(ADG_SCRIPTLET_MASK)) {
+                return null;
+            }
+            expectCommonOrSpecificSyntax(AdblockSyntax.Adg);
+            const body = AdgScriptletInjectionBodyParser.parse(rawBody, options, baseOffset + bodyStart);
+            if (options.isLocIncluded) {
+                body.start = baseOffset + bodyStart;
+                body.end = baseOffset + bodyEnd;
+            }
+            return {
+                syntax: AdblockSyntax.Adg,
+                type: CosmeticRuleType.ScriptletInjectionRule,
+                body,
+            };
+        };
+        const parseAdgJsInjection = () => {
+            expectCommonOrSpecificSyntax(AdblockSyntax.Adg);
+            const body = {
+                type: 'Value',
+                value: rawBody,
+            };
+            if (options.isLocIncluded) {
+                body.start = baseOffset + bodyStart;
+                body.end = baseOffset + bodyEnd;
+            }
+            return {
+                syntax: AdblockSyntax.Adg,
+                type: CosmeticRuleType.JsInjectionRule,
+                body,
+            };
+        };
+        const parseUboHtmlFiltering = () => {
+            if (!rawBody.startsWith(UBO_HTML_MASK)) {
+                return null;
+            }
+            if (!options.parseUboSpecificRules) {
+                throw new AdblockSyntaxError(sprintf(ERROR_MESSAGES.SYNTAX_DISABLED, AdblockSyntax.Ubo), baseOffset + bodyStart, baseOffset + bodyEnd);
+            }
+            expectCommonOrSpecificSyntax(AdblockSyntax.Ubo);
+            const body = {
+                type: 'Value',
+                value: rawBody,
+            };
+            if (options.isLocIncluded) {
+                body.start = baseOffset + bodyStart;
+                body.end = baseOffset + bodyEnd;
+            }
+            return {
+                syntax: AdblockSyntax.Ubo,
+                type: CosmeticRuleType.HtmlFilteringRule,
+                body,
+            };
+        };
+        const parseAdgHtmlFiltering = () => {
+            expectCommonOrSpecificSyntax(AdblockSyntax.Adg);
+            const body = {
+                type: 'Value',
+                value: rawBody,
+            };
+            if (options.isLocIncluded) {
+                body.start = baseOffset + bodyStart;
+                body.end = baseOffset + bodyEnd;
+            }
+            return {
+                syntax: AdblockSyntax.Adg,
+                type: CosmeticRuleType.HtmlFilteringRule,
+                body,
+            };
+        };
+        // Create a fast lookup table for cosmetic rule separators and their parsing functions.
+        // One separator can have multiple parsing functions. If the first function returns null,
+        // the next function is called, and so on.
+        // If all functions return null, an error should be thrown.
+        const separatorMap = {
+            '##': [parseUboHtmlFiltering, parseUboScriptletInjection, parseUboCssInjection, parseElementHiding],
+            '#@#': [parseUboHtmlFiltering, parseUboScriptletInjection, parseUboCssInjection, parseElementHiding],
+            '#?#': [parseUboCssInjection, parseElementHiding],
+            '#@?#': [parseUboCssInjection, parseElementHiding],
+            '#$#': [parseAdgCssInjection, parseAbpSnippetInjection],
+            '#@$#': [parseAdgCssInjection, parseAbpSnippetInjection],
+            '#$?#': [parseAdgCssInjection],
+            '#@$?#': [parseAdgCssInjection],
+            '#%#': [parseAdgScriptletInjection, parseAdgJsInjection],
+            '#@%#': [parseAdgScriptletInjection, parseAdgJsInjection],
+            $$: [parseAdgHtmlFiltering],
+            '$@$': [parseAdgHtmlFiltering],
+        };
+        const parseFunctions = separatorMap[separatorResult.separator];
+        let restProps;
+        for (const parseFunction of parseFunctions) {
+            restProps = parseFunction();
+            if (restProps) {
+                break;
+            }
+        }
+        // If none of the parsing functions returned a result, it means that the rule is unknown / invalid.
+        if (!restProps) {
+            throw new AdblockSyntaxError(sprintf(ERROR_MESSAGES.INVALID_BODY_FOR_SEPARATOR, rawBody, separatorResult.separator), baseOffset + bodyStart, baseOffset + bodyEnd);
+        }
+        // Combine the base rule with the rest of the properties.
+        return {
+            ...baseRule,
+            ...restProps,
+        };
+    }
+}
+
+export { CosmeticRuleParser, ERROR_MESSAGES };

package/dist/esm/parser/css/adg-css-injection-parser.mjs

@@ -0,0 +1,208 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { TokenType } from '@adguard/css-tokenizer';
+import { AdblockSyntaxError } from '../../errors/adblock-syntax-error.mjs';
+import { CSS_MEDIA_MARKER, EMPTY } from '../../utils/constants.mjs';
+import { CssTokenStream } from './css-token-stream.mjs';
+import { defaultParserOptions } from '../options.mjs';
+import { BaseParser } from '../base-parser.mjs';
+
+/**
+ * @file Parser for AdGuard CSS injections.
+ */
+const REMOVE_PROPERTY = 'remove';
+const REMOVE_VALUE = 'true';
+const ERROR_MESSAGES = {
+    MEDIA_QUERY_LIST_IS_EMPTY: 'Media query list is empty',
+    SELECTOR_LIST_IS_EMPTY: 'Selector list is empty',
+    DECLARATION_LIST_IS_EMPTY: 'Declaration list is empty',
+};
+/**
+ * Parser for AdGuard CSS injection.
+ */
+class AdgCssInjectionParser extends BaseParser {
+    /**
+     * Parses an AdGuard CSS injection.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     *
+     * @returns Parsed AdGuard CSS injection {@link CssInjectionRuleBody}.
+     * @throws An {@link AdblockSyntaxError} if the selector list is syntactically invalid.
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        let mediaQueryList;
+        const selectorList = { type: 'Value', value: EMPTY };
+        const declarationList = { type: 'Value', value: EMPTY };
+        const stream = new CssTokenStream(raw, baseOffset);
+        // Skip leading whitespace characters
+        stream.skipWhitespace();
+        // We have two possible CSS injection formats:
+        // 1. @media (media-query-list) { selector list { declarations separated by semicolons } }
+        // 2. selector list { declarations separated by semicolons }
+        // Handle '@media' case:
+        let balanceShift = 0;
+        if (stream.getOrFail().type === TokenType.AtKeyword) {
+            // Currently only '@media' is supported, we should throw an error if we encounter anything else,
+            // like '@supports' or '@charset', etc.
+            stream.expect(TokenType.AtKeyword, { value: CSS_MEDIA_MARKER, balance: 0 });
+            stream.advance();
+            // Skip whitespace characters after @media keyword, if any
+            // @media (media-query-list) { ...
+            //       ↑
+            //       └ this one (if any)
+            stream.skipWhitespace();
+            const mediaQueryListStart = stream.getOrFail().start;
+            // Skip everything until we found the opening curly bracket of the declaration block
+            // @media media-query-list { ...
+            //                         ↑
+            //                         └ this one
+            let lastNonWsIndex = -1;
+            while (!stream.isEof()) {
+                const token = stream.getOrFail();
+                if (token.type === TokenType.OpenCurlyBracket && token.balance === 1) {
+                    break;
+                }
+                if (token.type !== TokenType.Whitespace) {
+                    lastNonWsIndex = token.end;
+                }
+                stream.advance();
+            }
+            // If the skipped tokens count is 0 without leading and trailing whitespace characters, then the media query
+            // list is empty
+            if (lastNonWsIndex === -1) {
+                throw new AdblockSyntaxError(ERROR_MESSAGES.MEDIA_QUERY_LIST_IS_EMPTY, baseOffset + mediaQueryListStart, baseOffset + raw.length);
+            }
+            // It is safe to use non-null assertion here, because we have already checked previous tokens.
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const mediaQueryListEnd = lastNonWsIndex;
+            mediaQueryList = {
+                type: 'Value',
+                value: raw.slice(mediaQueryListStart, mediaQueryListEnd),
+            };
+            if (options.isLocIncluded) {
+                mediaQueryList.start = baseOffset + mediaQueryListStart;
+                mediaQueryList.end = baseOffset + mediaQueryListEnd;
+            }
+            // Next token should be an open curly bracket
+            // @media (media-query-list) { ...
+            //                           ↑
+            //                           └ this one
+            stream.expect(TokenType.OpenCurlyBracket);
+            stream.advance();
+            // '@media' at-rule wrap increases the balance level by 1 for the rule within the at-rule, because it
+            // has its own { ... } block
+            balanceShift = 1;
+        }
+        // Skip leading whitespace before the rule, if any
+        // Note: rule = selector list { declarations separated by semicolons }
+        stream.skipWhitespace();
+        const selectorStart = stream.getOrFail().start;
+        // Jump to the opening curly bracket of the declaration block, based on the balance level
+        // .selector { padding-top: 10px; padding-bottom: 10px; }
+        //           ↑
+        //           └ this one
+        const { skippedTrimmed: selectorTokensLength } = stream.skipUntilExt(TokenType.OpenCurlyBracket, balanceShift + 1);
+        stream.expect(TokenType.OpenCurlyBracket);
+        // If the skipped tokens count is 0 without leading and trailing whitespace characters, then the selector list
+        // is empty
+        if (selectorTokensLength === 0) {
+            throw new AdblockSyntaxError(ERROR_MESSAGES.SELECTOR_LIST_IS_EMPTY, baseOffset + selectorStart, baseOffset + raw.length);
+        }
+        // It is safe to use non-null assertion here, because we have already checked previous tokens.
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const selectorEnd = stream.lookbehindForNonWs().end;
+        selectorList.value = raw.slice(selectorStart, selectorEnd);
+        if (options.isLocIncluded) {
+            selectorList.start = baseOffset + selectorStart;
+            selectorList.end = baseOffset + selectorEnd;
+        }
+        // Jump to the next token after the opening curly bracket of the declaration block
+        // .selector { padding-top: 10px; padding-bottom: 10px; }
+        //            ↑
+        //            └ this one
+        stream.advance();
+        // Skip whitespace characters after the opening curly bracket of the declaration block, if any
+        stream.skipWhitespace();
+        // Jump to the closing curly bracket of the declaration block, based on the balance level
+        // .selector { padding-top: 10px; padding-bottom: 10px; }
+        //                                                      ↑
+        //                                                      └ this one
+        const declarationsStart = stream.getOrFail().start;
+        const declarations = new Set();
+        let declarationsEnd = -1;
+        let remove = false;
+        let lastNonWsIndex = -1;
+        while (!stream.isEof()) {
+            const token = stream.getOrFail();
+            if (token.type === TokenType.CloseCurlyBracket && stream.getBalance() === balanceShift) {
+                declarationsEnd = lastNonWsIndex;
+                break;
+            }
+            if (token.type !== TokenType.Whitespace) {
+                lastNonWsIndex = token.end;
+            }
+            if (token.type === TokenType.Ident && stream.lookahead()?.type === TokenType.Colon) {
+                const ident = raw.slice(token.start, token.end);
+                declarations.add(ident);
+                // Consume ident and colon
+                stream.advance();
+                stream.advance();
+                // only 'remove: true' is allowed
+                if (ident === REMOVE_PROPERTY) {
+                    // Skip whitespace after colon, if any
+                    stream.skipWhitespace();
+                    // Next token should be an ident, with value 'true'
+                    stream.expect(TokenType.Ident, { value: REMOVE_VALUE });
+                    stream.advance();
+                    remove = true;
+                }
+            }
+            else {
+                stream.advance();
+            }
+        }
+        if (declarationsEnd === -1) {
+            throw new AdblockSyntaxError(ERROR_MESSAGES.DECLARATION_LIST_IS_EMPTY, baseOffset + declarationsStart, baseOffset + raw.length);
+        }
+        declarationList.value = raw.slice(declarationsStart, declarationsEnd);
+        if (options.isLocIncluded) {
+            declarationList.start = baseOffset + declarationsStart;
+            declarationList.end = baseOffset + declarationsEnd;
+        }
+        // Eat the close curly bracket of the declaration block
+        // .selector { padding-top: 10px; padding-bottom: 10px; }
+        //                                                      ↑
+        //                                                      └ this one
+        stream.expect(TokenType.CloseCurlyBracket);
+        stream.advance();
+        // Skip whitespace after the rule, if any
+        stream.skipWhitespace();
+        // If we have a media query, we should have an extra close curly bracket
+        if (balanceShift === 1) {
+            stream.expect(TokenType.CloseCurlyBracket);
+            stream.advance();
+        }
+        const result = {
+            type: 'CssInjectionRuleBody',
+            selectorList,
+            declarationList,
+            remove,
+        };
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        if (mediaQueryList) {
+            result.mediaQueryList = mediaQueryList;
+        }
+        return result;
+    }
+}
+
+export { AdgCssInjectionParser, ERROR_MESSAGES, REMOVE_PROPERTY, REMOVE_VALUE };