@adguard/agtree 2.2.0 → 3.0.0-alpha.2

package/dist/nodes/index.js

@@ -0,0 +1,168 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+const OperatorValue = {
+    Not: '!',
+    And: '&&',
+    Or: '||',
+};
+/**
+ * Represents the different comment markers that can be used in an adblock rule.
+ *
+ * @example
+ * - If the rule is `! This is just a comment`, then the marker will be `!`.
+ * - If the rule is `# This is just a comment`, then the marker will be `#`.
+ */
+const CommentMarker = {
+    /**
+     * Regular comment marker. It is supported by all ad blockers.
+     */
+    Regular: '!',
+    /**
+     * Hashmark comment marker. It is supported by uBlock Origin and AdGuard,
+     * and also used in hosts files.
+     */
+    Hashmark: '#',
+};
+/**
+ * Represents the main categories that an adblock rule can belong to.
+ * Of course, these include additional subcategories.
+ */
+const RuleCategory = {
+    /**
+     * Empty "rules" that are only containing whitespaces. These rules are handled just for convenience.
+     */
+    Empty: 'Empty',
+    /**
+     * Syntactically invalid rules (tolerant mode only).
+     */
+    Invalid: 'Invalid',
+    /**
+     * Comment rules, such as comment rules, metadata rules, preprocessor rules, etc.
+     */
+    Comment: 'Comment',
+    /**
+     * Cosmetic rules, such as element hiding rules, CSS rules, scriptlet rules, HTML rules, and JS rules.
+     */
+    Cosmetic: 'Cosmetic',
+    /**
+     * Network rules, such as basic network rules, header remover network rules, redirect network rules,
+     * response header filtering rules, etc.
+     */
+    Network: 'Network',
+};
+/**
+ * Represents similar types of modifiers values
+ * which may be separated by a comma `,` (only for DomainList) or a pipe `|`.
+ */
+const ListNodeType = {
+    Unknown: 'Unknown',
+    AppList: 'AppList',
+    DomainList: 'DomainList',
+    MethodList: 'MethodList',
+    StealthOptionList: 'StealthOptionList',
+};
+/**
+ * Represents child items for {@link ListNodeType}.
+ */
+const ListItemNodeType = {
+    Unknown: 'Unknown',
+    App: 'App',
+    Domain: 'Domain',
+    Method: 'Method',
+    StealthOption: 'StealthOption',
+};
+/**
+ * Represents possible comment types.
+ */
+const CommentRuleType = {
+    AgentCommentRule: 'AgentCommentRule',
+    CommentRule: 'CommentRule',
+    ConfigCommentRule: 'ConfigCommentRule',
+    HintCommentRule: 'HintCommentRule',
+    MetadataCommentRule: 'MetadataCommentRule',
+    PreProcessorCommentRule: 'PreProcessorCommentRule',
+};
+/**
+ * Represents possible cosmetic rule types.
+ */
+const CosmeticRuleType = {
+    ElementHidingRule: 'ElementHidingRule',
+    CssInjectionRule: 'CssInjectionRule',
+    ScriptletInjectionRule: 'ScriptletInjectionRule',
+    HtmlFilteringRule: 'HtmlFilteringRule',
+    JsInjectionRule: 'JsInjectionRule',
+};
+/**
+ * Represents possible cosmetic rule separators.
+ */
+const CosmeticRuleSeparator = {
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    ElementHiding: '##',
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    ElementHidingException: '#@#',
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    ExtendedElementHiding: '#?#',
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    ExtendedElementHidingException: '#@?#',
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    AbpSnippet: '#$#',
+    /**
+     * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
+     */
+    AbpSnippetException: '#@$#',
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    AdgCssInjection: '#$#',
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    AdgCssInjectionException: '#@$#',
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    AdgExtendedCssInjection: '#$?#',
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
+     */
+    AdgExtendedCssInjectionException: '#@$?#',
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
+     */
+    AdgJsInjection: '#%#',
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
+     */
+    AdgJsInjectionException: '#@%#',
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#html-filtering-rules}
+     */
+    AdgHtmlFiltering: '$$',
+    /**
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#html-filtering-rules}
+     */
+    AdgHtmlFilteringException: '$@$',
+};
+/**
+ * Represents the different types of network rules.
+ */
+const NetworkRuleType = {
+    NetworkRule: 'NetworkRule',
+    HostRule: 'HostRule',
+};
+
+export { CommentMarker, CommentRuleType, CosmeticRuleSeparator, CosmeticRuleType, ListItemNodeType, ListNodeType, NetworkRuleType, OperatorValue, RuleCategory };

