@tbela99/css-parser 0.0.1 → 0.2.0

package/dist/index.d.ts

@@ -1,711 +1,862 @@
-interface LiteralToken {
-    typ: 'Literal';
+declare enum EnumToken {
+    CommentTokenType = 0,
+    CDOCOMMTokenType = 1,
+    StyleSheetNodeType = 2,
+    AtRuleNodeType = 3,
+    RuleNodeType = 4,
+    DeclarationNodeType = 5,
+    LiteralTokenType = 6,
+    IdenTokenType = 7,
+    DashedIdenTokenType = 8,
+    CommaTokenType = 9,
+    ColonTokenType = 10,
+    SemiColonTokenType = 11,
+    NumberTokenType = 12,
+    AtRuleTokenType = 13,
+    PercentageTokenType = 14,
+    FunctionTokenType = 15,
+    TimelineFunctionTokenType = 16,
+    TimingFunctionTokenType = 17,
+    UrlFunctionTokenType = 18,
+    ImageFunctionTokenType = 19,
+    StringTokenType = 20,
+    UnclosedStringTokenType = 21,
+    DimensionTokenType = 22,
+    LengthTokenType = 23,
+    AngleTokenType = 24,
+    TimeTokenType = 25,
+    FrequencyTokenType = 26,
+    ResolutionTokenType = 27,
+    HashTokenType = 28,
+    BlockStartTokenType = 29,
+    BlockEndTokenType = 30,
+    AttrStartTokenType = 31,
+    AttrEndTokenType = 32,
+    StartParensTokenType = 33,
+    EndParensTokenType = 34,
+    ParensTokenType = 35,
+    WhitespaceTokenType = 36,
+    IncludeMatchTokenType = 37,
+    DashMatchTokenType = 38,
+    LtTokenType = 39,
+    LteTokenType = 40,
+    GtTokenType = 41,
+    GteTokenType = 42,
+    PseudoClassTokenType = 43,
+    PseudoClassFuncTokenType = 44,
+    DelimTokenType = 45,
+    UrlTokenTokenType = 46,
+    EOFTokenType = 47,
+    ImportantTokenType = 48,
+    ColorTokenType = 49,
+    AttrTokenType = 50,
+    BadCommentTokenType = 51,
+    BadCdoTokenType = 52,
+    BadUrlTokenType = 53,
+    BadStringTokenType = 54,
+    BinaryExpressionTokenType = 55,
+    UnaryExpressionTokenType = 56,
+    ListToken = 57,
+    Add = 58,
+    Mul = 59,
+    Div = 60,
+    Sub = 61,
+    ColumnCombinatorTokenType = 62,
+    ContainMatchTokenType = 63,
+    StartMatchTokenType = 64,
+    EndMatchTokenType = 65,
+    MatchExpressionTokenType = 66,
+    NameSpaceAttributeTokenType = 67,
+    FractionTokenType = 68,
+    Time = 25,
+    Iden = 7,
+    Hash = 28,
+    Angle = 24,
+    Color = 49,
+    Comma = 9,
+    String = 20,
+    Length = 23,
+    Number = 12,
+    Perc = 14,
+    Literal = 6,
+    Comment = 0,
+    UrlFunc = 18,
+    Dimension = 22,
+    Frequency = 26,
+    Resolution = 27,
+    Whitespace = 36,
+    DashedIden = 8,
+    ImageFunc = 19,
+    CommentNodeType = 0,
+    CDOCOMMNodeType = 1,
+    TimingFunction = 17,
+    TimelineFunction = 16
+}
+
+declare function minify(ast: AstNode, options?: ParserOptions | MinifyOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean, context?: {
+    [key: string]: any;
+}): AstNode;
+
+declare function walk(node: AstNode, filter?: WalkerFilter): Generator<WalkResult>;
+declare function walkValues(values: Token[]): Generator<WalkAttributesResult>;
+
+declare function expand(ast: AstNode): AstNode;
+
+declare function renderToken(token: Token, options?: RenderOptions, cache?: {
+    [key: string]: any;
+}, reducer?: (acc: string, curr: Token) => string, errors?: ErrorDescription[]): string;
+
+declare function parseString(src: string, options?: {
+    location: boolean;
+}): Token[];
+declare function parseTokens(tokens: Token[], options?: ParseTokenOptions): Token[];
+
+export declare interface BaseToken {
+
+    typ: EnumToken;
+    loc?: Location;
+}
+
+export declare interface LiteralToken extends BaseToken {
+
+    typ: EnumToken.LiteralTokenType;
     val: string;
 }
-interface IdentToken {
-    typ: 'Iden';
+
+export declare interface IdentToken extends BaseToken {
+
+    typ: EnumToken.IdenTokenType,
+    val: string;
+}
+
+export declare interface DashedIdentToken extends BaseToken {
+
+    typ: EnumToken.DashedIdenTokenType,
     val: string;
 }
-interface CommaToken {
-    typ: 'Comma';
+
+export declare interface CommaToken extends BaseToken {
+
+    typ: EnumToken.CommaTokenType
 }
-interface ColonToken {
-    typ: 'Colon';
+
+export declare interface ColonToken extends BaseToken {
+
+    typ: EnumToken.ColonTokenType
 }
-interface SemiColonToken {
-    typ: 'Semi-colon';
+
+export declare interface SemiColonToken extends BaseToken {
+
+    typ: EnumToken.SemiColonTokenType
 }
-interface NumberToken {
-    typ: 'Number';
-    val: string;
+
+export declare interface NumberToken extends BaseToken {
+
+    typ: EnumToken.NumberTokenType,
+    val: string | FractionToken;
 }
-interface AtRuleToken {
-    typ: 'At-rule';
+
+export declare interface AtRuleToken extends BaseToken {
+
+    typ: EnumToken.AtRuleTokenType,
     val: string;
 }
-interface PercentageToken {
-    typ: 'Perc';
-    val: string;
+
+export declare interface PercentageToken extends BaseToken {
+
+    typ: EnumToken.PercentageTokenType,
+    val: string | FractionToken;
 }
-interface FunctionToken {
-    typ: 'Func';
+
+export declare interface FunctionToken extends BaseToken {
+
+    typ: EnumToken.FunctionTokenType,
     val: string;
     chi: Token[];
 }
-interface FunctionURLToken {
-    typ: 'UrlFunc';
+
+export declare interface FunctionURLToken extends BaseToken {
+
+    typ: EnumToken.UrlFunctionTokenType,
     val: 'url';
     chi: Array<UrlToken | CommentToken>;
 }
-interface StringToken {
-    typ: 'String';
+
+export declare interface FunctionImageToken extends BaseToken {
+
+    typ: EnumToken.ImageFunctionTokenType,
+    val: 'linear-gradient' | 'radial-gradient' | 'repeating-linear-gradient' | 'repeating-radial-gradient' | 'conic-gradient' | 'image' | 'image-set' | 'element' | 'cross-fade';
+    chi: Array<UrlToken | CommentToken>;
+}
+
+export declare interface TimingFunctionToken extends BaseToken {
+
+    typ: EnumToken.TimingFunctionTokenType;
     val: string;
+    chi: Token[];
 }
-interface BadStringToken {
-    typ: 'Bad-string';
+export declare interface TimelineFunctionToken extends BaseToken {
+
+    typ: EnumToken.TimelineFunctionTokenType;
     val: string;
+    chi: Token[];
 }
-interface UnclosedStringToken {
-    typ: 'Unclosed-string';
+
+export declare interface StringToken extends BaseToken {
+
+    typ: EnumToken.StringTokenType;
     val: string;
 }
-interface DimensionToken {
-    typ: 'Dimension';
+
+export declare interface BadStringToken extends BaseToken {
+
+    typ: EnumToken.BadStringTokenType;
     val: string;
-    unit: string;
 }
-interface LengthToken {
-    typ: 'Length';
+
+export declare interface UnclosedStringToken extends BaseToken {
+
+    typ: EnumToken.UnclosedStringTokenType;
     val: string;
+}
+
+export declare interface DimensionToken extends BaseToken {
+
+    typ: EnumToken.DimensionTokenType;
+    val: string | FractionToken;
     unit: string;
 }
-interface AngleToken {
-    typ: 'Angle';
-    val: string;
+
+export declare interface LengthToken extends BaseToken {
+
+    typ: EnumToken.LengthTokenType;
+    val: string | FractionToken;
     unit: string;
 }
-interface TimeToken {
-    typ: 'Time';
-    val: string;
+
+export declare interface AngleToken extends BaseToken {
+
+    typ: EnumToken.AngleTokenType;
+    val: string | FractionToken;
+    unit: string;
+}
+
+export declare interface TimeToken extends BaseToken {
+
+    typ: EnumToken.TimeTokenType;
+    val: string | FractionToken;
     unit: 'ms' | 's';
 }
-interface FrequencyToken {
-    typ: 'Frequency';
-    val: string;
+
+export declare interface FrequencyToken extends BaseToken {
+
+    typ: EnumToken.FrequencyTokenType;
+    val: string | FractionToken;
     unit: 'Hz' | 'Khz';
 }
-interface ResolutionToken {
-    typ: 'Resolution';
-    val: string;
+
+export declare interface ResolutionToken extends BaseToken {
+
+    typ: EnumToken.ResolutionTokenType;
+    val: string | FractionToken;
     unit: 'dpi' | 'dpcm' | 'dppx' | 'x';
 }
-interface HashToken {
-    typ: 'Hash';
+
+export declare interface HashToken extends BaseToken {
+
+    typ: EnumToken.HashTokenType;
     val: string;
 }
-interface BlockStartToken {
-    typ: 'Block-start';
+
+export declare interface BlockStartToken extends BaseToken {
+
+    typ: EnumToken.BlockStartTokenType
 }
-interface BlockEndToken {
-    typ: 'Block-end';
+
+export declare interface BlockEndToken extends BaseToken {
+
+    typ: EnumToken.BlockEndTokenType
 }
-interface AttrStartToken {
-    typ: 'Attr-start';
+
+export declare interface AttrStartToken extends BaseToken {
+
+    typ: EnumToken.AttrStartTokenType;
     chi?: Token[];
 }
-interface AttrEndToken {
-    typ: 'Attr-end';
+
+export declare interface AttrEndToken extends BaseToken {
+
+    typ: EnumToken.AttrEndTokenType
 }
-interface ParensStartToken {
-    typ: 'Start-parens';
-    chi?: Token[];
+
+export declare interface ParensStartToken extends BaseToken {
+
+    typ: EnumToken.StartParensTokenType;
 }
-interface ParensEndToken {
-    typ: 'End-parens';
+
+export declare interface ParensEndToken extends BaseToken {
+
+    typ: EnumToken.EndParensTokenType
 }
-interface WhitespaceToken {
-    typ: 'Whitespace';
+
+export declare interface ParensToken extends BaseToken {
+
+    typ: EnumToken.ParensTokenType;
+    chi: Token[];
 }
-interface CommentToken {
-    typ: 'Comment';
+
+export declare interface WhitespaceToken extends BaseToken {
+
+    typ: EnumToken.WhitespaceTokenType
+}
+
+export declare interface CommentToken extends BaseToken {
+
+    typ: EnumToken.CommentTokenType;
     val: string;
 }
-interface BadCommentToken {
-    typ: 'Bad-comment';
+
+export declare interface BadCommentToken extends BaseToken {
+
+    typ: EnumToken.BadCommentTokenType;
     val: string;
 }
-interface CDOCommentToken {
-    typ: 'CDOCOMM';
+
+export declare interface CDOCommentToken extends BaseToken {
+
+    typ: EnumToken.CDOCOMMTokenType;
     val: string;
 }
-interface BadCDOCommentToken {
-    typ: 'Bad-cdo';
+
+export declare interface BadCDOCommentToken extends BaseToken {
+
+    typ: EnumToken.BadCdoTokenType;
     val: string;
 }
-interface IncludesToken {
-    typ: 'Includes';
-    val: '~=';
+
+export declare interface IncludeMatchToken extends BaseToken {
+
+    typ: EnumToken.IncludeMatchTokenType;
+    // val: '~=';
+}
+
+export declare interface DashMatchToken extends BaseToken {
+
+    typ: EnumToken.DashMatchTokenType;
+    // val: '|=';
+}
+
+export declare interface StartMatchToken extends BaseToken {
+
+    typ: EnumToken.StartMatchTokenType;
+    // val: '^=';
+}
+
+export declare interface EndMatchToken extends BaseToken {
+
+    typ: EnumToken.EndMatchTokenType;
+    // val: '|=';
+}
+
+export declare interface ContainMatchToken extends BaseToken {
+
+    typ: EnumToken.ContainMatchTokenType;
+    // val: '|=';
 }
-interface DashMatchToken {
-    typ: 'Dash-match';
-    val: '|=';
+
+export declare interface LessThanToken extends BaseToken {
+
+    typ: EnumToken.LtTokenType;
 }
-interface LessThanToken {
-    typ: 'Lt';
+
+export declare interface LessThanOrEqualToken extends BaseToken {
+
+    typ: EnumToken.LteTokenType;
 }
-interface LessThanOrEqualToken {
-    typ: 'Lte';
+
+export declare interface GreaterThanToken extends BaseToken {
+
+    typ: EnumToken.GtTokenType;
 }
-interface GreaterThanToken {
-    typ: 'Gt';
+
+export declare interface GreaterThanOrEqualToken extends BaseToken {
+
+    typ: EnumToken.GteTokenType;
 }
-interface GreaterThanOrEqualToken {
-    typ: 'Gte';
+
+export declare interface ColumnCombinatorToken extends BaseToken {
+
+    typ: EnumToken.ColumnCombinatorTokenType;
 }
-interface PseudoClassToken {
-    typ: 'Pseudo-class';
+
+export declare interface PseudoClassToken extends BaseToken {
+
+    typ: EnumToken.PseudoClassTokenType;
     val: string;
 }
-interface PseudoClassFunctionToken {
-    typ: 'Pseudo-class-func';
+
+export declare interface PseudoClassFunctionToken extends BaseToken {
+
+    typ: EnumToken.PseudoClassFuncTokenType;
     val: string;
     chi: Token[];
 }
-interface DelimToken {
-    typ: 'Delim';
+
+export declare interface DelimToken extends BaseToken {
+
+    typ: EnumToken.DelimTokenType;
     val: '=';
 }
-interface BadUrlToken {
-    typ: 'Bad-url-token';
+
+export declare interface BadUrlToken extends BaseToken {
+
+    typ: EnumToken.BadUrlTokenType,
     val: string;
 }
-interface UrlToken {
-    typ: 'Url-token';
+
+export declare interface UrlToken extends BaseToken {
+
+    typ: EnumToken.UrlTokenTokenType,
     val: string;
 }
-interface EOFToken {
-    typ: 'EOF';
+
+export declare interface EOFToken extends BaseToken {
+
+    typ: EnumToken.EOFTokenType;
 }
-interface ImportantToken {
-    typ: 'Important';
+
+export declare interface ImportantToken extends BaseToken {
+
+    typ: EnumToken.ImportantTokenType;
 }
-interface ColorToken {
-    typ: 'Color';
+
+export declare interface ColorToken extends BaseToken {
+
+    typ: EnumToken.ColorTokenType;
     val: string;
     kin: 'lit' | 'hex' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'hwb' | 'device-cmyk';
     chi?: Token[];
 }
-interface AttrToken {
-    typ: 'Attr';
-    chi: Token[];
+
+export declare interface AttrToken extends BaseToken {
+
+    typ: EnumToken.AttrTokenType,
+    chi: Token[]
 }
-declare type Token = LiteralToken | IdentToken | CommaToken | ColonToken | SemiColonToken | NumberToken | AtRuleToken | PercentageToken | FunctionURLToken | FunctionToken | DimensionToken | LengthToken | AngleToken | StringToken | TimeToken | FrequencyToken | ResolutionToken | UnclosedStringToken | HashToken | BadStringToken | BlockStartToken | BlockEndToken | AttrStartToken | AttrEndToken | ParensStartToken | ParensEndToken | CDOCommentToken | BadCDOCommentToken | CommentToken | BadCommentToken | WhitespaceToken | IncludesToken | DashMatchToken | LessThanToken | LessThanOrEqualToken | GreaterThanToken | GreaterThanOrEqualToken | PseudoClassToken | PseudoClassFunctionToken | DelimToken | BadUrlToken | UrlToken | ImportantToken | ColorToken | AttrToken | EOFToken;
-
-interface PropertyMapType {
-    default: string[];
-    types: string[];
-    keywords: string[];
-    required?: boolean;
-    multiple?: boolean;
-    prefix?: {
-        typ: 'Literal';
-        val: string;
-    };
-    previous?: string;
-    separator?: {
-        typ: 'Comma';
-    };
-    constraints?: {
-        [key: string]: {
-            [key: string]: any;
-        };
-    };
-    mapping?: {
-        [key: string]: any;
-    };
+
+export declare interface AddToken extends BaseToken {
+
+    typ: EnumToken.Add;
 }
 
-interface PropertiesConfig {
-    properties: PropertiesConfigProperties;
-    map: Map;
-}
-interface Map {
-    border: Border;
-    "border-color": BackgroundPositionClass;
-    "border-style": BackgroundPositionClass;
-    "border-width": BackgroundPositionClass;
-    outline: Outline;
-    "outline-color": BackgroundPositionClass;
-    "outline-style": BackgroundPositionClass;
-    "outline-width": BackgroundPositionClass;
-    font: Font;
-    "font-weight": BackgroundPositionClass;
-    "font-style": BackgroundPositionClass;
-    "font-size": BackgroundPositionClass;
-    "line-height": BackgroundPositionClass;
-    "font-stretch": BackgroundPositionClass;
-    "font-variant": BackgroundPositionClass;
-    "font-family": BackgroundPositionClass;
-    background: Background;
-    "background-repeat": BackgroundPositionClass;
-    "background-color": BackgroundPositionClass;
-    "background-image": BackgroundPositionClass;
-    "background-attachment": BackgroundPositionClass;
-    "background-clip": BackgroundPositionClass;
-    "background-origin": BackgroundPositionClass;
-    "background-position": BackgroundPositionClass;
-    "background-size": BackgroundPositionClass;
-}
-interface Background {
-    shorthand: string;
-    pattern: string;
-    keywords: string[];
-    default: any[];
-    multiple: boolean;
-    separator: Separator;
-    properties: BackgroundProperties;
-}
-interface BackgroundProperties {
-    "background-repeat": BackgroundRepeat;
-    "background-color": PurpleBackgroundAttachment;
-    "background-image": PurpleBackgroundAttachment;
-    "background-attachment": PurpleBackgroundAttachment;
-    "background-clip": PurpleBackgroundAttachment;
-    "background-origin": PurpleBackgroundAttachment;
-    "background-position": BackgroundPosition;
-    "background-size": BackgroundSize;
-}
-interface PurpleBackgroundAttachment {
-    types: string[];
-    default: string[];
-    keywords: string[];
-    required?: boolean;
-    mapping?: BackgroundAttachmentMapping;
-}
-interface BackgroundAttachmentMapping {
-    "ultra-condensed": string;
-    "extra-condensed": string;
-    condensed: string;
-    "semi-condensed": string;
-    normal: string;
-    "semi-expanded": string;
-    expanded: string;
-    "extra-expanded": string;
-    "ultra-expanded": string;
-}
-interface BackgroundPosition {
-    multiple: boolean;
-    types: string[];
-    default: string[];
-    keywords: string[];
-    mapping: BackgroundPositionMapping;
-    constraints: BackgroundPositionConstraints;
-}
-interface BackgroundPositionConstraints {
-    mapping: ConstraintsMapping;
-}
-interface ConstraintsMapping {
-    max: number;
-}
-interface BackgroundPositionMapping {
-    left: string;
-    top: string;
-    center: string;
-    bottom: string;
-    right: string;
-}
-interface BackgroundRepeat {
-    types: any[];
-    default: string[];
-    multiple: boolean;
-    keywords: string[];
-    mapping: BackgroundRepeatMapping;
-}
-interface BackgroundRepeatMapping {
-    "repeat no-repeat": string;
-    "no-repeat repeat": string;
-    "repeat repeat": string;
-    "space space": string;
-    "round round": string;
-    "no-repeat no-repeat": string;
-}
-interface BackgroundSize {
-    multiple: boolean;
-    previous: string;
-    prefix: Prefix;
-    types: string[];
-    default: string[];
-    keywords: string[];
-    mapping: BackgroundSizeMapping;
-}
-interface BackgroundSizeMapping {
-    "auto auto": string;
-}
-interface Prefix {
-    typ: string;
-    val: string;
+export declare interface SubToken extends BaseToken {
+
+    typ: EnumToken.Sub;
 }
-interface Separator {
-    typ: string;
-}
-interface BackgroundPositionClass {
-    shorthand: string;
-}
-interface Border {
-    shorthand: string;
-    pattern: string;
-    keywords: string[];
-    default: string[];
-    properties: BorderProperties;
-}
-interface BorderProperties {
-    "border-color": BorderColorClass;
-    "border-style": BorderColorClass;
-    "border-width": BorderColorClass;
-}
-interface BorderColorClass {
-}
-interface Font {
-    shorthand: string;
-    pattern: string;
-    keywords: string[];
-    default: any[];
-    properties: FontProperties;
-}
-interface FontProperties {
-    "font-weight": FontWeight;
-    "font-style": PurpleBackgroundAttachment;
-    "font-size": PurpleBackgroundAttachment;
-    "line-height": LineHeight;
-    "font-stretch": PurpleBackgroundAttachment;
-    "font-variant": PurpleBackgroundAttachment;
-    "font-family": FontFamily;
-}
-interface FontFamily {
-    types: string[];
-    default: any[];
-    keywords: string[];
-    required: boolean;
-    multiple: boolean;
-    separator: Separator;
-}
-interface FontWeight {
-    types: string[];
-    default: string[];
-    keywords: string[];
-    constraints: FontWeightConstraints;
-    mapping: FontWeightMapping;
-}
-interface FontWeightConstraints {
-    value: Value;
-}
-interface Value {
-    min: string;
-    max: string;
-}
-interface FontWeightMapping {
-    thin: string;
-    hairline: string;
-    "extra light": string;
-    "ultra light": string;
-    light: string;
-    normal: string;
-    regular: string;
-    medium: string;
-    "semi bold": string;
-    "demi bold": string;
-    bold: string;
-    "extra bold": string;
-    "ultra bold": string;
-    black: string;
-    heavy: string;
-    "extra black": string;
-    "ultra black": string;
-}
-interface LineHeight {
-    types: string[];
-    default: string[];
-    keywords: string[];
-    previous: string;
-    prefix: Prefix;
-}
-interface Outline {
-    shorthand: string;
-    pattern: string;
-    keywords: string[];
-    default: string[];
-    properties: OutlineProperties;
-}
-interface OutlineProperties {
-    "outline-color": PurpleBackgroundAttachment;
-    "outline-style": PurpleBackgroundAttachment;
-    "outline-width": PurpleBackgroundAttachment;
-}
-interface PropertiesConfigProperties {
-    inset: BorderRadius;
-    top: BackgroundPositionClass;
-    right: BackgroundPositionClass;
-    bottom: BackgroundPositionClass;
-    left: BackgroundPositionClass;
-    margin: BorderRadius;
-    "margin-top": BackgroundPositionClass;
-    "margin-right": BackgroundPositionClass;
-    "margin-bottom": BackgroundPositionClass;
-    "margin-left": BackgroundPositionClass;
-    padding: BorderColor;
-    "padding-top": BackgroundPositionClass;
-    "padding-right": BackgroundPositionClass;
-    "padding-bottom": BackgroundPositionClass;
-    "padding-left": BackgroundPositionClass;
-    "border-radius": BorderRadius;
-    "border-top-left-radius": BackgroundPositionClass;
-    "border-top-right-radius": BackgroundPositionClass;
-    "border-bottom-right-radius": BackgroundPositionClass;
-    "border-bottom-left-radius": BackgroundPositionClass;
-    "border-width": BorderColor;
-    "border-top-width": BackgroundPositionClass;
-    "border-right-width": BackgroundPositionClass;
-    "border-bottom-width": BackgroundPositionClass;
-    "border-left-width": BackgroundPositionClass;
-    "border-style": BorderColor;
-    "border-top-style": BackgroundPositionClass;
-    "border-right-style": BackgroundPositionClass;
-    "border-bottom-style": BackgroundPositionClass;
-    "border-left-style": BackgroundPositionClass;
-    "border-color": BorderColor;
-    "border-top-color": BackgroundPositionClass;
-    "border-right-color": BackgroundPositionClass;
-    "border-bottom-color": BackgroundPositionClass;
-    "border-left-color": BackgroundPositionClass;
-}
-interface BorderColor {
-    shorthand: string;
-    map?: string;
-    properties: string[];
-    types: string[];
-    keywords: string[];
-}
-interface BorderRadius {
-    shorthand: string;
-    properties: string[];
-    types: string[];
-    multiple: boolean;
-    separator: null | string;
-    keywords: string[];
-}
-
-interface ErrorDescription {
 
-    // drop rule or declaration | fix rule or declaration
-    action: 'drop' | 'ignore';
-    message: string;
-    location?: {
-        src: string,
-        lin: number,
-        col: number;
-    };
-    error?: Error;
+export declare interface DivToken extends BaseToken {
+
+    typ: EnumToken.Div;
 }
 
-interface ParserOptions {
+export declare interface MulToken extends BaseToken {
 
-    src?: string;
-    sourcemap?: boolean;
-    minify?: boolean;
-    nestingRules?: boolean;
-    removeEmpty?: boolean;
-    resolveUrls?: boolean;
-    resolveImport?: boolean;
-    cwd?: string;
-    load?: (url: string, currentUrl: string) => Promise<string>;
-    resolve?: (url: string, currentUrl: string, currentWorkingDirectory?: string) => { absolute: string, relative: string };
-    nodeEventFilter?: NodeType[]
+    typ: EnumToken.Mul;
 }
 
-interface RenderOptions {
+export declare interface UnaryExpression extends BaseToken {
 
-    minify?: boolean;
-    expandNestingRules?: boolean;
-    preserveLicense?: boolean;
-    indent?: string;
-    newLine?: string;
-    removeComments?: boolean;
-    colorConvert?: boolean;
+    typ: EnumToken.UnaryExpressionTokenType
+    sign: EnumToken.Add | EnumToken.Sub;
+    val: UnaryExpressionNode;
 }
 
-interface TransformOptions extends ParserOptions, RenderOptions {
+export declare interface FractionToken extends BaseToken {
 
+    typ: EnumToken.FractionTokenType;
+    l: NumberToken;
+    r: NumberToken;
 }
 
-interface ParseResult {
-    ast: AstRuleStyleSheet;
-    errors: ErrorDescription[];
-    stats: {
-        bytesIn: number;
-        parse: string;
-        minify: string;
-        total: string;
-    }
+export declare interface BinaryExpressionToken extends BaseToken {
+
+    typ: EnumToken.BinaryExpressionTokenType
+    op: EnumToken.Add | EnumToken.Sub | EnumToken.Div | EnumToken.Mul;
+    l: BinaryExpressionNode | Token;
+    r: BinaryExpressionNode | Token;
 }
 
-interface RenderResult {
-    code: string ;
-    errors: ErrorDescription[];
-    stats: {
-        total: string;
-    }
+export declare interface MatchExpressionToken extends BaseToken {
+
+    typ: EnumToken.MatchExpressionTokenType
+    op: EnumToken.DashMatchTokenType | EnumToken.StartMatchTokenType | EnumToken.ContainMatchTokenType | EnumToken.EndMatchTokenType | EnumToken.IncludeMatchTokenType;
+    l: Token;
+    r: Token;
+    attr?: 'i' | 's';
 }
 
-interface TransformResult extends ParseResult, RenderResult {
+export declare interface NameSpaceAttributeToken extends BaseToken {
 
-    stats: {
-        bytesIn: number;
-        bytesOut: number;
-        parse: string;
-        minify: string;
-        render: string;
-        total: string;
-    }
+    typ: EnumToken.NameSpaceAttributeTokenType
+    l?: Token;
+    r: Token;
 }
 
-interface TokenizeResult {
-    token: string;
-    hint?: string;
-    position: Position;
-    bytesIn: number;
+export declare interface ListToken extends BaseToken {
+
+    typ: EnumToken.ListToken
+    chi: Token[];
 }
 
-interface Position {
+export declare type UnaryExpressionNode =
+    BinaryExpressionNode
+    | NumberToken
+    | DimensionToken
+    | TimeToken
+    | LengthToken
+    | AngleToken
+    | FrequencyToken;
+
+export declare type BinaryExpressionNode = NumberToken | DimensionToken | PercentageToken | FractionToken |
+    AngleToken | LengthToken | FrequencyToken | BinaryExpressionToken | FunctionToken | ParensToken;
+export declare type Token =
+    LiteralToken
+    | IdentToken
+    | DashedIdentToken
+    | CommaToken
+    | ColonToken
+    | SemiColonToken
+    |
+    NumberToken
+    | AtRuleToken
+    | PercentageToken
+    | FunctionURLToken
+    | FunctionImageToken
+    | TimingFunctionToken
+    | TimelineFunctionToken
+    | FunctionToken
+    | DimensionToken
+    | LengthToken
+    |
+    AngleToken
+    | StringToken
+    | TimeToken
+    | FrequencyToken
+    | ResolutionToken
+    |
+    UnclosedStringToken
+    | HashToken
+    | BadStringToken
+    | BlockStartToken
+    | BlockEndToken
+    |
+    AttrStartToken
+    | AttrEndToken
+    | ParensStartToken
+    | ParensEndToken
+    | ParensToken
+    | CDOCommentToken
+    |
+    BadCDOCommentToken
+    | CommentToken
+    | BadCommentToken
+    | WhitespaceToken
+    | IncludeMatchToken
+    | StartMatchToken
+    | EndMatchToken
+    | ContainMatchToken | MatchExpressionToken | NameSpaceAttributeToken
+    |
+    DashMatchToken
+    | LessThanToken
+    | LessThanOrEqualToken
+    | GreaterThanToken
+    | GreaterThanOrEqualToken
+    | ColumnCombinatorToken
+    |
+    ListToken
+    | PseudoClassToken
+    | PseudoClassFunctionToken
+    | DelimToken
+    | BinaryExpressionToken
+    | UnaryExpression
+    | FractionToken
+    |
+    AddToken
+    | SubToken
+    | DivToken
+    | MulToken
+    |
+    BadUrlToken
+    | UrlToken
+    | ImportantToken
+    | ColorToken
+    | AttrToken
+    | EOFToken;
+
+export declare interface Position {
 
     ind: number;
     lin: number;
     col: number;
 }
 
-interface Location {
+export declare interface Location {
 
     sta: Position;
     // end: Position;
     src: string;
 }
 
-declare type NodeType = 'StyleSheet' | 'InvalidComment' | 'Comment' | 'Declaration' | 'InvalidAtRule' | 'AtRule' | 'Rule';
-
-interface Node {
+export declare interface Node {
 
-    typ: NodeType;
+    typ: EnumToken;
     loc?: Location;
 }
 
-interface AstComment extends Node {
+export declare interface AstComment extends Node {
 
-    typ: 'Comment' | 'CDOCOMM',
+    typ: EnumToken.CommentNodeType | EnumToken.CDOCOMMNodeType,
     val: string;
 }
-interface AstDeclaration extends Node {
+
+export declare interface AstDeclaration extends Node {
 
     nam: string,
     val: Token[];
-    typ: 'Declaration'
+    typ: EnumToken.DeclarationNodeType
 }
 
-interface AstRule extends Node {
+export declare interface AstRule$1 extends Node {
 
-    typ: 'Rule';
+    typ: EnumToken.RuleNodeType;
     sel: string;
     chi: Array<AstDeclaration | AstComment | AstRuleList>;
     optimized?: OptimizedSelector;
     raw?: RawSelectorTokens;
 }
 
-declare type RawSelectorTokens  = string[][];
+export declare type RawSelectorTokens = string[][];
 
-interface OptimizedSelector {
+export declare interface OptimizedSelector {
     match: boolean;
     optimized: string[];
     selector: string[][],
     reducible: boolean;
 }
 
-interface AstAtRule extends Node {
+export declare interface AstAtRule$1 extends Node {
 
+    typ: AtRuleNodeType,
     nam: string;
     val: string;
-    chi?: Array<AstDeclaration | AstComment> | Array<AstRule | AstComment>
+    chi?: Array<AstDeclaration | AstComment> | Array<AstRule$1 | AstComment>
 }
 
-interface AstRuleList extends Node {
+export declare interface AstRuleList extends Node {
 
+    typ: StyleSheetNodeType | RuleNodeType | AtRuleNodeType,
     chi: Array<Node | AstComment>
 }
 
-interface AstRuleStyleSheet extends AstRuleList {
-    typ: 'StyleSheet',
+export declare interface AstRuleStyleSheet$1 extends AstRuleList {
+    typ: StyleSheetNodeType,
     chi: Array<AstRuleList | AstComment>
 }
 
-type AstNode =
-    AstRuleStyleSheet
+export declare type AstNode =
+    AstRuleStyleSheet$1
     | AstRuleList
     | AstComment
-    | AstAtRule
-    | AstRule
+    | AstAtRule$1
+    | AstRule$1
     | AstDeclaration;
 
-declare const combinators: string[];
-declare function minify(ast: AstNode, options?: ParserOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean): AstNode;
-declare function reduceSelector(selector: string[][]): {
-    match: boolean;
-    optimized: string[];
-    selector: string[][];
-    reducible: boolean;
-} | null;
-declare function hasDeclaration(node: AstRule): boolean;
-declare function minifyRule(ast: AstRule | AstAtRule): AstRule | AstAtRule;
-declare function splitRule(buffer: string): string[][];
-
-declare function walk(node: AstNode, parent?: AstRuleList, root?: AstRuleList): Generator<{
+/**
+ * Declaration visitor handler
+ */
+export declare type DeclarationVisitorHandler = (node: AstDeclaration) => AstDeclaration | AstDeclaration[] | null;
+/**
+ * Rule visitor handler
+ */
+export declare type RuleVisitorHandler = (node: AstRule$1) => AstRule$1 | AstRule$1[] | null;
+
+/**
+ * AtRule visitor handler
+ */
+export declare type AtRuleVisitorHandler = (node: AstAtRule$1) => AstAtRule$1 | AstAtRule$1[] | null;
+
+/**
+ * Value visitor handler
+ */
+export declare type ValueVisitorHandler = (node: Token) => Token | Token[] | null;
+
+
+export declare interface VisitorNodeMap {
+
+    AtRule?: Record<string, AtRuleVisitorHandler> | AtRuleVisitorHandler;
+    Declaration?: Record<string, DeclarationVisitorHandler> | DeclarationVisitorHandler;
+    Rule?: RuleVisitorHandler;
+    Value?: Record<EnumToken, ValueVisitorHandler> | ValueVisitorHandler;
+}
+
+export declare type WalkerOption = 'ignore' | 'stop' | 'children' | 'ignore-children' | null;
+/**
+ * return 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
+ */
+export declare type WalkerFilter = (node: AstNode) => WalkerOption;
+
+export declare interface WalkResult {
     node: AstNode;
     parent?: AstRuleList;
     root?: AstRuleList;
-}>;
-declare function walkValues(values: Token[], parent?: Token): Generator<{
+}
+
+export declare interface WalkAttributesResult {
     value: Token;
-    parent: Token | null;
-}>;
+    parent: FunctionToken | ParensToken | null;
+}
 
-declare function expand(ast: AstNode): AstNode;
-declare function replaceCompound(input: string, replace: string): string;
+export declare interface ErrorDescription {
 
-declare const colorsFunc: string[];
-declare function render(data: AstNode, opt?: RenderOptions): RenderResult;
-declare function renderToken(token: Token, options?: RenderOptions, reducer?: (acc: string, curr: Token) => string, errors?: ErrorDescription[]): string;
+    // drop rule or declaration | fix rule or declaration
+    action: 'drop' | 'ignore';
+    message: string;
+    location?: {
+        src: string,
+        lin: number,
+        col: number;
+    };
+    error?: Error;
+}
 
-declare const urlTokenMatcher: RegExp;
-declare function parseString(src: string, options?: {
-    location: boolean;
-}): Token[];
+export declare interface MinifyFeature {
 
-declare function tokenize(iterator: string): Generator<TokenizeResult>;
-
-declare function isLength(dimension: DimensionToken): boolean;
-declare function isResolution(dimension: DimensionToken): boolean;
-declare function isAngle(dimension: DimensionToken): boolean;
-declare function isTime(dimension: DimensionToken): boolean;
-declare function isFrequency(dimension: DimensionToken): boolean;
-declare function isColor(token: Token): boolean;
-declare function isIdentStart(codepoint: number): boolean;
-declare function isDigit(codepoint: number): boolean;
-declare function isIdentCodepoint(codepoint: number): boolean;
-declare function isIdent(name: string): boolean;
-declare function isNonPrintable(codepoint: number): boolean;
-declare function isPseudo(name: string): boolean;
-declare function isHash(name: string): boolean;
-declare function isNumber(name: string): boolean;
-declare function isDimension(name: string): boolean;
-declare function isPercentage(name: string): boolean;
-declare function parseDimension(name: string): DimensionToken | LengthToken | AngleToken;
-declare function isHexColor(name: string): boolean;
-declare function isFunction(name: string): boolean;
-declare function isAtKeyword(name: string): boolean;
-declare function isNewLine(codepoint: number): boolean;
-declare function isWhiteSpace(codepoint: number): boolean;
-
-declare const getConfig: () => PropertiesConfig;
-
-declare const funcList: string[];
-declare function matchType(val: Token, properties: PropertyMapType): boolean;
+    ordering: number;
 
-declare function load(url: string, currentFile: string): Promise<string>;
+    register: (options: MinifyOptions | ParserOptions) => void;
+    run: (ast: AstRule | AstAtRule, options: ParserOptions = {}, parent: AstRule | AstAtRule | AstRuleStyleSheet, context: {
+        [key: string]: any
+    }) => void;
+    cleanup?: (ast: AstRuleStyleSheet, options: ParserOptions = {}, context: { [key: string]: any }) => void;
+}
+
+export declare interface ParserOptions extends PropertyListOptions {
+
+    minify?: boolean;
+    src?: string;
+    sourcemap?: boolean;
+    nestingRules?: boolean;
+    expandNestingRules?: boolean;
+    removeCharset?: boolean;
+    removeEmpty?: boolean;
+    resolveUrls?: boolean;
+    resolveImport?: boolean;
+    cwd?: string;
+    removeDuplicateDeclarations?: boolean;
+    computeShorthand?: boolean;
+    inlineCssVariables?: boolean;
+    computeCalcExpression?: boolean;
+    load?: (url: string, currentUrl: string) => Promise<string>;
+    dirname?: (path: string) => string;
+    resolve?: (url: string, currentUrl: string, currentWorkingDirectory?: string) => {
+        absolute: string;
+        relative: string;
+    };
+    visitor?: VisitorNodeMap;
+    signal?: AbortSignal;
+}
+
+export declare interface MinifyOptions extends ParserOptions {
+
+    features: MinifyFeature[];
+}
+
+export declare interface ResolvedPath {
+    absolute: string;
+    relative: string;
+}
+
+export declare interface RenderOptions {
+
+    minify?: boolean;
+    expandNestingRules?: boolean;
+    preserveLicense?: boolean;
+    sourcemap?: boolean;
+    indent?: string;
+    newLine?: string;
+    removeComments?: boolean;
+    colorConvert?: boolean;
+    output?: string;
+    cwd?: string;
+    load?: (url: string, currentUrl: string) => Promise<string>;
+    resolve?: (url: string, currentUrl: string, currentWorkingDirectory?: string) => ResolvedPath;
+
+}
+
+export declare interface TransformOptions extends ParserOptions, RenderOptions {
+
+}
+
+export declare interface ParseResult {
+    ast: AstRuleStyleSheet;
+    errors: ErrorDescription[];
+    stats: {
+        bytesIn: number;
+        parse: string;
+        minify: string;
+        total: string;
+    }
+}
+
+export declare interface RenderResult {
+    code: string;
+    errors: ErrorDescription[];
+    stats: {
+        total: string;
+    },
+    map?: SourceMapObject
+}
+
+export declare interface TransformResult extends ParseResult, RenderResult {
+
+    stats: {
+        bytesIn: number;
+        bytesOut: number;
+        parse: string;
+        minify: string;
+        render: string;
+        total: string;
+    }
+}
+
+export declare interface ParseTokenOptions extends ParserOptions {
+    parseColor?: boolean;
+}
+
+export declare interface SourceMapObject {
+    version: number;
+    file?: string;
+    sourceRoot?: string;
+    sources?: string[];
+    sourcesContent?: Array<string | null>;
+    names?: string[];
+    mappings: string;
+}
 
-declare const matchUrl: RegExp;
 declare function dirname(path: string): string;
 declare function resolve(url: string, currentDirectory: string, cwd?: string): {
     absolute: string;
     relative: string;
 };
 
+declare function load(url: string, currentFile: string): Promise<string>;
+
+declare function render(data: AstNode, options?: RenderOptions): RenderResult;
 declare function parse(iterator: string, opt?: ParserOptions): Promise<ParseResult>;
 declare function transform(css: string, options?: TransformOptions): Promise<TransformResult>;
 
-export { colorsFunc, combinators, dirname, expand, funcList, getConfig, hasDeclaration, isAngle, isAtKeyword, isColor, isDigit, isDimension, isFrequency, isFunction, isHash, isHexColor, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, load, matchType, matchUrl, minify, minifyRule, parse, parseDimension, parseString, reduceSelector, render, renderToken, replaceCompound, resolve, splitRule, tokenize, transform, urlTokenMatcher, walk, walkValues };
+export { EnumToken, dirname, expand, load, minify, parse, parseString, parseTokens, render, renderToken, resolve, transform, walk, walkValues };