@adguard/agtree 2.2.0 → 3.0.0-alpha.2

package/dist/converter/cosmetic/rule-modifiers/adg.js

@@ -0,0 +1,79 @@
+/*
+ * 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 { RuleConversionError } from '../../../errors/rule-conversion-error.js';
+import { createModifierNode } from '../../../ast-utils/modifiers.js';
+import { RegExpUtils } from '../../../utils/regexp.js';
+import { REGEX_MARKER, OPEN_SQUARE_BRACKET, CLOSE_SQUARE_BRACKET, COMMA, ESCAPE_CHARACTER } from '../../../utils/constants.js';
+import { StringUtils } from '../../../utils/string.js';
+import { MultiValueMap } from '../../../utils/multi-value-map.js';
+import { clone } from '../../../utils/clone.js';
+import { createConversionResult } from '../../base-interfaces/conversion-result.js';
+
+/**
+ * @file Cosmetic rule modifier converter from uBO to ADG
+ */
+const UBO_MATCHES_PATH_OPERATOR = 'matches-path';
+const ADG_PATH_MODIFIER = 'path';
+/**
+ * Special characters in modifier regexps that should be escaped
+ */
+const SPECIAL_MODIFIER_REGEX_CHARS = new Set([
+    OPEN_SQUARE_BRACKET,
+    CLOSE_SQUARE_BRACKET,
+    COMMA,
+    ESCAPE_CHARACTER,
+]);
+/**
+ * Helper class for converting cosmetic rule modifiers from uBO to ADG
+ */
+class AdgCosmeticRuleModifierConverter {
+    /**
+     * Converts a uBO cosmetic rule modifier list to ADG, if possible.
+     *
+     * @param modifierList Cosmetic rule modifier list node to convert
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
+     * @throws If the modifier list cannot be converted
+     * @see {@link https://github.com/gorhill/uBlock/wiki/Procedural-cosmetic-filters#cosmetic-filter-operators}
+     */
+    static convertFromUbo(modifierList) {
+        const conversionMap = new MultiValueMap();
+        modifierList.children.forEach((modifier, index) => {
+            // :matches-path
+            if (modifier.name.value === UBO_MATCHES_PATH_OPERATOR) {
+                if (!modifier.value) {
+                    throw new RuleConversionError(`'${UBO_MATCHES_PATH_OPERATOR}' operator requires a value`);
+                }
+                const value = RegExpUtils.isRegexPattern(modifier.value.value)
+                    ? StringUtils.escapeCharacters(modifier.value.value, SPECIAL_MODIFIER_REGEX_CHARS)
+                    : modifier.value.value;
+                // Convert uBO's `:matches-path(...)` operator to ADG's `$path=...` modifier
+                conversionMap.add(index, createModifierNode(ADG_PATH_MODIFIER, 
+                // We should negate the regexp if the modifier is an exception
+                modifier.exception
+                    // eslint-disable-next-line max-len
+                    ? `${REGEX_MARKER}${RegExpUtils.negateRegexPattern(RegExpUtils.patternToRegexp(value))}${REGEX_MARKER}`
+                    : value));
+            }
+        });
+        // Check if we have any converted modifiers
+        if (conversionMap.size) {
+            const modifierListClone = clone(modifierList);
+            // Replace the original modifiers with the converted ones
+            modifierListClone.children = modifierListClone.children.map((modifier, index) => {
+                const convertedModifier = conversionMap.get(index);
+                return convertedModifier ?? modifier;
+            }).flat();
+            return createConversionResult(modifierListClone, true);
+        }
+        // Otherwise, just return the original modifier list
+        return createConversionResult(modifierList, false);
+    }
+}
+
+export { AdgCosmeticRuleModifierConverter };

package/dist/converter/cosmetic/scriptlet.js

