@adguard/agtree 2.1.2 → 3.0.0-alpha.1

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

@@ -0,0 +1,81 @@
+/*
+ * 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
+ */
+'use strict';
+
+var ruleConversionError = require('../../../errors/rule-conversion-error.js');
+var modifiers = require('../../../ast-utils/modifiers.js');
+var regexp = require('../../../utils/regexp.js');
+var constants = require('../../../utils/constants.js');
+var string = require('../../../utils/string.js');
+var multiValueMap = require('../../../utils/multi-value-map.js');
+var clone = require('../../../utils/clone.js');
+var conversionResult = require('../../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([
+    constants.OPEN_SQUARE_BRACKET,
+    constants.CLOSE_SQUARE_BRACKET,
+    constants.COMMA,
+    constants.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.MultiValueMap();
+        modifierList.children.forEach((modifier, index) => {
+            // :matches-path
+            if (modifier.name.value === UBO_MATCHES_PATH_OPERATOR) {
+                if (!modifier.value) {
+                    throw new ruleConversionError.RuleConversionError(`'${UBO_MATCHES_PATH_OPERATOR}' operator requires a value`);
+                }
+                const value = regexp.RegExpUtils.isRegexPattern(modifier.value.value)
+                    ? string.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, modifiers.createModifierNode(ADG_PATH_MODIFIER, 
+                // We should negate the regexp if the modifier is an exception
+                modifier.exception
+                    // eslint-disable-next-line max-len
+                    ? `${constants.REGEX_MARKER}${regexp.RegExpUtils.negateRegexPattern(regexp.RegExpUtils.patternToRegexp(value))}${constants.REGEX_MARKER}`
+                    : value));
+            }
+        });
+        // Check if we have any converted modifiers
+        if (conversionMap.size) {
+            const modifierListClone = clone.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 conversionResult.createConversionResult(modifierListClone, true);
+        }
+        // Otherwise, just return the original modifier list
+        return conversionResult.createConversionResult(modifierList, false);
+    }
+}
+
+exports.AdgCosmeticRuleModifierConverter = AdgCosmeticRuleModifierConverter;

package/dist/cjs/converter/cosmetic/scriptlet.js

