@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/types/compatibility-tables/schemas/scriptlet.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file Schema for scriptlet data.
+ */
+import zod from 'zod';
+/**
+ * Zod schema for scriptlet data.
+ */
+export declare const scriptletDataSchema: zod.ZodEffects<zod.ZodTypeAny, {
+    name: string;
+    description: string | null;
+    aliases: string[] | null;
+    docs: string | null;
+    versionAdded: string | null;
+    versionRemoved: string | null;
+    deprecated: boolean;
+    deprecationMessage: string | null;
+    removed: boolean;
+    removalMessage: string | null;
+    parameters?: {
+        name: string;
+        debug: boolean;
+        pattern: string | null;
+        description: string | null;
+        default: string | null;
+        required: boolean;
+    }[] | undefined;
+}, any>;
+/**
+ * Type of the scriptlet data schema.
+ */
+export type ScriptletDataSchema = zod.infer<typeof scriptletDataSchema>;

package/dist/types/compatibility-tables/scriptlets.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Compatibility tables for scriptlets.
+ */
+import { CompatibilityTableBase } from './base';
+import { type ScriptletDataSchema } from './schemas';
+/**
+ * Compatibility table for scriptlets.
+ */
+declare class ScriptletsCompatibilityTable extends CompatibilityTableBase<ScriptletDataSchema> {
+}
+/**
+ * Compatibility table instance for scriptlets.
+ */
+export declare const scriptletsCompatibilityTable: ScriptletsCompatibilityTable;
+export {};

package/dist/types/compatibility-tables/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @file Compatibility tables types.
+ */
+/**
+ * Map with shared storage.
+ * The idea is to avoid storing the same value multiple times in the map,
+ * so the value is stored in the `shared` array and the map refers to the index in the `shared` array.
+ *
+ * @template K Type of the map keys.
+ * @template V Type of the map values.
+ */
+interface MapWithSharedStorage<K extends string | number | symbol, V> {
+    /**
+     * Shared storage.
+     */
+    shared: V[];
+    /**
+     * Map of the values where the value is a pointer to the shared storage (refers to the index in the `shared` array).
+     */
+    map: Record<K, number>;
+}
+/**
+ * Compatibility table row.
+ *
+ * @template T Type of the compatibility data.
+ */
+export type CompatibilityTableRow<T> = MapWithSharedStorage<number, T>;
+/**
+ * Compatibility table.
+ *
+ * @template T Type of the compatibility data.
+ */
+export type CompatibilityTable<T> = MapWithSharedStorage<string, CompatibilityTableRow<T>>;
+export {};

package/dist/types/compatibility-tables/utils/platform-helpers.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file Provides platform mapping and helper functions.
+ */
+import { GenericPlatform, SpecificPlatform } from '../platforms';
+/**
+ * Map of specific platforms string names to their corresponding enum values.
+ */
+export declare const SPECIFIC_PLATFORM_MAP: Map<string, SpecificPlatform>;
+/**
+ * Map of specific platforms enum values to their corresponding string names.
+ *
+ * @note Reverse of {@link SPECIFIC_PLATFORM_MAP}.
+ */
+export declare const SPECIFIC_PLATFORM_MAP_REVERSE: Map<SpecificPlatform, string>;
+/**
+ * Map of generic platforms string names to their corresponding enum values.
+ */
+export declare const GENERIC_PLATFORM_MAP: Map<string, GenericPlatform>;
+/**
+ * Check if the platform is a generic platform.
+ *
+ * @param platform Platform to check.
+ *
+ * @returns True if the platform is a generic platform, false otherwise.
+ */
+export declare const isGenericPlatform: (platform: number) => boolean;
+/**
+ * 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.
+ */
+export declare const getPlatformId: (platform: string) => SpecificPlatform | GenericPlatform;
+/**
+ * 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.
+ */
+export declare const getSpecificPlatformName: (platform: SpecificPlatform) => string;

package/dist/types/compatibility-tables/utils/resource-type-helpers.d.ts

@@ -0,0 +1,20 @@
+import { type GenericPlatform, type SpecificPlatform } from '../platforms';
+import { ResourceType } from '../schemas/resource-type';
+/**
+ * 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.
+ */
+export declare const getResourceTypeModifier: (resourceType: ResourceType, platform: SpecificPlatform | GenericPlatform) => string | null;
+/**
+ * Checks if the given resource type is valid.
+ *
+ * @param resourceType Resource type to check.
+ *
+ * @returns `true` if the resource type is valid, `false` otherwise.
+ */
+export declare const isValidResourceType: (resourceType: string) => boolean;

package/dist/types/compatibility-tables/utils/zod-camelcase.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Zod camelCase utility.
+ */
+import type zod from 'zod';
+import { type CamelCasedPropertiesDeep } from 'type-fest';
+/**
+ * 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}
+ */
+export declare const zodToCamelCase: <T extends zod.ZodTypeAny>(zod: T) => zod.ZodEffects<zod.ZodTypeAny, CamelCasedPropertiesDeep<T["_output"]>, any>;

