@adguard/agtree 3.0.0 → 3.0.1

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

@@ -1,13 +1,11 @@
 import { type AdblockSyntax } from '../utils/adblockers';
 import { type COMMA_DOMAIN_LIST_SEPARATOR, type PIPE_MODIFIER_SEPARATOR } from '../utils/constants';
-/**
- * Possible operators in the logical expression.
- */
-export declare const enum OperatorValue {
-    Not = "!",
-    And = "&&",
-    Or = "||"
-}
+export declare const OperatorValue: {
+    readonly Not: "!";
+    readonly And: "&&";
+    readonly Or: "||";
+};
+export type OperatorValue = typeof OperatorValue[keyof typeof OperatorValue];
 /**
  * Represents possible new line types.
  */
@@ -39,147 +37,154 @@ export type AnyNetworkRule = NetworkRule | HostRule;
  * - If the rule is `! This is just a comment`, then the marker will be `!`.
  * - If the rule is `# This is just a comment`, then the marker will be `#`.
  */
-export declare const enum CommentMarker {
+export declare const CommentMarker: {
     /**
      * Regular comment marker. It is supported by all ad blockers.
      */
-    Regular = "!",
+    readonly Regular: "!";
     /**
      * Hashmark comment marker. It is supported by uBlock Origin and AdGuard,
      * and also used in hosts files.
      */
-    Hashmark = "#"
-}
+    readonly Hashmark: "#";
+};
+export type CommentMarker = typeof CommentMarker[keyof typeof CommentMarker];
 /**
  * Represents the main categories that an adblock rule can belong to.
  * Of course, these include additional subcategories.
  */
-export declare enum RuleCategory {
+export declare const RuleCategory: {
     /**
      * Empty "rules" that are only containing whitespaces. These rules are handled just for convenience.
      */
-    Empty = "Empty",
+    readonly Empty: "Empty";
     /**
      * Syntactically invalid rules (tolerant mode only).
      */
-    Invalid = "Invalid",
+    readonly Invalid: "Invalid";
     /**
      * Comment rules, such as comment rules, metadata rules, preprocessor rules, etc.
      */
-    Comment = "Comment",
+    readonly Comment: "Comment";
     /**
      * Cosmetic rules, such as element hiding rules, CSS rules, scriptlet rules, HTML rules, and JS rules.
      */
-    Cosmetic = "Cosmetic",
+    readonly Cosmetic: "Cosmetic";
     /**
      * Network rules, such as basic network rules, header remover network rules, redirect network rules,
      * response header filtering rules, etc.
      */
-    Network = "Network"
-}
+    readonly Network: "Network";
+};
+export type RuleCategory = typeof RuleCategory[keyof typeof RuleCategory];
 /**
  * Represents similar types of modifiers values
  * which may be separated by a comma `,` (only for DomainList) or a pipe `|`.
  */
-export declare const enum ListNodeType {
-    Unknown = "Unknown",
-    AppList = "AppList",
-    DomainList = "DomainList",
-    MethodList = "MethodList",
-    StealthOptionList = "StealthOptionList"
-}
+export declare const ListNodeType: {
+    readonly Unknown: "Unknown";
+    readonly AppList: "AppList";
+    readonly DomainList: "DomainList";
+    readonly MethodList: "MethodList";
+    readonly StealthOptionList: "StealthOptionList";
+};
+export type ListNodeType = typeof ListNodeType[keyof typeof ListNodeType];
 /**
  * Represents child items for {@link ListNodeType}.
  */
-export declare enum ListItemNodeType {
-    Unknown = "Unknown",
-    App = "App",
-    Domain = "Domain",
-    Method = "Method",
-    StealthOption = "StealthOption"
-}
+export declare const ListItemNodeType: {
+    readonly Unknown: "Unknown";
+    readonly App: "App";
+    readonly Domain: "Domain";
+    readonly Method: "Method";
+    readonly StealthOption: "StealthOption";
+};
+export type ListItemNodeType = typeof ListItemNodeType[keyof typeof ListItemNodeType];
 /**
  * Represents possible comment types.
  */
