@adguard/agtree 2.1.3 → 3.0.0

package/dist/cjs/compatibility-tables/scriptlets.js

@@ -0,0 +1,30 @@
+/*
+ * 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 base = require('./base.js');
+var compatibilityTableData = require('./compatibility-table-data.js');
+var deepFreeze = require('../utils/deep-freeze.js');
+
+/**
+ * @file Compatibility tables for scriptlets.
+ */
+/**
+ * Compatibility table for scriptlets.
+ */
+class ScriptletsCompatibilityTable extends base.CompatibilityTableBase {
+}
+/**
+ * Deep freeze the compatibility table data to avoid accidental modifications.
+ */
+deepFreeze.deepFreeze(compatibilityTableData.scriptletsCompatibilityTableData);
+/**
+ * Compatibility table instance for scriptlets.
+ */
+const scriptletsCompatibilityTable = new ScriptletsCompatibilityTable(compatibilityTableData.scriptletsCompatibilityTableData);
+
+exports.scriptletsCompatibilityTable = scriptletsCompatibilityTable;

package/dist/cjs/compatibility-tables/utils/platform-helpers.js

@@ -0,0 +1,112 @@
+/*
+ * AGTree v3.0.0 (build date: Tue, 12 Nov 2024 14:05:06 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var platforms = require('../platforms.js');
+
+/* eslint-disable no-bitwise */
+/**
+ * @file Provides platform mapping and helper functions.
+ */
+/**
+ * Map of specific platforms string names to their corresponding enum values.
+ */
+const SPECIFIC_PLATFORM_MAP = new Map([
+    ['adg_os_windows', platforms.SpecificPlatform.AdgOsWindows],
+    ['adg_os_mac', platforms.SpecificPlatform.AdgOsMac],
+    ['adg_os_android', platforms.SpecificPlatform.AdgOsAndroid],
+    ['adg_ext_chrome', platforms.SpecificPlatform.AdgExtChrome],
+    ['adg_ext_opera', platforms.SpecificPlatform.AdgExtOpera],
+    ['adg_ext_edge', platforms.SpecificPlatform.AdgExtEdge],
+    ['adg_ext_firefox', platforms.SpecificPlatform.AdgExtFirefox],
+    ['adg_cb_android', platforms.SpecificPlatform.AdgCbAndroid],
+    ['adg_cb_ios', platforms.SpecificPlatform.AdgCbIos],
+    ['adg_cb_safari', platforms.SpecificPlatform.AdgCbSafari],
+    ['ubo_ext_chrome', platforms.SpecificPlatform.UboExtChrome],
+    ['ubo_ext_opera', platforms.SpecificPlatform.UboExtOpera],
+    ['ubo_ext_edge', platforms.SpecificPlatform.UboExtEdge],
+    ['ubo_ext_firefox', platforms.SpecificPlatform.UboExtFirefox],
+    ['abp_ext_chrome', platforms.SpecificPlatform.AbpExtChrome],
+    ['abp_ext_opera', platforms.SpecificPlatform.AbpExtOpera],
+    ['abp_ext_edge', platforms.SpecificPlatform.AbpExtEdge],
+    ['abp_ext_firefox', platforms.SpecificPlatform.AbpExtFirefox],
+]);
+/**
+ * Map of specific platforms enum values to their corresponding string names.
+ *
+ * @note Reverse of {@link SPECIFIC_PLATFORM_MAP}.
+ */
+const SPECIFIC_PLATFORM_MAP_REVERSE = new Map([...SPECIFIC_PLATFORM_MAP].map(([key, value]) => [value, key]));
+/**
+ * Map of generic platforms string names to their corresponding enum values.
+ */
+const GENERIC_PLATFORM_MAP = new Map([
+    ['adg_os_any', platforms.GenericPlatform.AdgOsAny],
+    ['adg_safari_any', platforms.GenericPlatform.AdgSafariAny],
+    ['adg_ext_chromium', platforms.GenericPlatform.AdgExtChromium],
+    ['adg_ext_any', platforms.GenericPlatform.AdgExtAny],
+    ['adg_any', platforms.GenericPlatform.AdgAny],
+    ['ubo_ext_chromium', platforms.GenericPlatform.UboExtChromium],
+    ['ubo_ext_any', platforms.GenericPlatform.UboExtAny],
+    ['ubo_any', platforms.GenericPlatform.UboAny],
+    ['abp_ext_chromium', platforms.GenericPlatform.AbpExtChromium],
+    ['abp_ext_any', platforms.GenericPlatform.AbpExtAny],
+    ['abp_any', platforms.GenericPlatform.AbpAny],
+    ['any', platforms.GenericPlatform.Any],
+]);
+/**
+ * Check if the platform is a generic platform.
+ *
+ * @param platform Platform to check.
+ *
+ * @returns True if the platform is a generic platform, false otherwise.
+ */
+const isGenericPlatform = (platform) => {
+    // if more than one bit is set, it's a generic platform
+    return !!(platform & (platform - 1));
+};
+/**
+ * Returns the platform enum value for the given platform string name.
+ *
+ * @param platform Platform string name, e.g., 'adg_os_windows'.
+ *
+ * @returns Specific or generic platform enum value.
+ * @throws Error if the platform is unknown.
+ */
+const getPlatformId = (platform) => {
+    const specificPlatform = SPECIFIC_PLATFORM_MAP.get(platform);
+    if (specificPlatform) {
+        return specificPlatform;
+    }
+    const genericPlatform = GENERIC_PLATFORM_MAP.get(platform);
+    if (genericPlatform) {
+        return genericPlatform;
+    }
+    throw new Error(`Unknown platform: ${platform}`);
+};
+/**
+ * Returns the specific platform string name for the given platform enum value.
+ *
+ * @param platform Specific platform enum value.
+ *
+ * @returns Specific platform string name, e.g., 'adg_os_windows'.
+ * @throws Error if the platform is unknown.
+ */
+const getSpecificPlatformName = (platform) => {
+    const specificPlatform = SPECIFIC_PLATFORM_MAP_REVERSE.get(platform);
+    if (!specificPlatform) {
+        throw new Error(`Unknown platform: ${platform}`);
+    }
+    return specificPlatform;
+};
+
+exports.GENERIC_PLATFORM_MAP = GENERIC_PLATFORM_MAP;
+exports.SPECIFIC_PLATFORM_MAP = SPECIFIC_PLATFORM_MAP;
+exports.SPECIFIC_PLATFORM_MAP_REVERSE = SPECIFIC_PLATFORM_MAP_REVERSE;
+exports.getPlatformId = getPlatformId;
+exports.getSpecificPlatformName = getSpecificPlatformName;
+exports.isGenericPlatform = isGenericPlatform;

