@adguard/agtree 3.0.0 → 3.0.1

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

@@ -1,81 +0,0 @@
-/*
- * 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 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

@@ -1,356 +0,0 @@
-/*
- * 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 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

@@ -1,193 +0,0 @@
-/*
- * 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 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;