package/dist/types/converter/base-interfaces/base-converter.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @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
+ */
+import { type ConversionResult } from './conversion-result';
+/**
+ * Basic class for rule converters
+ */
+export declare 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: unknown): ConversionResult<unknown>;
+    /**
+     * 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: unknown): ConversionResult<unknown>;
+    /**
+     * 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: unknown): ConversionResult<unknown>;
+}

package/dist/types/converter/base-interfaces/conversion-result.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file Conversion result interface and helper functions
+ */
+import { type Node } from '../../nodes';
+/**
+ * Common conversion result interface
+ *
+ * @template T Type of the item to convert
+ * @template U Type of the conversion result (defaults to `T`, but can be `T[]` as well)
+ */
+export interface ConversionResult<T, U extends T | T[] = T> {
+    /**
+     * Conversion result
+     */
+    result: U;
+    /**
+     * Indicates whether the input item was converted
+     */
+    isConverted: boolean;
+}
+/**
+ * Adblock rule node conversion result interface, where the conversion result is an array of rules
+ */
+export type NodeConversionResult<T extends Node> = ConversionResult<T, T[]>;
+/**
+ * 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
+ */
+export declare function createConversionResult<T, U extends T | T[] = T>(result: U, isConverted: boolean): ConversionResult<T, U>;
+/**
+ * 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
+ */
+export declare function createNodeConversionResult<T extends Node>(nodes: T[], isConverted: boolean): NodeConversionResult<T>;

package/dist/types/converter/base-interfaces/rule-converter-base.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @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
+ */
+import { type Node } from '../../nodes';
+import { type NodeConversionResult } from './conversion-result';
+import { BaseConverter } from './base-converter';
+/**
+ * Basic class for rule converters
+ */
+export declare class RuleConverterBase extends 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: Node): NodeConversionResult<Node>;
+    /**
+     * 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: Node): NodeConversionResult<Node>;
+    /**
+     * 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: Node): NodeConversionResult<Node>;
+}

package/dist/types/converter/comment/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @file Comment rule converter
+ */
+import { type AnyCommentRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * Comment rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class CommentRuleConverter extends 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: AnyCommentRule): NodeConversionResult<AnyCommentRule>;
+}

package/dist/types/converter/cosmetic/css.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @file CSS injection rule converter
+ */
+import { type CssInjectionRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * CSS injection rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class CssInjectionRuleConverter extends 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: CssInjectionRule): NodeConversionResult<CssInjectionRule>;
+}

package/dist/types/converter/cosmetic/element-hiding.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @file Element hiding rule converter
+ */
+import { type ElementHidingRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * Element hiding rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class ElementHidingRuleConverter extends 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: ElementHidingRule): NodeConversionResult<ElementHidingRule>;
+}

package/dist/types/converter/cosmetic/header-removal.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @file Converter for request header removal rules
+ */
+import { type AnyRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+export declare const ERROR_MESSAGES: {
+    EMPTY_PARAMETER: string;
+    EXPECTED_END_OF_RULE: string;
+    MULTIPLE_DOMAINS_NOT_SUPPORTED: string;
+};
+/**
+ * Converter for request header removal rules
+ *
+ * @todo Implement `convertToUbo` (ABP currently doesn't support header removal rules)
+ */
+export declare class HeaderRemovalRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a header removal rule to AdGuard syntax, 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
+     * @example
+     * If the input rule is:
+     * ```adblock
+     * example.com##^responseheader(header-name)
+     * ```
+     * The output will be:
+     * ```adblock
+     * ||example.com^$removeheader=header-name
+     * ```
+     */
+    static convertToAdg(rule: AnyRule): NodeConversionResult<AnyRule>;
+}

package/dist/types/converter/cosmetic/html.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @file HTML filtering rule converter
+ */
+import { type HtmlFilteringRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+export declare const ERROR_MESSAGES: {
+    ABP_NOT_SUPPORTED: string;
+    TAG_SHOULD_BE_FIRST_CHILD: string;
+    EXPECTED_BUT_GOT_WITH_VALUE: string;
+    INVALID_ATTRIBUTE_NAME: string;
+    INVALID_ATTRIBUTE_VALUE: string;
+    INVALID_FLAG: string;
+    INVALID_OPERATOR_FOR_ATTR: string;
+    VALUE_FOR_ATTR_SHOULD_BE_INT: string;
+    INVALID_PSEUDO_CLASS: string;
+    VALUE_FOR_PSEUDO_CLASS_SHOULD_BE_INT: string;
+    REGEXP_NOT_SUPPORTED: string;
+    ATTRIBUTE_SELECTOR_REQUIRES_VALUE: string;
+    INVALID_ATTRIBUTE_SELECTOR_OPERATOR: string;
+    VALUE_SHOULD_BE_SPECIFIED: string;
+    OPERATOR_SHOULD_BE_SPECIFIED: string;
+    UNEXPECTED_TOKEN_WITH_VALUE: string;
+    FLAGS_NOT_SUPPORTED: string;
+};
+/**
+ * HTML filtering rule converter class
+ *
+ * @todo Implement `convertToUbo` (ABP currently doesn't support HTML filtering rules)
+ */
+export declare class HtmlRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a HTML rule to AdGuard syntax, if possible. Also can be used to convert
+     * AdGuard rules to AdGuard syntax to validate them.
+     *
+     * _Note:_ uBlock Origin supports multiple selectors within a single rule, but AdGuard doesn't,
+     * so the following rule
+     * ```
+     * example.com##^div[attr1="value1"][attr2="value2"], script:has-text(value)
+     * ```
+     * will be converted to multiple AdGuard rules:
+     * ```
+     * example.com$$div[attr1="value1"][attr2="value2"][max-length="262144"]
+     * example.com$$script[tag-content="value"][max-length="262144"]
+     * ```
+     *
+     * @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: HtmlFilteringRule): NodeConversionResult<HtmlFilteringRule>;
+}

