@adguard/agtree 2.2.0 → 3.0.0-alpha.2

package/dist/serializer/network/hostname-list-serializer.js

@@ -0,0 +1,53 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { BaseSerializer } from '../base-serializer.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { UINT16_MAX, NULL } from '../../utils/constants.js';
+import { ValueSerializer } from '../misc/value-serializer.js';
+import { HostnameListNodeMarshallingMap } from '../../marshalling-utils/misc/hostname-list-common.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+
+/**
+ * Serializer for hostname list nodes.
+ */
+class HostnameListSerializer extends BaseSerializer {
+    /**
+     * Serializes a hostname list node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    static serialize(node, buffer) {
+        buffer.writeUint8(BinaryTypeMarshallingMap.HostnameListNode);
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(HostnameListNodeMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(HostnameListNodeMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        const count = node.children.length;
+        // If there are no children, we do not write any data related to them, to avoid using unnecessary storage,
+        // but children is a required field, so during deserialization we should initialize it as an empty array,
+        // if there are no children in the binary data.
+        if (count) {
+            // note: we store the count, because re-construction of the array is faster if we know the length
+            if (count > UINT16_MAX) {
+                throw new Error(`Too many children: ${count}, the limit is ${UINT16_MAX}`);
+            }
+            buffer.writeUint8(HostnameListNodeMarshallingMap.Children);
+            buffer.writeUint16(count);
+            for (let i = 0; i < count; i += 1) {
+                ValueSerializer.serialize(node.children[i], buffer);
+            }
+        }
+        buffer.writeUint8(NULL);
+    }
+}
+
+export { HostnameListSerializer };

package/dist/serializer/network/network-rule-serializer.js

@@ -0,0 +1,54 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { NULL } from '../../utils/constants.js';
+import { isUndefined } from '../../utils/type-guards.js';
+import { ValueSerializer } from '../misc/value-serializer.js';
+import { BaseSerializer } from '../base-serializer.js';
+import { ModifierListSerializer } from '../misc/modifier-list-serializer.js';
+import { NetworkRuleMarshallingMap } from '../../marshalling-utils/network/network-rule-common.js';
+import { BinaryTypeMarshallingMap } from '../../marshalling-utils/misc/binary-type-common.js';
+import { getSyntaxSerializationMap } from '../../marshalling-utils/syntax-serialization-map.js';
+
+/**
+ * `NetworkRuleSerializer` is responsible for serializing network rules.
+ *
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#basic-rules}
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#basic}
+ */
+class NetworkRuleSerializer extends BaseSerializer {
+    /**
+     * Serializes a network rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    // TODO: add support for raws, if ever needed
+    static serialize(node, buffer) {
+        buffer.writeUint8(BinaryTypeMarshallingMap.NetworkRuleNode);
+        buffer.writeUint8(NetworkRuleMarshallingMap.Syntax);
+        buffer.writeUint8(getSyntaxSerializationMap().get(node.syntax) ?? 0);
+        buffer.writeUint8(NetworkRuleMarshallingMap.Exception);
+        buffer.writeUint8(node.exception ? 1 : 0);
+        buffer.writeUint8(NetworkRuleMarshallingMap.Pattern);
+        ValueSerializer.serialize(node.pattern, buffer);
+        if (!isUndefined(node.modifiers)) {
+            buffer.writeUint8(NetworkRuleMarshallingMap.ModifierList);
+            ModifierListSerializer.serialize(node.modifiers, buffer);
+        }
+        if (!isUndefined(node.start)) {
+            buffer.writeUint8(NetworkRuleMarshallingMap.Start);
+            buffer.writeUint32(node.start);
+        }
+        if (!isUndefined(node.end)) {
+            buffer.writeUint8(NetworkRuleMarshallingMap.End);
+            buffer.writeUint32(node.end);
+        }
+        buffer.writeUint8(NULL);
+    }
+}
+
+export { NetworkRuleSerializer };

package/dist/serializer/rule-serializer.js

@@ -0,0 +1,61 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { RuleCategory, NetworkRuleType } from '../nodes/index.js';
+import { BaseSerializer } from './base-serializer.js';
+import { CommentRuleSerializer } from './comment/comment-rule-serializer.js';
+import { CosmeticRuleSerializer } from './cosmetic/cosmetic-rule-serializer.js';
+import { HostRuleSerializer } from './network/host-rule-serializer.js';
+import { NetworkRuleSerializer } from './network/network-rule-serializer.js';
+import { EmptyRuleSerializer } from './empty-rule-serializer.js';
+import { InvalidRuleSerializer } from './invalid-rule-serializer.js';
+
+/**
+ * `RuleSerializer` is responsible for serializing the rules.
+ *
+ * It automatically determines the category and syntax of the rule, so you can pass any kind of rule to it.
+ */
+class RuleSerializer extends BaseSerializer {
+    /**
+     * Serializes a rule node to binary format.
+     *
+     * @param node Node to serialize.
+     * @param buffer ByteBuffer for writing binary data.
+     */
+    // TODO: add support for raws, if ever needed
+    static serialize(node, buffer) {
+        switch (node.category) {
+            case RuleCategory.Comment:
+                CommentRuleSerializer.serialize(node, buffer);
+                break;
+            case RuleCategory.Cosmetic:
+                CosmeticRuleSerializer.serialize(node, buffer);
+                break;
+            case RuleCategory.Network:
+                switch (node.type) {
+                    case NetworkRuleType.HostRule:
+                        HostRuleSerializer.serialize(node, buffer);
+                        break;
+                    case NetworkRuleType.NetworkRule:
+                        NetworkRuleSerializer.serialize(node, buffer);
+                        break;
+                    default:
+                        throw new Error('Unknown network rule type');
+                }
+                break;
+            case RuleCategory.Empty:
+                EmptyRuleSerializer.serialize(node, buffer);
+                break;
+            case RuleCategory.Invalid:
+                InvalidRuleSerializer.serialize(node, buffer);
+                break;
+            default:
+                throw new Error('Unknown rule category');
+        }
+    }
+}
+
+export { RuleSerializer };

package/dist/types/ast-utils/clone.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file Custom clone functions for AST nodes, this is probably the most efficient way to clone AST nodes.
+ * @todo Maybe move them to parser classes as 'clone' methods
+ */
+import { type ParameterList, type DomainList, type ModifierList } from '../nodes';
+/**
+ * Clones a scriptlet rule node.
+ *
+ * @param node Node to clone
+ * @returns Cloned node
+ */
+export declare function cloneScriptletRuleNode(node: ParameterList): ParameterList;
+/**
+ * Clones a domain list node.
+ *
+ * @param node Node to clone
+ * @returns Cloned node
+ */
+export declare function cloneDomainListNode(node: DomainList): DomainList;
+/**
+ * Clones a modifier list node.
+ *
+ * @param node Node to clone
+ * @returns Cloned node
+ */
+export declare function cloneModifierListNode(node: ModifierList): ModifierList;

package/dist/types/ast-utils/filter-list.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file Utility functions for working with filter list nodes
+ */
+import { type AnyRule, type FilterList } from '../nodes';
+/**
+ * Creates a filter list node
+ *
+ * @param rules Rules to put in the list (optional, defaults to an empty list)
+ * @returns Filter list node
+ */
+export declare function createFilterListNode(rules?: AnyRule[]): FilterList;

package/dist/types/ast-utils/modifiers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file Utility functions for working with modifier nodes
+ */
+import { type Modifier, type ModifierList } from '../nodes';
+/**
+ * Creates a modifier node
+ *
+ * @param name Name of the modifier
+ * @param value Value of the modifier
+ * @param exception Whether the modifier is an exception
+ * @returns Modifier node
+ */
+export declare function createModifierNode(name: string, value?: string | undefined, exception?: boolean): Modifier;
+/**
+ * Creates a modifier list node
+ *
+ * @param modifiers Modifiers to put in the list (optional, defaults to an empty list)
+ * @returns Modifier list node
+ */
+export declare function createModifierListNode(modifiers?: Modifier[]): ModifierList;

package/dist/types/ast-utils/network-rules.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Utility functions for working with network rule nodes
+ */
+import { type ModifierList, type NetworkRule } from '../nodes';
+import { AdblockSyntax } from '../utils/adblockers';
+/**
+ * Creates a network rule node
+ *
+ * @param pattern Rule pattern
+ * @param modifiers Rule modifiers (optional, default: undefined)
+ * @param exception Exception rule flag (optional, default: false)
+ * @param syntax Adblock syntax (optional, default: Common)
+ * @returns Network rule node
+ */
+export declare function createNetworkRuleNode(pattern: string, modifiers?: ModifierList | undefined, exception?: boolean, syntax?: AdblockSyntax): NetworkRule;

package/dist/types/ast-utils/scriptlets.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @file Utility functions for working with scriptlet nodes
+ */
+import { type ParameterList } from '../nodes';
+import { type QuoteType } from '../utils/quotes';
+/**
+ * Function to transform a parameter of the scriptlet node.
+ *
+ * @param param Parameter to transform or null if the parameter is not present.
+ *
+ * @returns Transformed parameter or null if the parameter should be removed.
+ */
+type ParamTransformer = (param: string | null) => string | null;
+/**
+ * Get name of the scriptlet from the scriptlet node
+ *
+ * @param scriptletNode Scriptlet node to get name of
+ * @returns Name of the scriptlet
+ * @throws If the scriptlet is empty
+ */
+export declare function getScriptletName(scriptletNode: ParameterList): string;
+/**
+ * Transform the nth argument of the scriptlet node
+ *
+ * @param scriptletNode Scriptlet node to transform argument of
+ * @param index Index of the argument to transform (index 0 is the scriptlet name)
+ * @param transform Function to transform the argument
+ */
+export declare function transformNthScriptletArgument(scriptletNode: ParameterList, index: number, transform: ParamTransformer): void;
+/**
+ * Transform all arguments of the scriptlet node
+ *
+ * @param scriptletNode Scriptlet node to transform arguments of
+ * @param transform Function to transform the arguments
+ */
+export declare function transformAllScriptletArguments(scriptletNode: ParameterList, transform: ParamTransformer): void;
+/**
+ * Set name of the scriptlet.
+ * Modifies input `scriptletNode` if needed.
+ *
+ * @param scriptletNode Scriptlet node to set name of
+ * @param name Name to set
+ */
+export declare function setScriptletName(scriptletNode: ParameterList, name: string): void;
+/**
+ * Set quote type of the scriptlet parameters
+ *
+ * @param scriptletNode Scriptlet node to set quote type of
+ * @param quoteType Preferred quote type
+ */
+export declare function setScriptletQuoteType(scriptletNode: ParameterList, quoteType: QuoteType): void;
+export {};

package/dist/types/common/abp-snippet-injection-body-common.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Common class for the ABP snippet injection body.
+ * This class contains shared constants and utilities for handling ABP snippet injection bodies.
+ */
+export declare class AbpSnippetInjectionBodyCommon {
+    /**
+     * Error messages used by the parser and generator.
+     */
+    static ERROR_MESSAGES: {
+        /**
+         * Error message indicating that an ABP snippet call is empty.
+         */
+        EMPTY_SCRIPTLET_CALL: string;
+    };
+}

package/dist/types/common/agent-common.d.ts

@@ -0,0 +1,10 @@
+import { AdblockSyntax } from '../utils/adblockers';
+/**
+ * Returns the adblock syntax based on the adblock name parsed from the agent type comment.
+ * Needed for modifiers validation of network rules by AGLint.
+ *
+ * @param name Adblock name.
+ *
+ * @returns Adblock syntax.
+ */
+export declare const getAdblockSyntax: (name: string) => AdblockSyntax;

package/dist/types/common/ubo-selector-common.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Known uBO-specific pseudo-class names.
+ */
+export declare const UboPseudoName: {
+    readonly MatchesMedia: "matches-media";
+    readonly MatchesPath: "matches-path";
+    readonly Remove: "remove";
+    readonly Style: "style";
+};
+export type UboPseudoName = typeof UboPseudoName[keyof typeof UboPseudoName];

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

@@ -0,0 +1,157 @@
+/**
+ * @file Provides common compatibility table methods.
+ */
+import { type BaseCompatibilityDataSchema } from './schemas';
+import { GenericPlatform, type SpecificPlatform } from './platforms';
+import { type CompatibilityTable } from './types';
+import { AdblockSyntax } from '../utils/adblockers';
+/**
+ * Lists all supported entity records by a product.
+ *
+ * Keys are compatibility flags, values are compatibility data records.
+ *
+ * @template T Compatibility data schema.
+ */
+export type ProductRecords<T> = {
+    [key: string]: T;
+};
+/**
+ * Defines a compatibility table row by product.
+ *
+ * Keys are Adblock syntaxes, values are product records.
+ *
+ * @template T Compatibility data schema.
+ */
+export type RowByProduct<T> = {
+    [AdblockSyntax.Adg]: ProductRecords<T>;
+    [AdblockSyntax.Ubo]: ProductRecords<T>;
+    [AdblockSyntax.Abp]: ProductRecords<T>;
+};
+/**
+ * Defines multiple compatibility table rows by product.
+ *
+ * @template T Compatibility data schema.
+ */
+export type RowsByProduct<T> = RowByProduct<T>[];
+/**
+ * Single platform records type.
+ *
+ * Keys are platform enums values, values are compatibility data records.
+ *
+ * @template T Compatibility data schema.
+ */
+type SinglePlatformRecords<T> = {
+    [key: string]: T;
+};
+/**
+ * Name transformer function type. This function is used to normalize compatibility data names before processing them,
+ * e.g. converting to lowercase, remove unnecessary prefixes, etc.
+ *
+ * @param name Compatibility data name.
+ *
+ * @returns Normalized name.
+ */
+type NameTransformer = (name: string) => string;
+/**
+ * Base compatibility table class which provides common methods to work with compatibility data.
+ *
+ * @template T Compatibility data schema.
+ */
+export declare abstract class CompatibilityTableBase<T extends BaseCompatibilityDataSchema> {
+    /**
+     * Compatibility table data.
+     */
+    private data;
+    /**
+     * Optional name transformer function. If provided,
+     * it will be called in all methods before processing compatibility data names.
+     */
+    private readonly nameTransformer;
+    /**
+     * Creates a new instance of the common compatibility table.
+     *
+     * @param data Compatibility table data.
+     * @param nameTransformer Optional name transformer function.
+     */
+    constructor(data: CompatibilityTable<T>, nameTransformer?: NameTransformer | null);
+    /**
+     * Helper method to get a 'row' from the compatibility table data by name.
+     *
+     * @param name Compatibility data name.
+     * @returns Compatibility table row storage or `null` if not found.
+     */
+    private getRowStorage;
+    /**
+     * Checks whether a compatibility data `name` exists for any platform.
+     *
+     * @note Technically, do the same as `exists()` method with generic platform _any_
+     * but it is faster because it does not apply complex logic.
+     *
+     * @param name Compatibility data name.
+     *
+     * @returns True if the compatibility data exists, false otherwise.
+     */
+    existsAny(name: string): boolean;
+    /**
+     * Checks whether a compatibility data `name` exists for a specified platform.
+     *
+     * @param name Compatibility data name.
+     * @param platform Specific or generic platform.
+     *
+     * @returns True if the compatibility data exists, false otherwise.
+     */
+    exists(name: string, platform: SpecificPlatform | GenericPlatform): boolean;
+    /**
+     * Returns a compatibility data by name and specific platform.
+     *
+     * @param name The name of the compatibility data.
+     * @param platform The specific platform.
+     *
+     * @returns A single compatibility data or `null` if not found.
+     */
+    getSingle(name: string, platform: SpecificPlatform): T | null;
+    /**
+     * Returns all compatibility data records for name and specified platform.
+     *
+     * @param name Compatibility data name.
+     * @param platform Specific or generic platform.
+     *
+     * @returns Multiple records grouped by platforms.
+     * Technically, it is an object where keys are platform enums values and values are compatibility data records.
+     *
+     * @note Platform enum values can be converted to string names using {@link getSpecificPlatformName} on demand.
+     */
+    getMultiple(name: string, platform: SpecificPlatform | GenericPlatform): SinglePlatformRecords<T> | null;
+    /**
+     * Returns all compatibility data records for the specified platform.
+     *
+     * @param platform Specific or generic platform.
+     *
+     * @returns Array of multiple records grouped by platforms.
+     */
+    getAllMultiple(platform: SpecificPlatform | GenericPlatform): SinglePlatformRecords<T>[];
+    /**
+     * Returns the first compatibility data record for name and specified platform.
+     *
+     * @param name Compatibility data name.
+     * @param platform Specific or generic platform.
+     *
+     * @returns First found compatibility data record or `null` if not found.
+     */
+    getFirst(name: string, platform: SpecificPlatform | GenericPlatform): T | null;
+    /**
+     * Returns all compatibility data records for the specified name.
+     *
+     * @param name Compatibility data name.
+     *
+     * @returns Array of multiple records grouped by platforms.
+     */
+    getRow(name: string): T[];
+    /**
+     * Returns all compatibility data grouped by products.
+     *
+     * @returns Array of multiple records grouped by products.
+     */
+    getRowsByProduct(): RowsByProduct<T>;
+}
+export {};

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

@@ -0,0 +1,68 @@
+/**
+ * @file Provides compatibility table data loading.
+ */
+import { type CompatibilityTable } from './types';
+/**
+ * Compatibility table data for scriptlets.
+ */
+export declare const scriptletsCompatibilityTableData: CompatibilityTable<{
+    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;
+}>;
+/**
+ * Compatibility table data for redirects.
+ */
+export declare const redirectsCompatibilityTableData: CompatibilityTable<{
+    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;
+    isBlocking: boolean;
+    resourceTypes: ("object" | "image" | "other" | "font" | "media" | "ping" | "script" | "stylesheet" | "websocket" | "xmlhttprequest" | "main_frame" | "sub_frame")[];
+}>;
+/**
+ * Compatibility table data for modifiers.
+ */
+export declare const modifiersCompatibilityTableData: CompatibilityTable<{
+    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;
+    conflicts: string[] | null;
+    inverseConflicts: boolean;
+    assignable: boolean;
+    negatable: boolean;
+    blockOnly: boolean;
+    exceptionOnly: boolean;
+    valueOptional: boolean;
+    valueFormat: string | null;
+    valueFormatFlags: string | null;
+}>;

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

@@ -0,0 +1,13 @@
+/**
+ * @file Compatibility tables variables and types reexport.
+ */
+export { modifiersCompatibilityTable } from './modifiers';
+export { redirectsCompatibilityTable } from './redirects';
+export { scriptletsCompatibilityTable } from './scriptlets';
+export * from './types';
+export * from './platforms';
+export type { ProductRecords, RowByProduct, RowsByProduct, } from './base';
+export { parseRawPlatforms } from './schemas';
+export { isGenericPlatform, getPlatformId, getSpecificPlatformName, } from './utils/platform-helpers';
+export { ResourceType, } from './schemas/resource-type';
+export { getResourceTypeModifier, isValidResourceType, } from './utils/resource-type-helpers';

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

@@ -0,0 +1,22 @@
+/**
+ * @file Compatibility tables for modifiers.
+ */
+import { CompatibilityTableBase } from './base';
+import { type ModifierDataSchema } from './schemas';
+import { type CompatibilityTable } from './types';
+/**
+ * Compatibility table for modifiers.
+ */
+declare class ModifiersCompatibilityTable extends CompatibilityTableBase<ModifierDataSchema> {
+    /**
+     * Creates a new instance of the compatibility table for modifiers.
+     *
+     * @param data Compatibility table data.
+     */
+    constructor(data: CompatibilityTable<ModifierDataSchema>);
+}
+/**
+ * Compatibility table instance for modifiers.
+ */
+export declare const modifiersCompatibilityTable: ModifiersCompatibilityTable;
+export {};

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

@@ -0,0 +1,49 @@
+/**
+ * @file Provides platform enums.
+ * The difference between specific and generic platforms is that specific platforms are individual platforms
+ * (e.g. AdGuard for Windows, AdGuard for Android, etc.),
+ * while generic platforms are groups of specific platforms
+ * (e.g. AdGuard for any OS, AdGuard for any Chromium-based extension, etc.).
+ */
+/**
+ * List of specific platforms.
+ */
+export declare const SpecificPlatform: {
+    readonly AdgOsWindows: 1;
+    readonly AdgOsMac: number;
+    readonly AdgOsAndroid: number;
+    readonly AdgExtChrome: number;
+    readonly AdgExtOpera: number;
+    readonly AdgExtEdge: number;
+    readonly AdgExtFirefox: number;
+    readonly AdgCbAndroid: number;
+    readonly AdgCbIos: number;
+    readonly AdgCbSafari: number;
+    readonly UboExtChrome: number;
+    readonly UboExtOpera: number;
+    readonly UboExtEdge: number;
+    readonly UboExtFirefox: number;
+    readonly AbpExtChrome: number;
+    readonly AbpExtOpera: number;
+    readonly AbpExtEdge: number;
+    readonly AbpExtFirefox: number;
+};
+export type SpecificPlatform = typeof SpecificPlatform[keyof typeof SpecificPlatform];
+/**
+ * List of generic platforms (combinations of specific platforms).
+ */
+export declare const GenericPlatform: {
+    readonly AdgOsAny: number;
+    readonly AdgSafariAny: number;
+    readonly AdgExtChromium: number;
+    readonly AdgExtAny: number;
+    readonly AdgAny: number;
+    readonly UboExtChromium: number;
+    readonly UboExtAny: number;
+    readonly UboAny: number;
+    readonly AbpExtChromium: number;
+    readonly AbpExtAny: number;
+    readonly AbpAny: number;
+    readonly Any: number;
+};
+export type GenericPlatform = typeof GenericPlatform[keyof typeof GenericPlatform];