@adguard/agtree 2.1.3 → 3.0.0-alpha.1

package/dist/types/parser/css/css-token-stream.d.ts

@@ -0,0 +1,210 @@
+/**
+ * @file CSS token stream.
+ */
+import { TokenType } from '@adguard/css-tokenizer';
+/**
+ * Interface for CSS token data.
+ */
+export interface TokenData {
+    /**
+     * Type of the token.
+     */
+    type: TokenType;
+    /**
+     * Start index in the source string.
+     */
+    start: number;
+    /**
+     * End index in the source string.
+     */
+    end: number;
+    /**
+     * Balance level of the token.
+     */
+    balance: number;
+}
+/**
+ * Interface for expectation data.
+ */
+export interface ExpectationData {
+    /**
+     * Expected balance level of the token (optional).
+     */
+    balance?: number;
+    /**
+     * Expected value of the token (optional).
+     */
+    value?: string;
+}
+/**
+ * Interface for skipUntilExt result.
+ */
+export interface SkipUntilExtResult {
+    /**
+     * Number of tokens skipped.
+     */
+    skipped: number;
+    /**
+     * Number of tokens skipped without leading and trailing whitespace tokens.
+     */
+    skippedTrimmed: number;
+}
+/**
+ * Represents a stream of CSS tokens.
+ */
+export declare class CssTokenStream {
+    /**
+     * The tokens in the stream.
+     */
+    private tokens;
+    /**
+     * The source string.
+     */
+    readonly source: string;
+    /**
+     * The current index in the stream.
+     */
+    private index;
+    /**
+     * The base offset of the source string.
+     */
+    private baseOffset;
+    /**
+     * Initializes a new instance of the TokenStream class.
+     *
+     * @param source The source string to tokenize.
+     * @param baseOffset The base offset of the source string.
+     */
+    constructor(source: string, baseOffset?: number);
+    /**
+     * Gets the number of tokens in the stream.
+     *
+     * @returns The number of tokens in the stream.
+     */
+    get length(): number;
+    /**
+     * Checks if the end of the token stream is reached.
+     *
+     * @returns True if the end of the stream is reached, otherwise false.
+     */
+    isEof(): boolean;
+    /**
+     * Gets the token at the specified index.
+     *
+     * @param index The index of the token to retrieve.
+     * @returns The token at the specified index or undefined if the index is out of bounds.
+     */
+    get(index?: number): TokenData | undefined;
+    /**
+     * Gets the token at the specified index or throws if no token is found at the specified index.
+     *
+     * @param index The index of the token to retrieve.
+     * @returns The token at the specified index or undefined if the index is out of bounds.
+     * @throws If no token is found at the specified index.
+     */
+    getOrFail(index?: number): TokenData;
+    /**
+     * Gets the source fragment of the token at the specified index.
+     *
+     * @param index The index of the token to retrieve the fragment for.
+     * @returns The source fragment of the token or an empty string if the index is out of bounds.
+     */
+    fragment(index?: number): string;
+    /**
+     * Moves the index to the next token and returns it.
+     *
+     * @returns The next token or undefined if the end of the stream is reached.
+     */
+    advance(): TokenData | undefined;
+    /**
+     * Looks ahead in the stream without changing the index.
+     *
+     * @param index The relative index to look ahead to, starting from the current index.
+     * @returns The next token or undefined if the end of the stream is reached.
+     */
+    lookahead(index?: number): TokenData | undefined;
+    /**
+     * Looks behind in the stream without changing the index.
+     *
+     * @param index The relative index to look behind to, starting from the current index.
+     * @returns The previous token or undefined if the current token is the first in the stream.
+     */
+    lookbehind(index?: number): TokenData | undefined;
+    /**
+     * Looks behind in the stream for the previous non-whitespace token without changing the index.
+     *
+     * @returns The previous non-whitespace token or undefined if it could not be found.
+     */
+    lookbehindForNonWs(): TokenData | undefined;
+    /**
+     * Skips whitespace tokens in the stream.
+     */
+    skipWhitespace(): void;
+    /**
+     * Skips tokens until the current balance level is reached.
+     *
+     * @returns The number of tokens skipped.
+     */
+    skipUntilBalanced(): number;
+    /**
+     * Skips tokens until a token with the specified type or the end of the stream is reached.
+     *
+     * @param type The type of token to skip until.
+     * @param balance The balance level of the token to skip until.
+     * @returns The number of tokens skipped.
+     */
+    skipUntil(type: TokenType, balance?: number): number;
+    /**
+     * Skips tokens until a token with the specified type or the end of the stream is reached. This is an extended
+     * version of skipUntil that also returns the number of tokens skipped without calculating leading and trailing
+     * whitespace tokens.
+     *
+     * @param type The type of token to skip until.
+     * @param balance The balance level of the token to skip until.
+     * @returns An array containing the number of tokens skipped and the number of tokens skipped without leading and
+     * trailing whitespace tokens.
+     */
+    skipUntilExt(type: TokenType, balance: number): SkipUntilExtResult;
+    /**
+     * Expects that the end of the stream is not reached.
+     */
+    expectNotEof(): void;
+    /**
+     * Expects the current token to have a specific type and optional value and balance level.
+     *
+     * @param type The expected token type.
+     * @param data Optional expectation data.
+     * @throws If the end of the stream is reached or if the token type or expectation data does not match.
+     */
+    expect(type: TokenType, data?: ExpectationData): void;
+    /**
+     * Gets the balance level of the token at the specified index.
+     *
+     * @param index The index of the token to retrieve the balance level for.
+     * @returns The balance level of the token or 0 if the index is out of bounds.
+     */
+    getBalance(index?: number): number;
+    /**
+     * Checks whether the token stream contains any Extended CSS elements, such as `:contains()`, etc.
+     *
+     * @returns `true` if the stream contains any Extended CSS elements, otherwise `false`.
+     */
+    hasAnySelectorExtendedCssNode(): boolean;
+    /**
+     * Strictly checks whether the token stream contains any Extended CSS elements, such as `:contains()`.
+     * Some Extended CSS elements are natively supported by browsers, like `:has()`.
+     * This method is used to check for Extended CSS elements that are not natively supported by browsers,
+     * this is why it called "strict", because it strictly checks for Extended CSS elements.
+     *
+     * @returns `true` if the stream contains any Extended CSS elements, otherwise `false`.
+     */
+    hasAnySelectorExtendedCssNodeStrict(): boolean;
+    /**
+     * Checks whether the token stream contains any Extended CSS elements, such as `:has()`, `:contains()`, etc.
+     *
+     * @param pseudos Set of pseudo-classes to check for.
+     *
+     * @returns `true` if the stream contains any Extended CSS elements, otherwise `false`.
+     */
+    private hasAnySelectorExtendedCssNodeInternal;
+}