package/dist/types/converter/cosmetic/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Cosmetic rule converter
+ */
+import { type AnyCosmeticRule, type AnyRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * Cosmetic rule converter class (also known as "non-basic rule converter")
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare class CosmeticRuleConverter extends RuleConverterBase {
+    /**
+     * Converts a cosmetic rule to AdGuard syntax, 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: AnyCosmeticRule): NodeConversionResult<AnyRule>;
+    /**
+     * Converts a cosmetic rule to uBlock Origin syntax, 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: AnyCosmeticRule): NodeConversionResult<AnyRule>;
+}

package/dist/types/converter/cosmetic/rule-modifiers/adg.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file Cosmetic rule modifier converter from uBO to ADG
+ */
+import { type ModifierList } from '../../../nodes';
+import { type ConversionResult } from '../../base-interfaces/conversion-result';
+/**
+ * Helper class for converting cosmetic rule modifiers from uBO to ADG
+ */
+export declare 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: ModifierList): ConversionResult<ModifierList>;
+}

package/dist/types/converter/cosmetic/scriptlet.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Scriptlet injection rule converter
+ */
+import { type ScriptletInjectionRule } from '../../nodes';
+import { RuleConverterBase } from '../base-interfaces/rule-converter-base';
+import { type NodeConversionResult } from '../base-interfaces/conversion-result';
+/**
+ * Scriptlet injection rule converter class
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare 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: ScriptletInjectionRule): NodeConversionResult<ScriptletInjectionRule>;
+    /**
+     * 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: ScriptletInjectionRule): NodeConversionResult<ScriptletInjectionRule>;
+}

package/dist/types/converter/css/index.d.ts

@@ -0,0 +1,23 @@
+import { BaseConverter } from '../base-interfaces/base-converter';
+import { type ConversionResult } from '../base-interfaces/conversion-result';
+import { CssTokenStream } from '../../parser/css/css-token-stream';
+export declare const ERROR_MESSAGES: {
+    INVALID_ATTRIBUTE_VALUE: string;
+};
+/**
+ * CSS selector converter
+ *
+ * @todo Implement `convertToUbo` and `convertToAbp`
+ */
+export declare 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: string | CssTokenStream): ConversionResult<string>;
+}

package/dist/types/converter/data/css.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @file Known CSS elements and attributes.
+ * TODO: Implement a compatibility table for Extended CSS
+ */
+/**
+ * Legacy Extended CSS attribute prefix.
+ *
+ * @example
+ * ```css
+ * [-ext-<name>=...]
+ * ```
+ */
+export declare const LEGACY_EXT_CSS_ATTRIBUTE_PREFIX = "-ext-";
+/**
+ * ABP Extended CSS prefix.
+ *
+ * @example
+ * ```css
+ * [-abp-<name>=...]
+ * -abp-<name>(...)
+ * ```
+ */
+export declare 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.
+ */
+export declare const EXT_CSS_PSEUDO_CLASSES_STRICT: Set<string>;
+/**
+ * _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.
+ */
+export declare const EXT_CSS_PSEUDO_CLASSES: Set<string>;
+/**
+ * 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.
+ */
+export declare const EXT_CSS_LEGACY_ATTRIBUTES: Set<string>;
+/**
+ * Known CSS functions that aren't allowed in CSS injection rules, because they
+ * able to load external resources. Please, keep this list sorted.
+ */
+export declare const FORBIDDEN_CSS_FUNCTIONS: Set<string>;

package/dist/types/converter/filter-list.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file Adblock filter list converter
+ */
+import { type FilterList } from '../nodes';
+import { type ConversionResult } from './base-interfaces/conversion-result';
+import { BaseConverter } from './base-interfaces/base-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
+ */
+export declare class FilterListConverter extends 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: FilterList, tolerant?: boolean): ConversionResult<FilterList>;
+}