package/dist/cjs/compatibility-tables/utils/resource-type-helpers.js

@@ -0,0 +1,64 @@
+/*
+ * 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 typeGuards = require('../../utils/type-guards.js');
+var modifiers = require('../modifiers.js');
+var resourceType = require('../schemas/resource-type.js');
+
+/**
+ * Map of resource types to their corresponding adblock modifier names.
+ *
+ * @note Record type is used to ensure that all resource types are present in the map.
+ */
+const RESOURCE_TYPE_MODIFIER_MAP = Object.freeze({
+    [resourceType.ResourceType.MainFrame]: 'document',
+    [resourceType.ResourceType.SubFrame]: 'subdocument',
+    [resourceType.ResourceType.Stylesheet]: 'stylesheet',
+    [resourceType.ResourceType.Script]: 'script',
+    [resourceType.ResourceType.Image]: 'image',
+    [resourceType.ResourceType.Font]: 'font',
+    [resourceType.ResourceType.Object]: 'object',
+    [resourceType.ResourceType.XmlHttpRequest]: 'xmlhttprequest',
+    [resourceType.ResourceType.Ping]: 'ping',
+    [resourceType.ResourceType.Media]: 'media',
+    [resourceType.ResourceType.WebSocket]: 'websocket',
+    [resourceType.ResourceType.Other]: 'other',
+});
+/**
+ * Gets the adblock modifier name for the given resource type.
+ *
+ * @param resourceType Resource type to get the modifier name for.
+ * @param platform Platform to get the modifier for.
+ *
+ * @returns A string containing the adblock modifier name for the given resource type
+ * or `null` if the modifier could not be found.
+ */
+const getResourceTypeModifier = (resourceType, platform) => {
+    const modifierName = RESOURCE_TYPE_MODIFIER_MAP[resourceType];
+    if (!modifierName) {
+        return null;
+    }
+    const modifierData = modifiers.modifiersCompatibilityTable.getFirst(modifierName, platform);
+    if (typeGuards.isNull(modifierData)) {
+        return null;
+    }
+    return modifierData.name;
+};
+/**
+ * Checks if the given resource type is valid.
+ *
+ * @param resourceType Resource type to check.
+ *
+ * @returns `true` if the resource type is valid, `false` otherwise.
+ */
+const isValidResourceType = (resourceType$1) => {
+    return Object.values(resourceType.ResourceType).includes(resourceType$1);
+};
+
+exports.getResourceTypeModifier = getResourceTypeModifier;
+exports.isValidResourceType = isValidResourceType;

