@tbela99/css-parser 1.0.0 → 1.1.1-alpha4

package/dist/index.d.ts

@@ -1,3 +1,23 @@
+/**
+ * validation level enum
+ */
+declare enum ValidationLevel {
+    /**
+     * disable validation
+     */
+    None = 0,
+    /**
+     * validate selectors and at-rules
+     */
+    Default = 1,// selectors + at-rules
+    /**
+     * validate selectors, at-rules and declarations
+     */
+    All = 2
+}
+/**
+ * token types enum
+ */
 declare enum EnumToken {
     CommentTokenType = 0,
     CDOCOMMTokenType = 1,
@@ -93,6 +113,7 @@ declare enum EnumToken {
     PseudoPageTokenType = 91,
     PseudoElementTokenType = 92,
     KeyframeAtRuleNodeType = 93,
+    InvalidDeclarationNodeType = 94,
     Time = 25,
     Iden = 7,
     EOF = 48,
@@ -131,7 +152,7 @@ declare enum EnumToken {
  * @param nestingContent
  * @param context
  */
-declare function minify(ast: AstNode, options?: ParserOptions | MinifyFeatureOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean, context?: {
+declare function minify(ast: AstNode, options?: ParserOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean, context?: {
     [key: string]: any;
 }): AstNode;
 
@@ -152,7 +173,7 @@ declare enum WalkerValueEvent {
  */
 declare function walk(node: AstNode, filter?: WalkerFilter): Generator<WalkResult>;
 /**
- * walk ast values
+ * walk ast node value tokens
  * @param values
  * @param root
  * @param filter
@@ -182,8 +203,37 @@ declare function renderToken(token: Token, options?: RenderOptions, cache?: {
     [key: string]: any;
 }, reducer?: (acc: string, curr: Token) => string, errors?: ErrorDescription[]): string;
 
+declare enum ColorKind {
+    SYS = 0,
+    DPSYS = 1,
+    LIT = 2,
+    HEX = 3,
+    RGB = 4,
+    RGBA = 5,
+    HSL = 6,
+    HSLA = 7,
+    HWB = 8,
+    DEVICE_CMYK = 9,
+    OKLAB = 10,
+    OKLCH = 11,
+    LAB = 12,
+    LCH = 13,
+    COLOR = 14,
+    SRGB = 15,
+    PROPHOTO_RGB = 16,
+    A98_RGB = 17,
+    REC2020 = 18,
+    DISPLAY_P3 = 19,
+    SRGB_LINEAR = 20,
+    XYZ = 21,
+    XYZ_D50 = 22,
+    XYZ_D65 = 23,
+    LIGHT_DARK = 24,
+    COLOR_MIX = 25
+}
+
 /**
- * parse string
+ * parse css string
  * @param src
  * @param options
  */
@@ -191,7 +241,7 @@ declare function parseString(src: string, options?: {
     location: boolean;
 }): Token[];
 /**
- * parse token list
+ * parse token array into a tree structure
  * @param tokens
  * @param options
  */
@@ -571,26 +621,6 @@ export declare interface ImportantToken extends BaseToken {
     typ: EnumToken.ImportantTokenType;
 }
 
-export declare type ColorKind =
-    'sys'
-    | 'dpsys'
-    | 'lit'
-    | 'hex'
-    | 'rgb'
-    | 'rgba'
-    | 'hsl'
-    | 'hsla'
-    | 'hwb'
-    | 'device-cmyk'
-    | 'oklab'
-    | 'oklch'
-    | 'lab'
-    | 'lch'
-    | 'color'
-    | 'light-dark';
-
-// export declare type HueInterpolationMethod = 'shorter' | 'longer' | 'increasing' | 'decreasing';
-
 export declare interface ColorToken extends BaseToken {
 
     typ: EnumToken.ColorTokenType;
@@ -845,6 +875,69 @@ export declare type Token =
     | AttrToken
     | EOFToken;
 
+declare enum ValidationTokenEnum {
+    Root = 0,
+    Keyword = 1,
+    PropertyType = 2,
+    DeclarationType = 3,
+    AtRule = 4,
+    ValidationFunctionDefinition = 5,
+    OpenBracket = 6,
+    CloseBracket = 7,
+    OpenParenthesis = 8,
+    CloseParenthesis = 9,
+    Comma = 10,
+    Pipe = 11,
+    Column = 12,
+    Star = 13,
+    OpenCurlyBrace = 14,
+    CloseCurlyBrace = 15,
+    HashMark = 16,
+    QuestionMark = 17,
+    Function = 18,
+    Number = 19,
+    Whitespace = 20,
+    Parenthesis = 21,
+    Bracket = 22,
+    Block = 23,
+    AtLeastOnce = 24,
+    Separator = 25,
+    Exclamation = 26,
+    Ampersand = 27,
+    PipeToken = 28,
+    ColumnToken = 29,
+    AmpersandToken = 30,
+    Parens = 31,
+    PseudoClassToken = 32,
+    PseudoClassFunctionToken = 33,
+    StringToken = 34,
+    AtRuleDefinition = 35,
+    DeclarationNameToken = 36,
+    DeclarationDefinitionToken = 37,
+    SemiColon = 38,
+    Character = 39,
+    InfinityToken = 40
+}
+interface Position$1 {
+    ind: number;
+    lin: number;
+    col: number;
+}
+interface ValidationToken {
+    typ: ValidationTokenEnum;
+    pos: Position$1;
+    isList?: boolean;
+    text?: string;
+    isRepeatable?: boolean;
+    atLeastOnce?: boolean;
+    isOptional?: boolean;
+    isRepeatableGroup?: boolean;
+    occurence?: {
+        min: number;
+        max: number | null;
+    };
+}
+
 export declare interface Position {
 
     ind: number;
@@ -855,7 +948,7 @@ export declare interface Position {
 export declare interface Location {
 
     sta: Position;
-    // end: Position;
+    end: Position;
     src: string;
 }
 
@@ -865,6 +958,7 @@ export declare interface BaseToken {
     loc?: Location;
     tokens?: Token[];
     parent?: AstRuleList;
+    validSyntax?: boolean;
 }
 
 export declare interface AstComment extends BaseToken {
@@ -885,8 +979,8 @@ export declare interface AstRule extends BaseToken {
     typ: EnumToken.RuleNodeType;
     sel: string;
     chi: Array<AstDeclaration | AstComment | AstRuleList>;
-    optimized?: OptimizedSelector;
-    raw?: RawSelectorTokens;
+    optimized?: OptimizedSelector | null;
+    raw?: RawSelectorTokens | null;
 }
 
 export declare interface AstInvalidRule extends BaseToken {
@@ -896,11 +990,10 @@ export declare interface AstInvalidRule extends BaseToken {
     chi: Array<AstNode>;
 }
 
-export declare interface AstInvalidAtRule extends BaseToken {
+export declare interface AstInvalidDeclaration extends BaseToken {
 
-    typ: EnumToken.InvalidAtRuleTokenType;
-    val: string;
-    chi?: Array<AstNode>;
+    typ: EnumToken.InvalidDeclarationNodeType;
+    val: Array<AstNode>;
 }
 
 export declare interface AstKeyFrameRule extends BaseToken {
@@ -927,14 +1020,14 @@ export declare interface AstAtRule extends BaseToken {
     typ: EnumToken.AtRuleNodeType,
     nam: string;
     val: string;
-    chi?: Array<AstDeclaration | AstComment> | Array<AstRule | AstComment>
+    chi?: Array<AstDeclaration | AstInvalidDeclaration | AstComment> | Array<AstRule | AstComment>
 }
 
 export declare interface AstKeyframeRule extends BaseToken {
 
     typ: EnumToken.KeyFrameRuleNodeType;
     sel: string;
-    chi: Array<AstDeclaration | AstComment | AstRuleList>;
+    chi: Array<AstDeclaration | AstInvalidDeclaration | AstComment | AstRuleList>;
     optimized?: OptimizedSelector;
     raw?: RawSelectorTokens;
 }
@@ -949,7 +1042,7 @@ export declare interface AstKeyframAtRule extends BaseToken {
 
 export declare interface AstRuleList extends BaseToken {
 
-    typ: EnumToken.StyleSheetNodeType | EnumToken.RuleNodeType | EnumToken.AtRuleNodeType | EnumToken.KeyframeAtRuleNodeType | EnumToken.KeyFrameRuleNodeType,
+    typ: EnumToken.StyleSheetNodeType | EnumToken.RuleNodeType | EnumToken.AtRuleNodeType | EnumToken.KeyframeAtRuleNodeType | EnumToken.KeyFrameRuleNodeType | EnumToken.InvalidRuleTokenType | EnumToken.InvalidAtRuleTokenType,
     chi: Array<BaseToken | AstComment>;
 }
 
@@ -968,7 +1061,7 @@ export declare type AstNode =
     | AstKeyframAtRule
     | AstKeyFrameRule
     | AstInvalidRule
-    | AstInvalidAtRule;
+    | AstInvalidDeclaration;
 
 /**
  * Declaration visitor handler
@@ -1012,6 +1105,11 @@ export declare interface PropertyListOptions {
     computeShorthand?: boolean;
 }
 
+declare enum FeatureWalkMode {
+    Pre = 0,
+    Post = 1
+}
+
 export declare type WalkerOption = WalkerOptionEnum | Token | null;
 /**
  * returned value:
@@ -1042,7 +1140,7 @@ export declare interface WalkAttributesResult {
     previousValue: Token | null;
     nextValue: Token | null;
     root?: AstNode;
-    parent: FunctionToken | ParensToken | BinaryExpressionToken | null;
+    parent: AstNode | Token | null;
     list: Token[] | null;
 }
 
@@ -1051,24 +1149,27 @@ export declare interface ErrorDescription {
     // drop rule or declaration | fix rule or declaration
     action: 'drop' | 'ignore';
     message: string;
-    location?: {
-        src: string,
-        lin: number,
-        col: number;
-    };
+    syntax?: string;
+    location?: Location;
     error?: Error;
     rawTokens?: TokenizeResult[];
 }
 
 interface ValidationOptions {
 
-    validation?: boolean;
+    validation?: boolean | ValidationLevel;
     lenient?: boolean;
+    visited?: WeakMap<Token, Map<string, Set<ValidationToken>>>;
+    isRepeatable?:boolean | null;
+    isList?:boolean | null;
+    occurence?:boolean | null;
+    atLeastOnce?: boolean | null;
 }
 
 interface MinifyOptions {
 
     minify?: boolean;
+    parseColor?: boolean;
     nestingRules?: boolean;
     expandNestingRules?: boolean;
     removeDuplicateDeclarations?: boolean;
@@ -1080,15 +1181,14 @@ interface MinifyOptions {
     pass?: number;
 }
 
-export declare interface ParserOptions extends MinifyOptions, ValidationOptions, PropertyListOptions {
+export declare interface ParserOptions extends MinifyOptions, MinifyFeatureOptions, ValidationOptions, PropertyListOptions {
 
     src?: string;
-    sourcemap?: boolean;
+    sourcemap?: boolean | 'inline';
     removeCharset?: boolean;
     resolveUrls?: boolean;
     resolveImport?: boolean;
     cwd?: string;
-    parseColor?: boolean;
     removePrefix?: boolean;
     load?: (url: string, currentUrl: string) => Promise<string>;
     dirname?: (path: string) => string;
@@ -1099,11 +1199,12 @@ export declare interface ParserOptions extends MinifyOptions, ValidationOptions,
     visitor?: VisitorNodeMap;
     signal?: AbortSignal;
     setParent?: boolean;
+    cache?: WeakMap<AstNode, string>;
 }
 
-export declare interface MinifyFeatureOptions extends ParserOptions {
+export declare interface MinifyFeatureOptions  {
 
-    features: MinifyFeature[];
+    features?: MinifyFeature[];
 }
 
 export declare interface MinifyFeature {
@@ -1120,10 +1221,12 @@ export declare interface MinifyFeature {
 export declare interface MinifyFeature {
 
     ordering: number;
+    preProcess: boolean;
+    postProcess: boolean;
     register: (options: MinifyFeatureOptions | ParserOptions) => void;
     run: (ast: AstRule | AstAtRule, options: ParserOptions, parent: AstRule | AstAtRule | AstRuleStyleSheet, context: {
         [key: string]: any
-    }) => void;
+    }, mode: FeatureWalkMode) => void;
 }
 
 export declare interface ResolvedPath {
@@ -1138,7 +1241,7 @@ export declare interface RenderOptions {
     removeEmpty?: boolean;
     expandNestingRules?: boolean;
     preserveLicense?: boolean;
-    sourcemap?: boolean;
+    sourcemap?: boolean | 'inline';
     indent?: string;
     newLine?: string;
     removeComments?: boolean;
@@ -1154,15 +1257,20 @@ export declare interface TransformOptions extends ParserOptions, RenderOptions {
 
 }
 
+export declare interface ParseResultStats {
+    src: string;
+    bytesIn: number;
+    importedBytesIn: number;
+    parse: string;
+    minify: string;
+    total: string;
+    imports: ParseResultStats[]
+}
+
 export declare interface ParseResult {
     ast: AstRuleStyleSheet;
     errors: ErrorDescription[];
-    stats: {
-        bytesIn: number;
-        parse: string;
-        minify: string;
-        total: string;
-    }
+    stats: ParseResultStats
 }
 
 export declare interface RenderResult {
@@ -1177,12 +1285,15 @@ export declare interface RenderResult {
 export declare interface TransformResult extends ParseResult, RenderResult {
 
     stats: {
+        src: string;
         bytesIn: number;
         bytesOut: number;
+        importedBytesIn: number;
         parse: string;
         minify: string;
         render: string;
         total: string;
+        imports: ParseResultStats[];
     }
 }
 
@@ -1193,7 +1304,8 @@ export declare interface TokenizeResult {
     token: string;
     len: number;
     hint?: EnumToken;
-    position: Position;
+    sta: Position;
+    end: Position;
     bytesIn: number;
 }
 
@@ -1207,12 +1319,27 @@ export declare interface SourceMapObject {
     mappings: string;
 }
 
+/**
+ * return the directory name of a path
+ * @param path
+ */
 declare function dirname(path: string): string;
+/**
+ * resolve path
+ * @param url
+ * @param currentDirectory
+ * @param cwd
+ */
 declare function resolve(url: string, currentDirectory: string, cwd?: string): {
     absolute: string;
     relative: string;
 };
 
+/**
+ * load file
+ * @param url
+ * @param currentFile
+ */
 declare function load(url: string, currentFile?: string): Promise<string>;
 
 /**
@@ -1228,4 +1355,4 @@ declare function parse(iterator: string, opt?: ParserOptions): Promise<ParseResu
  */
 declare function transform(css: string, options?: TransformOptions): Promise<TransformResult>;
 
-export { EnumToken, dirname, expand, load, minify, parse, parseString, parseTokens, render, renderToken, resolve, transform, walk, walkValues };
+export { EnumToken, ValidationLevel, dirname, expand, load, minify, parse, parseString, parseTokens, render, renderToken, resolve, transform, walk, walkValues };

package/dist/lib/ast/expand.js

@@ -1,10 +1,11 @@
 import { splitRule, combinators } from './minify.js';
 import { parseString } from '../parser/parse.js';
+import '../parser/tokenize.js';
+import '../parser/utils/config.js';
 import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
 import { renderToken } from '../renderer/render.js';
 import '../renderer/color/utils/constants.js';
-import '../parser/utils/config.js';
 
 /**
  * expand nested css ast

package/dist/lib/ast/features/calc.js

@@ -2,12 +2,23 @@ import { EnumToken } from '../types.js';
 import { walkValues, WalkerValueEvent, WalkerOptionEnum } from '../walk.js';
 import { evaluate } from '../math/expression.js';
 import { renderToken } from '../../renderer/render.js';
+import '../../renderer/color/utils/constants.js';
+import '../minify.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
 import { mathFuncs } from '../../syntax/syntax.js';
 
 class ComputeCalcExpressionFeature {
-    static get ordering() {
+    get ordering() {
         return 1;
     }
+    get preProcess() {
+        return false;
+    }
+    get postProcess() {
+        return true;
+    }
     static register(options) {
         if (options.computeCalcExpression) {
             // @ts-ignore

package/dist/lib/ast/features/inlinecssvariables.js

@@ -1,10 +1,35 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
 import { renderToken } from '../../renderer/render.js';
+import '../../renderer/color/utils/constants.js';
+import { splitRule } from '../minify.js';
+import '../../parser/parse.js';
+import '../../parser/tokenize.js';
+import '../../parser/utils/config.js';
+import { mathFuncs } from '../../syntax/syntax.js';
 
+function inlineExpression(token) {
+    const result = [];
+    if (token.typ == EnumToken.BinaryExpressionTokenType) {
+        result.push({
+            typ: EnumToken.ParensTokenType,
+            chi: [...inlineExpression(token.l), { typ: token.op }, ...inlineExpression(token.r)]
+        });
+    }
+    else {
+        result.push(token);
+    }
+    return result;
+}
 function replace(node, variableScope) {
     for (const { value, parent: parentValue } of walkValues(node.val)) {
-        if (value?.typ == EnumToken.FunctionTokenType && value.val == 'var') {
+        if (value.typ == EnumToken.BinaryExpressionTokenType && parentValue != null && 'chi' in parentValue) {
+            // @ts-ignore
+            parentValue.chi.splice(parentValue.chi.indexOf(value), 1, ...inlineExpression(value));
+        }
+    }
+    for (const { value, parent: parentValue } of walkValues(node.val)) {
+        if (value.typ == EnumToken.FunctionTokenType && value.val == 'var') {
             if (value.chi.length == 1 && value.chi[0].typ == EnumToken.DashedIdenTokenType) {
                 const info = variableScope.get(value.chi[0].val);
                 if (info?.replaceable) {
@@ -26,9 +51,15 @@ function replace(node, variableScope) {
     }
 }
 class InlineCssVariablesFeature {
-    static get ordering() {
+    get ordering() {
         return 0;
     }
+    get preProcess() {
+        return true;
+    }
+    get postProcess() {
+        return false;
+    }
     static register(options) {
         if (options.inlineCssVariables) {
             // @ts-ignore
@@ -36,18 +67,19 @@ class InlineCssVariablesFeature {
         }
     }
     run(ast, options = {}, parent, context) {
+        if (!('chi' in ast)) {
+            return;
+        }
         if (!('variableScope' in context)) {
             context.variableScope = new Map;
         }
-        const isRoot = parent.typ == EnumToken.StyleSheetNodeType && ast.typ == EnumToken.RuleNodeType && [':root', 'html'].includes(ast.sel);
+        // [':root', 'html']
+        const isRoot = parent.typ == EnumToken.StyleSheetNodeType && ast.typ == EnumToken.RuleNodeType && (ast.raw ?? splitRule(ast.sel)).some(segment => segment.some(s => s == ':root' || s == 'html'));
         const variableScope = context.variableScope;
         // @ts-ignore
         for (const node of ast.chi) {
-            if (node.typ == EnumToken.CDOCOMMNodeType || node.typ == EnumToken.CommentNodeType) {
-                continue;
-            }
             if (node.typ != EnumToken.DeclarationNodeType) {
-                break;
+                continue;
             }
             // css variable
             if (node.nam.startsWith('--')) {
@@ -58,13 +90,14 @@ class InlineCssVariablesFeature {
                         parent: new Set(),
                         declarationCount: 1,
                         replaceable: isRoot,
-                        node: node
+                        node: node,
+                        values: structuredClone(node.val)
                     };
                     info.parent.add(ast);
                     variableScope.set(node.nam, info);
                     let recursive = false;
-                    for (const { value, parent: parentValue } of walkValues(node.val)) {
-                        if (value?.typ == EnumToken.FunctionTokenType && value.val == 'var') {
+                    for (const { value } of walkValues(node.val)) {
+                        if (value?.typ == EnumToken.FunctionTokenType && (mathFuncs.includes(value.val) || value.val == 'var')) {
                             recursive = true;
                             break;
                         }
@@ -103,23 +136,13 @@ class InlineCssVariablesFeature {
                 for (const parent of info.parent) {
                     i = parent.chi?.length ?? 0;
                     while (i--) {
-                        if (parent.chi[i].typ == EnumToken.DeclarationNodeType && parent.chi[i].nam == info.node.nam) {
+                        if (parent.chi[i] == info.node) {
                             // @ts-ignore
-                            parent.chi.splice(i++, 1, {
+                            parent.chi.splice(i, 1, {
                                 typ: EnumToken.CommentTokenType,
-                                val: `/* ${info.node.nam}: ${info.node.val.reduce((acc, curr) => acc + renderToken(curr), '')} */`
+                                val: `/* ${info.node.nam}: ${info.values.reduce((acc, curr) => acc + renderToken(curr), '')} */`
                             });
-                        }
-                    }
-                    if (parent.chi?.length == 0 && 'parent' in parent) {
-                        // @ts-ignore
-                        for (i = 0; i < parent.parent.chi?.length; i++) {
-                            // @ts-ignore
-                            if (parent.parent.chi[i] == parent) {
-                                // @ts-ignore
-                                parent.parent.chi.splice(i, 1);
-                                break;
-                            }
+                            break;
                         }
                     }
                 }