@adguard/agtree 3.0.0 → 3.1.0

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

@@ -1,133 +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';
-
-/**
- * @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',
-]);
-
-exports.ABP_EXT_CSS_PREFIX = ABP_EXT_CSS_PREFIX;
-exports.EXT_CSS_LEGACY_ATTRIBUTES = EXT_CSS_LEGACY_ATTRIBUTES;
-exports.EXT_CSS_PSEUDO_CLASSES = EXT_CSS_PSEUDO_CLASSES;
-exports.EXT_CSS_PSEUDO_CLASSES_STRICT = EXT_CSS_PSEUDO_CLASSES_STRICT;
-exports.FORBIDDEN_CSS_FUNCTIONS = FORBIDDEN_CSS_FUNCTIONS;
-exports.LEGACY_EXT_CSS_ATTRIBUTE_PREFIX = LEGACY_EXT_CSS_ATTRIBUTE_PREFIX;

package/dist/cjs/converter/filter-list.js

@@ -1,90 +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 rule = require('./rule.js');
-var clone = require('../utils/clone.js');
-var multiValueMap = require('../utils/multi-value-map.js');
-var conversionResult = require('./base-interfaces/conversion-result.js');
-var baseConverter = require('./base-interfaces/base-converter.js');
-
-/**
- * @file Adblock filter list converter
- */
-/**
- * Adblock filter list converter class
- *
- * This class just provides an extra layer on top of the {@link RuleConverter}
- * and can be used to convert entire filter lists.
- *
- * @todo Implement `convertToUbo` and `convertToAbp`
- * @todo Implement tolerant mode, which will allow to convert a filter list
- * even if some of its rules are invalid
- */
-class FilterListConverter extends baseConverter.BaseConverter {
-    /**
-     * Converts an adblock filter list to AdGuard format, if possible.
-     *
-     * @param filterListNode Filter list node to convert
-     * @param tolerant Indicates whether the converter should be tolerant to invalid rules. If enabled and a rule is
-     * invalid, it will be left as is. If disabled and a rule is invalid, the whole filter list will be failed.
-     * Defaults to `true`.
-     * @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 filter list is invalid or cannot be converted (if the tolerant mode is disabled)
-     */
-    static convertToAdg(filterListNode, tolerant = true) {
-        // Prepare a map to store the converted rules by their index in the filter list
-        const conversionMap = new multiValueMap.MultiValueMap();
-        // Iterate over the filtering rules and convert them one by one, then add them to the result (one conversion may
-        // result in multiple rules)
-        for (let i = 0; i < filterListNode.children.length; i += 1) {
-            try {
-                const convertedRules = rule.RuleConverter.convertToAdg(filterListNode.children[i]);
-                // Add the converted rules to the map if they were converted
-                if (convertedRules.isConverted) {
-                    conversionMap.add(i, ...convertedRules.result);
-                }
-            }
-            catch (error) {
-                // If the tolerant mode is disabled, we should throw an error, this will fail the whole filter list
-                // conversion.
-                // Otherwise, we just ignore the error and leave the rule as is
-                if (!tolerant) {
-                    throw error;
-                }
-            }
-        }
-        // If the conversion map is empty, it means that no rules were converted, so we can return the original filter
-        // list
-        if (conversionMap.size === 0) {
-            return conversionResult.createConversionResult(filterListNode, false);
-        }
-        // Otherwise, create a new filter list node with the converted rules
-        const convertedFilterList = {
-            type: 'FilterList',
-            children: [],
-        };
-        // Iterate over the original rules again and add them to the converted filter list, replacing the converted
-        // rules with the new ones at the specified indexes
-        for (let i = 0; i < filterListNode.children.length; i += 1) {
-            const rules = conversionMap.get(i);
-            if (rules) {
-                convertedFilterList.children.push(...rules);
-            }
-            else {
-                // We clone the unconverted rules to avoid mutating the original filter list if we return the converted
-                // one
-                convertedFilterList.children.push(clone.clone(filterListNode.children[i]));
-            }
-        }
-        return conversionResult.createConversionResult(convertedFilterList, true);
-    }
-}
-
-exports.FilterListConverter = FilterListConverter;

package/dist/cjs/converter/index.js

@@ -1,15 +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 rawFilterList = require('./raw-filter-list.js');
-var rule = require('./rule.js');
-
-
-
-exports.RawFilterListConverter = rawFilterList.RawFilterListConverter;
-exports.RuleConverter = rule.RuleConverter;