-export declare enum CommentRuleType {
-    AgentCommentRule = "AgentCommentRule",
-    CommentRule = "CommentRule",
-    ConfigCommentRule = "ConfigCommentRule",
-    HintCommentRule = "HintCommentRule",
-    MetadataCommentRule = "MetadataCommentRule",
-    PreProcessorCommentRule = "PreProcessorCommentRule"
-}
+export declare const CommentRuleType: {
+    readonly AgentCommentRule: "AgentCommentRule";
+    readonly CommentRule: "CommentRule";
+    readonly ConfigCommentRule: "ConfigCommentRule";
+    readonly HintCommentRule: "HintCommentRule";
+    readonly MetadataCommentRule: "MetadataCommentRule";
+    readonly PreProcessorCommentRule: "PreProcessorCommentRule";
+};
+export type CommentRuleType = typeof CommentRuleType[keyof typeof CommentRuleType];
 /**
  * Represents possible cosmetic rule types.
  */
-export declare enum CosmeticRuleType {
-    ElementHidingRule = "ElementHidingRule",
-    CssInjectionRule = "CssInjectionRule",
-    ScriptletInjectionRule = "ScriptletInjectionRule",
-    HtmlFilteringRule = "HtmlFilteringRule",
-    JsInjectionRule = "JsInjectionRule"
-}
+export declare const CosmeticRuleType: {
+    readonly ElementHidingRule: "ElementHidingRule";
+    readonly CssInjectionRule: "CssInjectionRule";
+    readonly ScriptletInjectionRule: "ScriptletInjectionRule";
+    readonly HtmlFilteringRule: "HtmlFilteringRule";
+    readonly JsInjectionRule: "JsInjectionRule";
+};
+export type CosmeticRuleType = typeof CosmeticRuleType[keyof typeof CosmeticRuleType];
 /**
  * Represents possible cosmetic rule separators.
  */
-export declare const enum CosmeticRuleSeparator {
+export declare const CosmeticRuleSeparator: {
     /**
      * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
      */
-    ElementHiding = "##",
+    readonly ElementHiding: "##";
     /**
      * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
      */
-    ElementHidingException = "#@#",
+    readonly ElementHidingException: "#@#";
     /**
      * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
      */
-    ExtendedElementHiding = "#?#",
+    readonly ExtendedElementHiding: "#?#";
     /**
      * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
      */
-    ExtendedElementHidingException = "#@?#",
+    readonly ExtendedElementHidingException: "#@?#";
     /**
      * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
      */
-    AbpSnippet = "#$#",
+    readonly AbpSnippet: "#$#";
     /**
      * @see {@link https://help.eyeo.com/adblockplus/how-to-write-filters#elemhide_basic}
      */
-    AbpSnippetException = "#@$#",
+    readonly AbpSnippetException: "#@$#";
     /**
      * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
      */
-    AdgCssInjection = "#$#",
+    readonly AdgCssInjection: "#$#";
     /**
      * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
      */
-    AdgCssInjectionException = "#@$#",
+    readonly AdgCssInjectionException: "#@$#";
     /**
      * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
      */
-    AdgExtendedCssInjection = "#$?#",
+    readonly AdgExtendedCssInjection: "#$?#";
     /**
      * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#cosmetic-css-rules}
      */
-    AdgExtendedCssInjectionException = "#@$?#",
+    readonly AdgExtendedCssInjectionException: "#@$?#";
     /**
      * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
      */
-    AdgJsInjection = "#%#",
+    readonly AdgJsInjection: "#%#";
     /**
      * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#scriptlets}
      */
-    AdgJsInjectionException = "#@%#",
+    readonly AdgJsInjectionException: "#@%#";
     /**
      * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#html-filtering-rules}
      */
-    AdgHtmlFiltering = "$$",
+    readonly AdgHtmlFiltering: "$$";
     /**
      * @see {@link https://kb.adguard.com/en/general/how-to-create-your-own-ad-filters#html-filtering-rules}
      */
-    AdgHtmlFilteringException = "$@$"
-}
+    readonly AdgHtmlFilteringException: "$@$";
+};
+export type CosmeticRuleSeparator = typeof CosmeticRuleSeparator[keyof typeof CosmeticRuleSeparator];
 /**
  * Represents a basic node in the AST.
  */