@@ -0,0 +1,354 @@
+/*
+ * 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 { CosmeticRuleSeparator } from '../../nodes/index.js';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base.js';
+import { AdblockSyntax } from '../../utils/adblockers.js';
+import { QuoteUtils, QuoteType } from '../../utils/quotes.js';
+import { EMPTY, SPACE } from '../../utils/constants.js';
+import { getScriptletName, setScriptletName, transformAllScriptletArguments, setScriptletQuoteType, transformNthScriptletArgument } from '../../ast-utils/scriptlets.js';
+import { createNodeConversionResult } from '../base-interfaces/conversion-result.js';
+import { cloneScriptletRuleNode, cloneDomainListNode, cloneModifierListNode } from '../../ast-utils/clone.js';
+import '../../compatibility-tables/modifiers.js';
+import '../../compatibility-tables/redirects.js';
+import { scriptletsCompatibilityTable } from '../../compatibility-tables/scriptlets.js';
+import { GenericPlatform } from '../../compatibility-tables/platforms.js';
+import '../../compatibility-tables/schemas/base.js';
+import '../../compatibility-tables/schemas/modifier.js';
+import '../../compatibility-tables/schemas/redirect.js';
+import '../../compatibility-tables/schemas/scriptlet.js';
+import '../../compatibility-tables/schemas/platform.js';
+import '../../compatibility-tables/utils/platform-helpers.js';
+import '../../compatibility-tables/schemas/resource-type.js';
+import '../../compatibility-tables/utils/resource-type-helpers.js';
+import { isUndefined, isNull } from '../../utils/type-guards.js';
+
+/**
+ * @file Scriptlet injection rule converter
+ */
+const ABP_SCRIPTLET_PREFIX = 'abp-';
+const UBO_SCRIPTLET_PREFIX = 'ubo-';
+const UBO_SCRIPTLET_PREFIX_LENGTH = UBO_SCRIPTLET_PREFIX.length;
+const UBO_SCRIPTLET_JS_SUFFIX = '.js';
+const UBO_SCRIPTLET_JS_SUFFIX_LENGTH = UBO_SCRIPTLET_JS_SUFFIX.length;
+const COMMA_SEPARATOR = ',';
+const ADG_SET_CONSTANT_NAME = 'set-constant';
+const ADG_SET_CONSTANT_EMPTY_STRING = '';
+const ADG_SET_CONSTANT_EMPTY_ARRAY = 'emptyArr';
+const ADG_SET_CONSTANT_EMPTY_OBJECT = 'emptyObj';
+const UBO_SET_CONSTANT_EMPTY_STRING = '\'\'';
+const UBO_SET_CONSTANT_EMPTY_ARRAY = '[]';
+const UBO_SET_CONSTANT_EMPTY_OBJECT = '{}';
+const ADG_PREVENT_FETCH_NAME = 'prevent-fetch';
+const ADG_PREVENT_FETCH_EMPTY_STRING = '';
+const ADG_PREVENT_FETCH_WILDCARD = '*';
+const UBO_NO_FETCH_IF_WILDCARD = '/^/';
+const UBO_REMOVE_CLASS_NAME = 'remove-class.js';
+const UBO_REMOVE_ATTR_NAME = 'remove-attr.js';
+const setConstantAdgToUboMap = {
+    [ADG_SET_CONSTANT_EMPTY_STRING]: UBO_SET_CONSTANT_EMPTY_STRING,
+    [ADG_SET_CONSTANT_EMPTY_ARRAY]: UBO_SET_CONSTANT_EMPTY_ARRAY,
+    [ADG_SET_CONSTANT_EMPTY_OBJECT]: UBO_SET_CONSTANT_EMPTY_OBJECT,
+};
+const REMOVE_ATTR_CLASS_APPLYING = new Set([
+    'asap',
+    'stay',
+    'complete',
+]);
+/**
+ * Scriptlet injection rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class ScriptletRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a scriptlet injection rule to AdGuard format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToAdg(rule) {
+        // Ignore AdGuard rules
+        if (rule.syntax === AdblockSyntax.Adg) {
+            return createNodeConversionResult([rule], false);
+        }
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
+        convertedSeparator = rule.exception
+            ? CosmeticRuleSeparator.AdgJsInjectionException
+            : CosmeticRuleSeparator.AdgJsInjection;
+        const convertedScriptlets = [];
+        for (const scriptlet of rule.body.children) {
+            // Clone the node to avoid any side effects
+            const scriptletClone = cloneScriptletRuleNode(scriptlet);
+            // Remove possible quotes just to make it easier to work with the scriptlet name
+            const scriptletName = QuoteUtils.setStringQuoteType(getScriptletName(scriptletClone), QuoteType.None);
+            // Add prefix if it's not already there
+            let prefix;
+            // In uBO / ABP syntax, if a parameter contains the separator character, it should be escaped,
+            // but during the conversion, we need to unescape them, because AdGuard syntax uses quotes to
+            // distinguish between parameters.
+            let charToUnescape;
+            switch (rule.syntax) {
+                case AdblockSyntax.Abp:
+                    prefix = ABP_SCRIPTLET_PREFIX;
+                    charToUnescape = SPACE;
+                    break;
+                case AdblockSyntax.Ubo:
+                    prefix = UBO_SCRIPTLET_PREFIX;
+                    charToUnescape = COMMA_SEPARATOR;
+                    break;
+                default:
+                    prefix = EMPTY;
+            }
+            if (!scriptletName.startsWith(prefix)) {
+                setScriptletName(scriptletClone, `${prefix}${scriptletName}`);
+            }
+            if (!isUndefined(charToUnescape)) {
+                transformAllScriptletArguments(scriptletClone, (value) => {
+                    if (!isNull(value)) {
+                        return QuoteUtils.unescapeSingleEscapedOccurrences(value, charToUnescape);
+                    }
+                    return value;
+                });
+            }
+            if (rule.syntax === AdblockSyntax.Ubo) {
+                const scriptletData = scriptletsCompatibilityTable.getFirst(scriptletName, GenericPlatform.UboAny);
+                // Some scriptlets have special values that need to be converted
+                if (scriptletData
+                    && (scriptletData.name === UBO_REMOVE_CLASS_NAME
+                        || scriptletData.name === UBO_REMOVE_ATTR_NAME)
+                    && scriptletClone.children.length > 2) {
+                    const selectors = [];
+                    let applying = null;
+                    let lastArg = scriptletClone.children.pop();
+                    // The very last argument might be the 'applying' parameter
+                    if (lastArg) {
+                        if (REMOVE_ATTR_CLASS_APPLYING.has(lastArg.value)) {
+                            applying = lastArg.value;
+                        }
+                        else {
+                            selectors.push(lastArg.value);
+                        }
+                    }
+                    while (scriptletClone.children.length > 2) {
+                        lastArg = scriptletClone.children.pop();
+                        if (lastArg) {
+                            selectors.push(lastArg.value.trim());
+                        }
+                    }
+                    // Set last arg to be the combined selectors (in reverse order, because we popped them)
+                    if (selectors.length > 0) {
+                        scriptletClone.children.push({
+                            type: 'Value',
+                            value: selectors.reverse().join(', '),
+                        });
+                    }
+                    // Push back the 'applying' parameter if it was found previously
+                    if (!isNull(applying)) {
+                        // If we don't have any selectors,
+                        // we need to add an empty parameter before the 'applying' one
+                        if (selectors.length === 0) {
+                            scriptletClone.children.push({
+                                type: 'Value',
+                                value: EMPTY,
+                            });
+                        }
+                        scriptletClone.children.push({
+                            type: 'Value',
+                            value: applying,
+                        });
+                    }
+                }
+            }
+            // ADG scriptlet parameters should be quoted, and single quoted are preferred
+            setScriptletQuoteType(scriptletClone, QuoteType.Single);
+            convertedScriptlets.push(scriptletClone);
+        }
+        if (rule.body.children.length === 0) {
+            const convertedScriptletNode = {
+                category: rule.category,
+                type: rule.type,
+                syntax: AdblockSyntax.Adg,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: convertedSeparator,
+                },
+                body: {
+                    type: rule.body.type,
+                    children: [],
+                },
+            };
+            if (rule.modifiers) {
+                convertedScriptletNode.modifiers = cloneModifierListNode(rule.modifiers);
+            }
+            return createNodeConversionResult([convertedScriptletNode], true);
+        }
+        return createNodeConversionResult(convertedScriptlets.map((scriptlet) => {
+            const res = {
+                category: rule.category,
+                type: rule.type,
+                syntax: AdblockSyntax.Adg,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: convertedSeparator,
+                },
+                body: {
+                    type: rule.body.type,
+                    children: [scriptlet],
+                },
+            };
+            if (rule.modifiers) {
+                res.modifiers = cloneModifierListNode(rule.modifiers);
+            }
+            return res;
+        }), true);
+    }
+    /**
+     * Converts a scriptlet injection rule to uBlock format, if possible.
+     *
+     * @param rule Rule node to convert
+     * @returns An object which follows the {@link NodeConversionResult} interface. Its `result` property contains
+     * the array of converted rule nodes, and its `isConverted` flag indicates whether the original rule was converted.
+     * If the rule was not converted, the result array will contain the original node with the same object reference
+     * @throws If the rule is invalid or cannot be converted
+     */
+    static convertToUbo(rule) {
+        // Ignore uBlock rules
+        if (rule.syntax === AdblockSyntax.Ubo) {
+            return createNodeConversionResult([rule], false);
+        }
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
+        convertedSeparator = rule.exception
+            ? CosmeticRuleSeparator.ElementHidingException
+            : CosmeticRuleSeparator.ElementHiding;
+        const convertedScriptlets = [];
+        for (const scriptlet of rule.body.children) {
+            // Clone the node to avoid any side effects
+            const scriptletClone = cloneScriptletRuleNode(scriptlet);
+            // Remove possible quotes just to make it easier to work with the scriptlet name
+            const scriptletName = QuoteUtils.setStringQuoteType(getScriptletName(scriptletClone), QuoteType.None);
+            let uboScriptletName;
+            if (rule.syntax === AdblockSyntax.Adg && scriptletName.startsWith(UBO_SCRIPTLET_PREFIX)) {
+                // Special case: AdGuard syntax 'preserves' the original scriptlet name,
+                // so we need to convert it back by removing the uBO prefix
+                uboScriptletName = scriptletName.slice(UBO_SCRIPTLET_PREFIX_LENGTH);
+            }
+            else {
+                // Otherwise, try to find the corresponding uBO scriptlet name, or use the original one if not found
+                const uboScriptlet = scriptletsCompatibilityTable.getFirst(scriptletName, GenericPlatform.UboAny);
+                uboScriptletName = uboScriptlet?.name ?? scriptletName;
+            }
+            // Remove the '.js' suffix if it's there - its presence is not mandatory
+            if (uboScriptletName.endsWith(UBO_SCRIPTLET_JS_SUFFIX)) {
+                uboScriptletName = uboScriptletName.slice(0, -UBO_SCRIPTLET_JS_SUFFIX_LENGTH);
+            }
+            setScriptletName(scriptletClone, uboScriptletName);
+            setScriptletQuoteType(scriptletClone, QuoteType.None);
+            // Escape unescaped commas in parameters, because uBlock Origin uses them as separators.
+            // For example, the following AdGuard rule:
+            //
+            // example.com#%#//scriptlet('spoof-css', '.adsbygoogle, #ads', 'visibility', 'visible')
+            //
+            //      ↓↓ should be converted to ↓↓
+            //
+            // example.com##+js(spoof-css.js, .adsbygoogle\, #ads, visibility, visible)
+            //                  ------------  -------------------  ----------  -------
+            //                    arg 0              arg 1           arg 2      arg 3
+            //
+            // and we need to escape the comma in the second argument to prevent it from being treated
+            // as two separate arguments.
+            transformAllScriptletArguments(scriptletClone, (value) => {
+                if (!isNull(value)) {
+                    return QuoteUtils.escapeUnescapedOccurrences(value, COMMA_SEPARATOR);
+                }
+                return value;
+            });
+            // Unescape spaces in parameters, because uBlock Origin doesn't treat them as separators.
+            if (rule.syntax === AdblockSyntax.Abp) {
+                transformAllScriptletArguments(scriptletClone, (value) => {
+                    if (!isNull(value)) {
+                        return QuoteUtils.unescapeSingleEscapedOccurrences(value, SPACE);
+                    }
+                    return value;
+                });
+            }
+            // Some scriptlets have special values that need to be converted
+            switch (scriptletName) {
+                case ADG_SET_CONSTANT_NAME:
+                    transformNthScriptletArgument(scriptletClone, 2, (value) => {
+                        if (!isNull(value)) {
+                            return setConstantAdgToUboMap[value] ?? value;
+                        }
+                        return value;
+                    });
+                    break;
+                case ADG_PREVENT_FETCH_NAME:
+                    transformNthScriptletArgument(scriptletClone, 1, (value) => {
+                        if (value === ADG_PREVENT_FETCH_EMPTY_STRING || value === ADG_PREVENT_FETCH_WILDCARD) {
+                            return UBO_NO_FETCH_IF_WILDCARD;
+                        }
+                        return value;
+                    });
+                    break;
+            }
+            convertedScriptlets.push(scriptletClone);
+        }
+        // TODO: Refactor redundant code
+        if (rule.body.children.length === 0) {
+            const convertedScriptletNode = {
+                category: rule.category,
+                type: rule.type,
+                syntax: AdblockSyntax.Ubo,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: convertedSeparator,
+                },
+                body: {
+                    type: rule.body.type,
+                    children: [],
+                },
+            };
+            if (rule.modifiers) {
+                convertedScriptletNode.modifiers = cloneModifierListNode(rule.modifiers);
+            }
+            return createNodeConversionResult([convertedScriptletNode], true);
+        }
+        return createNodeConversionResult(convertedScriptlets.map((scriptlet) => {
+            const res = {
+                category: rule.category,
+                type: rule.type,
+                syntax: AdblockSyntax.Ubo,
+                exception: rule.exception,
+                domains: cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: convertedSeparator,
+                },
+                body: {
+                    type: rule.body.type,
+                    children: [scriptlet],
+                },
+            };
+            if (rule.modifiers) {
+                res.modifiers = cloneModifierListNode(rule.modifiers);
+            }
+            return res;
+        }), true);
+    }
+}
+
+export { ScriptletRuleConverter };