package/dist/types/parser/css/ubo-selector-parser.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @file Parser for special uBO selectors.
+ */
+import { type UboSelector } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * Possible error messages for uBO selectors. Formatted with {@link sprintf}.
+ */
+export declare const ERROR_MESSAGES: {
+    DUPLICATED_UBO_MODIFIER: string;
+    EXPECTED_BUT_GOT_BEFORE: string;
+    NEGATED_UBO_MODIFIER_CANNOT_BE_FOLLOWED_BY: string;
+    NEGATED_UBO_MODIFIER_CANNOT_BE_PRECEDED_BY: string;
+    PSEUDO_CANNOT_BE_NESTED: string;
+    UBO_MODIFIER_CANNOT_BE_NESTED: string;
+    UBO_STYLE_CANNOT_BE_FOLLOWED: string;
+};
+/**
+ * A simple helper function to format a pseudo name for error messages.
+ *
+ * @param name Pseudo name.
+ * @param wrapper Wrapper pseudo name (eg. `not`) (optional, defaults to `undefined`).
+ * @returns Formatted pseudo name.
+ * @example
+ * ```ts
+ * formatPseudoName('matches-path', 'not'); // => ':not(:matches-path(...))'
+ * formatPseudoName('matches-media'); // => ':matches-media(...)'
+ * ```
+ */
+export declare const formatPseudoName: (name: string, wrapper?: string) => string;
+/**
+ * Parser for uBO selectors.
+ */
+export declare class UboSelectorParser extends BaseParser {
+    /**
+     * Parses a uBO selector list, eg. `div:matches-path(/path)`.
+     *
+     * @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 uBO selector {@link UboSelectorParser}.
+     * @throws An {@link AdblockSyntaxError} if the selector list is syntactically invalid.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): UboSelector;
+}

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

@@ -0,0 +1,29 @@
+import { type FilterList } from '../nodes';
+import { BaseParser } from './base-parser';
+/**
+ * `FilterListParser` is responsible for parsing a whole adblock filter list (list of rules).
+ * It is a wrapper around `RuleParser` which parses each line separately.
+ */
+export declare class FilterListParser extends BaseParser {
+    /**
+     * Parses a whole adblock filter list (list of rules).
+     *
+     * @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 AST of the source code (list of rules)
+     * @example
+     * ```js
+     * import { readFileSync } from 'fs';
+     * import { FilterListParser } from '@adguard/agtree';
+     *
+     * // Read filter list content from file
+     * const content = readFileSync('your-adblock-filter-list.txt', 'utf-8');
+     *
+     * // Parse the filter list content, then do something with the AST
+     * const ast = FilterListParser.parse(content);
+     * ```
+     * @throws If one of the rules is syntactically invalid (if `tolerant` is `false`)
+     */
+    static parse(raw: string, options?: import("./options").ParserOptions, baseOffset?: number): FilterList;
+}

package/dist/types/parser/index.d.ts

@@ -0,0 +1,5 @@
+export { RuleParser } from './rule-parser';
+export { defaultParserOptions, type ParserOptions } from './options';
+export { CosmeticRuleParser } from './cosmetic/cosmetic-rule-parser';
+export { DomainListParser } from './misc/domain-list-parser';
+export { NetworkRuleParser } from './network/network-rule-parser';

package/dist/types/parser/misc/app-list-parser.d.ts

@@ -0,0 +1,22 @@
+import { type AppList } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `AppListParser` is responsible for parsing an app list.
+ *
+ * @see {@link https://adguard.app/kb/general/ad-filtering/create-own-filters/#app-modifier}
+ */
+export declare class AppListParser extends BaseParser {
+    /**
+     * Parses an app list which items are separated by `|`,
+     * e.g. `Example.exe|com.example.osx`.
+     *
+     * @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 App list AST.
+     * @throws An {@link AdblockSyntaxError} if the app list is syntactically invalid.
+     * @throws An {@link Error} if the options are invalid.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): AppList;
+}

package/dist/types/parser/misc/domain-list-parser.d.ts

@@ -0,0 +1,26 @@
+import { type DomainList } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `DomainListParser` is responsible for parsing a domain list.
+ *
+ * @example
+ * - If the rule is `example.com,~example.net##.ads`, the domain list is `example.com,~example.net`.
+ * - If the rule is `ads.js^$script,domains=example.com|~example.org`, the domain list is `example.com|~example.org`.
+ * This parser is responsible for parsing these domain lists.
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_domains}
+ */
+export declare class DomainListParser extends BaseParser {
+    /**
+     * Parses a domain list, eg. `example.com,example.org,~example.org`
+     *
+     * @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.
+     * @param separator Separator character (default: comma)
+     *
+     * @returns Domain list AST.
+     * @throws An {@link AdblockSyntaxError} if the domain list is syntactically invalid.
+     * @throws An {@link Error} if the options are invalid.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number, separator?: string): DomainList;
+}

package/dist/types/parser/misc/list-items-parser.d.ts

@@ -0,0 +1,34 @@
+import { type ListItem, ListItemNodeType } from '../../nodes';
+/**
+ * Prefixes for error messages which are used for parsing of value lists.
+ */
+export declare const LIST_PARSE_ERROR_PREFIX: {
+    EMPTY_ITEM: string;
+    NO_MULTIPLE_NEGATION: string;
+    NO_SEPARATOR_AFTER_NEGATION: string;
+    NO_SEPARATOR_AT_THE_BEGINNING: string;
+    NO_SEPARATOR_AT_THE_END: string;
+    NO_WHITESPACE_AFTER_NEGATION: string;
+};
+export declare class ListItemsParser {
+    /**
+     * Parses a `raw` modifier value which may be represented as a list of items separated by `separator`.
+     * Needed for $app, $denyallow, $domain, $method.
+     *
+     * @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.
+     * @param separator Separator character (default: comma)
+     * @param type Type of the list items (default: {@link ListItemNodeType.Domain}).
+     * @template T Type of the list items.
+     *
+     * @returns List of parsed items.
+     * @throws An {@link AdblockSyntaxError} if the list is syntactically invalid
+     *
+     * @example
+     * - parses an app list — `com.example.app|Example.exe`
+     * - parses a domain list — `example.com,example.org,~example.org` or `example.com|~example.org`
+     * - parses a method list — `~post|~put`
+     */
+    static parse<T extends ListItemNodeType>(raw: string, options?: import("../options").ParserOptions, baseOffset?: number, separator?: string, type?: T): ListItem<T>[];
+}

package/dist/types/parser/misc/logical-expression-parser.d.ts

@@ -0,0 +1,41 @@
+import { type AnyExpressionNode } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * Possible node types in the logical expression.
+ */
+export declare const enum NodeType {
+    Variable = "Variable",
+    Operator = "Operator",
+    Parenthesis = "Parenthesis"
+}
+/**
+ * `LogicalExpressionParser` is responsible for parsing logical expressions.
+ *
+ * @example
+ * From the following rule:
+ * ```adblock
+ * !#if (adguard_ext_android_cb || adguard_ext_safari)
+ * ```
+ * this parser will parse the expression `(adguard_ext_android_cb || adguard_ext_safari)`.
+ */
+export declare class LogicalExpressionParser extends BaseParser {
+    /**
+     * Split the expression into tokens.
+     *
+     * @param raw Source code of the expression
+     * @param baseOffset Starting offset of the input. Node locations are calculated relative to this offset.
+     * @returns Token list
+     * @throws {AdblockSyntaxError} If the expression is invalid
+     */
+    private static tokenize;
+    /**
+     * Parses a logical expression.
+     *
+     * @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 expression
+     * @throws {AdblockSyntaxError} If the expression is invalid
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): AnyExpressionNode;
+}

package/dist/types/parser/misc/method-list-parser.d.ts

@@ -0,0 +1,22 @@
+import { type MethodList } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `MethodListParser` is responsible for parsing a method list.
+ *
+ * @see {@link https://adguard.app/kb/general/ad-filtering/create-own-filters/#method-modifier}
+ */
+export declare class MethodListParser extends BaseParser {
+    /**
+     * Parses a method list which items are separated by `|`,
+     * e.g. `get|post|put`.
+     *
+     * @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 Method list AST.
+     * @throws An {@link AdblockSyntaxError} if the method list is syntactically invalid.
+     * @throws An {@link Error} if the options are invalid.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): MethodList;
+}

package/dist/types/parser/misc/modifier-list.d.ts

@@ -0,0 +1,24 @@
+import { type ModifierList } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `ModifierListParser` is responsible for parsing modifier lists. Please note that the name is not
+ * uniform, "modifiers" are also known as "options".
+ *
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#basic-rules-modifiers}
+ * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#non-basic-rules-modifiers}
+ * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#options}
+ */
+export declare class ModifierListParser extends BaseParser {
+    /**
+     * Parses the cosmetic rule modifiers, eg. `third-party,domain=example.com|~example.org`.
+     *
+     * _Note:_ you should remove `$` separator before passing the raw modifiers to this function,
+     *  or it will be parsed in the first modifier.
+     *
+     * @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 modifiers interface
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): ModifierList;
+}

package/dist/types/parser/misc/modifier-parser.d.ts

@@ -0,0 +1,21 @@
+import { type Modifier } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `ModifierParser` is responsible for parsing modifiers.
+ *
+ * @example
+ * `match-case`, `~third-party`, `domain=example.com|~example.org`
+ */
+export declare class ModifierParser extends BaseParser {
+    /**
+     * Parses a modifier.
+     *
+     * @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 modifier
+     * @throws An error if modifier name or value is empty.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): Modifier;
+}

package/dist/types/parser/misc/parameter-list-parser.d.ts

@@ -0,0 +1,14 @@
+import { type ParameterList } from '../../nodes';
+import { BaseParser } from '../base-parser';
+export declare class ParameterListParser extends BaseParser {
+    /**
+     * Parses a raw parameter list.
+     *
+     * @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.
+     * @param separator Separator character (default: comma)
+     * @returns Parameter list AST
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number, separator?: string): ParameterList;
+}

package/dist/types/parser/misc/stealth-option-list-parser.d.ts

@@ -0,0 +1,22 @@
+import { type StealthOptionList } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `StealthOptionListParser` is responsible for parsing a list of stealth options.
+ *
+ * @see {@link https://adguard.app/kb/general/ad-filtering/create-own-filters/#stealth-modifier}
+ */
+export declare class StealthOptionListParser extends BaseParser {
+    /**
+     * Parses a stealth option list which items are separated by `|`,
+     * e.g. `dpi|ip`.
+     *
+     * @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 Stealth option list AST.
+     * @throws An {@link AdblockSyntaxError} if the stealth option list is syntactically invalid.
+     * @throws An {@link Error} if the options are invalid.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): StealthOptionList;
+}

package/dist/types/parser/misc/ubo-parameter-list-parser.d.ts

@@ -0,0 +1,18 @@
+import { ParameterListParser } from './parameter-list-parser';
+import { type ParameterList } from '../../nodes';
+export declare class UboParameterListParser extends ParameterListParser {
+    /**
+     * Parses an "uBO-specific parameter list".
+     *
+     * @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.
+     * @param separator Separator character (default: comma).
+     * @param requireQuotes Whether to require quotes around the parameter values (default: false).
+     * @param supportedQuotes Set of accepted quotes (default: {@link QUOTE_SET}).
+     * @returns Parameter list node.
+     *
+     * @note Based on {@link https://github.com/gorhill/uBlock/blob/f9ab4b75041815e6e5690d80851189ae3dc660d0/src/js/static-filtering-parser.js#L607-L699} to provide consistency.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number, separator?: string, requireQuotes?: boolean, supportedQuotes?: Set<string>): ParameterList;
+}

package/dist/types/parser/misc/value-parser.d.ts

@@ -0,0 +1,18 @@
+import { BaseParser } from '../base-parser';
+import { type Value } from '../../nodes';
+/**
+ * Value parser.
+ * This parser is very simple, it just exists to provide a consistent interface for parsing and generating values.
+ */
+export declare class ValueParser extends BaseParser {
+    /**
+     * Parses a value.
+     *
+     * @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 Value node.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): Value;
+}

package/dist/types/parser/network/host-rule-parser.d.ts

@@ -0,0 +1,35 @@
+import { type HostRule } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `HostRuleParser` is responsible for parsing hosts-like rules.
+ *
+ * HostRule is a structure for simple host-level rules (i.e. /etc/hosts syntax).
+ * It also supports "just domain" syntax. In this case, the IP will be set to 0.0.0.0.
+ *
+ * Rules syntax looks like this:
+ * ```text
+ * IP_address canonical_hostname [aliases...]
+ * ```
+ *
+ * @example
+ * `192.168.1.13 bar.mydomain.org bar` -- ipv4
+ * `ff02::1 ip6-allnodes` -- ipv6
+ * `::1 localhost ip6-localhost ip6-loopback` -- ipv6 aliases
+ * `example.org` -- "just domain" syntax
+ * @see {@link http://man7.org/linux/man-pages/man5/hosts.5.html}
+ */
+export declare class HostRuleParser extends BaseParser {
+    static readonly NULL_IP = "0.0.0.0";
+    static readonly COMMENT_MARKER = "#";
+    /**
+     * Parses an etc/hosts-like 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 Host rule node.
+     *
+     * @throws If the input contains invalid data.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): HostRule;
+}

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

@@ -0,0 +1,31 @@
+import { type NetworkRule } from '../../nodes';
+import { BaseParser } from '../base-parser';
+/**
+ * `NetworkRuleParser` is responsible for parsing network rules.
+ *
+ * Please note that this will parse all syntactically correct network rules.
+ * Modifier compatibility is not checked at the parser level.
+ *
+ * @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}
+ */
+export declare class NetworkRuleParser extends BaseParser {
+    /**
+     * Parses a network rule (also known as basic 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 Network rule AST
+     *
+     * @throws If the rule is syntactically incorrect.
+     */
+    static parse(raw: string, options?: import("../options").ParserOptions, baseOffset?: number): NetworkRule;
+    /**
+     * Finds the index of the separator character in a network rule.
+     *
+     * @param rule Network rule to check
+     * @returns The index of the separator character, or -1 if there is no separator
+     */
+    private static findNetworkRuleSeparatorIndex;
+}