@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/types/parser/base-parser.d.ts

@@ -0,0 +1,16 @@
+import { type Node } from '../nodes';
+import { type ParserOptions } from './options';
+/**
+ * Base class for parsers. Each parser should extend this class.
+ */
+export declare class BaseParser {
+    /**
+     * Parses the input string and returns the AST node.
+     *
+     * @param input Input string to parse.
+     * @param options Parser options, see {@link ParserOptions}.
+     * @param baseOffset Base offset. Locations in the AST node will be relative to this offset.
+     * @param args Additional, parser-specific arguments, if needed.
+     */
+    static parse(input: string, options: ParserOptions, baseOffset: number, ...args: unknown[]): Node | null;
+}

package/dist/types/parser/comment/agent-comment-parser.d.ts

@@ -0,0 +1,42 @@
+import { type AgentCommentRule } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `AgentParser` is responsible for parsing an Adblock agent rules.
+ * Adblock agent comment marks that the filter list is supposed to
+ * be used by the specified ad blockers.
+ *
+ * @example
+ *  - ```adblock
+ *    [AdGuard]
+ *    ```
+ *  - ```adblock
+ *    [Adblock Plus 2.0]
+ *    ```
+ *  - ```adblock
+ *    [uBlock Origin]
+ *    ```
+ *  - ```adblock
+ *    [uBlock Origin 1.45.3]
+ *    ```
+ *  - ```adblock
+ *    [Adblock Plus 2.0; AdGuard]
+ *    ```
+ */
+export declare class AgentCommentParser extends BaseParser {
+    /**
+     * Checks if the raw rule is an adblock agent comment.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is an adblock agent, `false` otherwise
+     */
+    static isAgentRule(raw: string): boolean;
+    /**
+     * Parses a raw rule as an adblock agent comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Agent rule AST or null (if the raw rule cannot be parsed as an adblock agent comment)
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): AgentCommentRule | null;
+}

package/dist/types/parser/comment/agent-parser.d.ts

@@ -0,0 +1,33 @@
+import { type Agent } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `AgentParser` is responsible for parsing single adblock agent elements.
+ *
+ * @example
+ * If the adblock agent rule is
+ * ```adblock
+ * [Adblock Plus 2.0; AdGuard]
+ * ```
+ * then the adblock agents are `Adblock Plus 2.0` and `AdGuard`, and this
+ * class is responsible for parsing them. The rule itself is parsed by
+ * `AgentCommentParser`, which uses this class to parse single agents.
+ */
+export declare class AgentParser extends BaseParser {
+    /**
+     * Checks if the string is a valid version.
+     *
+     * @param str String to check
+     * @returns `true` if the string is a valid version, `false` otherwise
+     */
+    private static isValidVersion;
+    /**
+     * Parses a raw rule as an adblock agent comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Agent rule AST
+     * @throws {AdblockSyntaxError} If the raw rule cannot be parsed as an adblock agent
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): Agent;
+}

package/dist/types/parser/comment/comment-parser.d.ts

@@ -0,0 +1,76 @@
+import { type AnyCommentRule } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `CommentParser` is responsible for parsing any comment-like adblock rules.
+ *
+ * @example
+ * Example rules:
+ *  - Adblock agent rules:
+ *      - ```adblock
+ *        [AdGuard]
+ *        ```
+ *      - ```adblock
+ *        [Adblock Plus 2.0]
+ *        ```
+ *      - etc.
+ *  - AdGuard hint rules:
+ *      - ```adblock
+ *        !+ NOT_OPTIMIZED
+ *        ```
+ *      - ```adblock
+ *        !+ NOT_OPTIMIZED PLATFORM(windows)
+ *        ```
+ *      - etc.
+ *  - Pre-processor rules:
+ *      - ```adblock
+ *        !#if (adguard)
+ *        ```
+ *      - ```adblock
+ *        !#endif
+ *        ```
+ *      - etc.
+ *  - Metadata rules:
+ *      - ```adblock
+ *        ! Title: My List
+ *        ```
+ *      - ```adblock
+ *        ! Version: 2.0.150
+ *        ```
+ *      - etc.
+ *  - AGLint inline config rules:
+ *      - ```adblock
+ *        ! aglint-enable some-rule
+ *        ```
+ *      - ```adblock
+ *        ! aglint-disable some-rule
+ *        ```
+ *      - etc.
+ *  - Simple comments:
+ *      - Regular version:
+ *        ```adblock
+ *        ! This is just a comment
+ *        ```
+ *      - uBlock Origin / "hostlist" version:
+ *        ```adblock
+ *        # This is just a comment
+ *        ```
+ *      - etc.
+ */
+export declare class CommentParser extends BaseParser {
+    /**
+     * Checks whether a rule is a comment.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is a comment, `false` otherwise
+     */
+    static isCommentRule(raw: string): boolean;
+    /**
+     * Parses a raw rule as comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Comment AST or null (if the raw rule cannot be parsed as comment)
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): AnyCommentRule | null;
+}

package/dist/types/parser/comment/config-comment-parser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file AGLint configuration comments. Inspired by ESLint inline configuration comments.
+ * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
+ */
+import { type ConfigCommentRule } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `ConfigCommentParser` is responsible for parsing inline AGLint configuration rules.
+ * Generally, the idea is inspired by ESLint inline configuration comments.
+ *
+ * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}
+ */
+export declare class ConfigCommentParser extends BaseParser {
+    /**
+     * Checks if the raw rule is an inline configuration comment rule.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is an inline configuration comment rule, otherwise `false`.
+     */
+    static isConfigComment(raw: string): boolean;
+    /**
+     * Parses a raw rule as an inline configuration comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns
+     * Inline configuration comment AST or null (if the raw rule cannot be parsed as configuration comment)
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): ConfigCommentRule | null;
+}

package/dist/types/parser/comment/hint-comment-parser.d.ts

@@ -0,0 +1,33 @@
+import { type HintCommentRule } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `HintRuleParser` is responsible for parsing AdGuard hint rules.
+ *
+ * @example
+ * The following hint rule
+ * ```adblock
+ * !+ NOT_OPTIMIZED PLATFORM(windows)
+ * ```
+ * contains two hints: `NOT_OPTIMIZED` and `PLATFORM`.
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#hints}
+ */
+export declare class HintCommentParser extends BaseParser {
+    /**
+     * Checks if the raw rule is a hint rule.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is a hint rule, `false` otherwise
+     */
+    static isHintRule(raw: string): boolean;
+    /**
+     * Parses a raw rule as a hint comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Hint AST or null (if the raw rule cannot be parsed as a hint comment)
+     * @throws If the input matches the HINT pattern but syntactically invalid
+     * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#hints-1}
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): HintCommentRule | null;
+}

package/dist/types/parser/comment/hint-parser.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file AdGuard Hints
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#hints}
+ */
+import { type Hint } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `HintParser` is responsible for parsing AdGuard hints.
+ *
+ * @example
+ * If the hint rule is
+ * ```adblock
+ * !+ NOT_OPTIMIZED PLATFORM(windows)
+ * ```
+ * then the hints are `NOT_OPTIMIZED` and `PLATFORM(windows)`, and this
+ * class is responsible for parsing them. The rule itself is parsed by
+ * the `HintRuleParser`, which uses this class to parse single hints.
+ */
+export declare class HintParser extends BaseParser {
+    /**
+     * Parses a raw rule as a hint.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Hint rule AST or null
+     * @throws If the syntax is invalid
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): Hint;
+}

package/dist/types/parser/comment/metadata-comment-parser.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file Metadata comments
+ */
+import { type MetadataCommentRule } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `MetadataParser` is responsible for parsing metadata comments.
+ * Metadata comments are special comments that specify some properties of the list.
+ *
+ * @example
+ * For example, in the case of
+ * ```adblock
+ * ! Title: My List
+ * ```
+ * the name of the header is `Title`, and the value is `My List`, which means that
+ * the list title is `My List`, and it can be used in the adblocker UI.
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#special-comments}
+ */
+export declare class MetadataCommentParser extends BaseParser {
+    /**
+     * Parses a raw rule as a metadata comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Metadata comment AST or null (if the raw rule cannot be parsed as a metadata comment)
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): MetadataCommentRule | null;
+}

package/dist/types/parser/comment/preprocessor-parser.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Pre-processor directives
+ *
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#pre-processor-directives}
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#pre-parsing-directives}
+ */
+import type { PreProcessorCommentRule } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `PreProcessorParser` is responsible for parsing preprocessor rules.
+ * Pre-processor comments are special comments that are used to control the behavior of the filter list processor.
+ * Please note that this parser only handles general syntax for now, and does not validate the parameters at
+ * the parsing stage.
+ *
+ * @example
+ * If your rule is
+ * ```adblock
+ * !#if (adguard)
+ * ```
+ * then the directive's name is `if` and its value is `(adguard)`, but the parameter list
+ * is not parsed / validated further.
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#pre-processor-directives}
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#pre-parsing-directives}
+ */
+export declare class PreProcessorCommentParser extends BaseParser {
+    /**
+     * Determines whether the rule is a pre-processor rule.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is a pre-processor rule, `false` otherwise
+     */
+    static isPreProcessorRule(raw: string): boolean;
+    /**
+     * Parses a raw rule as a pre-processor comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns
+     * Pre-processor comment AST or null (if the raw rule cannot be parsed as a pre-processor comment)
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): PreProcessorCommentRule | null;
+}

package/dist/types/parser/comment/simple-comment-parser.d.ts

@@ -0,0 +1,33 @@
+import { type CommentRule } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `SimpleCommentParser` is responsible for parsing simple comments.
+ * Some comments have a special meaning in adblock syntax, like agent comments or hints,
+ * but this parser is only responsible for parsing regular comments,
+ * whose only purpose is to provide some human-readable information.
+ *
+ * @example
+ * ```adblock
+ * ! This is a simple comment
+ * # This is a simple comment, but in host-like syntax
+ * ```
+ */
+export declare class SimpleCommentParser extends BaseParser {
+    /**
+     * Checks if the raw rule is a simple comment.
+     *
+     * @param raw Raw input to check.
+     * @returns `true` if the input is a simple comment, `false` otherwise.
+     * @note This method does not check for adblock agent comments.
+     */
+    static isSimpleComment(raw: string): boolean;
+    /**
+     * Parses a raw rule as a simple comment.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Comment rule node or null (if the raw rule cannot be parsed as a simple comment).
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): CommentRule | null;
+}

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

@@ -0,0 +1,34 @@
+/**
+ * @file uBlock scriptlet injection body parser
+ */
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+import { BaseParser } from '../../base-parser';
+/**
+ * `AbpSnippetInjectionBodyParser` is responsible for parsing the body of an Adblock Plus-style snippet rule.
+ *
+ * Please note that the parser will parse any scriptlet rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com#$#snippet0 arg0
+ * ```
+ *
+ * but it didn't check if the scriptlet `snippet0` actually supported by any adblocker.
+ *
+ * @see {@link https://help.eyeo.com/adblockplus/snippet-filters-tutorial}
+ */
+export declare class AbpSnippetInjectionBodyParser extends BaseParser {
+    /**
+     * Parses the body of an Adblock Plus-style snippet rule.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Node of the parsed scriptlet call body
+     * @throws If the body is syntactically incorrect
+     * @example
+     * ```
+     * #$#snippet0 arg0
+     * ```
+     */
+    static parse(raw: string, options?: import("../../options").ParserOptions, baseOffset?: number): ScriptletInjectionRuleBody;
+}

package/dist/types/parser/cosmetic/body/adg-scriptlet-injection-body-parser.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @file AdGuard scriptlet injection body parser
+ */
+import { BaseParser } from '../../base-parser';
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+/**
+ * `AdgScriptletInjectionBodyParser` is responsible for parsing the body of an AdGuard-style scriptlet rule.
+ *
+ * Please note that the parser will parse any scriptlet rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com#%#//scriptlet('scriptlet0', 'arg0')
+ * ```
+ *
+ * but it didn't check if the scriptlet `scriptlet0` actually supported by any adblocker.
+ *
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
+ */
+export declare class AdgScriptletInjectionBodyParser extends BaseParser {
+    /**
+     * Error messages used by the parser.
+     */
+    static readonly ERROR_MESSAGES: {
+        NO_SCRIPTLET_MASK: string;
+        NO_OPENING_PARENTHESIS: string;
+        NO_CLOSING_PARENTHESIS: string;
+        WHITESPACE_AFTER_MASK: string;
+        NO_INCONSISTENT_QUOTES: string;
+        NO_UNCLOSED_PARAMETER: string;
+        EXPECTED_QUOTE: string;
+        EXPECTED_COMMA: string;
+    };
+    /**
+     * Parses the body of an AdGuard-style scriptlet rule.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Node of the parsed scriptlet call body
+     * @throws If the body is syntactically incorrect
+     * @example
+     * ```
+     * //scriptlet('scriptlet0', 'arg0')
+     * ```
+     */
+    static parse(raw: string, options?: import("../../options").ParserOptions, baseOffset?: number): ScriptletInjectionRuleBody;
+}

package/dist/types/parser/cosmetic/body/ubo-scriptlet-injection-body-parser.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file uBlock scriptlet injection body parser
+ */
+import { type ScriptletInjectionRuleBody } from '../../../nodes';
+import { BaseParser } from '../../base-parser';
+/**
+ * `UboScriptletInjectionBodyParser` is responsible for parsing the body of a uBlock-style scriptlet rule.
+ *
+ * Please note that the parser will parse any scriptlet rule if it is syntactically correct.
+ * For example, it will parse this:
+ * ```adblock
+ * example.com##+js(scriptlet0, arg0)
+ * ```
+ *
+ * but it didn't check if the scriptlet `scriptlet0` actually supported by any adblocker.
+ *
+ * @see {@link https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#scriptlet-injection}
+ */
+export declare class UboScriptletInjectionBodyParser extends BaseParser {
+    /**
+     * Error messages used by the parser.
+     */
+    static readonly ERROR_MESSAGES: {
+        NO_SCRIPTLET_MASK: string;
+        NO_OPENING_PARENTHESIS: string;
+        NO_CLOSING_PARENTHESIS: string;
+        NO_SCRIPTLET_NAME: string;
+        WHITESPACE_AFTER_MASK: string;
+    };
+    /**
+     * Parses the body of a uBlock-style scriptlet rule.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Node of the parsed scriptlet call body
+     * @throws If the body is syntactically incorrect
+     * @example
+     * ```
+     * ##+js(scriptlet0, arg0)
+     * ```
+     */
+    static parse(raw: string, options?: import("../../options").ParserOptions, baseOffset?: number): ScriptletInjectionRuleBody;
+}

package/dist/types/parser/cosmetic/cosmetic-rule-parser.d.ts

@@ -0,0 +1,51 @@
+import { type AnyCosmeticRule } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * Possible error messages for uBO selectors. Formatted with {@link sprintf}.
+ */
+export declare const ERROR_MESSAGES: {
+    EMPTY_RULE_BODY: string;
+    INVALID_BODY_FOR_SEPARATOR: string;
+    MISSING_ADGUARD_MODIFIER_LIST_END: string;
+    MISSING_ADGUARD_MODIFIER_LIST_MARKER: string;
+    SYNTAXES_CANNOT_BE_MIXED: string;
+    SYNTAX_DISABLED: string;
+};
+/**
+ * `CosmeticRuleParser` is responsible for parsing cosmetic rules.
+ *
+ * Where possible, it automatically detects the difference between supported syntaxes:
+ *  - AdGuard
+ *  - uBlock Origin
+ *  - Adblock Plus
+ *
+ * If the syntax is common / cannot be determined, the parser gives `Common` syntax.
+ *
+ * Please note that syntactically correct rules are parsed even if they are not actually
+ * compatible with the given adblocker. This is a completely natural behavior, meaningful
+ * checking of compatibility is not done at the parser level.
+ */
+export declare class CosmeticRuleParser extends BaseParser {
+    /**
+     * Determines whether a rule is a cosmetic rule. The rule is considered cosmetic if it
+     * contains a cosmetic rule separator.
+     *
+     * @param raw Raw rule
+     * @returns `true` if the rule is a cosmetic rule, `false` otherwise
+     */
+    static isCosmeticRule(raw: string): boolean;
+    /**
+     * Parses a cosmetic rule. The structure of the cosmetic rules:
+     *  - pattern (AdGuard pattern can have modifiers, other syntaxes don't)
+     *  - separator
+     *  - body
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns
+     * Parsed cosmetic rule AST or null if it failed to parse based on the known cosmetic rules
+     * @throws If the input matches the cosmetic rule pattern but syntactically invalid
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): AnyCosmeticRule | null;
+}

package/dist/types/parser/css/adg-css-injection-parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @file Parser for AdGuard CSS injections.
+ */
+import { type CssInjectionRuleBody } from '../../nodes';
+import { BaseParser } from '../base-parser';
+export declare const REMOVE_PROPERTY = "remove";
+export declare const REMOVE_VALUE = "true";
+export declare const ERROR_MESSAGES: {
+    MEDIA_QUERY_LIST_IS_EMPTY: string;
+    SELECTOR_LIST_IS_EMPTY: string;
+    DECLARATION_LIST_IS_EMPTY: string;
+};
+/**
+ * Parser for AdGuard CSS injection.
+ */
+export declare class AdgCssInjectionParser extends BaseParser {
+    /**
+     * Parses an AdGuard CSS injection.
+     *
+     * @param raw Raw input to parse.
+     * @param options Global parser options.
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     *
+     * @returns Parsed AdGuard CSS injection {@link CssInjectionRuleBody}.
+     * @throws An {@link AdblockSyntaxError} if the selector list is syntactically invalid.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): CssInjectionRuleBody;
+}

package/dist/types/parser/css/balancing.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @file Tokenizer helpers for balanced pairs.
+ */
+import { type OnErrorCallback, type OnTokenCallback, type TokenizerContextFunction } from '@adguard/css-tokenizer';
+/**
+ * Extended version of `OnTokenCallback` which also receives a `balance` parameter.
+ *
+ * @param type Type of the token.
+ * @param start Start index in the source string.
+ * @param end End index in the source string.
+ * @param props Additional properties of the token (if any - can be `undefined`, depending on the token type).
+ * @param balance Calculated balance level of the token.
+ * @note This function is keeping the same signature as the original `OnTokenCallback` to avoid breaking changes,
+ * just adding the `balance` parameter at the end.
+ */
+export type OnBalancedTokenCallback = (...args: [...Parameters<OnTokenCallback>, ...[balance: number]]) => ReturnType<OnTokenCallback>;
+/**
+ * Tokenize and ensure balanced pairs for standard CSS.
+ *
+ * @param raw Raw CSS string to tokenize
+ * @param onToken Callback which will be invoked for each token, extended with a `balance` parameter
+ * @param onError Error callback which is called when a parsing error is found (optional)
+ * @param functionHandlers Custom function handlers (optional)
+ * @throws If the input is not balanced
+ */
+export declare const tokenizeBalanced: (raw: string, onToken: OnBalancedTokenCallback, onError?: OnErrorCallback, functionHandlers?: Map<number, TokenizerContextFunction>) => void;
+/**
+ * Tokenize and ensure balanced pairs for function calls.
+ *
+ * @param raw Raw CSS string to tokenize
+ * @param onToken Callback which will be invoked for each token, extended with a `balance` parameter
+ * @param onError Error callback which is called when a parsing error is found (optional)
+ * @param functionHandlers Custom function handlers (optional)
+ * @throws If the input is not balanced
+ */
+export declare const tokenizeFnBalanced: (raw: string, onToken: OnBalancedTokenCallback, onError?: OnErrorCallback, functionHandlers?: Map<number, TokenizerContextFunction>) => void;

package/dist/types/parser/css/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file Error messages for CSS token stream and balancer.
+ */
+export declare const END_OF_INPUT = "end of input";
+export declare const ERROR_MESSAGES: {
+    EXPECTED_ANY_TOKEN_BUT_GOT: string;
+    EXPECTED_TOKEN_BUT_GOT: string;
+    EXPECTED_TOKEN_WITH_BALANCE_BUT_GOT: string;
+    EXPECTED_TOKEN_WITH_VALUE_BUT_GOT: string;
+};