@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/esm/parser/comment/preprocessor-parser.mjs

@@ -0,0 +1,199 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { AdblockSyntax } from '../../utils/adblockers.mjs';
+import { PREPROCESSOR_MARKER, PREPROCESSOR_MARKER_LEN, HASHMARK, PREPROCESSOR_SEPARATOR, OPEN_PARENTHESIS, SAFARI_CB_AFFINITY, CLOSE_PARENTHESIS, COMMA, IF, INCLUDE } from '../../utils/constants.mjs';
+import { StringUtils } from '../../utils/string.mjs';
+import { CommentRuleType, RuleCategory } from '../../nodes/index.mjs';
+import { LogicalExpressionParser } from '../misc/logical-expression-parser.mjs';
+import { AdblockSyntaxError } from '../../errors/adblock-syntax-error.mjs';
+import { ParameterListParser } from '../misc/parameter-list-parser.mjs';
+import { defaultParserOptions } from '../options.mjs';
+import { BaseParser } from '../base-parser.mjs';
+import { ValueParser } from '../misc/value-parser.mjs';
+
+/**
+ * Pre-processor directives
+ *
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#pre-processor-directives}
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#pre-parsing-directives}
+ */
+/**
+ * `PreProcessorParser` is responsible for parsing preprocessor rules.
+ * Pre-processor comments are special comments that are used to control the behavior of the filter list processor.
+ * Please note that this parser only handles general syntax for now, and does not validate the parameters at
+ * the parsing stage.
+ *
+ * @example
+ * If your rule is
+ * ```adblock
+ * !#if (adguard)
+ * ```
+ * then the directive's name is `if` and its value is `(adguard)`, but the parameter list
+ * is not parsed / validated further.
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#pre-processor-directives}
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#pre-parsing-directives}
+ */
+class PreProcessorCommentParser extends BaseParser {
+    /**
+     * Determines whether the rule is a pre-processor rule.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is a pre-processor rule, `false` otherwise
+     */
+    static isPreProcessorRule(raw) {
+        const trimmed = raw.trim();
+        // Avoid this case: !##... (commonly used in AdGuard filters)
+        return trimmed.startsWith(PREPROCESSOR_MARKER) && trimmed[PREPROCESSOR_MARKER_LEN] !== HASHMARK;
+    }
+    /**
+     * Parses a raw rule as a pre-processor 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
+     * Pre-processor comment AST or null (if the raw rule cannot be parsed as a pre-processor comment)
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        // Ignore non-pre-processor rules
+        if (!PreProcessorCommentParser.isPreProcessorRule(raw)) {
+            return null;
+        }
+        let offset = 0;
+        // Ignore whitespace characters before the rule (if any)
+        offset = StringUtils.skipWS(raw, offset);
+        // Ignore the pre-processor marker
+        offset += PREPROCESSOR_MARKER_LEN;
+        // Ignore whitespace characters after the pre-processor marker (if any)
+        // Note: this is incorrect according to the spec, but we do it for tolerance
+        offset = StringUtils.skipWS(raw, offset);
+        // Directive name should start at this offset, so we save this offset now
+        const nameStart = offset;
+        // Consume directive name, so parse the sequence until the first
+        // whitespace / opening parenthesis / end of string
+        while (offset < raw.length) {
+            const ch = raw[offset];
+            if (ch === PREPROCESSOR_SEPARATOR || ch === OPEN_PARENTHESIS) {
+                break;
+            }
+            offset += 1;
+        }
+        // Save name end offset
+        const nameEnd = offset;
+        // Create name node
+        const name = ValueParser.parse(raw.slice(nameStart, nameEnd), options, baseOffset + nameStart);
+        // Ignore whitespace characters after the directive name (if any)
+        // Note: this may incorrect according to the spec, but we do it for tolerance
+        offset = StringUtils.skipWS(raw, offset);
+        // If the directive name is "safari_cb_affinity", then we have a special case
+        if (name.value === SAFARI_CB_AFFINITY) {
+            // Throw error if there are spaces after the directive name
+            if (offset > nameEnd) {
+                throw new AdblockSyntaxError(`Unexpected whitespace after "${SAFARI_CB_AFFINITY}" directive name`, baseOffset + nameEnd, baseOffset + offset);
+            }
+            // safari_cb_affinity directive optionally accepts a parameter list
+            // So at this point we should check if there are parameters or not
+            // (cb_affinity directive followed by an opening parenthesis or if we
+            // skip the whitespace we reach the end of the string)
+            if (StringUtils.skipWS(raw, offset) !== raw.length) {
+                if (raw[offset] !== OPEN_PARENTHESIS) {
+                    throw new AdblockSyntaxError(`Unexpected character '${raw[offset]}' after '${SAFARI_CB_AFFINITY}' directive name`, baseOffset + offset, baseOffset + offset + 1);
+                }
+                // If we have parameters, then we should parse them
+                // Note: we don't validate the parameters at this stage
+                // Ignore opening parenthesis
+                offset += 1;
+                // Save parameter list start offset
+                const parameterListStart = offset;
+                // Check for closing parenthesis
+                const closingParenthesesIndex = StringUtils.skipWSBack(raw);
+                if (closingParenthesesIndex === -1 || raw[closingParenthesesIndex] !== CLOSE_PARENTHESIS) {
+                    throw new AdblockSyntaxError(`Missing closing parenthesis for '${SAFARI_CB_AFFINITY}' directive`, baseOffset + offset, baseOffset + raw.length);
+                }
+                // Save parameter list end offset
+                const parameterListEnd = closingParenthesesIndex;
+                // Parse parameters between the opening and closing parentheses
+                const result = {
+                    type: CommentRuleType.PreProcessorCommentRule,
+                    category: RuleCategory.Comment,
+                    syntax: AdblockSyntax.Adg,
+                    name,
+                    // comma separated list of parameters
+                    params: ParameterListParser.parse(raw.slice(parameterListStart, parameterListEnd), options, baseOffset + parameterListStart, COMMA),
+                };
+                if (options.includeRaws) {
+                    result.raws = {
+                        text: raw,
+                    };
+                }
+                if (options.isLocIncluded) {
+                    result.start = baseOffset;
+                    result.end = baseOffset + raw.length;
+                }
+                return result;
+            }
+        }
+        // If we reached the end of the string, then we have a directive without parameters
+        // (e.g. "!#safari_cb_affinity" or "!#endif")
+        // No need to continue parsing in this case.
+        if (offset === raw.length) {
+            // Throw error if the directive name is "if" or "include", because these directives
+            // should have parameters
+            if (name.value === IF || name.value === INCLUDE) {
+                throw new AdblockSyntaxError(`Directive "${name.value}" requires parameters`, baseOffset, baseOffset + raw.length);
+            }
+            const result = {
+                type: CommentRuleType.PreProcessorCommentRule,
+                category: RuleCategory.Comment,
+                syntax: AdblockSyntax.Common,
+                name,
+            };
+            if (options.includeRaws) {
+                result.raws = {
+                    text: raw,
+                };
+            }
+            if (options.isLocIncluded) {
+                result.start = baseOffset;
+                result.end = baseOffset + raw.length;
+            }
+            return result;
+        }
+        // Get start and end offsets of the directive parameters
+        const paramsStart = offset;
+        const paramsEnd = StringUtils.skipWSBack(raw) + 1;
+        // Prepare parameters node
+        let params;
+        // Parse parameters. Handle "if" and "safari_cb_affinity" directives
+        // separately.
+        if (name.value === IF) {
+            params = LogicalExpressionParser.parse(raw.slice(paramsStart, paramsEnd), options, baseOffset + paramsStart);
+        }
+        else {
+            params = ValueParser.parse(raw.slice(paramsStart, paramsEnd), options, baseOffset + paramsStart);
+        }
+        const result = {
+            type: CommentRuleType.PreProcessorCommentRule,
+            category: RuleCategory.Comment,
+            syntax: AdblockSyntax.Common,
+            name,
+            params,
+        };
+        if (options.includeRaws) {
+            result.raws = {
+                text: raw,
+            };
+        }
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        return result;
+    }
+}
+
+export { PreProcessorCommentParser };

package/dist/esm/parser/comment/simple-comment-parser.mjs

@@ -0,0 +1,106 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { AdblockSyntax } from '../../utils/adblockers.mjs';
+import { CosmeticRuleSeparatorUtils } from '../../utils/cosmetic-rule-separator.mjs';
+import { StringUtils } from '../../utils/string.mjs';
+import { CommentMarker, RuleCategory, CommentRuleType } from '../../nodes/index.mjs';
+import { BaseParser } from '../base-parser.mjs';
+import { ValueParser } from '../misc/value-parser.mjs';
+import { defaultParserOptions } from '../options.mjs';
+
+/**
+ * `SimpleCommentParser` is responsible for parsing simple comments.
+ * Some comments have a special meaning in adblock syntax, like agent comments or hints,
+ * but this parser is only responsible for parsing regular comments,
+ * whose only purpose is to provide some human-readable information.
+ *
+ * @example
+ * ```adblock
+ * ! This is a simple comment
+ * # This is a simple comment, but in host-like syntax
+ * ```
+ */
+class SimpleCommentParser extends BaseParser {
+    /**
+     * Checks if the raw rule is a simple comment.
+     *
+     * @param raw Raw input to check.
+     * @returns `true` if the input is a simple comment, `false` otherwise.
+     * @note This method does not check for adblock agent comments.
+     */
+    static isSimpleComment(raw) {
+        const trimmed = raw.trim();
+        // Exclamation mark based comments
+        if (trimmed.startsWith(CommentMarker.Regular)) {
+            return true;
+        }
+        // Hashmark based comments
+        // Note: in this case, we must be sure that we do not mistakenly parse a cosmetic rule as a #-like comment,
+        // since most cosmetic rule separators also start with #
+        if (trimmed.startsWith(CommentMarker.Hashmark)) {
+            const result = CosmeticRuleSeparatorUtils.find(trimmed);
+            // If we cannot find a separator, it means that the rule is definitely a comment
+            if (result === null) {
+                return true;
+            }
+            // Otherwise, we must check if the separator is followed by a valid selector
+            const { end } = result;
+            // No valid selector
+            if (!trimmed[end + 1]
+                || StringUtils.isWhitespace(trimmed[end + 1])
+                || (trimmed[end + 1] === CommentMarker.Hashmark && trimmed[end + 2] === CommentMarker.Hashmark)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Parses a raw rule as a simple 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 rule node or null (if the raw rule cannot be parsed as a simple comment).
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        // Ignore non-comment rules
+        if (!this.isSimpleComment(raw)) {
+            return null;
+        }
+        // If we are here, it means that the rule is a regular comment
+        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;
+        // Get comment text
+        const text = ValueParser.parse(raw.slice(offset), options, baseOffset + offset);
+        // Regular comment rule
+        const result = {
+            category: RuleCategory.Comment,
+            type: CommentRuleType.CommentRule,
+            // TODO: Change syntax when hashmark is used
+            syntax: AdblockSyntax.Common,
+            marker,
+            text,
+        };
+        if (options.includeRaws) {
+            result.raws = {
+                text: raw,
+            };
+        }
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        return result;
+    }
+}
+
+export { SimpleCommentParser };

package/dist/esm/parser/cosmetic/body/abp-snippet-injection-body-parser.mjs

@@ -0,0 +1,79 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { SEMICOLON, SPACE } from '../../../utils/constants.mjs';
+import { StringUtils } from '../../../utils/string.mjs';
+import { AdblockSyntaxError } from '../../../errors/adblock-syntax-error.mjs';
+import { ParameterListParser } from '../../misc/parameter-list-parser.mjs';
+import { defaultParserOptions } from '../../options.mjs';
+import { BaseParser } from '../../base-parser.mjs';
+import { AbpSnippetInjectionBodyCommon } from '../../../common/abp-snippet-injection-body-common.mjs';
+
+/**
+ * @file uBlock scriptlet injection body parser
+ */
+/**
+ * `AbpSnippetInjectionBodyParser` is responsible for parsing the body of an Adblock Plus-style snippet rule.
+ *
+ * Please note that the parser will parse any scriptlet rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com#$#snippet0 arg0
+ * ```
+ *
+ * but it didn't check if the scriptlet `snippet0` actually supported by any adblocker.
+ *
+ * @see {@link https://help.eyeo.com/adblockplus/snippet-filters-tutorial}
+ */
+class AbpSnippetInjectionBodyParser extends BaseParser {
+    /**
+     * Parses the body of an Adblock Plus-style snippet rule.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Node of the parsed scriptlet call body
+     * @throws If the body is syntactically incorrect
+     * @example
+     * ```
+     * #$#snippet0 arg0
+     * ```
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        const result = {
+            type: 'ScriptletInjectionRuleBody',
+            children: [],
+        };
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        let offset = 0;
+        // Skip leading spaces
+        offset = StringUtils.skipWS(raw, offset);
+        while (offset < raw.length) {
+            offset = StringUtils.skipWS(raw, offset);
+            const scriptletCallStart = offset;
+            // Find the next semicolon or the end of the string
+            let semicolonIndex = StringUtils.findUnescapedNonStringNonRegexChar(raw, SEMICOLON, offset);
+            if (semicolonIndex === -1) {
+                semicolonIndex = raw.length;
+            }
+            const scriptletCallEnd = Math.max(StringUtils.skipWSBack(raw, semicolonIndex - 1) + 1, scriptletCallStart);
+            const params = ParameterListParser.parse(raw.slice(scriptletCallStart, scriptletCallEnd), options, baseOffset + scriptletCallStart, SPACE);
+            // Parse the scriptlet call
+            result.children.push(params);
+            // Skip the semicolon
+            offset = semicolonIndex + 1;
+        }
+        if (result.children.length === 0) {
+            throw new AdblockSyntaxError(AbpSnippetInjectionBodyCommon.ERROR_MESSAGES.EMPTY_SCRIPTLET_CALL, baseOffset, baseOffset + raw.length);
+        }
+        return result;
+    }
+}
+
+export { AbpSnippetInjectionBodyParser };

package/dist/esm/parser/cosmetic/body/adg-scriptlet-injection-body-parser.mjs

@@ -0,0 +1,149 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 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 { ADG_SCRIPTLET_MASK, OPEN_PARENTHESIS, CLOSE_PARENTHESIS, SPACE, ESCAPE_CHARACTER, COMMA, SINGLE_QUOTE, DOUBLE_QUOTE } from '../../../utils/constants.mjs';
+import { StringUtils } from '../../../utils/string.mjs';
+import { AdblockSyntaxError } from '../../../errors/adblock-syntax-error.mjs';
+import { defaultParserOptions } from '../../options.mjs';
+import { BaseParser } from '../../base-parser.mjs';
+import { ValueParser } from '../../misc/value-parser.mjs';
+import { isNull } from '../../../utils/type-guards.mjs';
+
+/**
+ * @file AdGuard scriptlet injection body parser
+ */
+/**
+ * `AdgScriptletInjectionBodyParser` is responsible for parsing the body of an AdGuard-style scriptlet rule.
+ *
+ * Please note that the parser will parse any scriptlet rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com#%#//scriptlet('scriptlet0', 'arg0')
+ * ```
+ *
+ * but it didn't check if the scriptlet `scriptlet0` actually supported by any adblocker.
+ *
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
+ */
+class AdgScriptletInjectionBodyParser extends BaseParser {
+    /**
+     * Error messages used by the parser.
+     */
+    static ERROR_MESSAGES = {
+        NO_SCRIPTLET_MASK: `Invalid ADG scriptlet call, no scriptlet call mask '${ADG_SCRIPTLET_MASK}' found`,
+        NO_OPENING_PARENTHESIS: `Invalid ADG scriptlet call, no opening parentheses '${OPEN_PARENTHESIS}' found`,
+        NO_CLOSING_PARENTHESIS: `Invalid ADG scriptlet call, no closing parentheses '${CLOSE_PARENTHESIS}' found`,
+        WHITESPACE_AFTER_MASK: 'Invalid ADG scriptlet call, whitespace is not allowed after the scriptlet call mask',
+        NO_INCONSISTENT_QUOTES: 'Invalid ADG scriptlet call, inconsistent quotes',
+        NO_UNCLOSED_PARAMETER: 'Invalid ADG scriptlet call, unclosed parameter',
+        EXPECTED_QUOTE: "Invalid ADG scriptlet call, expected quote, got '%s'",
+        EXPECTED_COMMA: "Invalid ADG scriptlet call, expected comma, got '%s'",
+    };
+    /**
+     * Parses the body of an AdGuard-style scriptlet rule.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Node of the parsed scriptlet call body
+     * @throws If the body is syntactically incorrect
+     * @example
+     * ```
+     * //scriptlet('scriptlet0', 'arg0')
+     * ```
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        let offset = 0;
+        // Skip leading spaces
+        offset = StringUtils.skipWS(raw, offset);
+        // Scriptlet call should start with "//scriptlet"
+        if (!raw.startsWith(ADG_SCRIPTLET_MASK, offset)) {
+            throw new AdblockSyntaxError(this.ERROR_MESSAGES.NO_SCRIPTLET_MASK, baseOffset + offset, baseOffset + raw.length);
+        }
+        offset += ADG_SCRIPTLET_MASK.length;
+        // Whitespace is not allowed after the mask
+        if (raw[offset] === SPACE) {
+            throw new AdblockSyntaxError(this.ERROR_MESSAGES.WHITESPACE_AFTER_MASK, baseOffset + offset, baseOffset + raw.length);
+        }
+        // Parameter list should be wrapped in parentheses
+        if (raw[offset] !== OPEN_PARENTHESIS) {
+            throw new AdblockSyntaxError(this.ERROR_MESSAGES.NO_OPENING_PARENTHESIS, baseOffset + offset, baseOffset + raw.length);
+        }
+        // Save the offset of the opening parentheses
+        const openingParenthesesIndex = offset;
+        // Skip whitespace from the end
+        const closingParenthesesIndex = StringUtils.skipWSBack(raw, raw.length - 1);
+        // Closing parentheses should be present
+        if (raw[closingParenthesesIndex] !== CLOSE_PARENTHESIS
+            || raw[closingParenthesesIndex - 1] === ESCAPE_CHARACTER) {
+            throw new AdblockSyntaxError(this.ERROR_MESSAGES.NO_CLOSING_PARENTHESIS, baseOffset + offset, baseOffset + raw.length);
+        }
+        // Skip space, if any
+        offset = StringUtils.skipWS(raw, offset + 1);
+        const result = {
+            type: 'ScriptletInjectionRuleBody',
+            children: [],
+        };
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        // Special case: empty scriptlet call, like `//scriptlet()`, `//scriptlet( )` etc.
+        if (StringUtils.skipWS(raw, openingParenthesesIndex + 1) === closingParenthesesIndex) {
+            return result;
+        }
+        let detectedQuote = null;
+        const parameterList = {
+            type: 'ParameterList',
+            children: [],
+        };
+        if (options.isLocIncluded) {
+            parameterList.start = baseOffset + openingParenthesesIndex + 1;
+            parameterList.end = baseOffset + closingParenthesesIndex;
+        }
+        while (offset < closingParenthesesIndex) {
+            // Skip whitespace
+            offset = StringUtils.skipWS(raw, offset);
+            // Expect comma if not first parameter
+            if (parameterList.children.length > 0) {
+                if (raw[offset] !== COMMA) {
+                    throw new AdblockSyntaxError(sprintf(AdgScriptletInjectionBodyParser.ERROR_MESSAGES.EXPECTED_COMMA, raw[offset]), baseOffset + offset, baseOffset + raw.length);
+                }
+                // Eat the comma
+                offset += 1;
+                // Skip whitespace
+                offset = StringUtils.skipWS(raw, offset);
+            }
+            // Next character should be a quote
+            if (raw[offset] === SINGLE_QUOTE || raw[offset] === DOUBLE_QUOTE) {
+                if (isNull(detectedQuote)) {
+                    detectedQuote = raw[offset];
+                }
+                else if (detectedQuote !== raw[offset]) {
+                    throw new AdblockSyntaxError(AdgScriptletInjectionBodyParser.ERROR_MESSAGES.NO_INCONSISTENT_QUOTES, baseOffset + offset, baseOffset + raw.length);
+                }
+                // Find next unescaped same quote
+                const closingQuoteIndex = StringUtils.findNextUnescapedCharacter(raw, detectedQuote, offset + 1);
+                if (closingQuoteIndex === -1) {
+                    throw new AdblockSyntaxError(AdgScriptletInjectionBodyParser.ERROR_MESSAGES.NO_UNCLOSED_PARAMETER, baseOffset + offset, baseOffset + raw.length);
+                }
+                // Save the parameter
+                const parameter = ValueParser.parse(raw.slice(offset, closingQuoteIndex + 1), options, baseOffset + offset);
+                parameterList.children.push(parameter);
+                // Move after the closing quote
+                offset = StringUtils.skipWS(raw, closingQuoteIndex + 1);
+            }
+            else {
+                throw new AdblockSyntaxError(sprintf(AdgScriptletInjectionBodyParser.ERROR_MESSAGES.EXPECTED_QUOTE, raw[offset]), baseOffset + offset, baseOffset + raw.length);
+            }
+        }
+        result.children.push(parameterList);
+        return result;
+    }
+}
+
+export { AdgScriptletInjectionBodyParser };

package/dist/esm/parser/cosmetic/body/ubo-scriptlet-injection-body-parser.mjs

@@ -0,0 +1,110 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { UBO_SCRIPTLET_MASK, OPEN_PARENTHESIS, CLOSE_PARENTHESIS, UBO_SCRIPTLET_MASK_LEGACY, SPACE, ESCAPE_CHARACTER, COMMA } from '../../../utils/constants.mjs';
+import { StringUtils } from '../../../utils/string.mjs';
+import { AdblockSyntaxError } from '../../../errors/adblock-syntax-error.mjs';
+import { defaultParserOptions } from '../../options.mjs';
+import { BaseParser } from '../../base-parser.mjs';
+import { UboParameterListParser } from '../../misc/ubo-parameter-list-parser.mjs';
+
+/**
+ * @file uBlock scriptlet injection body parser
+ */
+/**
+ * `UboScriptletInjectionBodyParser` is responsible for parsing the body of a uBlock-style scriptlet rule.
+ *
+ * Please note that the parser will parse any scriptlet rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com##+js(scriptlet0, arg0)
+ * ```
+ *
+ * but it didn't check if the scriptlet `scriptlet0` actually supported by any adblocker.
+ *
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#scriptlet-injection}
+ */
+class UboScriptletInjectionBodyParser extends BaseParser {
+    /**
+     * Error messages used by the parser.
+     */
+    static ERROR_MESSAGES = {
+        NO_SCRIPTLET_MASK: `Invalid uBO scriptlet call, no scriptlet call mask '${UBO_SCRIPTLET_MASK}' found`,
+        NO_OPENING_PARENTHESIS: `Invalid uBO scriptlet call, no opening parentheses '${OPEN_PARENTHESIS}' found`,
+        NO_CLOSING_PARENTHESIS: `Invalid uBO scriptlet call, no closing parentheses '${CLOSE_PARENTHESIS}' found`,
+        NO_SCRIPTLET_NAME: 'Invalid uBO scriptlet call, no scriptlet name specified',
+        WHITESPACE_AFTER_MASK: 'Invalid uBO scriptlet call, whitespace is not allowed after the scriptlet call mask',
+    };
+    /**
+     * Parses the body of a uBlock-style scriptlet rule.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Node of the parsed scriptlet call body
+     * @throws If the body is syntactically incorrect
+     * @example
+     * ```
+     * ##+js(scriptlet0, arg0)
+     * ```
+     */
+    static parse(raw, options = defaultParserOptions, baseOffset = 0) {
+        let offset = 0;
+        // Skip leading spaces
+        offset = StringUtils.skipWS(raw, offset);
+        let scriptletMaskLength = 0;
+        if (raw.startsWith(UBO_SCRIPTLET_MASK, offset)) {
+            scriptletMaskLength = UBO_SCRIPTLET_MASK.length;
+        }
+        else if (raw.startsWith(UBO_SCRIPTLET_MASK_LEGACY, offset)) {
+            scriptletMaskLength = UBO_SCRIPTLET_MASK_LEGACY.length;
+        }
+        // Scriptlet call should start with "+js"
+        if (!scriptletMaskLength) {
+            throw new AdblockSyntaxError(this.ERROR_MESSAGES.NO_SCRIPTLET_MASK, baseOffset + offset, baseOffset + raw.length);
+        }
+        offset += scriptletMaskLength;
+        // Whitespace is not allowed after the mask
+        if (raw[offset] === SPACE) {
+            throw new AdblockSyntaxError(this.ERROR_MESSAGES.WHITESPACE_AFTER_MASK, baseOffset + offset, baseOffset + raw.length);
+        }
+        // Parameter list should be wrapped in parentheses
+        if (raw[offset] !== OPEN_PARENTHESIS) {
+            throw new AdblockSyntaxError(this.ERROR_MESSAGES.NO_OPENING_PARENTHESIS, baseOffset + offset, baseOffset + raw.length);
+        }
+        // Save the offset of the opening parentheses
+        const openingParenthesesIndex = offset;
+        // Skip whitespace from the end
+        const closingParenthesesIndex = StringUtils.skipWSBack(raw, raw.length - 1);
+        // Closing parentheses should be present
+        if (raw[closingParenthesesIndex] !== CLOSE_PARENTHESIS
+            || raw[closingParenthesesIndex - 1] === ESCAPE_CHARACTER) {
+            throw new AdblockSyntaxError(this.ERROR_MESSAGES.NO_CLOSING_PARENTHESIS, baseOffset + offset, baseOffset + raw.length);
+        }
+        const result = {
+            type: 'ScriptletInjectionRuleBody',
+            children: [],
+        };
+        if (options.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        // Special case: empty scriptlet call, like +js(), +js( ), etc.
+        if (StringUtils.skipWS(raw, openingParenthesesIndex + 1) === closingParenthesesIndex) {
+            return result;
+        }
+        // Parse parameter list
+        const params = UboParameterListParser.parse(raw.slice(openingParenthesesIndex + 1, closingParenthesesIndex), options, baseOffset + openingParenthesesIndex + 1, COMMA);
+        // Do not allow parameters without scriptlet: +js(, arg0, arg1)
+        if (params.children.length > 0 && params.children[0] === null) {
+            throw new AdblockSyntaxError(this.ERROR_MESSAGES.NO_SCRIPTLET_NAME, baseOffset + offset, baseOffset + raw.length);
+        }
+        result.children.push(params);
+        return result;
+    }
+}
+
+export { UboScriptletInjectionBodyParser };