@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/esm/converter/cosmetic/scriptlet.mjs

@@ -0,0 +1,354 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { CosmeticRuleSeparator } from '../../nodes/index.mjs';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base.mjs';
+import { AdblockSyntax } from '../../utils/adblockers.mjs';
+import { QuoteUtils, QuoteType } from '../../utils/quotes.mjs';
+import { EMPTY, SPACE } from '../../utils/constants.mjs';
+import { getScriptletName, setScriptletName, transformAllScriptletArguments, setScriptletQuoteType, transformNthScriptletArgument } from '../../ast-utils/scriptlets.mjs';
+import { createNodeConversionResult } from '../base-interfaces/conversion-result.mjs';
+import { cloneScriptletRuleNode, cloneDomainListNode, cloneModifierListNode } from '../../ast-utils/clone.mjs';
+import '../../compatibility-tables/modifiers.mjs';
+import '../../compatibility-tables/redirects.mjs';
+import { scriptletsCompatibilityTable } from '../../compatibility-tables/scriptlets.mjs';
+import { GenericPlatform } from '../../compatibility-tables/platforms.mjs';
+import '../../compatibility-tables/schemas/base.mjs';
+import '../../compatibility-tables/schemas/modifier.mjs';
+import '../../compatibility-tables/schemas/redirect.mjs';
+import '../../compatibility-tables/schemas/scriptlet.mjs';
+import '../../compatibility-tables/schemas/platform.mjs';
+import '../../compatibility-tables/utils/platform-helpers.mjs';
+import '../../compatibility-tables/schemas/resource-type.mjs';
+import '../../compatibility-tables/utils/resource-type-helpers.mjs';
+import { isUndefined, isNull } from '../../utils/type-guards.mjs';
+
+/**
+ * @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/esm/converter/css/index.mjs

@@ -0,0 +1,190 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { getFormattedTokenName, TokenType } from '@adguard/css-tokenizer';
+import { sprintf } from 'sprintf-js';
+import { EQUALS, COLON, CLOSE_PARENTHESIS, OPEN_PARENTHESIS, COMMA, EMPTY } from '../../utils/constants.mjs';
+import { LEGACY_EXT_CSS_ATTRIBUTE_PREFIX, ABP_EXT_CSS_PREFIX } from '../data/css.mjs';
+import { BaseConverter } from '../base-interfaces/base-converter.mjs';
+import { createConversionResult } from '../base-interfaces/conversion-result.mjs';
+import { CssTokenStream } from '../../parser/css/css-token-stream.mjs';
+
+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`,
+};
+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 {
+    /**
+     * 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 };

package/dist/esm/converter/data/css.mjs

@@ -0,0 +1,126 @@
+/*
+ * 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
+ */
+/**
+ * @file Known CSS elements and attributes.
+ * TODO: Implement a compatibility table for Extended CSS
+ */
+/**
+ * Legacy Extended CSS attribute prefix.
+ *
+ * @example
+ * ```css
+ * [-ext-<name>=...]
+ * ```
+ */
+const LEGACY_EXT_CSS_ATTRIBUTE_PREFIX = '-ext-';
+/**
+ * ABP Extended CSS prefix.
+ *
+ * @example
+ * ```css
+ * [-abp-<name>=...]
+ * -abp-<name>(...)
+ * ```
+ */
+const ABP_EXT_CSS_PREFIX = '-abp';
+/**
+ * Known _strict_ Extended CSS pseudo-classes. Please, keep this list sorted.
+ * Strict means that these pseudo-classes are not supported by any browser natively,
+ * and they always require Extended CSS libraries to work.
+ */
+const EXT_CSS_PSEUDO_CLASSES_STRICT = new Set([
+    // AdGuard
+    // https://github.com/AdguardTeam/ExtendedCss
+    'contains',
+    'if-not',
+    'matches-attr',
+    'matches-css',
+    'matches-property',
+    'nth-ancestor',
+    'remove',
+    'upward',
+    'xpath',
+    // uBlock Origin
+    // https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#procedural-cosmetic-filters
+    'has-text',
+    'matches-css-after',
+    'matches-css-before',
+    'matches-path',
+    'min-text-length',
+    'watch-attr',
+    // Adblock Plus
+    // https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide-emulation
+    '-abp-contains',
+    '-abp-has',
+    '-abp-properties',
+]);
+/**
+ * _ALL_ known Extended CSS pseudo-classes. Please, keep this list sorted.
+ * It includes strict pseudo-classes and additional pseudo-classes that may be
+ * supported by some browsers natively.
+ */
+const EXT_CSS_PSEUDO_CLASSES = new Set([
+    ...EXT_CSS_PSEUDO_CLASSES_STRICT,
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/CSS/:has
+     */
+    'has',
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/CSS/:is
+     */
+    'is',
+]);
+/**
+ * Known legacy Extended CSS attributes. These attributes are deprecated and
+ * should be replaced with the corresponding pseudo-classes. In a long term,
+ * these attributes will be COMPLETELY removed from the Extended CSS syntax.
+ *
+ * Please, keep this list sorted.
+ */
+const EXT_CSS_LEGACY_ATTRIBUTES = new Set([
+    // AdGuard
+    '-ext-contains',
+    '-ext-has',
+    '-ext-if-not',
+    '-ext-is',
+    '-ext-matches-attr',
+    '-ext-matches-css',
+    '-ext-matches-property',
+    '-ext-nth-ancestor',
+    '-ext-remove',
+    '-ext-upward',
+    '-ext-xpath',
+    // uBlock Origin
+    '-ext-has-text',
+    '-ext-matches-css-after',
+    '-ext-matches-css-before',
+    '-ext-matches-path',
+    '-ext-min-text-length',
+    '-ext-watch-attr',
+    // Adblock Plus
+    '-ext-abp-contains',
+    '-ext-abp-has',
+    '-ext-abp-properties',
+]);
+/**
+ * Known CSS functions that aren't allowed in CSS injection rules, because they
+ * able to load external resources. Please, keep this list sorted.
+ */
+const FORBIDDEN_CSS_FUNCTIONS = new Set([
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/cross-fade
+    '-webkit-cross-fade',
+    'cross-fade',
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/image
+    'image',
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/image-set
+    '-webkit-image-set',
+    'image-set',
+    // https://developer.mozilla.org/en-US/docs/Web/CSS/url
+    'url',
+]);
+
+export { ABP_EXT_CSS_PREFIX, EXT_CSS_LEGACY_ATTRIBUTES, EXT_CSS_PSEUDO_CLASSES, EXT_CSS_PSEUDO_CLASSES_STRICT, FORBIDDEN_CSS_FUNCTIONS, LEGACY_EXT_CSS_ATTRIBUTE_PREFIX };