@@ -0,0 +1,356 @@
+/*
+ * 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
+ */
+'use strict';
+
+var index = require('../../nodes/index.js');
+var ruleConverterBase = require('../base-interfaces/rule-converter-base.js');
+var adblockers = require('../../utils/adblockers.js');
+var quotes = require('../../utils/quotes.js');
+var constants = require('../../utils/constants.js');
+var scriptlets = require('../../ast-utils/scriptlets.js');
+var conversionResult = require('../base-interfaces/conversion-result.js');
+var clone = require('../../ast-utils/clone.js');
+require('../../compatibility-tables/modifiers.js');
+require('../../compatibility-tables/redirects.js');
+var scriptlets$1 = require('../../compatibility-tables/scriptlets.js');
+var platforms = require('../../compatibility-tables/platforms.js');
+require('../../compatibility-tables/schemas/base.js');
+require('../../compatibility-tables/schemas/modifier.js');
+require('../../compatibility-tables/schemas/redirect.js');
+require('../../compatibility-tables/schemas/scriptlet.js');
+require('../../compatibility-tables/schemas/platform.js');
+require('../../compatibility-tables/utils/platform-helpers.js');
+require('../../compatibility-tables/schemas/resource-type.js');
+require('../../compatibility-tables/utils/resource-type-helpers.js');
+var typeGuards = require('../../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.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 === adblockers.AdblockSyntax.Adg) {
+            return conversionResult.createNodeConversionResult([rule], false);
+        }
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
+        convertedSeparator = rule.exception
+            ? index.CosmeticRuleSeparator.AdgJsInjectionException
+            : index.CosmeticRuleSeparator.AdgJsInjection;
+        const convertedScriptlets = [];
+        for (const scriptlet of rule.body.children) {
+            // Clone the node to avoid any side effects
+            const scriptletClone = clone.cloneScriptletRuleNode(scriptlet);
+            // Remove possible quotes just to make it easier to work with the scriptlet name
+            const scriptletName = quotes.QuoteUtils.setStringQuoteType(scriptlets.getScriptletName(scriptletClone), quotes.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 adblockers.AdblockSyntax.Abp:
+                    prefix = ABP_SCRIPTLET_PREFIX;
+                    charToUnescape = constants.SPACE;
+                    break;
+                case adblockers.AdblockSyntax.Ubo:
+                    prefix = UBO_SCRIPTLET_PREFIX;
+                    charToUnescape = COMMA_SEPARATOR;
+                    break;
+                default:
+                    prefix = constants.EMPTY;
+            }
+            if (!scriptletName.startsWith(prefix)) {
+                scriptlets.setScriptletName(scriptletClone, `${prefix}${scriptletName}`);
+            }
+            if (!typeGuards.isUndefined(charToUnescape)) {
+                scriptlets.transformAllScriptletArguments(scriptletClone, (value) => {
+                    if (!typeGuards.isNull(value)) {
+                        return quotes.QuoteUtils.unescapeSingleEscapedOccurrences(value, charToUnescape);
+                    }
+                    return value;
+                });
+            }
+            if (rule.syntax === adblockers.AdblockSyntax.Ubo) {
+                const scriptletData = scriptlets$1.scriptletsCompatibilityTable.getFirst(scriptletName, platforms.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 (!typeGuards.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: constants.EMPTY,
+                            });
+                        }
+                        scriptletClone.children.push({
+                            type: 'Value',
+                            value: applying,
+                        });
+                    }
+                }
+            }
+            // ADG scriptlet parameters should be quoted, and single quoted are preferred
+            scriptlets.setScriptletQuoteType(scriptletClone, quotes.QuoteType.Single);
+            convertedScriptlets.push(scriptletClone);
+        }
+        if (rule.body.children.length === 0) {
+            const convertedScriptletNode = {
+                category: rule.category,
+                type: rule.type,
+                syntax: adblockers.AdblockSyntax.Adg,
+                exception: rule.exception,
+                domains: clone.cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: convertedSeparator,
+                },
+                body: {
+                    type: rule.body.type,
+                    children: [],
+                },
+            };
+            if (rule.modifiers) {
+                convertedScriptletNode.modifiers = clone.cloneModifierListNode(rule.modifiers);
+            }
+            return conversionResult.createNodeConversionResult([convertedScriptletNode], true);
+        }
+        return conversionResult.createNodeConversionResult(convertedScriptlets.map((scriptlet) => {
+            const res = {
+                category: rule.category,
+                type: rule.type,
+                syntax: adblockers.AdblockSyntax.Adg,
+                exception: rule.exception,
+                domains: clone.cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: convertedSeparator,
+                },
+                body: {
+                    type: rule.body.type,
+                    children: [scriptlet],
+                },
+            };
+            if (rule.modifiers) {
+                res.modifiers = clone.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 === adblockers.AdblockSyntax.Ubo) {
+            return conversionResult.createNodeConversionResult([rule], false);
+        }
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
+        convertedSeparator = rule.exception
+            ? index.CosmeticRuleSeparator.ElementHidingException
+            : index.CosmeticRuleSeparator.ElementHiding;
+        const convertedScriptlets = [];
+        for (const scriptlet of rule.body.children) {
+            // Clone the node to avoid any side effects
+            const scriptletClone = clone.cloneScriptletRuleNode(scriptlet);
+            // Remove possible quotes just to make it easier to work with the scriptlet name
+            const scriptletName = quotes.QuoteUtils.setStringQuoteType(scriptlets.getScriptletName(scriptletClone), quotes.QuoteType.None);
+            let uboScriptletName;
+            if (rule.syntax === adblockers.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 = scriptlets$1.scriptletsCompatibilityTable.getFirst(scriptletName, platforms.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);
+            }
+            scriptlets.setScriptletName(scriptletClone, uboScriptletName);
+            scriptlets.setScriptletQuoteType(scriptletClone, quotes.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.
+            scriptlets.transformAllScriptletArguments(scriptletClone, (value) => {
+                if (!typeGuards.isNull(value)) {
+                    return quotes.QuoteUtils.escapeUnescapedOccurrences(value, COMMA_SEPARATOR);
+                }
+                return value;
+            });
+            // Unescape spaces in parameters, because uBlock Origin doesn't treat them as separators.
+            if (rule.syntax === adblockers.AdblockSyntax.Abp) {
+                scriptlets.transformAllScriptletArguments(scriptletClone, (value) => {
+                    if (!typeGuards.isNull(value)) {
+                        return quotes.QuoteUtils.unescapeSingleEscapedOccurrences(value, constants.SPACE);
+                    }
+                    return value;
+                });
+            }
+            // Some scriptlets have special values that need to be converted
+            switch (scriptletName) {
+                case ADG_SET_CONSTANT_NAME:
+                    scriptlets.transformNthScriptletArgument(scriptletClone, 2, (value) => {
+                        if (!typeGuards.isNull(value)) {
+                            return setConstantAdgToUboMap[value] ?? value;
+                        }
+                        return value;
+                    });
+                    break;
+                case ADG_PREVENT_FETCH_NAME:
+                    scriptlets.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: adblockers.AdblockSyntax.Ubo,
+                exception: rule.exception,
+                domains: clone.cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: convertedSeparator,
+                },
+                body: {
+                    type: rule.body.type,
+                    children: [],
+                },
+            };
+            if (rule.modifiers) {
+                convertedScriptletNode.modifiers = clone.cloneModifierListNode(rule.modifiers);
+            }
+            return conversionResult.createNodeConversionResult([convertedScriptletNode], true);
+        }
+        return conversionResult.createNodeConversionResult(convertedScriptlets.map((scriptlet) => {
+            const res = {
+                category: rule.category,
+                type: rule.type,
+                syntax: adblockers.AdblockSyntax.Ubo,
+                exception: rule.exception,
+                domains: clone.cloneDomainListNode(rule.domains),
+                separator: {
+                    type: 'Value',
+                    value: convertedSeparator,
+                },
+                body: {
+                    type: rule.body.type,
+                    children: [scriptlet],
+                },
+            };
+            if (rule.modifiers) {
+                res.modifiers = clone.cloneModifierListNode(rule.modifiers);
+            }
+            return res;
+        }), true);
+    }
+}
+
+exports.ScriptletRuleConverter = ScriptletRuleConverter;