package/dist/converter/css/index.js

@@ -0,0 +1,188 @@
+/*
+ * 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 { getFormattedTokenName, TokenType } from '@adguard/css-tokenizer';
+import { sprintf } from 'sprintf-js';
+import { EQUALS, COLON, CLOSE_PARENTHESIS, OPEN_PARENTHESIS, COMMA, EMPTY } from '../../utils/constants.js';
+import { LEGACY_EXT_CSS_ATTRIBUTE_PREFIX, ABP_EXT_CSS_PREFIX } from '../data/css.js';
+import { BaseConverter } from '../base-interfaces/base-converter.js';
+import { createConversionResult } from '../base-interfaces/conversion-result.js';
+import { CssTokenStream } from '../../parser/css/css-token-stream.js';
+
+const ERROR_MESSAGES = {
+    // eslint-disable-next-line max-len
+    INVALID_ATTRIBUTE_VALUE: `Expected '${getFormattedTokenName(TokenType.Ident)}' or '${getFormattedTokenName(TokenType.String)}' as attribute value, but got '%s' with value '%s`,
+};
+const PseudoClasses = {
+    AbpContains: '-abp-contains',
+    AbpHas: '-abp-has',
+    Contains: 'contains',
+    Has: 'has',
+    HasText: 'has-text',
+    MatchesCss: 'matches-css',
+    MatchesCssAfter: 'matches-css-after',
+    MatchesCssBefore: 'matches-css-before',
+    Not: 'not',
+};
+const PseudoElements = {
+    After: 'after',
+    Before: 'before',
+};
+const PSEUDO_ELEMENT_NAMES = new Set([
+    PseudoElements.After,
+    PseudoElements.Before,
+]);
+/**
+ * CSS selector converter
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class CssSelectorConverter extends BaseConverter {
+    /**
+     * Converts Extended CSS elements to AdGuard-compatible ones
+     *
+     * @param selectorList Selector list to convert
+     * @returns An object which follows the {@link ConversionResult} interface. Its `result` property contains
+     * the converted node, and its `isConverted` flag indicates whether the original node was converted.
+     * If the node was not converted, the result will contain the original node with the same object reference
+     * @throws If the rule is invalid or incompatible
+     */
+    static convertToAdg(selectorList) {
+        const stream = selectorList instanceof CssTokenStream
+            ? selectorList
+            : new CssTokenStream(selectorList);
+        const converted = [];
+        const convertAndPushPseudo = (pseudo) => {
+            switch (pseudo) {
+                case PseudoClasses.AbpContains:
+                case PseudoClasses.HasText:
+                    converted.push(PseudoClasses.Contains);
+                    converted.push(OPEN_PARENTHESIS);
+                    break;
+                case PseudoClasses.AbpHas:
+                    converted.push(PseudoClasses.Has);
+                    converted.push(OPEN_PARENTHESIS);
+                    break;
+                // a bit special case:
+                // - `:matches-css-before(...)` → `:matches-css(before, ...)`
+                // - `:matches-css-after(...)`  → `:matches-css(after, ...)`
+                case PseudoClasses.MatchesCssBefore:
+                case PseudoClasses.MatchesCssAfter:
+                    converted.push(PseudoClasses.MatchesCss);
+                    converted.push(OPEN_PARENTHESIS);
+                    converted.push(pseudo.substring(PseudoClasses.MatchesCss.length + 1));
+                    converted.push(COMMA);
+                    break;
+                default:
+                    converted.push(pseudo);
+                    converted.push(OPEN_PARENTHESIS);
+                    break;
+            }
+        };
+        while (!stream.isEof()) {
+            const token = stream.getOrFail();
+            if (token.type === TokenType.Colon) {
+                // Advance colon
+                stream.advance();
+                converted.push(COLON);
+                const tempToken = stream.getOrFail();
+                // Double colon is a pseudo-element
+                if (tempToken.type === TokenType.Colon) {
+                    stream.advance();
+                    converted.push(COLON);
+                    continue;
+                }
+                if (tempToken.type === TokenType.Ident) {
+                    const name = stream.source.slice(tempToken.start, tempToken.end);
+                    if (PSEUDO_ELEMENT_NAMES.has(name)) {
+                        // Add an extra colon to the name
+                        converted.push(COLON);
+                        converted.push(name);
+                    }
+                    else {
+                        // Add the name as is
+                        converted.push(name);
+                    }
+                    // Advance the names
+                    stream.advance();
+                }
+                else if (tempToken.type === TokenType.Function) {
+                    const name = stream.source.slice(tempToken.start, tempToken.end - 1); // omit the last parenthesis
+                    // :-abp-contains(...) → :contains(...)
+                    // :has-text(...)      → :contains(...)
+                    // :-abp-has(...)      → :has(...)
+                    convertAndPushPseudo(name);
+                    // Advance the function name
+                    stream.advance();
+                }
+            }
+            else if (token.type === TokenType.OpenSquareBracket) {
+                let tempToken;
+                const { start } = token;
+                stream.advance();
+                // Converts legacy Extended CSS selectors to the modern Extended CSS syntax.
+                // For example:
+                // - `[-ext-has=...]`                  → `:has(...)`
+                // - `[-ext-contains=...]`             → `:contains(...)`
+                // - `[-ext-matches-css-before=...]`   → `:matches-css(before, ...)`
+                stream.skipWhitespace();
+                stream.expect(TokenType.Ident);
+                tempToken = stream.getOrFail();
+                let attr = stream.source.slice(tempToken.start, tempToken.end);
+                // Skip if the attribute name is not a legacy Extended CSS one
+                if (!(attr.startsWith(LEGACY_EXT_CSS_ATTRIBUTE_PREFIX) || attr.startsWith(ABP_EXT_CSS_PREFIX))) {
+                    converted.push(stream.source.slice(start, tempToken.end));
+                    stream.advance();
+                    continue;
+                }
+                if (attr.startsWith(LEGACY_EXT_CSS_ATTRIBUTE_PREFIX)) {
+                    attr = attr.slice(LEGACY_EXT_CSS_ATTRIBUTE_PREFIX.length);
+                }
+                stream.advance();
+                stream.skipWhitespace();
+                // Next token should be an equality operator (=), because Extended CSS attribute selectors
+                // do not support other operators
+                stream.expect(TokenType.Delim, { value: EQUALS });
+                stream.advance();
+                // Skip optional whitespace after the operator
+                stream.skipWhitespace();
+                // Parse attribute value
+                tempToken = stream.getOrFail();
+                // According to the spec, attribute value should be an identifier or a string
+                if (tempToken.type !== TokenType.Ident && tempToken.type !== TokenType.String) {
+                    throw new Error(sprintf(ERROR_MESSAGES.INVALID_ATTRIBUTE_VALUE, getFormattedTokenName(tempToken.type), stream.source.slice(tempToken.start, tempToken.end)));
+                }
+                const value = stream.source.slice(tempToken.start, tempToken.end);
+                // Advance the attribute value
+                stream.advance();
+                // Skip optional whitespace after the attribute value
+                stream.skipWhitespace();
+                // Next character should be a closing square bracket
+                // We don't allow flags for Extended CSS attribute selectors
+                stream.expect(TokenType.CloseSquareBracket);
+                stream.advance();
+                converted.push(COLON);
+                convertAndPushPseudo(attr);
+                let processedValue = value.slice(1, -1); // omit the quotes
+                if (attr === PseudoClasses.Has) {
+                    // TODO: Optimize this to avoid double tokenization
+                    processedValue = CssSelectorConverter.convertToAdg(processedValue).result;
+                }
+                converted.push(processedValue);
+                converted.push(CLOSE_PARENTHESIS);
+            }
+            else {
+                converted.push(stream.source.slice(token.start, token.end));
+                // Advance the token
+                stream.advance();
+            }
+        }
+        const convertedSelectorList = converted.join(EMPTY);
+        return createConversionResult(convertedSelectorList, stream.source !== convertedSelectorList);
+    }
+}
+
+export { CssSelectorConverter, ERROR_MESSAGES, PseudoClasses, PseudoElements };