@tbela99/css-parser 1.3.2 → 1.3.4

package/dist/index.d.ts

@@ -17,14 +17,26 @@ declare enum ValidationLevel {
      * disable validation
      */
     None = 0,
+    /**
+     * validate selectors
+     */
+    Selector = 1,
+    /**
+     * validate at-rules
+     */
+    AtRule = 2,
+    /**
+     * validate declarations
+     */
+    Declaration = 4,
     /**
      * validate selectors and at-rules
      */
-    Default = 1,// selectors + at-rules
+    Default = 3,// selectors + at-rules
     /**
      * validate selectors, at-rules and declarations
      */
-    All = 2
+    All = 7
 }
 /**
  * enum of all token types
@@ -325,7 +337,7 @@ declare enum EnumToken {
     /**
      * keyframe rule node type
      */
-    KeyFrameRuleNodeType = 73,
+    KeyFramesRuleNodeType = 73,
     /**
      * class selector token type
      */
@@ -405,7 +417,7 @@ declare enum EnumToken {
     /**
      * keyframe at rule node type
      */
-    KeyframeAtRuleNodeType = 93,
+    KeyframesAtRuleNodeType = 93,
     /**
      * invalid declaration node type
      */
@@ -643,53 +655,167 @@ declare enum ColorType {
  *
  * @private
  */
-declare function minify(ast: AstNode, options: ParserOptions | MinifyFeatureOptions, recursive: boolean, errors?: ErrorDescription[], nestingContent?: boolean): AstNode;
+declare function minify(ast: AstNode$1, options: ParserOptions | MinifyFeatureOptions, recursive: boolean, errors?: ErrorDescription[], nestingContent?: boolean): AstNode$1;
 
+/**
+ * options for the walk function
+ */
 declare enum WalkerOptionEnum {
     /**
      * ignore the current node and its children
      */
-    Ignore = 0,
+    Ignore = 1,
     /**
      * stop walking the tree
      */
-    Stop = 1,
+    Stop = 2,
     /**
-     * ignore node and process children
+     * ignore the current node and process its children
      */
-    Children = 2,
+    Children = 4,
     /**
-     * ignore children
+     * ignore the current node children
      */
-    IgnoreChildren = 3
+    IgnoreChildren = 8
 }
-declare enum WalkerValueEvent {
+/**
+ * event types for the walkValues function
+ */
+declare enum WalkerEvent {
     /**
      * enter node
      */
-    Enter = 0,
+    Enter = 1,
     /**
      * leave node
      */
-    Leave = 1
+    Leave = 2
 }
 /**
  * walk ast nodes
- * @param node
- * @param filter
+ * @param node initial node
+ * @param filter control the walk process
+ * @param reverse walk in reverse order
+ *
+ * ```ts
+ *
+ * import {walk} from '@tbela99/css-parser';
+ *
+ * const css = `
+ * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+ *
+ * html,
+ * body {
+ *     line-height: 1.474;
+ * }
+ *
+ * .ruler {
+ *
+ *     height: 10px;
+ * }
+ * `;
+ *
+ * for (const {node, parent, root} of walk(ast)) {
+ *
+ *     // do something with node
+ * }
+ * ```
+ *
+ * Using a {@link filter} function to control the ast traversal.  the filter function returns a value of type {@link WalkerOption}.
+ *
+ * ```ts
+ * import {EnumToken, transform, walk, WalkerOptionEnum} from '@tbela99/css-parser';
+ *
+ * const css = `
+ * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+ *
+ * html,
+ * body {
+ *     line-height: 1.474;
+ * }
+ *
+ * .ruler {
+ *
+ *     height: 10px;
+ * }
+ * `;
+ *
+ * function filter(node) {
+ *
+ *     if (node.typ == EnumToken.AstRule && node.sel.includes('html')) {
+ *
+ *         // skip the children of the current node
+ *         return WalkerOptionEnum.IgnoreChildren;
+ *     }
+ * }
+ *
+ * const result = await transform(css);
+ * for (const {node} of walk(result.ast, filter)) {
+ *
+ *     console.error([EnumToken[node.typ]]);
+ * }
+ *
+ * // [ "StyleSheetNodeType" ]
+ * // [ "RuleNodeType" ]
+ * // [ "DeclarationNodeType" ]
+ * // [ "RuleNodeType" ]
+ * // [ "DeclarationNodeType" ]
+ * // [ "RuleNodeType" ]
+ * // [ "DeclarationNodeType" ]
+ * ```
  */
-declare function walk(node: AstNode, filter?: WalkerFilter): Generator<WalkResult>;
+declare function walk(node: AstNode$1, filter?: WalkerFilter | null, reverse?: boolean): Generator<WalkResult>;
 /**
  * walk ast node value tokens
  * @param values
  * @param root
  * @param filter
  * @param reverse
+ *
+ * Example:
+ *
+ * ```ts
+ *
+ * import {AstDeclaration, EnumToken, transform, walkValues} from '@tbela99/css-parser';
+ *
+ * const css = `
+ * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+ * `;
+ *
+ * const result = await transform(css);
+ * const declaration = result.ast.chi[0].chi[0] as AstDeclaration;
+ *
+ * // walk the node attribute's tokens in reverse order
+ * for (const {value} of walkValues(declaration.val, null, null,true)) {
+ *
+ *     console.error([EnumToken[value.typ], value.val]);
+ * }
+ *
+ * // [ "Color", "color" ]
+ * // [ "FunctionTokenType", "calc" ]
+ * // [ "Number", 0.15 ]
+ * // [ "Add", undefined ]
+ * // [ "Iden", "b" ]
+ * // [ "Whitespace", undefined ]
+ * // [ "FunctionTokenType", "calc" ]
+ * // [ "Number", 0.24 ]
+ * // [ "Add", undefined ]
+ * // [ "Iden", "g" ]
+ * // [ "Whitespace", undefined ]
+ * // [ "Iden", "r" ]
+ * // [ "Whitespace", undefined ]
+ * // [ "Iden", "display-p3" ]
+ * // [ "Whitespace", undefined ]
+ * // [ "FunctionTokenType", "var" ]
+ * // [ "DashedIden", "--base-color" ]
+ * // [ "Whitespace", undefined ]
+ * // [ "Iden", "from" ]
+ * ```
  */
-declare function walkValues(values: Token[], root?: AstNode | Token | null, filter?: WalkerValueFilter | {
-    event?: WalkerValueEvent;
+declare function walkValues(values: Token$1[], root?: AstNode$1 | Token$1 | null, filter?: WalkerValueFilter | null | {
+    event?: WalkerEvent;
     fn?: WalkerValueFilter;
-    type?: EnumToken | EnumToken[] | ((token: Token) => boolean);
+    type?: EnumToken | EnumToken[] | ((token: Token$1) => boolean);
 }, reverse?: boolean): Generator<WalkAttributesResult>;
 
 /**
@@ -698,7 +824,7 @@ declare function walkValues(values: Token[], root?: AstNode | Token | null, filt
  *
  * @private
  */
-declare function expand(ast: AstNode): AstNode;
+declare function expand(ast: AstStyleSheet | AstAtRule | AstRule): AstNode$1;
 
 /**
  *
@@ -707,9 +833,9 @@ declare function expand(ast: AstNode): AstNode;
  *
  * @private
  */
-declare function renderToken(token: Token, options?: RenderOptions, cache?: {
+declare function renderToken(token: Token$1, options?: RenderOptions, cache?: {
     [key: string]: any;
-}, reducer?: (acc: string, curr: Token) => string, errors?: ErrorDescription[]): string;
+}, reducer?: (acc: string, curr: Token$1) => string, errors?: ErrorDescription[]): string;
 
 /**
  * Source map class
@@ -748,7 +874,7 @@ declare class SourceMap {
  * console.log(declarations);
  * ```
  */
-declare function parseDeclarations(declaration: string): Promise<AstDeclaration[]>;
+declare function parseDeclarations(declaration: string): Promise<Array<AstDeclaration | AstComment>>;
 /**
  * parse css string and return an array of tokens
  * @param src
@@ -771,7 +897,7 @@ declare function parseDeclarations(declaration: string): Promise<AstDeclaration[
  */
 declare function parseString(src: string, options?: {
     location: boolean;
-}): Token[];
+}): Token$1[];
 /**
  * parse function tokens in a token array
  * @param tokens
@@ -792,76 +918,114 @@ declare function parseString(src: string, options?: {
  *
  * @private
  */
-declare function parseTokens(tokens: Token[], options?: ParseTokenOptions): Token[];
+declare function parseTokens(tokens: Token$1[], options?: ParseTokenOptions): Token$1[];
 
+/**
+ * Literal token
+ */
 export declare interface LiteralToken extends BaseToken {
 
     typ: EnumToken.LiteralTokenType;
     val: string;
 }
 
+/**
+ * Class selector token
+ */
 export declare interface ClassSelectorToken extends BaseToken {
 
     typ: EnumToken.ClassSelectorTokenType;
     val: string;
 }
 
+/**
+ * Invalid class selector token
+ */
 export declare interface InvalidClassSelectorToken extends BaseToken {
 
     typ: EnumToken.InvalidClassSelectorTokenType;
     val: string;
 }
 
+/**
+ * Universal selector token
+ */
 export declare interface UniversalSelectorToken extends BaseToken {
 
     typ: EnumToken.UniversalSelectorTokenType;
 }
 
-
+/**
+ * Ident token
+ */
 export declare interface IdentToken extends BaseToken {
 
     typ: EnumToken.IdenTokenType,
     val: string;
 }
 
+/**
+ * Ident list token
+ */
 export declare interface IdentListToken extends BaseToken {
 
     typ: EnumToken.IdenListTokenType,
     val: string;
 }
 
+/**
+ * Dashed ident token
+ */
 export declare interface DashedIdentToken extends BaseToken {
 
     typ: EnumToken.DashedIdenTokenType,
     val: string;
 }
 
+/**
+ * Comma token
+ */
 export declare interface CommaToken extends BaseToken {
 
     typ: EnumToken.CommaTokenType
 }
 
+/**
+ * Colon token
+ */
 export declare interface ColonToken extends BaseToken {
 
     typ: EnumToken.ColonTokenType
 }
 
+/**
+ * Semicolon token
+ */
 export declare interface SemiColonToken extends BaseToken {
 
     typ: EnumToken.SemiColonTokenType
 }
 
+/**
+ * Nesting selector token
+ */
 export declare interface NestingSelectorToken extends BaseToken {
 
     typ: EnumToken.NestingSelectorTokenType
 }
 
+/**
+ * Number token
+ */
 export declare interface NumberToken extends BaseToken {
 
     typ: EnumToken.NumberTokenType,
     val: number | FractionToken;
 }
 
+/**
+ * At rule token
+ */
 export declare interface AtRuleToken extends BaseToken {
 
     typ: EnumToken.AtRuleTokenType,
@@ -869,32 +1033,47 @@ export declare interface AtRuleToken extends BaseToken {
     pre: string;
 }
 
+/**
+ * Percentage token
+ */
 export declare interface PercentageToken extends BaseToken {
 
     typ: EnumToken.PercentageTokenType,
     val: number | FractionToken;
 }
 
+/**
+ * Flex token
+ */
 export declare interface FlexToken extends BaseToken {
 
     typ: EnumToken.FlexTokenType,
     val: number | FractionToken;
 }
 
+/**
+ * Function token
+ */
 export declare interface FunctionToken extends BaseToken {
 
     typ: EnumToken.FunctionTokenType,
     val: string;
-    chi: Token[];
+    chi: Token$1[];
 }
 
+/**
+ * Grid template function token
+ */
 export declare interface GridTemplateFuncToken extends BaseToken {
 
     typ: EnumToken.GridTemplateFuncTokenType,
     val: string;
-    chi: Token[];
+    chi: Token$1[];
 }
 
+/**
+ * Function URL token
+ */
 export declare interface FunctionURLToken extends BaseToken {
 
     typ: EnumToken.UrlFunctionTokenType,
@@ -902,6 +1081,9 @@ export declare interface FunctionURLToken extends BaseToken {
     chi: Array<UrlToken | CommentToken>;
 }
 
+/**
+ * Function image token
+ */
 export declare interface FunctionImageToken extends BaseToken {
 
     typ: EnumToken.ImageFunctionTokenType,
@@ -909,38 +1091,56 @@ export declare interface FunctionImageToken extends BaseToken {
     chi: Array<UrlToken | CommentToken>;
 }
 
+/**
+ * Timing function token
+ */
 export declare interface TimingFunctionToken extends BaseToken {
 
     typ: EnumToken.TimingFunctionTokenType;
     val: string;
-    chi: Token[];
+    chi: Token$1[];
 }
 
+/**
+ * Timeline function token
+ */
 export declare interface TimelineFunctionToken extends BaseToken {
 
     typ: EnumToken.TimelineFunctionTokenType;
     val: string;
-    chi: Token[];
+    chi: Token$1[];
 }
 
+/**
+ * String token
+ */
 export declare interface StringToken extends BaseToken {
 
     typ: EnumToken.StringTokenType;
     val: string;
 }
 
+/**
+ * Bad string token
+ */
 export declare interface BadStringToken extends BaseToken {
 
     typ: EnumToken.BadStringTokenType;
     val: string;
 }
 
+/**
+ * Unclosed string token
+ */
 export declare interface UnclosedStringToken extends BaseToken {
 
     typ: EnumToken.UnclosedStringTokenType;
     val: string;
 }
 
+/**
+ * Dimension token
+ */
 export declare interface DimensionToken extends BaseToken {
 
     typ: EnumToken.DimensionTokenType;
@@ -948,6 +1148,9 @@ export declare interface DimensionToken extends BaseToken {
     unit: string;
 }
 
+/**
+ * Length token
+ */
 export declare interface LengthToken extends BaseToken {
 
     typ: EnumToken.LengthTokenType;
@@ -955,6 +1158,9 @@ export declare interface LengthToken extends BaseToken {
     unit: string;
 }
 
+/**
+ * Angle token
+ */
 export declare interface AngleToken extends BaseToken {
 
     typ: EnumToken.AngleTokenType;
@@ -962,6 +1168,9 @@ export declare interface AngleToken extends BaseToken {
     unit: string;
 }
 
+/**
+ * Time token
+ */
 export declare interface TimeToken extends BaseToken {
 
     typ: EnumToken.TimeTokenType;
@@ -969,6 +1178,9 @@ export declare interface TimeToken extends BaseToken {
     unit: 'ms' | 's';
 }
 
+/**
+ * Frequency token
+ */
 export declare interface FrequencyToken extends BaseToken {
 
     typ: EnumToken.FrequencyTokenType;
@@ -976,6 +1188,9 @@ export declare interface FrequencyToken extends BaseToken {
     unit: 'Hz' | 'Khz';
 }
 
+/**
+ * Resolution token
+ */
 export declare interface ResolutionToken extends BaseToken {
 
     typ: EnumToken.ResolutionTokenType;
@@ -983,289 +1198,442 @@ export declare interface ResolutionToken extends BaseToken {
     unit: 'dpi' | 'dpcm' | 'dppx' | 'x';
 }
 
+/**
+ * Hash token
+ */
 export declare interface HashToken extends BaseToken {
 
     typ: EnumToken.HashTokenType;
     val: string;
 }
 
+/**
+ * Block start token
+ */
 export declare interface BlockStartToken extends BaseToken {
 
     typ: EnumToken.BlockStartTokenType
 }
 
+/**
+ * Block end token
+ */
 export declare interface BlockEndToken extends BaseToken {
 
     typ: EnumToken.BlockEndTokenType
 }
 
+/**
+ * Attribute start token
+ */
 export declare interface AttrStartToken extends BaseToken {
 
     typ: EnumToken.AttrStartTokenType;
-    chi?: Token[];
+    chi?: Token$1[];
 }
 
+/**
+ * Attribute end token
+ */
 export declare interface AttrEndToken extends BaseToken {
 
     typ: EnumToken.AttrEndTokenType
 }
 
+/**
+ * Parenthesis start token
+ */
 export declare interface ParensStartToken extends BaseToken {
 
     typ: EnumToken.StartParensTokenType;
 }
 
+/**
+ * Parenthesis end token
+ */
 export declare interface ParensEndToken extends BaseToken {
 
     typ: EnumToken.EndParensTokenType
 }
 
+/**
+ * Parenthesis token
+ */
 export declare interface ParensToken extends BaseToken {
 
     typ: EnumToken.ParensTokenType;
-    chi: Token[];
+    chi: Token$1[];
 }
 
+/**
+ * Whitespace token
+ */
 export declare interface WhitespaceToken extends BaseToken {
 
     typ: EnumToken.WhitespaceTokenType
 }
 
+/**
+ * Comment token
+ */
 export declare interface CommentToken extends BaseToken {
 
     typ: EnumToken.CommentTokenType;
     val: string;
 }
 
+/**
+ * Bad comment token
+ */
 export declare interface BadCommentToken extends BaseToken {
 
     typ: EnumToken.BadCommentTokenType;
     val: string;
 }
 
+/**
+ * CDO comment token
+ */
 export declare interface CDOCommentToken extends BaseToken {
 
     typ: EnumToken.CDOCOMMTokenType;
     val: string;
 }
 
+/**
+ * Bad CDO comment token
+ */
 export declare interface BadCDOCommentToken extends BaseToken {
 
     typ: EnumToken.BadCdoTokenType;
     val: string;
 }
 
+/**
+ * Include match token
+ */
 export declare interface IncludeMatchToken extends BaseToken {
 
     typ: EnumToken.IncludeMatchTokenType;
     // val: '~=';
 }
 
+/**
+ * Dash match token
+ */
 export declare interface DashMatchToken extends BaseToken {
 
     typ: EnumToken.DashMatchTokenType;
     // val: '|=';
 }
 
+/**
+ * Equal match token
+ */
 export declare interface EqualMatchToken extends BaseToken {
 
     typ: EnumToken.EqualMatchTokenType;
     // val: '|=';
 }
 
+/**
+ * Start match token
+ */
 export declare interface StartMatchToken extends BaseToken {
 
     typ: EnumToken.StartMatchTokenType;
     // val: '^=';
 }
 
+/**
+ * End match token
+ */
 export declare interface EndMatchToken extends BaseToken {
 
     typ: EnumToken.EndMatchTokenType;
     // val: '|=';
 }
 
+/**
+ * Contain match token
+ */
 export declare interface ContainMatchToken extends BaseToken {
 
     typ: EnumToken.ContainMatchTokenType;
     // val: '|=';
 }
 
+/**
+ * Less than token
+ */
 export declare interface LessThanToken extends BaseToken {
 
     typ: EnumToken.LtTokenType;
 }
 
+/**
+ * Less than or equal token
+ */
 export declare interface LessThanOrEqualToken extends BaseToken {
 
     typ: EnumToken.LteTokenType;
 }
 
+/**
+ * Greater than token
+ */
 export declare interface GreaterThanToken extends BaseToken {
 
     typ: EnumToken.GtTokenType;
 }
 
+/**
+ * Greater than or equal token
+ */
 export declare interface GreaterThanOrEqualToken extends BaseToken {
 
     typ: EnumToken.GteTokenType;
 }
 
+/**
+ * Column combinator token
+ */
 export declare interface ColumnCombinatorToken extends BaseToken {
 
     typ: EnumToken.ColumnCombinatorTokenType;
 }
 
+/**
+ * Pseudo class token
+ */
 export declare interface PseudoClassToken extends BaseToken {
 
     typ: EnumToken.PseudoClassTokenType;
     val: string;
 }
 
+/**
+ * Pseudo element token
+ */
 export declare interface PseudoElementToken extends BaseToken {
 
     typ: EnumToken.PseudoElementTokenType;
     val: string;
 }
 
+/**
+ * Pseudo page token
+ */
 export declare interface PseudoPageToken extends BaseToken {
 
     typ: EnumToken.PseudoPageTokenType;
     val: string;
 }
 
+/**
+ * Pseudo class function token
+ */
 export declare interface PseudoClassFunctionToken extends BaseToken {
 
     typ: EnumToken.PseudoClassFuncTokenType;
     val: string;
-    chi: Token[];
+    chi: Token$1[];
 }
 
+/**
+ * Delim token
+ */
 export declare interface DelimToken extends BaseToken {
 
     typ: EnumToken.DelimTokenType;
 }
 
+/**
+ * Bad URL token
+ */
 export declare interface BadUrlToken extends BaseToken {
 
     typ: EnumToken.BadUrlTokenType,
     val: string;
 }
 
+/**
+ * URL token
+ */
 export declare interface UrlToken extends BaseToken {
 
     typ: EnumToken.UrlTokenTokenType,
     val: string;
 }
 
+/**
+ * EOF token
+ */
 export declare interface EOFToken extends BaseToken {
 
     typ: EnumToken.EOFTokenType;
 }
 
+/**
+ * Important token
+ */
 export declare interface ImportantToken extends BaseToken {
 
     typ: EnumToken.ImportantTokenType;
 }
 
+/**
+ * Color token
+ */
 export declare interface ColorToken extends BaseToken {
 
     typ: EnumToken.ColorTokenType;
     val: string;
     kin: ColorType;
-    chi?: Token[];
+    chi?: Token$1[];
     /* calculated */
     cal?: 'rel' | 'mix';
 }
 
+/**
+ * Attribute token
+ */
 export declare interface AttrToken extends BaseToken {
 
     typ: EnumToken.AttrTokenType,
-    chi: Token[]
+    chi: Token$1[]
 }
 
+/**
+ * Invalid attribute token
+ */
 export declare interface InvalidAttrToken extends BaseToken {
 
     typ: EnumToken.InvalidAttrTokenType,
-    chi: Token[]
+    chi: Token$1[]
 }
 
+/**
+ * Child combinator token
+ */
 export declare interface ChildCombinatorToken extends BaseToken {
 
     typ: EnumToken.ChildCombinatorTokenType
 }
 
+/**
+ * Media feature token
+ */
 export declare interface MediaFeatureToken extends BaseToken {
 
     typ: EnumToken.MediaFeatureTokenType,
     val: string;
 }
 
+/**
+ * Media feature not token
+ */
 export declare interface MediaFeatureNotToken extends BaseToken {
 
     typ: EnumToken.MediaFeatureNotTokenType,
-    val: Token;
+    val: Token$1;
 }
 
+/**
+ * Media feature only token
+ */
 export declare interface MediaFeatureOnlyToken extends BaseToken {
 
     typ: EnumToken.MediaFeatureOnlyTokenType,
-    val: Token;
+    val: Token$1;
 }
 
+/**
+ * Media feature and token
+ */
 export declare interface MediaFeatureAndToken extends BaseToken {
 
     typ: EnumToken.MediaFeatureAndTokenType;
 }
 
+/**
+ * Media feature or token
+ */
 export declare interface MediaFeatureOrToken extends BaseToken {
 
     typ: EnumToken.MediaFeatureOrTokenType;
 }
 
+/**
+ * Media query condition token
+ */
 export declare interface MediaQueryConditionToken extends BaseToken {
 
     typ: EnumToken.MediaQueryConditionTokenType,
-    l: Token,
+    l: Token$1,
     op: ColonToken | GreaterThanToken | LessThanToken | GreaterThanOrEqualToken | LessThanOrEqualToken,
-    r: Token[]
+    r: Token$1[]
 }
 
+/**
+ * Descendant combinator token
+ */
 export declare interface DescendantCombinatorToken extends BaseToken {
 
     typ: EnumToken.DescendantCombinatorTokenType
 }
 
+/**
+ * Next sibling combinator token
+ */
 export declare interface NextSiblingCombinatorToken extends BaseToken {
 
     typ: EnumToken.NextSiblingCombinatorTokenType
 }
 
+/**
+ * Subsequent sibling combinator token
+ */
 export declare interface SubsequentCombinatorToken extends BaseToken {
 
     typ: EnumToken.SubsequentSiblingCombinatorTokenType
 }
 
+/**
+ * Add token
+ */
 export declare interface AddToken extends BaseToken {
 
     typ: EnumToken.Add;
 }
 
+/**
+ * Sub token
+ */
 export declare interface SubToken extends BaseToken {
 
     typ: EnumToken.Sub;
 }
 
+/**
+ * Div token
+ */
 export declare interface DivToken extends BaseToken {
 
     typ: EnumToken.Div;
 }
 
+/**
+ * Mul token
+ */
 export declare interface MulToken extends BaseToken {
 
     typ: EnumToken.Mul;
 }
 
+/**
+ * Unary expression token
+ */
 export declare interface UnaryExpression extends BaseToken {
 
     typ: EnumToken.UnaryExpressionTokenType
@@ -1273,6 +1641,9 @@ export declare interface UnaryExpression extends BaseToken {
     val: UnaryExpressionNode;
 }
 
+/**
+ * Fraction token
+ */
 export declare interface FractionToken extends BaseToken {
 
     typ: EnumToken.FractionTokenType;
@@ -1280,36 +1651,51 @@ export declare interface FractionToken extends BaseToken {
     r: NumberToken;
 }
 
+/**
+ * Binary expression token
+ */
 export declare interface BinaryExpressionToken extends BaseToken {
 
     typ: EnumToken.BinaryExpressionTokenType
     op: EnumToken.Add | EnumToken.Sub | EnumToken.Div | EnumToken.Mul;
-    l: BinaryExpressionNode | Token;
-    r: BinaryExpressionNode | Token;
+    l: BinaryExpressionNode | Token$1;
+    r: BinaryExpressionNode | Token$1;
 }
 
+/**
+ * Match expression token
+ */
 export declare interface MatchExpressionToken extends BaseToken {
 
     typ: EnumToken.MatchExpressionTokenType
     op: EqualMatchToken | DashMatchToken | StartMatchToken | ContainMatchToken | EndMatchToken | IncludeMatchToken;
-    l: Token;
-    r: Token;
+    l: Token$1;
+    r: Token$1;
     attr?: 'i' | 's';
 }
 
+/**
+ * Name space attribute token
+ */
 export declare interface NameSpaceAttributeToken extends BaseToken {
 
     typ: EnumToken.NameSpaceAttributeTokenType
-    l?: Token;
-    r: Token;
+    l?: Token$1;
+    r: Token$1;
 }
 
+/**
+ * List token
+ */
 export declare interface ListToken extends BaseToken {
 
     typ: EnumToken.ListToken
-    chi: Token[];
+    chi: Token$1[];
 }
 
+/**
+ * Unary expression node
+ */
 export declare type UnaryExpressionNode =
     BinaryExpressionNode
     | NumberToken
@@ -1319,10 +1705,16 @@ export declare type UnaryExpressionNode =
     | AngleToken
     | FrequencyToken;
 
+/**
+ * Binary expression node
+ */
 export declare type BinaryExpressionNode = NumberToken | DimensionToken | PercentageToken | FlexToken | FractionToken |
     AngleToken | LengthToken | FrequencyToken | BinaryExpressionToken | FunctionToken | ParensToken;
 
-export declare type Token =
+/**
+ * Token
+ */
+export declare type Token$1 =
     InvalidClassSelectorToken
     | InvalidAttrToken
     |
@@ -1472,12 +1864,16 @@ declare const enum ValidationSyntaxGroupEnum {
     Selectors = "selectors",
     AtRules = "atRules"
 }
+
 interface Position$1 {
+
     ind: number;
     lin: number;
     col: number;
 }
-interface ValidationToken {
+
+interface ValidationToken$1 {
+
     typ: ValidationTokenEnum;
     pos: Position$1;
     isList?: boolean;
@@ -1489,13 +1885,13 @@ interface ValidationToken {
     occurence?: {
         min: number;
         max: number | null;
-    };
+    }
 }
 
 export declare interface ValidationSyntaxNode {
 
     syntax: string;
-    ast?: ValidationToken[];
+    ast?: ValidationToken$1[];
 }
 
 interface ValidationSelectorOptions extends ValidationOptions {
@@ -1517,16 +1913,16 @@ export declare interface ValidationConfiguration {
 interface ValidationResult {
 
     valid: SyntaxValidationResult;
-    node: AstNode | Token | null;
-    syntax: ValidationToken | string | null;
+    node: AstNode$1 | Token$1 | null;
+    syntax: ValidationToken$1 | string | null;
     error: string;
     cycle?: boolean;
 }
 
 interface ValidationSyntaxResult extends ValidationResult {
 
-    syntax: ValidationToken | string | null;
-    context: Context<Token> | Token[];
+    syntax: ValidationToken$1 | string | null;
+    context: Context<Token$1> | Token$1[];
 }
 
 interface Context<Type> {
@@ -1565,6 +1961,8 @@ interface Context<Type> {
  * @param token
  * @param to
  *
+ * @private
+ *
  * <code>
  *
  *     const token = {typ: EnumToken.ColorTokenType, kin: ColorType.HEX, val: '#F00'}
@@ -1632,67 +2030,115 @@ export declare interface Location {
 
 export declare interface BaseToken {
 
+    /**
+     * token type
+     */
     typ: EnumToken;
+    /**
+     * location info
+     */
     loc?: Location;
-    tokens?: Token[];
-    parent?: AstRuleList;
+    /**
+     * prelude or selector tokens
+     */
+    tokens?: Token$1[] | null;
+    /**
+     * parent node
+     */
+    parent?: AstAtRule | astRule | AstKeyframesAtRule | AstKeyFrameRule | AstInvalidRule | AstInvalidAtRule | null;
+    /**
+     * @private
+     */
     validSyntax?: boolean;
 }
 
+/**
+ * comment node
+ */
 export declare interface AstComment extends BaseToken {
 
     typ: EnumToken.CommentNodeType | EnumToken.CDOCOMMNodeType,
+    tokens?: null;
     val: string;
 }
 
+/**
+ * declaration node
+ */
 export declare interface AstDeclaration extends BaseToken {
 
     nam: string,
-    val: Token[];
+    tokens?: null;
+    val: Token$1[];
     typ: EnumToken.DeclarationNodeType
 }
 
+/**
+ * rule node
+ */
 export declare interface AstRule extends BaseToken {
 
     typ: EnumToken.RuleNodeType;
     sel: string;
-    chi: Array<AstDeclaration | AstComment | AstRuleList>;
+    chi: Array<AstDeclaration | AstComment | AstRule | AstAtRule | AstInvalidRule | AstInvalidDeclaration | AstInvalidAtRule>;
     optimized?: OptimizedSelector | null;
     raw?: RawSelectorTokens | null;
 }
 
+/**
+ * invalid rule node
+ */
 export declare interface AstInvalidRule extends BaseToken {
 
     typ: EnumToken.InvalidRuleTokenType;
     sel: string;
-    chi: Array<AstNode>;
+    chi: Array<AstNode$1>;
 }
 
+/**
+ * invalid declaration node
+ */
 export declare interface AstInvalidDeclaration extends BaseToken {
 
     typ: EnumToken.InvalidDeclarationNodeType;
-    val: Array<AstNode>;
+    tokens?: null;
+    val: Array<Token$1>;
 }
 
+/**
+ * invalid at rule node
+ */
 export declare interface AstInvalidAtRule extends BaseToken {
 
     typ: EnumToken.InvalidAtRuleTokenType;
+    nam: string;
     val: string;
-    chi?: Array<AstNode>;
+    chi?: Array<AstNode$1>;
 }
 
+/**
+ * keyframe rule node
+ */
 export declare interface AstKeyFrameRule extends BaseToken {
 
-    typ: EnumToken.KeyFrameRuleNodeType;
+    typ: EnumToken.KeyFramesRuleNodeType;
     sel: string;
-    chi: Array<AstDeclaration | AstComment>;
+    chi: Array<AstDeclaration | AstComment | AstInvalidDeclaration>;
     optimized?: OptimizedSelector;
     raw?: RawSelectorTokens;
-    tokens?: Token[]
+    tokens?: Token$1[]
 }
 
-export declare type RawSelectorTokens = string[][];
+/**
+ * raw selector tokens
+ */
+export declare type RawSelectorTokens = string[][];
 
+/**
+ * optimized selector
+ *
+ * @private
+ */
 export declare interface OptimizedSelector {
     match: boolean;
     optimized: string[];
@@ -1700,13 +2146,21 @@ export declare interface OptimizedSelector {
     reducible: boolean;
 }
 
+/**
+ * optimized selector token
+ *
+ * @private
+ */
 export declare interface OptimizedSelectorToken {
     match: boolean;
-    optimized: Token[];
-    selector: Token[][],
+    optimized: Token$1[];
+    selector: Token$1[][],
     reducible: boolean;
 }
 
+/**
+ * at rule node
+ */
 export declare interface AstAtRule extends BaseToken {
 
     typ: EnumToken.AtRuleNodeType,
@@ -1715,59 +2169,88 @@ export declare interface AstAtRule extends BaseToken {
     chi?: Array<AstDeclaration | AstInvalidDeclaration | AstComment> | Array<AstRule | AstComment>
 }
 
-export declare interface AstKeyframeRule extends BaseToken {
+/**
+ * keyframe rule node
+ */
+export declare interface AstKeyframesRule extends BaseToken {
 
-    typ: EnumToken.KeyFrameRuleNodeType;
+    typ: EnumToken.KeyFramesRuleNodeType;
     sel: string;
     chi: Array<AstDeclaration | AstInvalidDeclaration | AstComment | AstRuleList>;
     optimized?: OptimizedSelector;
     raw?: RawSelectorTokens;
 }
 
-export declare interface AstKeyframAtRule extends BaseToken {
+/**
+ * keyframe at rule node
+ */
+export declare interface AstKeyframesAtRule extends BaseToken {
 
-    typ: EnumToken.KeyframeAtRuleNodeType,
+    typ: EnumToken.KeyframesAtRuleNodeType,
     nam: string;
     val: string;
-    chi: Array<AstKeyframeRule | AstComment>;
+    chi: Array<AstKeyframesRule | AstComment>;
 }
 
-export declare interface AstRuleList extends BaseToken {
-
-    typ: EnumToken.StyleSheetNodeType | EnumToken.RuleNodeType | EnumToken.AtRuleNodeType | EnumToken.KeyframeAtRuleNodeType | EnumToken.KeyFrameRuleNodeType | EnumToken.InvalidRuleTokenType | EnumToken.InvalidAtRuleTokenType,
-    chi: Array<BaseToken | AstComment>;
-}
+/**
+ * rule list node
+ */
+export declare type AstRuleList =
+    AstStyleSheet
+    | AstAtRule
+    | AstRule
+    | AstKeyframesAtRule
+    | AstKeyFrameRule
+    | AstInvalidRule;
 
-export declare interface AstRuleStyleSheet extends AstRuleList {
+/**
+ * stylesheet node
+ */
+export declare interface AstStyleSheet extends BaseToken {
     typ: EnumToken.StyleSheetNodeType,
-    chi: Array<AstRuleList | AstComment>
+    chi: Array<AstRule | AstAtRule | astKeyframesAtRule | AstComment | AstInvalidAtRule | AstInvalidRule>;
+    tokens?: null;
 }
 
-export declare type AstNode =
-    AstRuleStyleSheet
+/**
+ * ast node
+ */
+export declare type AstNode$1 =
+    AstStyleSheet
     | AstRuleList
     | AstComment
     | AstAtRule
     | AstRule
     | AstDeclaration
-    | AstKeyframAtRule
+    | AstKeyframesAtRule
     | AstKeyFrameRule
     | AstInvalidRule
+    | AstInvalidAtRule
     | AstInvalidDeclaration;
 
+export declare type GenericVisitorResult<T> = T | T[] | Promise<T> | Promise<T[]> | null | Promise<null>;
+export declare type GenericVisitorHandler<T> = ((node: T, parent?: AstNode | Token, root?: AstNode | Token) => GenericVisitorResult<T>);
+export declare type GenericVisitorAstNodeHandlerMap<T> =
+    Record<string, GenericVisitorHandler<T>>
+    | GenericVisitorHandler<T>
+    | { type: WalkerEvent, handler: GenericVisitorHandler<T> }
+    | { type: WalkerEvent, handler: Record<string, GenericVisitorHandler<T>> };
+
+export declare type ValueVisitorHandler = GenericVisitorHandler<Token>;
+
 /**
  * Declaration visitor handler
  */
-export declare type DeclarationVisitorHandler = (node: AstDeclaration) => (AstDeclaration | AstDeclaration[] | null | Promise<AstDeclaration> | Promise<AstDeclaration[]> | Promise<null>);
+export declare type DeclarationVisitorHandler = GenericVisitorHandler<AstDeclaration>;
 /**
  * Rule visitor handler
  */
-export declare type RuleVisitorHandler = (node: AstRule) => (AstRule | AstRule[] | null | Promise<AstRule> | Promise<AstRule[]> | Promise<null>);
+export declare type RuleVisitorHandler = GenericVisitorHandler<AstRule>;
 
 /**
  * AtRule visitor handler
  */
-export declare type AtRuleVisitorHandler = (node: AstAtRule) => (AstAtRule | AstAtRule[] | null | Promise<AstAtRule> | Promise<AstAtRule[]> | Promise<null>);
+export declare type AtRuleVisitorHandler = GenericVisitorHandler<AstAtRule>;
 
 /**
  * node visitor callback map
@@ -1817,7 +2300,7 @@ export declare interface VisitorNodeMap {
      * // @media tv,screen{.foo{height:calc(40px/3)}}
      * ```
      */
-    AtRule?: Record<string, AtRuleVisitorHandler> | AtRuleVisitorHandler;
+    AtRule?: GenericVisitorAstNodeHandlerMap<AstAtRule>;
     /**
      * declaration visitor
      *
@@ -1919,7 +2402,7 @@ export declare interface VisitorNodeMap {
      * // .foo{width:calc(40px/3);padding:10px}.selector{padding:20px}
      * ```
      */
-    Declaration?: Record<string, DeclarationVisitorHandler> | DeclarationVisitorHandler;
+    Declaration?: GenericVisitorAstNodeHandlerMap<AstDeclaration>;
 
     /**
      * rule visitor
@@ -1961,35 +2444,110 @@ export declare interface VisitorNodeMap {
      * // .foo{width:3px;.foo{width:3px}}
      * ```
      */
-    Rule?: RuleVisitorHandler;
+    Rule?: GenericVisitorAstNodeHandlerMap<AstRule>;
+
+    KeyframesRule?: GenericVisitorAstNodeHandlerMap<AstKeyframesRule>;
+
+    KeyframesAtRule?: GenericVisitorAstNodeHandlerMap<AstKeyframesAtRule>;
+
+    /**
+     * value visitor
+     */
+    Value?: GenericVisitorAstNodeHandlerMap<Token>;
+
+    /**
+     * generic token visitor. the key name is of type keyof EnumToken.
+     * generic tokens are called for every token of the specified type.
+     *
+     * ```ts
+     *
+     * import {transform, parse, parseDeclarations} from "@tbela99/css-parser";
+     *
+     * const options: ParserOptions = {
+     *
+     *     inlineCssVariables: true,
+     *     visitor: {
+     *
+     *         // Stylesheet node visitor
+     *         StyleSheetNodeType: async (node) => {
+     *
+     *             // insert a new rule
+     *             node.chi.unshift(await parse('html {--base-color: pink}').then(result => result.ast.chi[0]))
+     *         },
+     *         ColorTokenType:  (node) => {
+     *
+     *             // dump all color tokens
+     *             // console.debug(node);
+     *          },
+     *          FunctionTokenType:  (node) => {
+     *
+     *              // dump all function tokens
+     *              // console.debug(node);
+     *          },
+     *          DeclarationNodeType:  (node) => {
+     *
+     *              // dump all declaration nodes
+     *              // console.debug(node);
+     *          }
+     *     }
+     * };
+     *
+     * const css = `
+     *
+     * body { color:    color(from var(--base-color) display-p3 r calc(g + 0.24) calc(b + 0.15)); }
+     * `;
+     *
+     * console.debug(await transform(css, options));
+     *
+     * // body {color:#f3fff0}
+     * ```
+     */
+    [key: keyof typeof EnumToken]: GenericVisitorAstNodeHandlerMap<Token> | GenericVisitorAstNodeHandlerMap<AstNode>;
 }
 
 export declare interface PropertyListOptions {
 
-    removeDuplicateDeclarations?: boolean;
+    removeDuplicateDeclarations?: boolean | string | string[];
     computeShorthand?: boolean;
 }
 
+/**
+ * parse info
+ */
 export declare interface ParseInfo {
 
+    /**
+     * read buffer
+     */
     buffer: string;
+    /**
+     * stream
+     */
     stream: string;
+    /**
+     * last token position
+     */
     position: Position;
+    /**
+     * current parsing position
+     */
     currentPosition: Position;
 }
 
 /**
  * feature walk mode
+ *
+ * @internal
  */
 declare enum FeatureWalkMode {
     /**
      * pre process
      */
-    Pre = 0,
+    Pre = 1,
     /**
      * post process
      */
-    Post = 1
+    Post = 2
 }
 
 /**
@@ -2100,11 +2658,17 @@ interface ShorthandType {
 
 // generated from config.json at https://app.quicktype.io/?l=ts
 
+/**
+ * @private
+ */
 export declare interface PropertiesConfig {
     properties: PropertiesConfigProperties;
     map:        Map$1;
 }
 
+/**
+ * @private
+ */
 interface Map$1 {
     border:                  Border;
     "border-color":          BackgroundPositionClass;
@@ -2133,6 +2697,9 @@ interface Map$1 {
     "background-size":       BackgroundPositionClass;
 }
 
+/**
+ * @private
+ */
 interface Background {
     shorthand:  string;
     pattern:    string;
@@ -2143,6 +2710,9 @@ interface Background {
     properties: BackgroundProperties;
 }
 
+/**
+ * @private
+ */
 interface BackgroundProperties {
     "background-repeat":     BackgroundRepeat;
     "background-color":      PurpleBackgroundAttachment;
@@ -2154,6 +2724,9 @@ interface BackgroundProperties {
     "background-size":       BackgroundSize;
 }
 
+/**
+ * @private
+ */
 interface PurpleBackgroundAttachment {
     types:     string[];
     default:   string[];
@@ -2162,6 +2735,9 @@ interface PurpleBackgroundAttachment {
     mapping?:  BackgroundAttachmentMapping;
 }
 
+/**
+ * @private
+ */
 interface BackgroundAttachmentMapping {
     "ultra-condensed": string;
     "extra-condensed": string;
@@ -2174,6 +2750,9 @@ interface BackgroundAttachmentMapping {
     "ultra-expanded":  string;
 }
 
+/**
+ * @private
+ */
 interface BackgroundPosition {
     multiple:    boolean;
     types:       string[];
@@ -2183,14 +2762,23 @@ interface BackgroundPosition {
     constraints: BackgroundPositionConstraints;
 }
 
+/**
+ * @private
+ */
 interface BackgroundPositionConstraints {
     mapping: ConstraintsMapping;
 }
 
+/**
+ * @private
+ */
 interface ConstraintsMapping {
     max: number;
 }
 
+/**
+ * @private
+ */
 interface BackgroundPositionMapping {
     left:   string;
     top:    string;
@@ -2199,6 +2787,9 @@ interface BackgroundPositionMapping {
     right:  string;
 }
 
+/**
+ * @private
+ */
 interface BackgroundRepeat {
     types:    any[];
     default:  string[];
@@ -2207,6 +2798,9 @@ interface BackgroundRepeat {
     mapping:  BackgroundRepeatMapping;
 }
 
+/**
+ * @private
+ */
 interface BackgroundRepeatMapping {
     "repeat no-repeat":    string;
     "no-repeat repeat":    string;
@@ -2216,6 +2810,9 @@ interface BackgroundRepeatMapping {
     "no-repeat no-repeat": string;
 }
 
+/**
+ * @private
+ */
 interface BackgroundSize {
     multiple: boolean;
     previous: string;
@@ -2226,23 +2823,38 @@ interface BackgroundSize {
     mapping:  BackgroundSizeMapping;
 }
 
+/**
+ * @private
+ */
 interface BackgroundSizeMapping {
     "auto auto": string;
 }
 
+/**
+ * @private
+ */
 interface Prefix {
     typ: string;
     val: string;
 }
 
+/**
+ * @private
+ */
 interface Separator {
     typ: string;
 }
 
+/**
+ * @private
+ */
 interface BackgroundPositionClass {
     shorthand: string;
 }
 
+/**
+ * @private
+ */
 interface Border {
     shorthand:  string;
     pattern:    string;
@@ -2251,15 +2863,24 @@ interface Border {
     properties: BorderProperties;
 }
 
+/**
+ * @private
+ */
 interface BorderProperties {
     "border-color": BorderColorClass;
     "border-style": BorderColorClass;
     "border-width": BorderColorClass;
 }
 
+/**
+ * @private
+ */
 interface BorderColorClass {
 }
 
+/**
+ * @private
+ */
 interface Font {
     shorthand:  string;
     pattern:    string;
@@ -2268,6 +2889,9 @@ interface Font {
     properties: FontProperties;
 }
 
+/**
+ * @private
+ */
 interface FontProperties {
     "font-weight":  FontWeight;
     "font-style":   PurpleBackgroundAttachment;
@@ -2278,6 +2902,9 @@ interface FontProperties {
     "font-family":  FontFamily;
 }
 
+/**
+ * @private
+ */
 interface FontFamily {
     types:     string[];
     default:   any[];
@@ -2287,6 +2914,9 @@ interface FontFamily {
     separator: Separator;
 }
 
+/**
+ * @private
+ */
 interface FontWeight {
     types:       string[];
     default:     string[];
@@ -2295,15 +2925,24 @@ interface FontWeight {
     mapping:     FontWeightMapping;
 }
 
+/**
+ * @private
+ */
 interface FontWeightConstraints {
     value: Value;
 }
 
+/**
+ * @private
+ */
 interface Value {
     min: string;
     max: string;
 }
 
+/**
+ * @private
+ */
 interface FontWeightMapping {
     thin:          string;
     hairline:      string;
@@ -2324,6 +2963,9 @@ interface FontWeightMapping {
     "ultra black": string;
 }
 
+/**
+ * @private
+ */
 interface LineHeight {
     types:    string[];
     default:  string[];
@@ -2332,6 +2974,9 @@ interface LineHeight {
     prefix:   Prefix;
 }
 
+/**
+ * @private
+ */
 interface Outline {
     shorthand:  string;
     pattern:    string;
@@ -2340,12 +2985,18 @@ interface Outline {
     properties: OutlineProperties;
 }
 
+/**
+ * @private
+ */
 interface OutlineProperties {
     "outline-color": PurpleBackgroundAttachment;
     "outline-style": PurpleBackgroundAttachment;
     "outline-width": PurpleBackgroundAttachment;
 }
 
+/**
+ * @private
+ */
 interface PropertiesConfigProperties {
     inset:                        BorderRadius;
     top:                          BackgroundPositionClass;
@@ -2384,6 +3035,9 @@ interface PropertiesConfigProperties {
     "border-left-color":          BackgroundPositionClass;
 }
 
+/**
+ * @private
+ */
 interface BorderColor {
     shorthand:  string;
     map?:       string;
@@ -2392,6 +3046,9 @@ interface BorderColor {
     keywords:   string[];
 }
 
+/**
+ * @private
+ */
 interface BorderRadius {
     shorthand:  string;
     properties: string[];
@@ -2401,38 +3058,38 @@ interface BorderRadius {
     keywords:   string[];
 }
 
-export declare type WalkerOption = WalkerOptionEnum | Token | null;
+/**
+ * node walker option
+ */
+export declare type WalkerOption = WalkerOptionEnum | AstNode$1 | Token$1 | null;
 /**
  * returned value:
- * - WalkerOptionEnum.Ignore: ignore this node and its children
- * - WalkerOptionEnum.Stop: stop walking the tree
- * - WalkerOptionEnum.Children: walk the children and ignore the node itself
- * - WalkerOptionEnum.IgnoreChildren: walk the node and ignore children
+ * - {@link WalkerOptionEnum.Ignore}: ignore this node and its children
+ * - {@link WalkerOptionEnum.Stop}: stop walking the tree
+ * - {@link WalkerOptionEnum.Children}: walk the children and ignore the current node
+ * - {@link WalkerOptionEnum.IgnoreChildren}: walk the node and ignore children
+ * - {@link AstNode}:
+ * - {@link Token}:
  */
-export declare type WalkerFilter = (node: AstNode) => WalkerOption;
+export declare type WalkerFilter = (node: AstNode$1) => WalkerOption;
 
 /**
- * returned value:
- * - 'ignore': ignore this node and its children
- * - 'stop': stop walking the tree
- * - 'children': walk the children and ignore the node itself
- * - 'ignore-children': walk the node and ignore children
+ * filter nod
  */
-export declare type WalkerValueFilter = (node: AstNode | Token, parent?: FunctionToken | ParensToken | BinaryExpressionToken, event?: WalkerValueEvent) => WalkerOption | null;
+export declare type WalkerValueFilter = (node: AstNode$1 | Token$1, parent?: AstNode$1 | Token$1 | null, event?: WalkerEvent) => WalkerOption | null;
 
 export declare interface WalkResult {
-    node: AstNode;
+    node: AstNode$1;
     parent?: AstRuleList;
-    root?: AstNode;
+    root?: AstNode$1;
 }
 
 export declare interface WalkAttributesResult {
-    value: Token;
-    previousValue: Token | null;
-    nextValue: Token | null;
-    root?: AstNode;
-    parent: AstNode | Token | null;
-    list: Token[] | null;
+    value: Token$1;
+    previousValue: Token$1 | null;
+    nextValue: Token$1 | null;
+    root?: AstNode$1 | Token$1 | null;
+    parent: AstNode$1 | Token$1 | null;
 }
 
 /**
@@ -2456,7 +3113,7 @@ export declare interface ErrorDescription {
     /**
      * error node
      */
-    node?: Token | AstNode | null;
+    node?: Token$1 | AstNode$1 | null;
     /**
      * error location
      */
@@ -2491,7 +3148,7 @@ interface ValidationOptions {
      *
      * @private
      */
-    visited?: WeakMap<Token, Map<string, Set<ValidationToken>>>;
+    visited?: WeakMap<Token$1, Map<string, Set<ValidationToken>>>;
     /**
      * is optional
      *
@@ -2515,7 +3172,7 @@ interface ValidationOptions {
      *
      * @private
      */
-    occurence?: boolean | null;
+    occurrence?: boolean | null;
     /**
      * at least once
      *
@@ -2542,13 +3199,37 @@ interface MinifyOptions {
      */
     nestingRules?: boolean;
     /**
-     * expand nested rules
-     */
-    expandNestingRules?: boolean;
-    /**
-     * remove duplicate declarations from the same rule
+     * remove duplicate declarations from the same rule. if passed as a string array, duplicated declarations are removed, except for those in the array
+     *
+     *
+     * ```ts
+     *
+     * import {transform} from '@tbela99/css-parser';
+     *
+     * const css = `
+     *
+     * .table {
+     *
+     *     width: 100%;
+     *     width: calc(100% + 40px);
+     *     margin-left: 20px;
+     *     margin-left: min(100% , 20px)
+     * }
+     *
+     * `;
+     * const result = await transform(css, {
+     *
+     *     beautify: true,
+     *     validation: true,
+     *     removeDuplicateDeclarations: ['width']
+     * }
+     * );
+     *
+     * console.log(result.code);
+     *
+     * ```
      */
-    removeDuplicateDeclarations?: boolean;
+    removeDuplicateDeclarations?: boolean | string | string[];
     /**
      * compute shorthand properties
      */
@@ -2571,12 +3252,22 @@ interface MinifyOptions {
      * remove empty ast nodes
      */
     removeEmpty?: boolean;
+    /**
+     * remove css prefix
+     */
+    removePrefix?: boolean;
     /**
      * define minification passes.
      */
     pass?: number;
 }
 
+export declare type LoadResult =
+    Promise<ReadableStream<Uint8Array>>
+    | ReadableStream<Uint8Array>
+    | string
+    | Promise<string>;
+
 /**
  * parser options
  */
@@ -2591,34 +3282,31 @@ export declare interface ParserOptions extends MinifyOptions, MinifyFeatureOptio
      */
     sourcemap?: boolean | 'inline';
     /**
-     * remove @charset at-rule
+     * remove at-rule charset
      */
     removeCharset?: boolean;
-    /**
-     * resolve urls
-     */
-    resolveUrls?: boolean;
     /**
      * resolve import
      */
     resolveImport?: boolean;
     /**
      * current working directory
-     * @ignore
+     *
+     * @internal
      */
     cwd?: string;
     /**
-     * remove css prefix
+     * expand nested rules
      */
-    removePrefix?: boolean;
+    expandNestingRules?: boolean;
     /**
-     * get file or url as stream
+     * url and file loader
      * @param url
      * @param currentUrl
+     * @param asStream
      *
-     * @private
      */
-    getStream?: (url: string, currentUrl: string) => Promise<ReadableStream<string>>;
+    load?: (url: string, currentUrl: string, asStream?: boolean) => LoadResult;
     /**
      * get directory name
      * @param path
@@ -2627,22 +3315,26 @@ export declare interface ParserOptions extends MinifyOptions, MinifyFeatureOptio
      */
     dirname?: (path: string) => string;
     /**
-     * resolve path
+     * resolve urls
+     */
+    resolveUrls?: boolean;
+    /**
+     * url and path resolver
      * @param url
      * @param currentUrl
      * @param currentWorkingDirectory
      *
-     * @private
      */
     resolve?: (url: string, currentUrl: string, currentWorkingDirectory?: string) => {
         absolute: string;
         relative: string;
     };
+
     /**
      * node visitor
-     * {@link VisitorNodeMap}
+     * {@link VisitorNodeMap | VisitorNodeMap[]}
      */
-    visitor?: VisitorNodeMap;
+    visitor?: VisitorNodeMap | VisitorNodeMap[];
     /**
      * abort signal
      *
@@ -2658,6 +3350,8 @@ export declare interface ParserOptions extends MinifyOptions, MinifyFeatureOptio
     signal?: AbortSignal;
     /**
      * set parent node
+     *
+     * @private
      */
     setParent?: boolean;
     /**
@@ -2665,7 +3359,7 @@ export declare interface ParserOptions extends MinifyOptions, MinifyFeatureOptio
      *
      * @private
      */
-    cache?: WeakMap<AstNode, string>;
+    cache?: WeakMap<AstNode$1, string>;
 }
 
 /**
@@ -2678,7 +3372,7 @@ export declare interface MinifyFeatureOptions {
     /**
      * minify features
      *
-     * @internal
+     * @private
      */
     features?: MinifyFeature[];
 }
@@ -2691,17 +3385,18 @@ export declare interface MinifyFeatureOptions {
 export declare interface MinifyFeature {
 
     /**
-     * ordering
+     * accepted tokens
      */
-    ordering: number;
+    accept?: Set<EnumToken>;
+
     /**
-     * use in pre process
+     * ordering
      */
-    preProcess: boolean;
+    ordering: number;
     /**
-     * use in post process
+     * process mode
      */
-    postProcess: boolean;
+    processMode: FeatureWalkMode;
     /**
      * register feature
      * @param options
@@ -2715,9 +3410,9 @@ export declare interface MinifyFeature {
      * @param context
      * @param mode
      */
-    run: (ast: AstRule | AstAtRule, options: ParserOptions, parent: AstRule | AstAtRule | AstRuleStyleSheet, context: {
+    run: (ast: AstRule | AstAtRule, options: ParserOptions, parent: AstRule | AstAtRule | AstStyleSheet, context: {
         [key: string]: any
-    }, mode: FeatureWalkMode) => void;
+    }, mode: FeatureWalkMode) => AstNode$1 | null;
 }
 
 /**
@@ -2741,15 +3436,31 @@ export declare interface ResolvedPath {
 export declare interface RenderOptions {
 
     /**
-     * minify ast node.
+     * minify css values.
      */
     minify?: boolean;
     /**
      * pretty print css
+     *
+     * ```ts
+     * const result = await transform(css, {beautify: true});
+     * ```
      */
     beautify?: boolean;
     /**
-     * remove empty rule lists from the ast
+     * remove empty nodes. empty nodes are removed by default
+     *
+     * ```ts
+     *
+     * const css = `
+     * @supports selector(:-ms-input-placeholder) {
+     *
+     * :-ms-input-placeholder {
+     *
+     * }
+     * }`;
+     * const result = await transform(css, {removeEmpty: false});
+     * ```
      */
     removeEmpty?: boolean;
     /**
@@ -2781,7 +3492,7 @@ export declare interface RenderOptions {
      */
     convertColor?: boolean | ColorType;
     /**
-     * ernder the node along with its parents
+     * render the node along with its parents
      */
     withParents?: boolean;
     /**
@@ -2839,7 +3550,17 @@ export declare interface ParseResultStats {
     /**
      * imported files stats
      */
-    imports: ParseResultStats[]
+    imports: ParseResultStats[],
+
+    /**
+     * nodes count
+     */
+    nodesCount: number;
+
+    /**
+     * tokens count
+     */
+    tokensCount: number;
 }
 
 /**
@@ -2849,7 +3570,7 @@ export declare interface ParseResult {
     /**
      * parsed ast tree
      */
-    ast: AstRuleStyleSheet;
+    ast: AstStyleSheet;
     /**
      * parse errors
      */
@@ -3023,7 +3744,7 @@ export declare interface VariableScopeInfo {
     /**
      * declaration values
      */
-    values: Token[];
+    values: Token$1[];
 }
 
 /**
@@ -3043,7 +3764,8 @@ export declare interface SourceMapObject {
 /**
  * return the directory name of a path
  * @param path
- * @internal
+ *
+ * @private
  */
 declare function dirname(path: string): string;
 /**
@@ -3059,21 +3781,18 @@ declare function resolve(url: string, currentDirectory: string, cwd?: string): {
     relative: string;
 };
 
-/**
- * node module entry point
- * @module node
- */
-
 /**
  * load file or url as stream
  * @param url
  * @param currentFile
+ * @param asStream
+ * @throws Error file not found
  *
  * @private
  */
-declare function getStream(url: string, currentFile?: string): Promise<ReadableStream<string>>;
+declare function load(url: string, currentFile?: string, asStream?: boolean): Promise<string | ReadableStream<Uint8Array<ArrayBufferLike>>>;
 /**
- * render ast tree
+ * render the ast tree
  * @param data
  * @param options
  *
@@ -3083,20 +3802,31 @@ declare function getStream(url: string, currentFile?: string): Promise<ReadableS
  *
  *  import {render, ColorType} from '@tbela99/css-parser';
  *
- *  // remote file
- * let result = render(ast);
- * console.log(result.code);
+ *  const css = 'body { color: color(from hsl(0 100% 50%) xyz x y z); }';
+ *  const parseResult = await parse(css);
  *
- * // local file
- * result = await parseFile(ast, {beatify: true, convertColor: ColorType.SRGB});
+ * let renderResult = render(parseResult.ast);
  * console.log(result.code);
+ *
+ * // body{color:red}
+ *
+ *
+ * renderResult = render(parseResult.ast, {beautify: true, convertColor: ColorType.SRGB});
+ * console.log(renderResult.code);
+ *
+ * // body {
+ * //  color: color(srgb 1 0 0)
+ * // }
  * ```
  */
-declare function render(data: AstNode, options?: RenderOptions): RenderResult;
+declare function render(data: AstNode$1, options?: RenderOptions): RenderResult;
 /**
  * parse css file
  * @param file url or path
  * @param options
+ * @param asStream load file as stream
+ *
+ * @throws Error file not found
  *
  * Example:
  *
@@ -3113,21 +3843,21 @@ declare function render(data: AstNode, options?: RenderOptions): RenderResult;
  * console.log(result.ast);
  * ```
  */
-declare function parseFile(file: string, options?: ParserOptions): Promise<ParseResult>;
+declare function parseFile(file: string, options?: ParserOptions, asStream?: boolean): Promise<ParseResult>;
 /**
  * parse css
  * @param stream
- * @param opt
+ * @param options
  *
  * Example:
  *
  * ```ts
  *
- * import {transform} from '@tbela99/css-parser';
+ * import {parse} from '@tbela99/css-parser';
  *
  *  // css string
- *  let result = await transform(css);
- *  console.log(result.code);
+ *  let result = await parse(css);
+ *  console.log(result.ast);
  * ```
  *
  * Example using stream
@@ -3140,28 +3870,31 @@ declare function parseFile(file: string, options?: ParserOptions): Promise<Parse
  * // usage: node index.ts < styles.css or cat styles.css | node index.ts
  *
  *  const readableStream = Readable.toWeb(process.stdin);
- *  const result = await parse(readableStream, {beautify: true});
+ *  let result = await parse(readableStream, {beautify: true});
  *
  *  console.log(result.ast);
  * ```
  *
- * Example using fetch
+ * Example using fetch and readable stream
  *
  * ```ts
  *
  *  import {parse} from '@tbela99/css-parser';
  *
  *  const response = await fetch('https://docs.deno.com/styles.css');
- *  result = await parse(response.body, {beautify: true});
+ *  const result = await parse(response.body, {beautify: true});
  *
  *  console.log(result.ast);
  * ```
  */
-declare function parse(stream: string | ReadableStream<string>, opt?: ParserOptions): Promise<ParseResult>;
+declare function parse(stream: string | ReadableStream<Uint8Array>, options?: ParserOptions): Promise<ParseResult>;
 /**
  * transform css file
  * @param file url or path
  * @param options
+ * @param asStream load file as stream
+ *
+ * @throws Error file not found
  *
  * Example:
  *
@@ -3178,7 +3911,7 @@ declare function parse(stream: string | ReadableStream<string>, opt?: ParserOpti
  * console.log(result.code);
  * ```
  */
-declare function transformFile(file: string, options?: TransformOptions): Promise<TransformResult>;
+declare function transformFile(file: string, options?: TransformOptions, asStream?: boolean): Promise<TransformResult>;
 /**
  * transform css
  * @param css
@@ -3191,7 +3924,7 @@ declare function transformFile(file: string, options?: TransformOptions): Promis
  * import {transform} from '@tbela99/css-parser';
  *
  *  // css string
- *  let result = await transform(css);
+ *  const result = await transform(css);
  *  console.log(result.code);
  * ```
  *
@@ -3222,7 +3955,7 @@ declare function transformFile(file: string, options?: TransformOptions): Promis
  *  console.log(result.code);
  * ```
  */
-declare function transform(css: string | ReadableStream<string>, options?: TransformOptions): Promise<TransformResult>;
+declare function transform(css: string | ReadableStream<Uint8Array>, options?: TransformOptions): Promise<TransformResult>;
 
-export { ColorType, EnumToken, FeatureWalkMode, SourceMap, ValidationLevel, WalkerOptionEnum, WalkerValueEvent, convertColor, dirname, expand, getStream, isOkLabClose, mathFuncs, minify, okLabDistance, parse, parseDeclarations, parseFile, parseString, parseTokens, render, renderToken, resolve, transform, transformFile, transformFunctions, walk, walkValues };
-export type { AddToken, AngleToken, AstAtRule, AstComment, AstDeclaration, AstInvalidAtRule, AstInvalidDeclaration, AstInvalidRule, AstKeyFrameRule, AstKeyframAtRule, AstKeyframeRule, AstNode, AstRule, AstRuleList, AstRuleStyleSheet, AtRuleToken, AtRuleVisitorHandler, AttrEndToken, AttrStartToken, AttrToken, Background, BackgroundAttachmentMapping, BackgroundPosition, BackgroundPositionClass, BackgroundPositionConstraints, BackgroundPositionMapping, BackgroundProperties, BackgroundRepeat, BackgroundRepeatMapping, BackgroundSize, BackgroundSizeMapping, BadCDOCommentToken, BadCommentToken, BadStringToken, BadUrlToken, BaseToken, BinaryExpressionNode, BinaryExpressionToken, BlockEndToken, BlockStartToken, Border, BorderColor, BorderColorClass, BorderProperties, BorderRadius, CDOCommentToken, ChildCombinatorToken, ClassSelectorToken, ColonToken, ColorToken, ColumnCombinatorToken, CommaToken, CommentToken, ConstraintsMapping, ContainMatchToken, Context, DashMatchToken, DashedIdentToken, DeclarationVisitorHandler, DelimToken, DescendantCombinatorToken, DimensionToken, DivToken, EOFToken, EndMatchToken, EqualMatchToken, ErrorDescription, FlexToken, Font, FontFamily, FontProperties, FontWeight, FontWeightConstraints, FontWeightMapping, FractionToken, FrequencyToken, FunctionImageToken, FunctionToken, FunctionURLToken, GreaterThanOrEqualToken, GreaterThanToken, GridTemplateFuncToken, HashToken, IdentListToken, IdentToken, ImportantToken, IncludeMatchToken, InvalidAttrToken, InvalidClassSelectorToken, LengthToken, LessThanOrEqualToken, LessThanToken, LineHeight, ListToken, LiteralToken, Location, Map$1 as Map, MatchExpressionToken, MatchedSelector, MediaFeatureAndToken, MediaFeatureNotToken, MediaFeatureOnlyToken, MediaFeatureOrToken, MediaFeatureToken, MediaQueryConditionToken, MinifyFeature, MinifyFeatureOptions, MinifyOptions, MulToken, NameSpaceAttributeToken, NestingSelectorToken, NextSiblingCombinatorToken, NumberToken, OptimizedSelector, OptimizedSelectorToken, Outline, OutlineProperties, ParensEndToken, ParensStartToken, ParensToken, ParseInfo, ParseResult, ParseResultStats, ParseTokenOptions, ParserOptions, PercentageToken, Position, Prefix, PropertiesConfig, PropertiesConfigProperties, PropertyListOptions, PropertyMapType, PropertySetType, PropertyType, PseudoClassFunctionToken, PseudoClassToken, PseudoElementToken, PseudoPageToken, PurpleBackgroundAttachment, RawSelectorTokens, RenderOptions, RenderResult, ResolutionToken, ResolvedPath, RuleVisitorHandler, SemiColonToken, Separator, ShorthandDef, ShorthandMapType, ShorthandProperties, ShorthandPropertyType, ShorthandType, SourceMapObject, StartMatchToken, StringToken, SubToken, SubsequentCombinatorToken, TimeToken, TimelineFunctionToken, TimingFunctionToken, Token, TokenizeResult, TransformOptions, TransformResult, UnaryExpression, UnaryExpressionNode, UnclosedStringToken, UniversalSelectorToken, UrlToken, ValidationConfiguration, ValidationOptions, ValidationResult, ValidationSelectorOptions, ValidationSyntaxNode, ValidationSyntaxResult, Value, VariableScopeInfo, VisitorNodeMap, WalkAttributesResult, WalkResult, WalkerFilter, WalkerOption, WalkerValueFilter, WhitespaceToken };
+export { ColorType, EnumToken, FeatureWalkMode, SourceMap, ValidationLevel, WalkerEvent, WalkerOptionEnum, convertColor, dirname, expand, isOkLabClose, load, mathFuncs, minify, okLabDistance, parse, parseDeclarations, parseFile, parseString, parseTokens, render, renderToken, resolve, transform, transformFile, transformFunctions, walk, walkValues };
+export type { AddToken, AngleToken, AstAtRule, AstComment, AstDeclaration, AstInvalidAtRule, AstInvalidDeclaration, AstInvalidRule, AstKeyFrameRule, AstKeyframesAtRule, AstKeyframesRule, AstNode$1 as AstNode, AstRule, AstRuleList, AstStyleSheet, AtRuleToken, AtRuleVisitorHandler, AttrEndToken, AttrStartToken, AttrToken, Background, BackgroundAttachmentMapping, BackgroundPosition, BackgroundPositionClass, BackgroundPositionConstraints, BackgroundPositionMapping, BackgroundProperties, BackgroundRepeat, BackgroundRepeatMapping, BackgroundSize, BackgroundSizeMapping, BadCDOCommentToken, BadCommentToken, BadStringToken, BadUrlToken, BaseToken, BinaryExpressionNode, BinaryExpressionToken, BlockEndToken, BlockStartToken, Border, BorderColor, BorderColorClass, BorderProperties, BorderRadius, CDOCommentToken, ChildCombinatorToken, ClassSelectorToken, ColonToken, ColorToken, ColumnCombinatorToken, CommaToken, CommentToken, ConstraintsMapping, ContainMatchToken, Context, DashMatchToken, DashedIdentToken, DeclarationVisitorHandler, DelimToken, DescendantCombinatorToken, DimensionToken, DivToken, EOFToken, EndMatchToken, EqualMatchToken, ErrorDescription, FlexToken, Font, FontFamily, FontProperties, FontWeight, FontWeightConstraints, FontWeightMapping, FractionToken, FrequencyToken, FunctionImageToken, FunctionToken, FunctionURLToken, GenericVisitorAstNodeHandlerMap, GenericVisitorHandler, GenericVisitorResult, GreaterThanOrEqualToken, GreaterThanToken, GridTemplateFuncToken, HashToken, IdentListToken, IdentToken, ImportantToken, IncludeMatchToken, InvalidAttrToken, InvalidClassSelectorToken, LengthToken, LessThanOrEqualToken, LessThanToken, LineHeight, ListToken, LiteralToken, LoadResult, Location, Map$1 as Map, MatchExpressionToken, MatchedSelector, MediaFeatureAndToken, MediaFeatureNotToken, MediaFeatureOnlyToken, MediaFeatureOrToken, MediaFeatureToken, MediaQueryConditionToken, MinifyFeature, MinifyFeatureOptions, MinifyOptions, MulToken, NameSpaceAttributeToken, NestingSelectorToken, NextSiblingCombinatorToken, NumberToken, OptimizedSelector, OptimizedSelectorToken, Outline, OutlineProperties, ParensEndToken, ParensStartToken, ParensToken, ParseInfo, ParseResult, ParseResultStats, ParseTokenOptions, ParserOptions, PercentageToken, Position, Prefix, PropertiesConfig, PropertiesConfigProperties, PropertyListOptions, PropertyMapType, PropertySetType, PropertyType, PseudoClassFunctionToken, PseudoClassToken, PseudoElementToken, PseudoPageToken, PurpleBackgroundAttachment, RawSelectorTokens, RenderOptions, RenderResult, ResolutionToken, ResolvedPath, RuleVisitorHandler, SemiColonToken, Separator, ShorthandDef, ShorthandMapType, ShorthandProperties, ShorthandPropertyType, ShorthandType, SourceMapObject, StartMatchToken, StringToken, SubToken, SubsequentCombinatorToken, TimeToken, TimelineFunctionToken, TimingFunctionToken, Token$1 as Token, TokenizeResult, TransformOptions, TransformResult, UnaryExpression, UnaryExpressionNode, UnclosedStringToken, UniversalSelectorToken, UrlToken, ValidationConfiguration, ValidationOptions, ValidationResult, ValidationSelectorOptions, ValidationSyntaxNode, ValidationSyntaxResult, Value, ValueVisitorHandler, VariableScopeInfo, VisitorNodeMap, WalkAttributesResult, WalkResult, WalkerFilter, WalkerOption, WalkerValueFilter, WhitespaceToken };