package/dist/cjs/compatibility-tables/utils/zod-camelcase.js

@@ -0,0 +1,27 @@
+/*
+ * 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 camelCaseKeys = require('camelcase-keys');
+
+/**
+ * @file Zod camelCase utility.
+ */
+/**
+ * Transforms Zod schema to camelCase.
+ *
+ * @param zod Zod schema.
+ *
+ * @returns Zod schema with camelCase properties.
+ *
+ * @see {@link https://github.com/colinhacks/zod/issues/486#issuecomment-1501097361}
+ */
+const zodToCamelCase = (zod) => {
+    return zod.transform((val) => camelCaseKeys(val));
+};
+
+exports.zodToCamelCase = zodToCamelCase;

package/dist/cjs/converter/base-interfaces/base-converter.js

@@ -0,0 +1,61 @@
+/*
+ * 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 notImplementedError = require('../../errors/not-implemented-error.js');
+
+/**
+ * @file Base class for converters
+ *
+ * TS doesn't support abstract static methods, so we should use
+ * a workaround and extend this class instead of implementing it
+ */
+/* eslint-disable jsdoc/require-returns-check */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Basic class for rule converters
+ */
+class BaseConverter {
+    /**
+     * Converts some data to AdGuard format
+     *
+     * @param data Data 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 data is invalid or incompatible
+     */
+    static convertToAdg(data) {
+        throw new notImplementedError.NotImplementedError();
+    }
+    /**
+     * Converts some data to Adblock Plus format
+     *
+     * @param data Data 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 data is invalid or incompatible
+     */
+    static convertToAbp(data) {
+        throw new notImplementedError.NotImplementedError();
+    }
+    /**
+     * Converts some data to uBlock Origin format
+     *
+     * @param data Data 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 data is invalid or incompatible
+     */
+    static convertToUbo(data) {
+        throw new notImplementedError.NotImplementedError();
+    }
+}
+
+exports.BaseConverter = BaseConverter;

package/dist/cjs/converter/base-interfaces/conversion-result.js

@@ -0,0 +1,41 @@
+/*
+ * 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';
+
+/**
+ * @file Conversion result interface and helper functions
+ */
+/**
+ * Helper function to create a generic conversion result.
+ *
+ * @param result Conversion result
+ * @param isConverted Indicates whether the input item was converted
+ * @template T Type of the item to convert
+ * @template U Type of the conversion result (defaults to `T`, but can be `T[]` as well)
+ * @returns Generic conversion result
+ */
+// eslint-disable-next-line max-len
+function createConversionResult(result, isConverted) {
+    return {
+        result,
+        isConverted,
+    };
+}
+/**
+ * Helper function to create a node conversion result.
+ *
+ * @param nodes Array of nodes
+ * @param isConverted Indicates whether the input item was converted
+ * @template T Type of the node (extends `Node`)
+ * @returns Node conversion result
+ */
+function createNodeConversionResult(nodes, isConverted) {
+    return createConversionResult(nodes, isConverted);
+}
+
+exports.createConversionResult = createConversionResult;
+exports.createNodeConversionResult = createNodeConversionResult;