package/dist/package.json.js

@@ -0,0 +1,9 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+const version = "3.0.0-alpha.2";
+
+export { version };

package/dist/parser/base-parser.js

@@ -0,0 +1,30 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { NotImplementedError } from '../errors/not-implemented-error.js';
+
+/**
+ * @file Base parser class.
+ */
+/**
+ * Base class for parsers. Each parser should extend this class.
+ */
+class BaseParser {
+    /**
+     * Parses the input string and returns the AST node.
+     *
+     * @param input Input string to parse.
+     * @param options Parser options, see {@link ParserOptions}.
+     * @param baseOffset Base offset. Locations in the AST node will be relative to this offset.
+     * @param args Additional, parser-specific arguments, if needed.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static parse(input, options, baseOffset, ...args) {
+        throw new NotImplementedError();
+    }
+}
+
+export { BaseParser };

package/dist/parser/comment/agent-comment-parser.js

@@ -0,0 +1,119 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { OPEN_SQUARE_BRACKET, CLOSE_SQUARE_BRACKET, SEMICOLON } from '../../utils/constants.js';
+import { StringUtils } from '../../utils/string.js';
+import { CommentRuleType, RuleCategory } from '../../nodes/index.js';
+import { AgentParser } from './agent-parser.js';
+import { AdblockSyntaxError } from '../../errors/adblock-syntax-error.js';
+import { AdblockSyntax } from '../../utils/adblockers.js';
+import { CosmeticRuleSeparatorUtils } from '../../utils/cosmetic-rule-separator.js';
+import { BaseParser } from '../base-parser.js';
+import { defaultParserOptions } from '../options.js';
+import { isNull } from '../../utils/type-guards.js';
+
+/**
+ * `AgentParser` is responsible for parsing an Adblock agent rules.
+ * Adblock agent comment marks that the filter list is supposed to
+ * be used by the specified ad blockers.
+ *
+ * @example
+ *  - ```adblock
+ *    [AdGuard]
+ *    ```
+ *  - ```adblock
+ *    [Adblock Plus 2.0]
+ *    ```
+ *  - ```adblock
+ *    [uBlock Origin]
+ *    ```
+ *  - ```adblock
+ *    [uBlock Origin 1.45.3]
+ *    ```
+ *  - ```adblock
+ *    [Adblock Plus 2.0; AdGuard]
+ *    ```
+ */
+class AgentCommentParser extends BaseParser {
+    /**
+     * Checks if the raw rule is an adblock agent comment.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is an adblock agent, `false` otherwise
+     */
+    static isAgentRule(raw) {
+        const rawTrimmed = raw.trim();
+        if (rawTrimmed.startsWith(OPEN_SQUARE_BRACKET) && rawTrimmed.endsWith(CLOSE_SQUARE_BRACKET)) {
+            // Avoid this case: [$adg-modifier]##[class^="adg-"]
+            return isNull(CosmeticRuleSeparatorUtils.find(rawTrimmed));
+        }
+        return false;
+    }
+    /**
+     * Parses a raw rule as an adblock agent comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Agent rule AST or null (if the raw rule cannot be parsed as an adblock agent comment)
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        // Ignore non-agent rules
+        if (!AgentCommentParser.isAgentRule(raw)) {
+            return null;
+        }
+        let offset = 0;
+        // Skip whitespace characters before the rule
+        offset = StringUtils.skipWS(raw, offset);
+        // Skip opening bracket
+        offset += 1;
+        // last character should be a closing bracket
+        const closingBracketIndex = StringUtils.skipWSBack(raw, raw.length - 1);
+        if (closingBracketIndex === -1 || raw[closingBracketIndex] !== CLOSE_SQUARE_BRACKET) {
+            throw new AdblockSyntaxError('Missing closing bracket', offset, offset + raw.length);
+        }
+        // Initialize the agent list
+        const result = {
+            type: CommentRuleType.AgentCommentRule,
+            syntax: AdblockSyntax.Common,
+            category: RuleCategory.Comment,
+            children: [],
+        };
+        if (options.includeRaws) {
+            result.raws = {
+                text: raw,
+            };
+        }
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        while (offset < closingBracketIndex) {
+            // Skip whitespace characters before the agent
+            offset = StringUtils.skipWS(raw, offset);
+            // Find the separator or the closing bracket
+            let separatorIndex = raw.indexOf(SEMICOLON, offset);
+            if (separatorIndex === -1) {
+                separatorIndex = closingBracketIndex;
+            }
+            // Find the last non-whitespace character of the agent
+            // [AdGuard  ; Adblock Plus 2.0]
+            //        ^
+            // (if we have spaces between the agent name and the separator)
+            const agentEndIndex = StringUtils.findLastNonWhitespaceCharacter(raw.slice(offset, separatorIndex)) + offset + 1;
+            // Collect the agent
+            result.children.push(AgentParser.parse(raw.slice(offset, agentEndIndex), options, baseOffset + offset));
+            // Set the offset to the next agent or the end of the rule
+            offset = separatorIndex + 1;
+        }
+        if (result.children.length === 0) {
+            throw new AdblockSyntaxError('Empty agent list', baseOffset, baseOffset + raw.length);
+        }
+        return result;
+    }
+}
+
+export { AgentCommentParser };

package/dist/parser/comment/agent-parser.js

@@ -0,0 +1,110 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * 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 { StringUtils } from '../../utils/string.js';
+import { AdblockSyntaxError } from '../../errors/adblock-syntax-error.js';
+import { AdblockSyntax } from '../../utils/adblockers.js';
+import { BaseParser } from '../base-parser.js';
+import { defaultParserOptions } from '../options.js';
+import { ValueParser } from '../misc/value-parser.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { getAdblockSyntax } from '../../common/agent-common.js';
+
+/* eslint-disable no-param-reassign */
+// eslint-disable-next-line import/extensions
+/**
+ * `AgentParser` is responsible for parsing single adblock agent elements.
+ *
+ * @example
+ * If the adblock agent rule is
+ * ```adblock
+ * [Adblock Plus 2.0; AdGuard]
+ * ```
+ * then the adblock agents are `Adblock Plus 2.0` and `AdGuard`, and this
+ * class is responsible for parsing them. The rule itself is parsed by
+ * `AgentCommentParser`, which uses this class to parse single agents.
+ */
+class AgentParser extends BaseParser {
+    /**
+     * Checks if the string is a valid version.
+     *
+     * @param str String to check
+     * @returns `true` if the string is a valid version, `false` otherwise
+     */
+    static isValidVersion(str) {
+        return valid(coerce(str)) !== null;
+    }
+    /**
+     * Parses a raw rule as an adblock agent comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Agent rule AST
+     * @throws {AdblockSyntaxError} If the raw rule cannot be parsed as an adblock agent
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        let offset = 0;
+        // Save name start position
+        const nameStartIndex = offset;
+        let nameEndIndex = offset;
+        // Prepare variables for name and version
+        let name;
+        let version;
+        // 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) {
+            // Skip whitespace before the part
+            offset = StringUtils.skipWS(raw, offset);
+            const partEnd = StringUtils.findNextWhitespaceCharacter(raw, offset);
+            const part = raw.slice(offset, partEnd);
+            if (AgentParser.isValidVersion(part)) {
+                if (!isUndefined(version)) {
+                    throw new AdblockSyntaxError('Duplicated versions are not allowed', baseOffset + offset, baseOffset + partEnd);
+                }
+                const parsedNamePart = raw.slice(nameStartIndex, nameEndIndex);
+                name = ValueParser.parse(parsedNamePart, options, baseOffset + nameStartIndex);
+                version = ValueParser.parse(part, options, baseOffset + offset);
+                syntax = getAdblockSyntax(parsedNamePart);
+            }
+            else {
+                nameEndIndex = partEnd;
+            }
+            // Skip whitespace after the part
+            offset = StringUtils.skipWS(raw, partEnd);
+        }
+        // If we didn't find a version, the whole string is the name
+        if (isUndefined(name)) {
+            const parsedNamePart = raw.slice(nameStartIndex, nameEndIndex);
+            name = ValueParser.parse(parsedNamePart, options, baseOffset + nameStartIndex);
+            syntax = getAdblockSyntax(parsedNamePart);
+        }
+        // Agent name cannot be empty
+        if (name.value.length === 0) {
+            throw new AdblockSyntaxError('Agent name cannot be empty', baseOffset, baseOffset + raw.length);
+        }
+        const result = {
+            type: 'Agent',
+            adblock: name,
+            syntax,
+        };
+        // only add version if it's present
+        if (version) {
+            result.version = version;
+        }
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        return result;
+    }
+}
+
+export { AgentParser };

package/dist/parser/comment/comment-parser.js

@@ -0,0 +1,108 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { AgentCommentParser } from './agent-comment-parser.js';
+import { ConfigCommentParser } from './config-comment-parser.js';
+import { HintCommentParser } from './hint-comment-parser.js';
+import { MetadataCommentParser } from './metadata-comment-parser.js';
+import { PreProcessorCommentParser } from './preprocessor-parser.js';
+import { defaultParserOptions } from '../options.js';
+import { BaseParser } from '../base-parser.js';
+import { SimpleCommentParser } from './simple-comment-parser.js';
+
+/* eslint-disable no-param-reassign */
+/**
+ * `CommentParser` is responsible for parsing any comment-like adblock rules.
+ *
+ * @example
+ * Example rules:
+ *  - Adblock agent rules:
+ *      - ```adblock
+ *        [AdGuard]
+ *        ```
+ *      - ```adblock
+ *        [Adblock Plus 2.0]
+ *        ```
+ *      - etc.
+ *  - AdGuard hint rules:
+ *      - ```adblock
+ *        !+ NOT_OPTIMIZED
+ *        ```
+ *      - ```adblock
+ *        !+ NOT_OPTIMIZED PLATFORM(windows)
+ *        ```
+ *      - etc.
+ *  - Pre-processor rules:
+ *      - ```adblock
+ *        !#if (adguard)
+ *        ```
+ *      - ```adblock
+ *        !#endif
+ *        ```
+ *      - etc.
+ *  - Metadata rules:
+ *      - ```adblock
+ *        ! Title: My List
+ *        ```
+ *      - ```adblock
+ *        ! Version: 2.0.150
+ *        ```
+ *      - etc.
+ *  - AGLint inline config rules:
+ *      - ```adblock
+ *        ! aglint-enable some-rule
+ *        ```
+ *      - ```adblock
+ *        ! aglint-disable some-rule
+ *        ```
+ *      - etc.
+ *  - Simple comments:
+ *      - Regular version:
+ *        ```adblock
+ *        ! This is just a comment
+ *        ```
+ *      - uBlock Origin / "hostlist" version:
+ *        ```adblock
+ *        # This is just a comment
+ *        ```
+ *      - etc.
+ */
+class CommentParser extends BaseParser {
+    /**
+     * Checks whether a rule is a comment.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is a comment, `false` otherwise
+     */
+    static isCommentRule(raw) {
+        const trimmed = raw.trim();
+        return SimpleCommentParser.isSimpleComment(trimmed) || AgentCommentParser.isAgentRule(trimmed);
+    }
+    /**
+     * Parses a raw rule as comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Comment AST or null (if the raw rule cannot be parsed as comment)
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        // Ignore non-comment rules
+        if (!CommentParser.isCommentRule(raw)) {
+            return null;
+        }
+        // Note: we parse non-functional comments at the end,
+        // if the input does not match any of the previous, more specific comment patterns
+        return AgentCommentParser.parse(raw, options, baseOffset)
+            || HintCommentParser.parse(raw, options, baseOffset)
+            || PreProcessorCommentParser.parse(raw, options, baseOffset)
+            || MetadataCommentParser.parse(raw, options, baseOffset)
+            || ConfigCommentParser.parse(raw, options, baseOffset)
+            || SimpleCommentParser.parse(raw, options, baseOffset);
+    }
+}
+
+export { CommentParser };

package/dist/parser/comment/config-comment-parser.js

@@ -0,0 +1,137 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import JSON5 from 'json5';
+import { AdblockSyntax } from '../../utils/adblockers.js';
+import { AGLINT_CONFIG_COMMENT_MARKER, AGLINT_COMMAND_PREFIX, COMMA } from '../../utils/constants.js';
+import { CommentMarker, CommentRuleType, RuleCategory } from '../../nodes/index.js';
+import { StringUtils } from '../../utils/string.js';
+import { ParameterListParser } from '../misc/parameter-list-parser.js';
+import { defaultParserOptions } from '../options.js';
+import { BaseParser } from '../base-parser.js';
+import { ValueParser } from '../misc/value-parser.js';
+
+/**
+ * @file AGLint configuration comments. Inspired by ESLint inline configuration comments.
+ * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
+ */
+/**
+ * `ConfigCommentParser` is responsible for parsing inline AGLint configuration rules.
+ * Generally, the idea is inspired by ESLint inline configuration comments.
+ *
+ * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
+ */
+class ConfigCommentParser extends BaseParser {
+    /**
+     * Checks if the raw rule is an inline configuration comment rule.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is an inline configuration comment rule, otherwise `false`.
+     */
+    static isConfigComment(raw) {
+        const trimmed = raw.trim();
+        if (trimmed[0] === CommentMarker.Regular || trimmed[0] === CommentMarker.Hashmark) {
+            // Skip comment marker and trim comment text (it is necessary because of "!     something")
+            const text = raw.slice(1).trim();
+            // The code below is "not pretty", but it runs fast, which is necessary, since it will run on EVERY comment
+            // The essence of the indicator is that the control comment always starts with the "aglint" prefix
+            return ((text[0] === 'a' || text[0] === 'A')
+                && (text[1] === 'g' || text[1] === 'G')
+                && (text[2] === 'l' || text[2] === 'L')
+                && (text[3] === 'i' || text[3] === 'I')
+                && (text[4] === 'n' || text[4] === 'N')
+                && (text[5] === 't' || text[5] === 'T'));
+        }
+        return false;
+    }
+    /**
+     * Parses a raw rule as an inline configuration comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns
+     * Inline configuration comment AST or null (if the raw rule cannot be parsed as configuration comment)
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        if (!ConfigCommentParser.isConfigComment(raw)) {
+            return null;
+        }
+        let offset = 0;
+        // Skip leading whitespace (if any)
+        offset = StringUtils.skipWS(raw, offset);
+        // Get comment marker
+        const marker = ValueParser.parse(raw[offset], options, baseOffset + offset);
+        // Skip marker
+        offset += 1;
+        // Skip whitespace (if any)
+        offset = StringUtils.skipWS(raw, offset);
+        // Save the command start position
+        const commandStart = offset;
+        // Get comment text, for example: "aglint-disable-next-line"
+        offset = StringUtils.findNextWhitespaceCharacter(raw, offset);
+        const command = ValueParser.parse(raw.slice(commandStart, offset), options, baseOffset + commandStart);
+        // Skip whitespace after command
+        offset = StringUtils.skipWS(raw, offset);
+        // Get comment (if any)
+        const commentStart = raw.indexOf(AGLINT_CONFIG_COMMENT_MARKER, offset);
+        const commentEnd = commentStart !== -1 ? StringUtils.skipWSBack(raw) + 1 : -1;
+        let comment;
+        // Check if there is a comment
+        if (commentStart !== -1) {
+            comment = ValueParser.parse(raw.slice(commentStart, commentEnd), options, baseOffset + commentStart);
+        }
+        // Get parameter
+        const paramsStart = offset;
+        const paramsEnd = commentStart !== -1
+            ? StringUtils.skipWSBack(raw, commentStart - 1) + 1
+            : StringUtils.skipWSBack(raw) + 1;
+        let params;
+        // `! aglint ...` config comment
+        if (command.value === AGLINT_COMMAND_PREFIX) {
+            params = {
+                type: 'ConfigNode',
+                // It is necessary to use JSON5.parse instead of JSON.parse because JSON5 allows unquoted keys.
+                // But don't forget to add { } to the beginning and end of the string,
+                // otherwise JSON5 will not be able to parse it.
+                // TODO: Better solution? ESLint uses "levn" package for parsing these comments.
+                value: JSON5.parse(`{${raw.slice(paramsStart, paramsEnd)}}`),
+            };
+            if (options.isLocIncluded) {
+                params.start = paramsStart;
+                params.end = paramsEnd;
+            }
+            // Throw error for empty config
+            if (Object.keys(params.value).length === 0) {
+                throw new Error('Empty AGLint config');
+            }
+        }
+        else if (paramsStart < paramsEnd) {
+            params = ParameterListParser.parse(raw.slice(paramsStart, paramsEnd), options, baseOffset + paramsStart, COMMA);
+        }
+        const result = {
+            type: CommentRuleType.ConfigCommentRule,
+            category: RuleCategory.Comment,
+            syntax: AdblockSyntax.Common,
+            marker,
+            command,
+            params,
+            comment,
+        };
+        if (options.includeRaws) {
+            result.raws = {
+                text: raw,
+            };
+        }
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        return result;
+    }
+}
+
+export { ConfigCommentParser };