@adguard/agtree 2.1.3 → 3.0.0

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

@@ -0,0 +1,201 @@
+/*
+ * 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
+ */
+'use strict';
+
+var adblockers = require('../../utils/adblockers.js');
+var constants = require('../../utils/constants.js');
+var string = require('../../utils/string.js');
+var index = require('../../nodes/index.js');
+var logicalExpressionParser = require('../misc/logical-expression-parser.js');
+var adblockSyntaxError = require('../../errors/adblock-syntax-error.js');
+var parameterListParser = require('../misc/parameter-list-parser.js');
+var options = require('../options.js');
+var baseParser = require('../base-parser.js');
+var valueParser = require('../misc/value-parser.js');
+
+/**
+ * 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.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(constants.PREPROCESSOR_MARKER) && trimmed[constants.PREPROCESSOR_MARKER_LEN] !== constants.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$1 = 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 = string.StringUtils.skipWS(raw, offset);
+        // Ignore the pre-processor marker
+        offset += constants.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 = string.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 === constants.PREPROCESSOR_SEPARATOR || ch === constants.OPEN_PARENTHESIS) {
+                break;
+            }
+            offset += 1;
+        }
+        // Save name end offset
+        const nameEnd = offset;
+        // Create name node
+        const name = valueParser.ValueParser.parse(raw.slice(nameStart, nameEnd), options$1, 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 = string.StringUtils.skipWS(raw, offset);
+        // If the directive name is "safari_cb_affinity", then we have a special case
+        if (name.value === constants.SAFARI_CB_AFFINITY) {
+            // Throw error if there are spaces after the directive name
+            if (offset > nameEnd) {
+                throw new adblockSyntaxError.AdblockSyntaxError(`Unexpected whitespace after "${constants.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 (string.StringUtils.skipWS(raw, offset) !== raw.length) {
+                if (raw[offset] !== constants.OPEN_PARENTHESIS) {
+                    throw new adblockSyntaxError.AdblockSyntaxError(`Unexpected character '${raw[offset]}' after '${constants.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 = string.StringUtils.skipWSBack(raw);
+                if (closingParenthesesIndex === -1 || raw[closingParenthesesIndex] !== constants.CLOSE_PARENTHESIS) {
+                    throw new adblockSyntaxError.AdblockSyntaxError(`Missing closing parenthesis for '${constants.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: index.CommentRuleType.PreProcessorCommentRule,
+                    category: index.RuleCategory.Comment,
+                    syntax: adblockers.AdblockSyntax.Adg,
+                    name,
+                    // comma separated list of parameters
+                    params: parameterListParser.ParameterListParser.parse(raw.slice(parameterListStart, parameterListEnd), options$1, baseOffset + parameterListStart, constants.COMMA),
+                };
+                if (options$1.includeRaws) {
+                    result.raws = {
+                        text: raw,
+                    };
+                }
+                if (options$1.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 === constants.IF || name.value === constants.INCLUDE) {
+                throw new adblockSyntaxError.AdblockSyntaxError(`Directive "${name.value}" requires parameters`, baseOffset, baseOffset + raw.length);
+            }
+            const result = {
+                type: index.CommentRuleType.PreProcessorCommentRule,
+                category: index.RuleCategory.Comment,
+                syntax: adblockers.AdblockSyntax.Common,
+                name,
+            };
+            if (options$1.includeRaws) {
+                result.raws = {
+                    text: raw,
+                };
+            }
+            if (options$1.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 = string.StringUtils.skipWSBack(raw) + 1;
+        // Prepare parameters node
+        let params;
+        // Parse parameters. Handle "if" and "safari_cb_affinity" directives
+        // separately.
+        if (name.value === constants.IF) {
+            params = logicalExpressionParser.LogicalExpressionParser.parse(raw.slice(paramsStart, paramsEnd), options$1, baseOffset + paramsStart);
+        }
+        else {
+            params = valueParser.ValueParser.parse(raw.slice(paramsStart, paramsEnd), options$1, baseOffset + paramsStart);
+        }
+        const result = {
+            type: index.CommentRuleType.PreProcessorCommentRule,
+            category: index.RuleCategory.Comment,
+            syntax: adblockers.AdblockSyntax.Common,
+            name,
+            params,
+        };
+        if (options$1.includeRaws) {
+            result.raws = {
+                text: raw,
+            };
+        }
+        if (options$1.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        return result;
+    }
+}
+
+exports.PreProcessorCommentParser = PreProcessorCommentParser;

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

@@ -0,0 +1,108 @@
+/*
+ * 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
+ */
+'use strict';
+
+var adblockers = require('../../utils/adblockers.js');
+var cosmeticRuleSeparator = require('../../utils/cosmetic-rule-separator.js');
+var string = require('../../utils/string.js');
+var index = require('../../nodes/index.js');
+var baseParser = require('../base-parser.js');
+var valueParser = require('../misc/value-parser.js');
+var options = require('../options.js');
+
+/**
+ * `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.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(index.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(index.CommentMarker.Hashmark)) {
+            const result = cosmeticRuleSeparator.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]
+                || string.StringUtils.isWhitespace(trimmed[end + 1])
+                || (trimmed[end + 1] === index.CommentMarker.Hashmark && trimmed[end + 2] === index.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$1 = 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 = string.StringUtils.skipWS(raw, offset);
+        // Get comment marker
+        const marker = valueParser.ValueParser.parse(raw[offset], options$1, baseOffset + offset);
+        // Skip marker
+        offset += 1;
+        // Get comment text
+        const text = valueParser.ValueParser.parse(raw.slice(offset), options$1, baseOffset + offset);
+        // Regular comment rule
+        const result = {
+            category: index.RuleCategory.Comment,
+            type: index.CommentRuleType.CommentRule,
+            // TODO: Change syntax when hashmark is used
+            syntax: adblockers.AdblockSyntax.Common,
+            marker,
+            text,
+        };
+        if (options$1.includeRaws) {
+            result.raws = {
+                text: raw,
+            };
+        }
+        if (options$1.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        return result;
+    }
+}
+
+exports.SimpleCommentParser = SimpleCommentParser;

package/dist/cjs/parser/cosmetic/body/abp-snippet-injection-body-parser.js

@@ -0,0 +1,81 @@
+/*
+ * 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
+ */
+'use strict';
+
+var constants = require('../../../utils/constants.js');
+var string = require('../../../utils/string.js');
+var adblockSyntaxError = require('../../../errors/adblock-syntax-error.js');
+var parameterListParser = require('../../misc/parameter-list-parser.js');
+var options = require('../../options.js');
+var baseParser = require('../../base-parser.js');
+var abpSnippetInjectionBodyCommon = require('../../../common/abp-snippet-injection-body-common.js');
+
+/**
+ * @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.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$1 = options.defaultParserOptions, baseOffset = 0) {
+        const result = {
+            type: 'ScriptletInjectionRuleBody',
+            children: [],
+        };
+        if (options$1.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        let offset = 0;
+        // Skip leading spaces
+        offset = string.StringUtils.skipWS(raw, offset);
+        while (offset < raw.length) {
+            offset = string.StringUtils.skipWS(raw, offset);
+            const scriptletCallStart = offset;
+            // Find the next semicolon or the end of the string
+            let semicolonIndex = string.StringUtils.findUnescapedNonStringNonRegexChar(raw, constants.SEMICOLON, offset);
+            if (semicolonIndex === -1) {
+                semicolonIndex = raw.length;
+            }
+            const scriptletCallEnd = Math.max(string.StringUtils.skipWSBack(raw, semicolonIndex - 1) + 1, scriptletCallStart);
+            const params = parameterListParser.ParameterListParser.parse(raw.slice(scriptletCallStart, scriptletCallEnd), options$1, baseOffset + scriptletCallStart, constants.SPACE);
+            // Parse the scriptlet call
+            result.children.push(params);
+            // Skip the semicolon
+            offset = semicolonIndex + 1;
+        }
+        if (result.children.length === 0) {
+            throw new adblockSyntaxError.AdblockSyntaxError(abpSnippetInjectionBodyCommon.AbpSnippetInjectionBodyCommon.ERROR_MESSAGES.EMPTY_SCRIPTLET_CALL, baseOffset, baseOffset + raw.length);
+        }
+        return result;
+    }
+}
+
+exports.AbpSnippetInjectionBodyParser = AbpSnippetInjectionBodyParser;

package/dist/cjs/parser/cosmetic/body/adg-scriptlet-injection-body-parser.js

@@ -0,0 +1,151 @@
+/*
+ * 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
+ */
+'use strict';
+
+var sprintfJs = require('sprintf-js');
+var constants = require('../../../utils/constants.js');
+var string = require('../../../utils/string.js');
+var adblockSyntaxError = require('../../../errors/adblock-syntax-error.js');
+var options = require('../../options.js');
+var baseParser = require('../../base-parser.js');
+var valueParser = require('../../misc/value-parser.js');
+var typeGuards = require('../../../utils/type-guards.js');
+
+/**
+ * @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.BaseParser {
+    /**
+     * Error messages used by the parser.
+     */
+    static ERROR_MESSAGES = {
+        NO_SCRIPTLET_MASK: `Invalid ADG scriptlet call, no scriptlet call mask '${constants.ADG_SCRIPTLET_MASK}' found`,
+        NO_OPENING_PARENTHESIS: `Invalid ADG scriptlet call, no opening parentheses '${constants.OPEN_PARENTHESIS}' found`,
+        NO_CLOSING_PARENTHESIS: `Invalid ADG scriptlet call, no closing parentheses '${constants.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$1 = options.defaultParserOptions, baseOffset = 0) {
+        let offset = 0;
+        // Skip leading spaces
+        offset = string.StringUtils.skipWS(raw, offset);
+        // Scriptlet call should start with "//scriptlet"
+        if (!raw.startsWith(constants.ADG_SCRIPTLET_MASK, offset)) {
+            throw new adblockSyntaxError.AdblockSyntaxError(this.ERROR_MESSAGES.NO_SCRIPTLET_MASK, baseOffset + offset, baseOffset + raw.length);
+        }
+        offset += constants.ADG_SCRIPTLET_MASK.length;
+        // Whitespace is not allowed after the mask
+        if (raw[offset] === constants.SPACE) {
+            throw new adblockSyntaxError.AdblockSyntaxError(this.ERROR_MESSAGES.WHITESPACE_AFTER_MASK, baseOffset + offset, baseOffset + raw.length);
+        }
+        // Parameter list should be wrapped in parentheses
+        if (raw[offset] !== constants.OPEN_PARENTHESIS) {
+            throw new adblockSyntaxError.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 = string.StringUtils.skipWSBack(raw, raw.length - 1);
+        // Closing parentheses should be present
+        if (raw[closingParenthesesIndex] !== constants.CLOSE_PARENTHESIS
+            || raw[closingParenthesesIndex - 1] === constants.ESCAPE_CHARACTER) {
+            throw new adblockSyntaxError.AdblockSyntaxError(this.ERROR_MESSAGES.NO_CLOSING_PARENTHESIS, baseOffset + offset, baseOffset + raw.length);
+        }
+        // Skip space, if any
+        offset = string.StringUtils.skipWS(raw, offset + 1);
+        const result = {
+            type: 'ScriptletInjectionRuleBody',
+            children: [],
+        };
+        if (options$1.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        // Special case: empty scriptlet call, like `//scriptlet()`, `//scriptlet( )` etc.
+        if (string.StringUtils.skipWS(raw, openingParenthesesIndex + 1) === closingParenthesesIndex) {
+            return result;
+        }
+        let detectedQuote = null;
+        const parameterList = {
+            type: 'ParameterList',
+            children: [],
+        };
+        if (options$1.isLocIncluded) {
+            parameterList.start = baseOffset + openingParenthesesIndex + 1;
+            parameterList.end = baseOffset + closingParenthesesIndex;
+        }
+        while (offset < closingParenthesesIndex) {
+            // Skip whitespace
+            offset = string.StringUtils.skipWS(raw, offset);
+            // Expect comma if not first parameter
+            if (parameterList.children.length > 0) {
+                if (raw[offset] !== constants.COMMA) {
+                    throw new adblockSyntaxError.AdblockSyntaxError(sprintfJs.sprintf(AdgScriptletInjectionBodyParser.ERROR_MESSAGES.EXPECTED_COMMA, raw[offset]), baseOffset + offset, baseOffset + raw.length);
+                }
+                // Eat the comma
+                offset += 1;
+                // Skip whitespace
+                offset = string.StringUtils.skipWS(raw, offset);
+            }
+            // Next character should be a quote
+            if (raw[offset] === constants.SINGLE_QUOTE || raw[offset] === constants.DOUBLE_QUOTE) {
+                if (typeGuards.isNull(detectedQuote)) {
+                    detectedQuote = raw[offset];
+                }
+                else if (detectedQuote !== raw[offset]) {
+                    throw new adblockSyntaxError.AdblockSyntaxError(AdgScriptletInjectionBodyParser.ERROR_MESSAGES.NO_INCONSISTENT_QUOTES, baseOffset + offset, baseOffset + raw.length);
+                }
+                // Find next unescaped same quote
+                const closingQuoteIndex = string.StringUtils.findNextUnescapedCharacter(raw, detectedQuote, offset + 1);
+                if (closingQuoteIndex === -1) {
+                    throw new adblockSyntaxError.AdblockSyntaxError(AdgScriptletInjectionBodyParser.ERROR_MESSAGES.NO_UNCLOSED_PARAMETER, baseOffset + offset, baseOffset + raw.length);
+                }
+                // Save the parameter
+                const parameter = valueParser.ValueParser.parse(raw.slice(offset, closingQuoteIndex + 1), options$1, baseOffset + offset);
+                parameterList.children.push(parameter);
+                // Move after the closing quote
+                offset = string.StringUtils.skipWS(raw, closingQuoteIndex + 1);
+            }
+            else {
+                throw new adblockSyntaxError.AdblockSyntaxError(sprintfJs.sprintf(AdgScriptletInjectionBodyParser.ERROR_MESSAGES.EXPECTED_QUOTE, raw[offset]), baseOffset + offset, baseOffset + raw.length);
+            }
+        }
+        result.children.push(parameterList);
+        return result;
+    }
+}
+
+exports.AdgScriptletInjectionBodyParser = AdgScriptletInjectionBodyParser;