package/dist/cjs/converter/misc/network-rule-modifier.js

@@ -1,313 +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 constants = require('../../utils/constants.js');
-var modifiers = require('../../ast-utils/modifiers.js');
-var baseConverter = require('../base-interfaces/base-converter.js');
-var ruleConversionError = require('../../errors/rule-conversion-error.js');
-var multiValueMap = require('../../utils/multi-value-map.js');
-var conversionResult = require('../base-interfaces/conversion-result.js');
-var clone = require('../../ast-utils/clone.js');
-var modifiers$1 = require('../../compatibility-tables/modifiers.js');
-var redirects = require('../../compatibility-tables/redirects.js');
-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');
-var resourceTypeHelpers = require('../../compatibility-tables/utils/resource-type-helpers.js');
-var typeGuards = require('../../utils/type-guards.js');
-
-/**
- * @file Network rule modifier list converter.
- */
-/**
- * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#csp-modifier}
- */
-const CSP_MODIFIER = 'csp';
-const CSP_SEPARATOR = constants.SEMICOLON + constants.SPACE;
-/**
- * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#csp-modifier}
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy}
- */
-const COMMON_CSP_PARAMS = '\'self\' \'unsafe-eval\' http: https: data: blob: mediastream: filesystem:';
-/**
- * @see {@link https://help.adblockplus.org/hc/en-us/articles/360062733293#rewrite}
- */
-const ABP_REWRITE_MODIFIER = 'rewrite';
-/**
- * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#redirect-modifier}
- */
-const REDIRECT_MODIFIER = 'redirect';
-/**
- * @see {@link https://adguard.com/kb/general/ad-filtering/create-own-filters/#redirect-rule-modifier}
- */
-const REDIRECT_RULE_MODIFIER = 'redirect-rule';
-/**
- * @see {@link https://github.com/gorhill/uBlock/wiki/Resources-Library#empty-redirect-resources}
- */
-const UBO_NOOP_TEXT_RESOURCE = 'noop.txt';
-/**
- * Redirect-related modifiers.
- */
-const REDIRECT_MODIFIERS = new Set([
-    ABP_REWRITE_MODIFIER,
-    REDIRECT_MODIFIER,
-    REDIRECT_RULE_MODIFIER,
-]);
-/**
- * Conversion map for ADG network rule modifiers.
- */
-const ADG_CONVERSION_MAP = new Map([
-    ['1p', [{ name: () => 'third-party', exception: (actual) => !actual }]],
-    ['3p', [{ name: () => 'third-party' }]],
-    ['css', [{ name: () => 'stylesheet' }]],
-    ['doc', [{ name: () => 'document' }]],
-    ['ehide', [{ name: () => 'elemhide' }]],
-    ['empty', [{ name: () => 'redirect', value: () => 'nooptext' }]],
-    ['first-party', [{ name: () => 'third-party', exception: (actual) => !actual }]],
-    ['frame', [{ name: () => 'subdocument' }]],
-    ['ghide', [{ name: () => 'generichide' }]],
-    ['inline-font', [{ name: () => CSP_MODIFIER, value: () => `font-src ${COMMON_CSP_PARAMS}` }]],
-    ['inline-script', [{ name: () => CSP_MODIFIER, value: () => `script-src ${COMMON_CSP_PARAMS}` }]],
-    ['mp4', [{ name: () => 'redirect', value: () => 'noopmp4-1s' }, { name: () => 'media', value: () => undefined }]],
-    ['queryprune', [{ name: () => 'removeparam' }]],
-    ['shide', [{ name: () => 'specifichide' }]],
-    ['xhr', [{ name: () => 'xmlhttprequest' }]],
-]);
-/**
- * Helper class for converting network rule modifier lists.
- *
- * @todo Implement `convertToUbo` and `convertToAbp`
- */
-class NetworkRuleModifierListConverter extends baseConverter.BaseConverter {
-    /**
-     * Converts a network rule modifier list to AdGuard format, if possible.
-     *
-     * @param modifierList Network rule modifier list node to convert
-     * @param isException If `true`, the rule is an exception rule
-     * @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 conversion is not possible
-     */
-    static convertToAdg(modifierList, isException = false) {
-        const conversionMap = new multiValueMap.MultiValueMap();
-        // Special case: $csp modifier
-        let cspCount = 0;
-        modifierList.children.forEach((modifierNode, index) => {
-            const modifierConversions = ADG_CONVERSION_MAP.get(modifierNode.name.value);
-            if (modifierConversions) {
-                for (const modifierConversion of modifierConversions) {
-                    const name = modifierConversion.name(modifierNode.name.value);
-                    const exception = modifierConversion.exception
-                        // If the exception value is undefined in the original modifier, it
-                        // means that the modifier isn't negated
-                        ? modifierConversion.exception(modifierNode.exception || false)
-                        : modifierNode.exception;
-                    const value = modifierConversion.value
-                        ? modifierConversion.value(modifierNode.value?.value)
-                        : modifierNode.value?.value;
-                    // Check if the name or the value is different from the original modifier
-                    // If so, add the converted modifier to the list
-                    if (name !== modifierNode.name.value || value !== modifierNode.value?.value) {
-                        conversionMap.add(index, modifiers.createModifierNode(name, value, exception));
-                    }
-                    // Special case: $csp modifier
-                    if (name === CSP_MODIFIER) {
-                        cspCount += 1;
-                    }
-                }
-                return;
-            }
-            // Handle special case: resource redirection modifiers
-            if (REDIRECT_MODIFIERS.has(modifierNode.name.value)) {
-                // Redirect modifiers can't be negated
-                if (modifierNode.exception === true) {
-                    throw new ruleConversionError.RuleConversionError(`Modifier '${modifierNode.name.value}' cannot be negated`);
-                }
-                // Convert the redirect resource name to ADG format
-                const redirectResource = modifierNode.value?.value;
-                // Special case: for exception rules, $redirect without value is allowed,
-                // and in this case it means an exception for all redirects
-                if (!redirectResource && !isException) {
-                    throw new ruleConversionError.RuleConversionError(`No redirect resource specified for '${modifierNode.name.value}' modifier`);
-                }
-                // Leave $redirect and $redirect-rule modifiers as is, but convert $rewrite to $redirect
-                const modifierName = modifierNode.name.value === ABP_REWRITE_MODIFIER
-                    ? REDIRECT_MODIFIER
-                    : modifierNode.name.value;
-                const convertedRedirectResource = redirectResource
-                    ? redirects.redirectsCompatibilityTable.getFirst(redirectResource, platforms.GenericPlatform.AdgAny)?.name
-                    : undefined;
-                // Check if the modifier name or the redirect resource name is different from the original modifier.
-                // If so, add the converted modifier to the list
-                if (modifierName !== modifierNode.name.value
-                    || (convertedRedirectResource !== undefined && convertedRedirectResource !== redirectResource)) {
-                    conversionMap.add(index, modifiers.createModifierNode(modifierName, 
-                    // If the redirect resource name is unknown, fall back to the original one
-                    // Later, the validator will throw an error if the resource name is invalid
-                    convertedRedirectResource || redirectResource, modifierNode.exception));
-                }
-            }
-        });
-        // Prepare the result if there are any converted modifiers or $csp modifiers
-        if (conversionMap.size || cspCount) {
-            const modifierListClone = clone.cloneModifierListNode(modifierList);
-            // Replace the original modifiers with the converted ones
-            // One modifier may be replaced with multiple modifiers, so we need to flatten the array
-            modifierListClone.children = modifierListClone.children.map((modifierNode, index) => {
-                const conversionRecord = conversionMap.get(index);
-                if (conversionRecord) {
-                    return conversionRecord;
-                }
-                return modifierNode;
-            }).flat();
-            // Special case: $csp modifier: merge multiple $csp modifiers into one
-            // and put it at the end of the modifier list
-            if (cspCount) {
-                const cspValues = [];
-                modifierListClone.children = modifierListClone.children.filter((modifierNode) => {
-                    if (modifierNode.name.value === CSP_MODIFIER) {
-                        if (!modifierNode.value?.value) {
-                            throw new ruleConversionError.RuleConversionError('$csp modifier value is missing');
-                        }
-                        cspValues.push(modifierNode.value?.value);
-                        return false;
-                    }
-                    return true;
-                });
-                modifierListClone.children.push(modifiers.createModifierNode(CSP_MODIFIER, cspValues.join(CSP_SEPARATOR)));
-            }
-            // Before returning the result, remove duplicated modifiers
-            modifierListClone.children = modifierListClone.children.filter((modifierNode, index, self) => self.findIndex((m) => m.name.value === modifierNode.name.value
-                && m.exception === modifierNode.exception
-                && m.value?.value === modifierNode.value?.value) === index);
-            return conversionResult.createConversionResult(modifierListClone, true);
-        }
-        return conversionResult.createConversionResult(modifierList, false);
-    }
-    /**
-     * Converts a network rule modifier list to uBlock format, if possible.
-     *
-     * @param modifierList Network rule modifier list node to convert
-     * @param isException If `true`, the rule is an exception rule
-     * @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 conversion is not possible
-     */
-    // TODO: Optimize
-    static convertToUbo(modifierList, isException = false) {
-        const conversionMap = new multiValueMap.MultiValueMap();
-        const resourceTypeModifiersToAdd = new Set();
-        modifierList.children.forEach((modifierNode, index) => {
-            const originalModifierName = modifierNode.name.value;
-            const modifierData = modifiers$1.modifiersCompatibilityTable.getFirst(originalModifierName, platforms.GenericPlatform.UboAny);
-            // Handle special case: resource redirection modifiers
-            if (REDIRECT_MODIFIERS.has(originalModifierName)) {
-                // Redirect modifiers cannot be negated
-                if (modifierNode.exception === true) {
-                    throw new ruleConversionError.RuleConversionError(`Modifier '${modifierNode.name.value}' cannot be negated`);
-                }
-                // Convert the redirect resource name to uBO format
-                const redirectResourceName = modifierNode.value?.value;
-                // Special case: for exception rules, $redirect without value is allowed,
-                // and in this case it means an exception for all redirects
-                if (!redirectResourceName && !isException) {
-                    throw new ruleConversionError.RuleConversionError(`No redirect resource specified for '${modifierNode.name.value}' modifier`);
-                }
-                if (!redirectResourceName) {
-                    // Jump to the next modifier if the redirect resource is not specified
-                    return;
-                }
-                // Leave $redirect and $redirect-rule modifiers as is, but convert $rewrite to $redirect
-                const modifierName = modifierNode.name.value === ABP_REWRITE_MODIFIER
-                    ? REDIRECT_MODIFIER
-                    : modifierNode.name.value;
-                const convertedRedirectResourceData = redirects.redirectsCompatibilityTable.getFirst(redirectResourceName, platforms.GenericPlatform.UboAny);
-                const convertedRedirectResourceName = convertedRedirectResourceData?.name ?? redirectResourceName;
-                // uBlock requires the $redirect modifier to have a resource type
-                // https://github.com/AdguardTeam/Scriptlets/issues/101
-                if (convertedRedirectResourceData?.resourceTypes?.length) {
-                    // Convert the resource types to uBO modifiers
-                    const uboResourceTypeModifiers = redirects.redirectsCompatibilityTable.getResourceTypeModifiers(convertedRedirectResourceData, platforms.GenericPlatform.UboAny);
-                    // Special case: noop text resource
-                    // If any of resource type is already present, we don't need to add other resource types,
-                    // otherwise, add all resource types
-                    // TODO: Optimize this logic
-                    // Check if the current resource is the noop text resource
-                    const isNoopTextResource = convertedRedirectResourceName === UBO_NOOP_TEXT_RESOURCE;
-                    // Determine if there are any valid resource types already present
-                    const hasValidResourceType = modifierList.children.some((modifier) => {
-                        const name = modifier.name.value;
-                        if (!resourceTypeHelpers.isValidResourceType(name)) {
-                            return false;
-                        }
-                        const convertedModifierData = modifiers$1.modifiersCompatibilityTable.getFirst(name, platforms.GenericPlatform.UboAny);
-                        return uboResourceTypeModifiers.has(convertedModifierData?.name ?? name);
-                    });
-                    // If it's not the noop text resource or if no valid resource types are present
-                    if (!isNoopTextResource || !hasValidResourceType) {
-                        uboResourceTypeModifiers.forEach((resourceType) => {
-                            resourceTypeModifiersToAdd.add(resourceType);
-                        });
-                    }
-                }
-                // Check if the modifier name or the redirect resource name is different from the original modifier.
-                // If so, add the converted modifier to the list
-                if (modifierName !== originalModifierName
-                    || (!typeGuards.isUndefined(convertedRedirectResourceName)
-                        && convertedRedirectResourceName !== redirectResourceName)) {
-                    conversionMap.add(index, modifiers.createModifierNode(modifierName, 
-                    // If the redirect resource name is unknown, fall back to the original one
-                    // Later, the validator will throw an error if the resource name is invalid
-                    convertedRedirectResourceName || redirectResourceName, modifierNode.exception));
-                }
-                return;
-            }
-            // Generic modifier conversion
-            if (modifierData && modifierData.name !== originalModifierName) {
-                conversionMap.add(index, modifiers.createModifierNode(modifierData.name, modifierNode.value?.value, modifierNode.exception));
-            }
-        });
-        // Prepare the result if there are any converted modifiers or $csp modifiers
-        if (conversionMap.size || resourceTypeModifiersToAdd.size) {
-            const modifierListClone = clone.cloneModifierListNode(modifierList);
-            // Replace the original modifiers with the converted ones
-            // One modifier may be replaced with multiple modifiers, so we need to flatten the array
-            modifierListClone.children = modifierListClone.children.map((modifierNode, index) => {
-                const conversionRecord = conversionMap.get(index);
-                if (conversionRecord) {
-                    return conversionRecord;
-                }
-                return modifierNode;
-            }).flat();
-            // Before returning the result, remove duplicated modifiers
-            modifierListClone.children = modifierListClone.children.filter((modifierNode, index, self) => self.findIndex((m) => m.name.value === modifierNode.name.value
-                && m.exception === modifierNode.exception
-                && m.value?.value === modifierNode.value?.value) === index);
-            if (resourceTypeModifiersToAdd.size) {
-                const modifierNameSet = new Set(modifierList.children.map((m) => m.name.value));
-                resourceTypeModifiersToAdd.forEach((resourceType) => {
-                    if (!modifierNameSet.has(resourceType)) {
-                        modifierListClone.children.push(modifiers.createModifierNode(resourceType));
-                    }
-                });
-            }
-            return conversionResult.createConversionResult(modifierListClone, true);
-        }
-        return conversionResult.createConversionResult(modifierList, false);
-    }
-}
-
-exports.NetworkRuleModifierListConverter = NetworkRuleModifierListConverter;

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