package/dist/cjs/converter/base-interfaces/rule-converter-base.js

@@ -0,0 +1,62 @@
+/*
+ * 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 notImplementedError = require('../../errors/not-implemented-error.js');
+var baseConverter = require('./base-converter.js');
+
+/**
+ * @file Base class for rule converters
+ *
+ * TS doesn't support abstract static methods, so we should use
+ * a workaround and extend this class instead of implementing it
+ */
+/* eslint-disable jsdoc/require-returns-check */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Basic class for rule converters
+ */
+class RuleConverterBase extends baseConverter.BaseConverter {
+    /**
+     * Converts an adblock filtering 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) {
+        throw new notImplementedError.NotImplementedError();
+    }
+    /**
+     * Converts an adblock filtering rule to Adblock Plus 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 convertToAbp(rule) {
+        throw new notImplementedError.NotImplementedError();
+    }
+    /**
+     * Converts an adblock filtering rule to uBlock Origin 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) {
+        throw new notImplementedError.NotImplementedError();
+    }
+}
+
+exports.RuleConverterBase = RuleConverterBase;

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

@@ -0,0 +1,56 @@
+/*
+ * 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 constants = require('../../utils/constants.js');
+var ruleConverterBase = require('../base-interfaces/rule-converter-base.js');
+var clone = require('../../utils/clone.js');
+var conversionResult = require('../base-interfaces/conversion-result.js');
+
+/**
+ * @file Comment rule converter
+ */
+/**
+ * Comment rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class CommentRuleConverter extends ruleConverterBase.RuleConverterBase {
+    /**
+     * Converts a comment 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) {
+        // TODO: Add support for other comment types, if needed
+        // Main task is # -> ! conversion
+        switch (rule.type) {
+            case index.CommentRuleType.CommentRule:
+                // Check if the rule needs to be converted
+                if (rule.type === index.CommentRuleType.CommentRule && rule.marker.value === index.CommentMarker.Hashmark) {
+                    // Add a ! to the beginning of the comment
+                    // TODO: Replace with custom clone method
+                    const ruleClone = clone.clone(rule);
+                    ruleClone.marker.value = index.CommentMarker.Regular;
+                    // Add the hashmark to the beginning of the comment text
+                    ruleClone.text.value = `${constants.SPACE}${index.CommentMarker.Hashmark}${ruleClone.text.value}`;
+                    return conversionResult.createNodeConversionResult([ruleClone], true);
+                }
+                return conversionResult.createNodeConversionResult([rule], false);
+            // Leave any other comment rule as is
+            default:
+                return conversionResult.createNodeConversionResult([rule], false);
+        }
+    }
+}
+
+exports.CommentRuleConverter = CommentRuleConverter;

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

@@ -0,0 +1,71 @@
+/*
+ * 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$1 = require('../../nodes/index.js');
+var ruleConverterBase = require('../base-interfaces/rule-converter-base.js');
+var index = require('../css/index.js');
+var adblockers = require('../../utils/adblockers.js');
+var clone = require('../../utils/clone.js');
+var conversionResult = require('../base-interfaces/conversion-result.js');
+var cssTokenStream = require('../../parser/css/css-token-stream.js');
+
+/**
+ * @file CSS injection rule converter
+ */
+/**
+ * CSS injection rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class CssInjectionRuleConverter extends ruleConverterBase.RuleConverterBase {
+    /**
+     * Converts a CSS 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) {
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
+        const stream = new cssTokenStream.CssTokenStream(rule.body.selectorList.value);
+        const convertedSelectorList = index.CssSelectorConverter.convertToAdg(stream);
+        // Change the separator if the rule contains ExtendedCSS elements,
+        // but do not force non-extended CSS separator if the rule does not contain any ExtendedCSS selectors,
+        // because sometimes we use it to force executing ExtendedCSS library.
+        if (stream.hasAnySelectorExtendedCssNodeStrict() || rule.body.remove) {
+            convertedSeparator = rule.exception
+                ? index$1.CosmeticRuleSeparator.AdgExtendedCssInjectionException
+                : index$1.CosmeticRuleSeparator.AdgExtendedCssInjection;
+        }
+        else if (rule.syntax !== adblockers.AdblockSyntax.Adg) {
+            // If the original rule syntax is not AdGuard, use the default separator
+            // e.g. if the input rule is from uBO, we need to convert ## to #$#.
+            convertedSeparator = rule.exception
+                ? index$1.CosmeticRuleSeparator.AdgCssInjectionException
+                : index$1.CosmeticRuleSeparator.AdgCssInjection;
+        }
+        // Check if the rule needs to be converted
+        if (!(rule.syntax === adblockers.AdblockSyntax.Common || rule.syntax === adblockers.AdblockSyntax.Adg)
+            || separator !== convertedSeparator
+            || convertedSelectorList.isConverted) {
+            // TODO: Replace with custom clone method
+            const ruleClone = clone.clone(rule);
+            ruleClone.syntax = adblockers.AdblockSyntax.Adg;
+            ruleClone.separator.value = convertedSeparator;
+            ruleClone.body.selectorList.value = convertedSelectorList.result;
+            return conversionResult.createNodeConversionResult([ruleClone], true);
+        }
+        // Otherwise, return the original rule
+        return conversionResult.createNodeConversionResult([rule], false);
+    }
+}
+
+exports.CssInjectionRuleConverter = CssInjectionRuleConverter;

package/dist/cjs/converter/cosmetic/element-hiding.js

@@ -0,0 +1,64 @@
+/*
+ * 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$1 = require('../../nodes/index.js');
+var ruleConverterBase = require('../base-interfaces/rule-converter-base.js');
+var index = require('../css/index.js');
+var adblockers = require('../../utils/adblockers.js');
+var clone = require('../../utils/clone.js');
+var conversionResult = require('../base-interfaces/conversion-result.js');
+var cssTokenStream = require('../../parser/css/css-token-stream.js');
+
+/**
+ * @file Element hiding rule converter
+ */
+/**
+ * Element hiding rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+class ElementHidingRuleConverter extends ruleConverterBase.RuleConverterBase {
+    /**
+     * Converts an element hiding 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) {
+        const separator = rule.separator.value;
+        let convertedSeparator = separator;
+        const stream = new cssTokenStream.CssTokenStream(rule.body.selectorList.value);
+        const convertedSelectorList = index.CssSelectorConverter.convertToAdg(stream);
+        // Change the separator if the rule contains ExtendedCSS elements,
+        // but do not force non-extended CSS separator if the rule does not contain any ExtendedCSS selectors,
+        // because sometimes we use it to force executing ExtendedCSS library.
+        if (stream.hasAnySelectorExtendedCssNodeStrict()) {
+            convertedSeparator = rule.exception
+                ? index$1.CosmeticRuleSeparator.ExtendedElementHidingException
+                : index$1.CosmeticRuleSeparator.ExtendedElementHiding;
+        }
+        // Check if the rule needs to be converted
+        if (!(rule.syntax === adblockers.AdblockSyntax.Common || rule.syntax === adblockers.AdblockSyntax.Adg)
+            || separator !== convertedSeparator
+            || convertedSelectorList.isConverted) {
+            // TODO: Replace with custom clone method
+            const ruleClone = clone.clone(rule);
+            ruleClone.syntax = adblockers.AdblockSyntax.Adg;
+            ruleClone.separator.value = convertedSeparator;
+            ruleClone.body.selectorList.value = convertedSelectorList.result;
+            return conversionResult.createNodeConversionResult([ruleClone], true);
+        }
+        // Otherwise, return the original rule
+        return conversionResult.createNodeConversionResult([rule], false);
+    }
+}
+
+exports.ElementHidingRuleConverter = ElementHidingRuleConverter;