package/dist/cjs/parser/cosmetic/body/ubo-scriptlet-injection-body-parser.js

@@ -0,0 +1,112 @@
+/*
+ * 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
+ */
+'use strict';
+
+var constants = require('../../../utils/constants.js');
+var string = require('../../../utils/string.js');
+var adblockSyntaxError = require('../../../errors/adblock-syntax-error.js');
+var options = require('../../options.js');
+var baseParser = require('../../base-parser.js');
+var uboParameterListParser = require('../../misc/ubo-parameter-list-parser.js');
+
+/**
+ * @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.BaseParser {
+    /**
+     * Error messages used by the parser.
+     */
+    static ERROR_MESSAGES = {
+        NO_SCRIPTLET_MASK: `Invalid uBO scriptlet call, no scriptlet call mask '${constants.UBO_SCRIPTLET_MASK}' found`,
+        NO_OPENING_PARENTHESIS: `Invalid uBO scriptlet call, no opening parentheses '${constants.OPEN_PARENTHESIS}' found`,
+        NO_CLOSING_PARENTHESIS: `Invalid uBO scriptlet call, no closing parentheses '${constants.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$1 = options.defaultParserOptions, baseOffset = 0) {
+        let offset = 0;
+        // Skip leading spaces
+        offset = string.StringUtils.skipWS(raw, offset);
+        let scriptletMaskLength = 0;
+        if (raw.startsWith(constants.UBO_SCRIPTLET_MASK, offset)) {
+            scriptletMaskLength = constants.UBO_SCRIPTLET_MASK.length;
+        }
+        else if (raw.startsWith(constants.UBO_SCRIPTLET_MASK_LEGACY, offset)) {
+            scriptletMaskLength = constants.UBO_SCRIPTLET_MASK_LEGACY.length;
+        }
+        // Scriptlet call should start with "+js"
+        if (!scriptletMaskLength) {
+            throw new adblockSyntaxError.AdblockSyntaxError(this.ERROR_MESSAGES.NO_SCRIPTLET_MASK, baseOffset + offset, baseOffset + raw.length);
+        }
+        offset += scriptletMaskLength;
+        // Whitespace is not allowed after the mask
+        if (raw[offset] === constants.SPACE) {
+            throw new adblockSyntaxError.AdblockSyntaxError(this.ERROR_MESSAGES.WHITESPACE_AFTER_MASK, baseOffset + offset, baseOffset + raw.length);
+        }
+        // Parameter list should be wrapped in parentheses
+        if (raw[offset] !== constants.OPEN_PARENTHESIS) {
+            throw new adblockSyntaxError.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 = string.StringUtils.skipWSBack(raw, raw.length - 1);
+        // Closing parentheses should be present
+        if (raw[closingParenthesesIndex] !== constants.CLOSE_PARENTHESIS
+            || raw[closingParenthesesIndex - 1] === constants.ESCAPE_CHARACTER) {
+            throw new adblockSyntaxError.AdblockSyntaxError(this.ERROR_MESSAGES.NO_CLOSING_PARENTHESIS, baseOffset + offset, baseOffset + raw.length);
+        }
+        const result = {
+            type: 'ScriptletInjectionRuleBody',
+            children: [],
+        };
+        if (options$1.isLocIncluded) {
+            result.start = baseOffset;
+            result.end = baseOffset + raw.length;
+        }
+        // Special case: empty scriptlet call, like +js(), +js( ), etc.
+        if (string.StringUtils.skipWS(raw, openingParenthesesIndex + 1) === closingParenthesesIndex) {
+            return result;
+        }
+        // Parse parameter list
+        const params = uboParameterListParser.UboParameterListParser.parse(raw.slice(openingParenthesesIndex + 1, closingParenthesesIndex), options$1, baseOffset + openingParenthesesIndex + 1, constants.COMMA);
+        // Do not allow parameters without scriptlet: +js(, arg0, arg1)
+        if (params.children.length > 0 && params.children[0] === null) {
+            throw new adblockSyntaxError.AdblockSyntaxError(this.ERROR_MESSAGES.NO_SCRIPTLET_NAME, baseOffset + offset, baseOffset + raw.length);
+        }
+        result.children.push(params);
+        return result;
+    }
+}
+
+exports.UboScriptletInjectionBodyParser = UboScriptletInjectionBodyParser;