@@ -1,101 +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 networkRuleModifier = require('../misc/network-rule-modifier.js');
-var ruleConverterBase = require('../base-interfaces/rule-converter-base.js');
-var conversionResult = require('../base-interfaces/conversion-result.js');
-
-/**
- * @file Network rule converter
- */
-/**
- * Network rule converter class (also known as "basic rule converter")
- *
- * @todo Implement `convertToUbo` and `convertToAbp`
- */
-class NetworkRuleConverter extends ruleConverterBase.RuleConverterBase {
-    /**
-     * Converts a network 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 host rules
-        if (rule.type !== index.NetworkRuleType.NetworkRule) {
-            throw new Error(`Invalid rule type: ${rule.type}`);
-        }
-        if (rule.modifiers) {
-            const modifiers = networkRuleModifier.NetworkRuleModifierListConverter.convertToAdg(rule.modifiers, rule.exception);
-            // If the object reference is different, it means that the modifiers were converted
-            // In this case, we should clone the entire rule and replace the modifiers with the converted ones
-            if (modifiers.isConverted) {
-                return {
-                    result: [{
-                            category: index.RuleCategory.Network,
-                            type: index.NetworkRuleType.NetworkRule,
-                            syntax: rule.syntax,
-                            exception: rule.exception,
-                            pattern: {
-                                type: 'Value',
-                                value: rule.pattern.value,
-                            },
-                            modifiers: modifiers.result,
-                        }],
-                    isConverted: true,
-                };
-            }
-        }
-        // If the modifiers were not converted, return the original rule
-        return conversionResult.createNodeConversionResult([rule], false);
-    }
-    /**
-     * Converts a network 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) {
-        // TODO: add support for host rules
-        if (rule.type !== index.NetworkRuleType.NetworkRule) {
-            throw new Error(`Invalid rule type: ${rule.type}`);
-        }
-        if (rule.modifiers) {
-            const modifiers = networkRuleModifier.NetworkRuleModifierListConverter.convertToUbo(rule.modifiers, rule.exception);
-            // If the object reference is different, it means that the modifiers were converted
-            // In this case, we should clone the entire rule and replace the modifiers with the converted ones
-            if (modifiers.isConverted) {
-                return {
-                    result: [{
-                            category: index.RuleCategory.Network,
-                            type: index.NetworkRuleType.NetworkRule,
-                            syntax: rule.syntax,
-                            exception: rule.exception,
-                            pattern: {
-                                type: 'Value',
-                                value: rule.pattern.value,
-                            },
-                            modifiers: modifiers.result,
-                        }],
-                    isConverted: true,
-                };
-            }
-        }
-        // If the modifiers were not converted, return the original rule
-        return conversionResult.createNodeConversionResult([rule], false);
-    }
-}
-
-exports.NetworkRuleConverter = NetworkRuleConverter;