@@ -347,7 +352,7 @@ export interface InvalidRule extends RuleBase {
     /**
      * Category of the adblock rule
      */
-    category: RuleCategory.Invalid;
+    category: typeof RuleCategory.Invalid;
     /**
      * Raw rule text
      */
@@ -368,13 +373,13 @@ export interface EmptyRule extends RuleBase {
     /**
      * Category of the adblock rule
      */
-    category: RuleCategory.Empty;
+    category: typeof RuleCategory.Empty;
 }
 /**
  * Represents the basic comment rule interface.
  */
 export interface CommentBase extends RuleBase {
-    category: RuleCategory.Comment;
+    category: typeof RuleCategory.Comment;
     type: CommentRuleType;
 }
 /**
@@ -390,7 +395,7 @@ export interface CommentBase extends RuleBase {
  *     ```
  */
 export interface CommentRule extends CommentBase {
-    type: CommentRuleType.CommentRule;
+    type: typeof CommentRuleType.CommentRule;
     /**
      * Comment marker.
      *
@@ -419,7 +424,7 @@ export interface CommentRule extends CommentBase {
  * the name of the header is `Title`, and the value is `My List`.
  */
 export interface MetadataCommentRule extends CommentBase {
-    type: CommentRuleType.MetadataCommentRule;
+    type: typeof CommentRuleType.MetadataCommentRule;
     /**
      * Comment marker.
      */
@@ -459,8 +464,8 @@ export interface ConfigNode extends Node {
  * then the command is `aglint-disable` and its params is `["some-rule", "another-rule"]`.
  */
 export interface ConfigCommentRule extends CommentBase {
-    category: RuleCategory.Comment;
-    type: CommentRuleType.ConfigCommentRule;
+    category: typeof RuleCategory.Comment;
+    type: typeof CommentRuleType.ConfigCommentRule;
     /**
      * The marker for the comment. It can be `!` or `#`. It is always the first non-whitespace character in the comment.
      */
@@ -508,8 +513,8 @@ export interface ConfigCommentRule extends CommentBase {
  * the general syntax.
  */
 export interface PreProcessorCommentRule extends CommentBase {
-    category: RuleCategory.Comment;
-    type: CommentRuleType.PreProcessorCommentRule;
+    category: typeof RuleCategory.Comment;
+    type: typeof CommentRuleType.PreProcessorCommentRule;
     /**
      * Name of the directive
      */
@@ -549,8 +554,8 @@ export interface Agent extends Node {
  *   ```
  */
 export interface AgentCommentRule extends RuleBase {
-    category: RuleCategory.Comment;
-    type: CommentRuleType.AgentCommentRule;
+    category: typeof RuleCategory.Comment;
+    type: typeof CommentRuleType.AgentCommentRule;
     /**
      * Agent list.
      */
@@ -595,8 +600,8 @@ export interface Hint extends Node {
  * then there are two hint members: `NOT_OPTIMIZED` and `PLATFORM`.
  */
 export interface HintCommentRule extends RuleBase {
-    category: RuleCategory.Comment;
-    type: CommentRuleType.HintCommentRule;
+    category: typeof RuleCategory.Comment;
+    type: typeof CommentRuleType.HintCommentRule;
     /**
      * Currently only AdGuard supports hints.
      */
@@ -690,19 +695,19 @@ export interface ListItem<T extends ListItemNodeType> extends Node {
 /**
  * Represents an element of the app list — $app.
  */
-export type App = ListItem<ListItemNodeType.App>;
+export type App = ListItem<typeof ListItemNodeType.App>;
 /**
  * Represents an element of the domain list — $domain, $denyallow.
  */
-export type Domain = ListItem<ListItemNodeType.Domain>;
+export type Domain = ListItem<typeof ListItemNodeType.Domain>;
 /**
  * Represents an element of the method list — $method.
  */
-export type Method = ListItem<ListItemNodeType.Method>;
+export type Method = ListItem<typeof ListItemNodeType.Method>;
 /**
  * Represents an element of the stealth option list — $stealth.
  */
-export type StealthOption = ListItem<ListItemNodeType.StealthOption>;
+export type StealthOption = ListItem<typeof ListItemNodeType.StealthOption>;
 /**
  * Represents any list item.
  */
@@ -718,7 +723,7 @@ export interface DomainList extends Node {
     /**
      * Type of the node. Basically, the idea is that each main AST part should have a type
      */
-    type: ListNodeType.DomainList;
+    type: typeof ListNodeType.DomainList;
     /**
      * Separator used in the domain list.
      */
@@ -739,7 +744,7 @@ export interface AppList extends Node {
     /**
      * Type of the node. Basically, the idea is that each main AST part should have a type
      */
-    type: ListNodeType.AppList;
+    type: typeof ListNodeType.AppList;
     /**
      * Separator used in the app list.
      */
@@ -760,7 +765,7 @@ export interface MethodList extends Node {
     /**
      * Type of the node. Basically, the idea is that each main AST part should have a type
      */
-    type: ListNodeType.MethodList;
+    type: typeof ListNodeType.MethodList;
     /**
      * Separator used in the method list.
      */
@@ -781,7 +786,7 @@ export interface StealthOptionList extends Node {
     /**
      * Type of the node. Basically, the idea is that each main AST part should have a type
      */
-    type: ListNodeType.StealthOptionList;
+    type: typeof ListNodeType.StealthOptionList;
     /**
      * Separator used in the stealth option list.
      */
@@ -872,7 +877,7 @@ export interface HtmlFilteringRuleBody extends Node {
  * all other properties can be defined at this level.
  */
 export interface CosmeticRule extends RuleBase {
-    category: RuleCategory.Cosmetic;
+    category: typeof RuleCategory.Cosmetic;
     type: CosmeticRuleType;
     /**
      * List of modifiers (optional)
@@ -921,7 +926,7 @@ export interface CosmeticRule extends RuleBase {
  *   ```
  */
 export interface ElementHidingRule extends CosmeticRule {
-    type: CosmeticRuleType.ElementHidingRule;
+    type: typeof CosmeticRuleType.ElementHidingRule;
     body: ElementHidingRuleBody;
 }
 /**
@@ -950,7 +955,7 @@ export interface ElementHidingRule extends CosmeticRule {
  *    ```
  */
 export interface CssInjectionRule extends CosmeticRule {
-    type: CosmeticRuleType.CssInjectionRule;
+    type: typeof CosmeticRuleType.CssInjectionRule;
     body: CssInjectionRuleBody;
 }
 /**
@@ -984,7 +989,7 @@ export interface CssInjectionRule extends CosmeticRule {
  *    ```
  */
 export interface ScriptletInjectionRule extends CosmeticRule {
-    type: CosmeticRuleType.ScriptletInjectionRule;
+    type: typeof CosmeticRuleType.ScriptletInjectionRule;
     body: ScriptletInjectionRuleBody;
 }
 /**
@@ -1007,7 +1012,7 @@ export interface ScriptletInjectionRule extends CosmeticRule {
  *    ```
  */
 export interface HtmlFilteringRule extends CosmeticRule {
-    type: CosmeticRuleType.HtmlFilteringRule;
+    type: typeof CosmeticRuleType.HtmlFilteringRule;
     body: Value;
 }
 /**
@@ -1022,16 +1027,17 @@ export interface HtmlFilteringRule extends CosmeticRule {
  *    ```
  */
 export interface JsInjectionRule extends CosmeticRule {
-    type: CosmeticRuleType.JsInjectionRule;
+    type: typeof CosmeticRuleType.JsInjectionRule;
     body: Value;
 }
 /**
  * Represents the different types of network rules.
  */
-export declare enum NetworkRuleType {
-    NetworkRule = "NetworkRule",
-    HostRule = "HostRule"
-}
+export declare const NetworkRuleType: {
+    readonly NetworkRule: "NetworkRule";
+    readonly HostRule: "HostRule";
+};
+export type NetworkRuleType = typeof NetworkRuleType[keyof typeof NetworkRuleType];
 /**
  * Represents the common properties of network rules
  */
@@ -1039,7 +1045,7 @@ export interface NetworkRuleBase extends RuleBase {
     /**
      * Category of the adblock rule.
      */
-    category: RuleCategory.Network;
+    category: typeof RuleCategory.Network;
     /**
      * Type of the network rule.
      */
@@ -1057,7 +1063,7 @@ export interface NetworkRule extends NetworkRuleBase {
     /**
      * Type of the node.
      */
-    type: NetworkRuleType.NetworkRule;
+    type: typeof NetworkRuleType.NetworkRule;
     /**
      * If the rule is an exception rule. If the rule begins with `@@`, it means that it is an exception rule.
      *
@@ -1125,7 +1131,7 @@ export interface HostRule extends NetworkRuleBase {
     /**
      * Type of the node.
      */
-    type: NetworkRuleType.HostRule;
+    type: typeof NetworkRuleType.HostRule;
     /**
      * IP address. It can be an IPv4 or IPv6 address.
      *

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

@@ -13,9 +13,16 @@ import { BaseParser } from '../base-parser';
  * `AgentCommentParser`, which uses this class to parse single agents.
  */
 export declare class AgentParser extends BaseParser {
+    /**
+     * Regex to match a version inside a string.
+     */
+    private static readonly VERSION_REGEX;
     /**
      * Checks if the string is a valid version.
      *
+     * The string can have a version in formats like
+     * [Adblock Plus 2.0], or [Adblock Plus 3.1; AdGuard].
+     *
      * @param str String to check
      * @returns `true` if the string is a valid version, `false` otherwise
      */

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

@@ -2,6 +2,24 @@
  * @file Tokenizer helpers for balanced pairs.
  */
 import { type OnErrorCallback, type OnTokenCallback, type TokenizerContextFunction } from '@adguard/css-tokenizer';
+/**
+ * Utility type to get the last element from a tuple, handling optional last elements correctly.
+ *
+ * @param T - The tuple to extract the last element from.
+ * @returns The last element of the tuple if present; `L | undefined` if the last element is optional.
+ */
+type Last<T extends unknown[]> = T extends [...infer _I, infer L] ? L : T extends [...infer _I, (infer L)?] ? L | undefined : never;
+/**
+ * Utility type to remove the last element from a tuple, handling optional last elements correctly.
+ *
+ * @param T - The tuple to remove the last element from.
+ * @returns A tuple without the last element. If the last element is optional, it is also removed.
+ */
+type OmitLast<T extends unknown[]> = T extends [...infer Rest, infer _Last] ? Rest : T extends [...infer Rest, (infer _Last)?] ? Rest : never;
+/**
+ * Extracts the parameters of `OnTokenCallback` as a tuple.
+ */
+type OnTokenCallbackParameters = Parameters<OnTokenCallback>;
 /**
  * Extended version of `OnTokenCallback` which also receives a `balance` parameter.
  *
@@ -10,10 +28,11 @@ import { type OnErrorCallback, type OnTokenCallback, type TokenizerContextFuncti
  * @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.
+ * @param stop Function to halt tokenization.
  * @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>;
+export type OnBalancedTokenCallback = (...args: [...OmitLast<OnTokenCallbackParameters>, balance: number, Last<OnTokenCallbackParameters>]) => ReturnType<OnTokenCallback>;
 /**
  * Tokenize and ensure balanced pairs for standard CSS.
  *
@@ -34,3 +53,4 @@ export declare const tokenizeBalanced: (raw: string, onToken: OnBalancedTokenCal
  * @throws If the input is not balanced
  */
 export declare const tokenizeFnBalanced: (raw: string, onToken: OnBalancedTokenCallback, onError?: OnErrorCallback, functionHandlers?: Map<number, TokenizerContextFunction>) => void;
+export {};

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

@@ -3,3 +3,4 @@ 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';
+export { FilterListParser } from './filterlist-parser';

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

@@ -10,6 +10,9 @@ export declare const LIST_PARSE_ERROR_PREFIX: {
     NO_SEPARATOR_AT_THE_END: string;
     NO_WHITESPACE_AFTER_NEGATION: string;
 };
+/**
+ * Parser for list items in modifiers.
+ */
 export declare class ListItemsParser {
     /**
      * Parses a `raw` modifier value which may be represented as a list of items separated by `separator`.

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

@@ -3,11 +3,12 @@ import { BaseParser } from '../base-parser';
 /**
  * Possible node types in the logical expression.
  */
-export declare const enum NodeType {
-    Variable = "Variable",
-    Operator = "Operator",
-    Parenthesis = "Parenthesis"
-}
+export declare const NodeType: {
+    readonly Variable: "Variable";
+    readonly Operator: "Operator";
+    readonly Parenthesis: "Parenthesis";
+};
+export type NodeType = typeof NodeType[keyof typeof NodeType];
 /**
  * `LogicalExpressionParser` is responsible for parsing logical expressions.
  *

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

@@ -1,5 +1,8 @@
 import { type ParameterList } from '../../nodes';
 import { BaseParser } from '../base-parser';
+/**
+ * Parser for parameter lists.
+ */
 export declare class ParameterListParser extends BaseParser {
     /**
      * Parses a raw parameter list.

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

@@ -1,5 +1,8 @@
 import { ParameterListParser } from './parameter-list-parser';
 import { type ParameterList } from '../../nodes';
+/**
+ * Parser for uBO-specific parameter lists.
+ */
 export declare class UboParameterListParser extends ParameterListParser {
     /**
      * Parses an "uBO-specific parameter list".

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

@@ -2,7 +2,7 @@ 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.
+ * This parser is very simple, it just exists to provide a consistent interface for parsing.
  */
 export declare class ValueParser extends BaseParser {
     /**

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

@@ -2,16 +2,7 @@ import { type Agent } from '../../nodes';
 import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
 import { BaseSerializer } from '../base-serializer';
 /**
- * `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
- * `AgentCommentSerializer`, which uses this class to parse single agents.
+ * `AgentSerializer` is responsible for serializing single adblock agent elements into a binary format.
  */
 export declare class AgentSerializer extends BaseSerializer {
     /**

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

@@ -2,7 +2,7 @@ import { type ConfigCommentRule } from '../../nodes';
 import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
 import { BaseSerializer } from '../base-serializer';
 /**
- * `ConfigCommentParser` is responsible for parsing inline AGLint configuration rules.
+ * `ConfigCommentSerializer` is responsible for serializing inline AGLint configuration rules into a binary format.
  * Generally, the idea is inspired by ESLint inline configuration comments.
  *
  * @see {@link https://eslint.org/docs/latest/user-guide/configuring/rules#using-configuration-comments}

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

@@ -2,9 +2,9 @@ import { type OutputByteBuffer } from '../../utils/output-byte-buffer';
 import { type CommentRule } from '../../nodes';
 import { BaseSerializer } from '../base-serializer';
 /**
- * `SimpleCommentSerializer` is responsible for parsing simple comments.
+ * `SimpleCommentSerializer` is responsible for serializing 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,
+ * but this serializer is only responsible for serializing regular comments,
  * whose only purpose is to provide some human-readable information.
  *
  * @example

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

@@ -2,15 +2,15 @@ import { type ScriptletInjectionRuleBody } from '../../../nodes';
 import { type OutputByteBuffer } from '../../../utils/output-byte-buffer';
 import { BaseSerializer } from '../../base-serializer';
 /**
- * `AbpSnippetInjectionBodyParser` is responsible for parsing the body of an Adblock Plus-style snippet rule.
+ * `AbpSnippetInjectionBodySerializer` is responsible for serializing 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:
+ * Please note that the serializer will serialize any scriptlet rule if it is syntactically correct.
+ * For example, it will serialize this:
  * ```adblock
  * example.com#$#snippet0 arg0
  * ```
  *
- * but it didn't check if the scriptlet `snippet0` actually supported by any adblocker.
+ * but it doesn't check if the scriptlet `snippet0` is actually supported by any adblocker.
  *
  * @see {@link https://help.eyeo.com/adblockplus/snippet-filters-tutorial}
  */