package/dist/cjs/converter/css/index.js

@@ -0,0 +1,193 @@
+/*
+ * 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
+ */
+'use strict';
+
+var cssTokenizer = require('@adguard/css-tokenizer');
+var sprintfJs = require('sprintf-js');
+var constants = require('../../utils/constants.js');
+var css = require('../data/css.js');
+var baseConverter = require('../base-interfaces/base-converter.js');
+var conversionResult = require('../base-interfaces/conversion-result.js');
+var cssTokenStream = require('../../parser/css/css-token-stream.js');
+
+const ERROR_MESSAGES = {
+    // eslint-disable-next-line max-len
+    INVALID_ATTRIBUTE_VALUE: `Expected '${cssTokenizer.getFormattedTokenName(cssTokenizer.TokenType.Ident)}' or '${cssTokenizer.getFormattedTokenName(cssTokenizer.TokenType.String)}' as attribute value, but got '%s' with value '%s`,
+};
+var PseudoClasses;
+(function (PseudoClasses) {
+    PseudoClasses["AbpContains"] = "-abp-contains";
+    PseudoClasses["AbpHas"] = "-abp-has";
+    PseudoClasses["Contains"] = "contains";
+    PseudoClasses["Has"] = "has";
+    PseudoClasses["HasText"] = "has-text";
+    PseudoClasses["MatchesCss"] = "matches-css";
+    PseudoClasses["MatchesCssAfter"] = "matches-css-after";
+    PseudoClasses["MatchesCssBefore"] = "matches-css-before";
+    PseudoClasses["Not"] = "not";
+})(PseudoClasses || (PseudoClasses = {}));
+var PseudoElements;
+(function (PseudoElements) {
+    PseudoElements["After"] = "after";
+    PseudoElements["Before"] = "before";
+})(PseudoElements || (PseudoElements = {}));
+const PSEUDO_ELEMENT_NAMES = new Set([
+    PseudoElements.After,
+    PseudoElements.Before,
+]);
+/**
+ * CSS selector converter
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class CssSelectorConverter extends baseConverter.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.CssTokenStream
+            ? selectorList
+            : new cssTokenStream.CssTokenStream(selectorList);
+        const converted = [];
+        const convertAndPushPseudo = (pseudo) => {
+            switch (pseudo) {
+                case PseudoClasses.AbpContains:
+                case PseudoClasses.HasText:
+                    converted.push(PseudoClasses.Contains);
+                    converted.push(constants.OPEN_PARENTHESIS);
+                    break;
+                case PseudoClasses.AbpHas:
+                    converted.push(PseudoClasses.Has);
+                    converted.push(constants.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(constants.OPEN_PARENTHESIS);
+                    converted.push(pseudo.substring(PseudoClasses.MatchesCss.length + 1));
+                    converted.push(constants.COMMA);
+                    break;
+                default:
+                    converted.push(pseudo);
+                    converted.push(constants.OPEN_PARENTHESIS);
+                    break;
+            }
+        };
+        while (!stream.isEof()) {
+            const token = stream.getOrFail();
+            if (token.type === cssTokenizer.TokenType.Colon) {
+                // Advance colon
+                stream.advance();
+                converted.push(constants.COLON);
+                const tempToken = stream.getOrFail();
+                // Double colon is a pseudo-element
+                if (tempToken.type === cssTokenizer.TokenType.Colon) {
+                    stream.advance();
+                    converted.push(constants.COLON);
+                    continue;
+                }
+                if (tempToken.type === cssTokenizer.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(constants.COLON);
+                        converted.push(name);
+                    }
+                    else {
+                        // Add the name as is
+                        converted.push(name);
+                    }
+                    // Advance the names
+                    stream.advance();
+                }
+                else if (tempToken.type === cssTokenizer.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 === cssTokenizer.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(cssTokenizer.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(css.LEGACY_EXT_CSS_ATTRIBUTE_PREFIX) || attr.startsWith(css.ABP_EXT_CSS_PREFIX))) {
+                    converted.push(stream.source.slice(start, tempToken.end));
+                    stream.advance();
+                    continue;
+                }
+                if (attr.startsWith(css.LEGACY_EXT_CSS_ATTRIBUTE_PREFIX)) {
+                    attr = attr.slice(css.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(cssTokenizer.TokenType.Delim, { value: constants.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 !== cssTokenizer.TokenType.Ident && tempToken.type !== cssTokenizer.TokenType.String) {
+                    throw new Error(sprintfJs.sprintf(ERROR_MESSAGES.INVALID_ATTRIBUTE_VALUE, cssTokenizer.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(cssTokenizer.TokenType.CloseSquareBracket);
+                stream.advance();
+                converted.push(constants.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(constants.CLOSE_PARENTHESIS);
+            }
+            else {
+                converted.push(stream.source.slice(token.start, token.end));
+                // Advance the token
+                stream.advance();
+            }
+        }
+        const convertedSelectorList = converted.join(constants.EMPTY);
+        return conversionResult.createConversionResult(convertedSelectorList, stream.source !== convertedSelectorList);
+    }
+}
+
+exports.CssSelectorConverter = CssSelectorConverter;
+exports.ERROR_MESSAGES = ERROR_MESSAGES;