@tbela99/css-parser 0.7.1 → 0.9.0

package/dist/index.d.ts

@@ -38,57 +38,66 @@ declare enum EnumToken {
     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,
-    FlexTokenType = 57,
-    ListToken = 58,
-    Add = 59,
-    Mul = 60,
-    Div = 61,
-    Sub = 62,
-    ColumnCombinatorTokenType = 63,
-    ContainMatchTokenType = 64,
-    StartMatchTokenType = 65,
-    EndMatchTokenType = 66,
-    MatchExpressionTokenType = 67,
-    NameSpaceAttributeTokenType = 68,
-    FractionTokenType = 69,
-    IdenListTokenType = 70,
-    GridTemplateFuncTokenType = 71,
-    KeyFrameRuleNodeType = 72,
-    ClassSelectorTokenType = 73,
-    UniversalSelectorTokenType = 74,
-    ChildCombinatorTokenType = 75,
-    DescendantCombinatorTokenType = 76,// whitespace
-    NextSiblingCombinatorTokenType = 77,
-    SubsequentSiblingCombinatorTokenType = 78,
-    NestingSelectorTokenType = 79,
-    InvalidRuleTokenType = 80,
-    InvalidClassSelectorTokenType = 81,
-    InvalidAttrTokenType = 82,
+    EqualMatchTokenType = 39,
+    LtTokenType = 40,
+    LteTokenType = 41,
+    GtTokenType = 42,
+    GteTokenType = 43,
+    PseudoClassTokenType = 44,
+    PseudoClassFuncTokenType = 45,
+    DelimTokenType = 46,
+    UrlTokenTokenType = 47,
+    EOFTokenType = 48,
+    ImportantTokenType = 49,
+    ColorTokenType = 50,
+    AttrTokenType = 51,
+    BadCommentTokenType = 52,
+    BadCdoTokenType = 53,
+    BadUrlTokenType = 54,
+    BadStringTokenType = 55,
+    BinaryExpressionTokenType = 56,
+    UnaryExpressionTokenType = 57,
+    FlexTokenType = 58,
+    ListToken = 59,
+    Add = 60,
+    Mul = 61,
+    Div = 62,
+    Sub = 63,
+    ColumnCombinatorTokenType = 64,
+    ContainMatchTokenType = 65,
+    StartMatchTokenType = 66,
+    EndMatchTokenType = 67,
+    MatchExpressionTokenType = 68,
+    NameSpaceAttributeTokenType = 69,
+    FractionTokenType = 70,
+    IdenListTokenType = 71,
+    GridTemplateFuncTokenType = 72,
+    KeyFrameRuleNodeType = 73,
+    ClassSelectorTokenType = 74,
+    UniversalSelectorTokenType = 75,
+    ChildCombinatorTokenType = 76,// >
+    DescendantCombinatorTokenType = 77,// whitespace
+    NextSiblingCombinatorTokenType = 78,// +
+    SubsequentSiblingCombinatorTokenType = 79,// ~
+    NestingSelectorTokenType = 80,// &
+    InvalidRuleTokenType = 81,
+    InvalidClassSelectorTokenType = 82,
+    InvalidAttrTokenType = 83,
+    InvalidAtRuleTokenType = 84,
+    MediaQueryConditionTokenType = 85,
+    MediaFeatureTokenType = 86,
+    MediaFeatureOnlyTokenType = 87,
+    MediaFeatureNotTokenType = 88,
+    MediaFeatureAndTokenType = 89,
+    MediaFeatureOrTokenType = 90,
+    PseudoPageTokenType = 91,
     Time = 25,
     Iden = 7,
-    EOF = 47,
+    EOF = 48,
     Hash = 28,
-    Flex = 57,
+    Flex = 58,
     Angle = 24,
-    Color = 49,
+    Color = 50,
     Comma = 9,
     String = 20,
     Length = 23,
@@ -101,9 +110,9 @@ declare enum EnumToken {
     Frequency = 26,
     Resolution = 27,
     Whitespace = 36,
-    IdenList = 70,
+    IdenList = 71,
     DashedIden = 8,
-    GridTemplateFunc = 71,
+    GridTemplateFunc = 72,
     ImageFunc = 19,
     CommentNodeType = 0,
     CDOCOMMNodeType = 1,
@@ -111,22 +120,73 @@ declare enum EnumToken {
     TimelineFunction = 16
 }
 
+/**
+ * minify ast
+ * @param ast
+ * @param options
+ * @param recursive
+ * @param errors
+ * @param nestingContent
+ * @param context
+ */
 declare function minify(ast: AstNode, options?: ParserOptions | MinifyOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean, context?: {
     [key: string]: any;
 }): AstNode;
 
+declare enum WalkerValueEvent {
+    Enter = 0,
+    Leave = 1
+}
+/**
+ * walk ast nodes
+ * @param node
+ * @param filter
+ */
 declare function walk(node: AstNode, filter?: WalkerFilter): Generator<WalkResult>;
-declare function walkValues(values: Token[], root?: AstNode | null, filter?: WalkerValueFilter): Generator<WalkAttributesResult>;
+/**
+ * walk ast values
+ * @param values
+ * @param root
+ * @param filter
+ * @param reverse
+ */
+declare function walkValues(values: Token[], root?: AstNode | Token | null, filter?: WalkerValueFilter | {
+    event: WalkerValueEvent;
+    fn?: WalkerValueFilter;
+    type?: EnumToken | EnumToken[] | ((token: Token) => boolean);
+}, reverse?: boolean): Generator<WalkAttributesResult>;
 
+/**
+ * expand nested css ast
+ * @param ast
+ */
 declare function expand(ast: AstNode): AstNode;
 
+/**
+ * render ast token
+ * @param token
+ * @param options
+ * @param cache
+ * @param reducer
+ * @param errors
+ */
 declare function renderToken(token: Token, options?: RenderOptions, cache?: {
     [key: string]: any;
 }, reducer?: (acc: string, curr: Token) => string, errors?: ErrorDescription[]): string;
 
+/**
+ * parse string
+ * @param src
+ * @param options
+ */
 declare function parseString(src: string, options?: {
     location: boolean;
 }): Token[];
+/**
+ * parse token list
+ * @param tokens
+ * @param options
+ */
 declare function parseTokens(tokens: Token[], options?: ParseTokenOptions): Token[];
 
 export declare interface LiteralToken extends BaseToken {
@@ -201,6 +261,7 @@ export declare interface AtRuleToken extends BaseToken {
 
     typ: EnumToken.AtRuleTokenType,
     val: string;
+    pre: string;
 }
 
 export declare interface PercentageToken extends BaseToken {
@@ -401,6 +462,12 @@ export declare interface DashMatchToken extends BaseToken {
     // val: '|=';
 }
 
+export declare interface EqualMatchToken extends BaseToken {
+
+    typ: EnumToken.EqualMatchTokenType;
+    // val: '|=';
+}
+
 export declare interface StartMatchToken extends BaseToken {
 
     typ: EnumToken.StartMatchTokenType;
@@ -450,6 +517,12 @@ export declare interface PseudoClassToken extends BaseToken {
     val: string;
 }
 
+export declare interface PseudoPageToken extends BaseToken {
+
+    typ: EnumToken.PseudoPageTokenType;
+    val: string;
+}
+
 export declare interface PseudoClassFunctionToken extends BaseToken {
 
     typ: EnumToken.PseudoClassFuncTokenType;
@@ -531,6 +604,42 @@ export declare interface ChildCombinatorToken extends BaseToken {
     typ: EnumToken.ChildCombinatorTokenType
 }
 
+export declare interface MediaFeatureToken extends BaseToken {
+
+    typ: EnumToken.MediaFeatureTokenType,
+    val: string;
+}
+
+export declare interface MediaFeatureNotToken extends BaseToken {
+
+    typ: EnumToken.MediaFeatureNotTokenType,
+    val: Token;
+}
+
+export declare interface MediaFeatureOnlyToken extends BaseToken {
+
+    typ: EnumToken.MediaFeatureOnlyTokenType,
+    val: Token;
+}
+
+export declare interface MediaFeatureAndToken extends BaseToken {
+
+    typ: EnumToken.MediaFeatureAndTokenType;
+}
+
+export declare interface MediaFeatureOrToken extends BaseToken {
+
+    typ: EnumToken.MediaFeatureOrTokenType;
+}
+
+export declare interface MediaQueryConditionToken extends BaseToken {
+
+    typ: EnumToken.MediaQueryConditionTokenType,
+    l: Token,
+    op: ColonToken | GreaterThanToken | LessThanToken | GreaterThanOrEqualToken | LessThanOrEqualToken,
+    r: Token[]
+}
+
 export declare interface DescendantCombinatorToken extends BaseToken {
 
     typ: EnumToken.DescendantCombinatorTokenType
@@ -591,7 +700,7 @@ export declare interface BinaryExpressionToken extends BaseToken {
 export declare interface MatchExpressionToken extends BaseToken {
 
     typ: EnumToken.MatchExpressionTokenType
-    op: EnumToken.DashMatchTokenType | EnumToken.StartMatchTokenType | EnumToken.ContainMatchTokenType | EnumToken.EndMatchTokenType | EnumToken.IncludeMatchTokenType;
+    op: EqualMatchToken | DashMatchToken | StartMatchToken | ContainMatchToken | EndMatchToken | IncludeMatchToken;
     l: Token;
     r: Token;
     attr?: 'i' | 's';
@@ -642,6 +751,14 @@ export declare type Token =
     | ColumnCombinatorToken
     | NestingSelectorToken
     |
+    MediaQueryConditionToken
+    | MediaFeatureToken
+    | MediaFeatureNotToken
+    | MediaFeatureOnlyToken
+    | MediaFeatureAndToken
+    | MediaFeatureOrToken
+    | AstDeclaration
+    |
     NumberToken
     | AtRuleToken
     | PercentageToken
@@ -686,6 +803,7 @@ export declare type Token =
     | NameSpaceAttributeToken
     |
     DashMatchToken
+    | EqualMatchToken
     | LessThanToken
     | LessThanOrEqualToken
     | GreaterThanToken
@@ -693,6 +811,7 @@ export declare type Token =
     |
     ListToken
     | PseudoClassToken
+    | PseudoPageToken
     | PseudoClassFunctionToken
     | DelimToken
     | BinaryExpressionToken
@@ -729,6 +848,8 @@ export declare interface BaseToken {
 
     typ: EnumToken;
     loc?: Location;
+    tokens?: Token[];
+    parent?: AstRuleList;
 }
 
 export declare interface AstComment extends BaseToken {
@@ -754,6 +875,32 @@ export declare interface AstRule extends BaseToken {
     raw?: RawSelectorTokens;
 }
 
+export declare interface AstInvalidRule extends BaseToken {
+
+    typ: EnumToken.InvalidRuleTokenType;
+    sel: string;
+    chi: Array<AstDeclaration | AstComment | AstRuleList>;
+}
+
+export declare interface AstInvalidAtRule extends BaseToken {
+
+    typ: EnumToken.InvalidAtRuleTokenType;
+    val: string;
+    chi?: Array<AstNode>;
+}
+
+
+
+export declare interface AstKeyFrameRule extends BaseToken {
+
+    typ: EnumToken.KeyFrameRuleNodeType;
+    sel: string;
+    chi: Array<AstDeclaration | AstComment>;
+    optimized?: OptimizedSelector;
+    raw?: RawSelectorTokens;
+    tokens?: Token[]
+}
+
 export declare type RawSelectorTokens = string[][];
 
 export declare interface OptimizedSelector {
@@ -765,7 +912,7 @@ export declare interface OptimizedSelector {
 
 export declare interface AstAtRule extends BaseToken {
 
-    typ: AtRuleNodeType,
+    typ: EnumToken.AtRuleNodeType,
     nam: string;
     val: string;
     chi?: Array<AstDeclaration | AstComment> | Array<AstRule | AstComment>
@@ -773,12 +920,12 @@ export declare interface AstAtRule extends BaseToken {
 
 export declare interface AstRuleList extends BaseToken {
 
-    typ: StyleSheetNodeType | RuleNodeType | AtRuleNodeType,
-    chi: Array<BaseToken | AstComment>
+    typ:  EnumToken.StyleSheetNodeType |  EnumToken.RuleNodeType |  EnumToken.AtRuleNodeType,
+    chi: Array<BaseToken | AstComment>;
 }
 
 export declare interface AstRuleStyleSheet extends AstRuleList {
-    typ: StyleSheetNodeType,
+    typ:  EnumToken.StyleSheetNodeType,
     chi: Array<AstRuleList | AstComment>
 }
 
@@ -788,7 +935,10 @@ export declare type AstNode =
     | AstComment
     | AstAtRule
     | AstRule
-    | AstDeclaration;
+    | AstDeclaration
+    | AstKeyFrameRule
+    | AstInvalidRule
+    | AstInvalidAtRule;
 
 /**
  * Declaration visitor handler
@@ -826,7 +976,13 @@ declare class SourceMap {
     toJSON(): SourceMapObject;
 }
 
-export declare type WalkerOption = 'ignore' | 'stop' | 'children' | 'ignore-children' | null;
+export declare interface PropertyListOptions {
+
+    removeDuplicateDeclarations?: boolean;
+    computeShorthand?: boolean;
+}
+
+export declare type WalkerOption = 'ignore' | 'stop' | 'children' | 'ignore-children' | Token | null;
 /**
  * returned value:
  * - 'ignore': ignore this node and its children
@@ -843,20 +999,21 @@ export declare type WalkerFilter = (node: AstNode) => WalkerOption;
  * - 'children': walk the children and ignore the node itself
  * - 'ignore-children': walk the node and ignore children
  */
-export declare type WalkerValueFilter = (node: Token) => WalkerOption;
+export declare type WalkerValueFilter = (node: AstNode | Token, parent: FunctionToken | ParensToken | BinaryExpressionToken, event?: WalkerValueEvent) => WalkerOption | null;
 
 export declare interface WalkResult {
     node: AstNode;
     parent?: AstRuleList;
-    root?: AstRuleList;
+    root?: AstNode;
 }
 
 export declare interface WalkAttributesResult {
     value: Token;
     previousValue: Token | null;
-    nextValue: AstNode | null;
+    nextValue: Token | null;
     root?: AstNode;
     parent: FunctionToken | ParensToken | BinaryExpressionToken | null;
+    list: Token[] | null;
 }
 
 export declare interface ErrorDescription {
@@ -875,6 +1032,7 @@ export declare interface ErrorDescription {
 interface ValidationOptions {
 
     validation?: boolean;
+    lenient?: boolean;
 }
 
 export declare interface ParserOptions extends ValidationOptions, PropertyListOptions {
@@ -925,9 +1083,7 @@ export declare interface MinifyFeature {
 export declare interface MinifyFeature {
 
     ordering: number;
-
     register: (options: MinifyOptions | ParserOptions) => void;
-
     run: (ast: AstRule | AstAtRule, options: ParserOptions, parent: AstRule | AstAtRule | AstRuleStyleSheet, context: {
         [key: string]: any
     }) => void;
@@ -941,6 +1097,8 @@ export declare interface ResolvedPath {
 export declare interface RenderOptions {
 
     minify?: boolean;
+    beautify?: boolean;
+    removeEmpty?: boolean;
     expandNestingRules?: boolean;
     preserveLicense?: boolean;
     sourcemap?: boolean;
@@ -953,7 +1111,6 @@ export declare interface RenderOptions {
     cwd?: string;
     load?: (url: string, currentUrl: string) => Promise<string>;
     resolve?: (url: string, currentUrl: string, currentWorkingDirectory?: string) => ResolvedPath;
-
 }
 
 export declare interface TransformOptions extends ParserOptions, RenderOptions {
@@ -1013,11 +1170,6 @@ declare function resolve(url: string, currentDirectory: string, cwd?: string): {
 
 declare function load(url: string, currentFile: string): Promise<string>;
 
-/**
- * entry point for node and other runtimes
- * @module
- */
-
 /**
  * render ast node
  */

package/dist/lib/ast/expand.js

@@ -6,6 +6,10 @@ import { renderToken } from '../renderer/render.js';
 import '../renderer/color/utils/constants.js';
 import '../parser/utils/config.js';
 
+/**
+ * expand nested css ast
+ * @param ast
+ */
 function expand(ast) {
     //
     if (![EnumToken.RuleNodeType, EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType].includes(ast.typ)) {
@@ -34,6 +38,7 @@ function expand(ast) {
             let hasRule = false;
             let j = node.chi.length;
             while (j--) {
+                // @ts-ignore
                 if (node.chi[j].typ == EnumToken.RuleNodeType || node.chi[j].typ == EnumToken.AtRuleNodeType) {
                     hasRule = true;
                     break;
@@ -72,20 +77,21 @@ function expandRule(node) {
                     }
                 }
                 else {
-                    let childSelectorCompund = [];
+                    let childSelectorCompound = [];
                     let withCompound = [];
                     let withoutCompound = [];
                     const rules = splitRule(ast.sel);
+                    const parentSelector = !node.sel.includes('&');
                     for (const sel of (rule.raw ?? splitRule(rule.sel))) {
                         const s = sel.join('');
-                        if (s.includes('&')) {
+                        if (s.includes('&') || parentSelector) {
                             if (s.indexOf('&', 1) == -1) {
                                 if (s.at(0) == '&') {
                                     if (s.at(1) == ' ') {
-                                        childSelectorCompund.push(s.slice(2));
+                                        childSelectorCompound.push(s.slice(2));
                                     }
                                     else {
-                                        if (s == '&') {
+                                        if (s == '&' || parentSelector) {
                                             withCompound.push(s);
                                         }
                                         else {
@@ -93,6 +99,9 @@ function expandRule(node) {
                                         }
                                     }
                                 }
+                                else {
+                                    withoutCompound.push(s);
+                                }
                             }
                             else {
                                 withCompound.push(s);
@@ -104,12 +113,18 @@ function expandRule(node) {
                     }
                     const selectors = [];
                     const selector = rules.length > 1 ? ':is(' + rules.map(a => a.join('')).join(',') + ')' : rules[0].join('');
-                    if (childSelectorCompund.length > 0) {
-                        if (childSelectorCompund.length == 1) {
-                            selectors.push(replaceCompound('& ' + childSelectorCompund[0].trim(), selector));
+                    if (childSelectorCompound.length > 0) {
+                        if (childSelectorCompound.length == 1) {
+                            selectors.push(replaceCompound('& ' + childSelectorCompound[0].trim(), selector));
                         }
                         else {
-                            selectors.push(replaceCompound('& :is(' + childSelectorCompund.reduce((acc, curr) => acc + (acc.length > 0 ? ',' : '') + curr.trim(), '') + ')', selector));
+                            selectors.push(replaceCompound('& :is(' + childSelectorCompound.reduce((acc, curr) => acc + (acc.length > 0 ? ',' : '') + curr.trim(), '') + ')', selector));
+                        }
+                    }
+                    if (withCompound.length > 0) {
+                        if (withCompound.every((t) => t[0] == '&' && t.indexOf('&', 1) == -1)) {
+                            withoutCompound.push(...withCompound.map(t => t.slice(1)));
+                            withCompound.length = 0;
                         }
                     }
                     if (withoutCompound.length > 0) {
@@ -144,7 +159,10 @@ function expandRule(node) {
                     if (astAtRule.val.includes('&')) {
                         astAtRule.val = replaceCompound(astAtRule.val, ast.sel);
                     }
-                    astAtRule = expand(astAtRule);
+                    const slice = astAtRule.chi.slice().filter(t => t.typ == EnumToken.RuleNodeType && t.sel.includes('&'));
+                    if (slice.length > 0) {
+                        expandRule({ ...node, chi: astAtRule.chi.slice() });
+                    }
                 }
                 else {
                     // @ts-ignore
@@ -183,11 +201,30 @@ function expandRule(node) {
     // @ts-ignore
     return ast.chi.length > 0 ? [ast].concat(result) : result;
 }
+/**
+ * replace compound selector
+ * @param input
+ * @param replace
+ */
 function replaceCompound(input, replace) {
     const tokens = parseString(input);
+    let replacement = null;
     for (const t of walkValues(tokens)) {
         if (t.value.typ == EnumToken.LiteralTokenType) {
             if (t.value.val == '&') {
+                if (tokens.length == 2) {
+                    if (replacement == null) {
+                        replacement = parseString(replace);
+                    }
+                    if (tokens[1].typ == EnumToken.IdenTokenType) {
+                        t.value.val = replacement.length == 1 || (!replace.includes(' ') && replace.charAt(0).match(/[:.]/)) ? tokens[1].val + replace : replaceCompoundLiteral(tokens[1].val + '&', replace);
+                        tokens.splice(1, 1);
+                    }
+                    else {
+                        t.value.val = replaceCompoundLiteral(t.value.val, replace);
+                    }
+                    continue;
+                }
                 const rule = splitRule(replace);
                 t.value.val = rule.length > 1 ? ':is(' + replace + ')' : replace;
             }