@tbela99/css-parser 0.9.1 → 1.1.0

package/dist/index.d.ts

@@ -1,3 +1,14 @@
+/**
+ * validation level enum
+ */
+declare enum ValidationLevel {
+    None = 0,
+    Default = 1,// selectors + at-rules
+    All = 2
+}
+/**
+ * token types enum
+ */
 declare enum EnumToken {
     CommentTokenType = 0,
     CDOCOMMTokenType = 1,
@@ -92,6 +103,8 @@ declare enum EnumToken {
     MediaFeatureOrTokenType = 90,
     PseudoPageTokenType = 91,
     PseudoElementTokenType = 92,
+    KeyframeAtRuleNodeType = 93,
+    InvalidDeclarationNodeType = 94,
     Time = 25,
     Iden = 7,
     EOF = 48,
@@ -130,10 +143,16 @@ 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;
 
+declare enum WalkerOptionEnum {
+    Ignore = 0,
+    Stop = 1,
+    Children = 2,
+    IgnoreChildren = 3
+}
 declare enum WalkerValueEvent {
     Enter = 0,
     Leave = 1
@@ -145,14 +164,14 @@ 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
  * @param reverse
  */
 declare function walkValues(values: Token[], root?: AstNode | Token | null, filter?: WalkerValueFilter | {
-    event: WalkerValueEvent;
+    event?: WalkerValueEvent;
     fn?: WalkerValueFilter;
     type?: EnumToken | EnumToken[] | ((token: Token) => boolean);
 }, reverse?: boolean): Generator<WalkAttributesResult>;
@@ -175,8 +194,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
  */
@@ -184,7 +232,7 @@ declare function parseString(src: string, options?: {
     location: boolean;
 }): Token[];
 /**
- * parse token list
+ * parse token array into a tree structure
  * @param tokens
  * @param options
  */
@@ -564,26 +612,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;
@@ -838,6 +866,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;
@@ -848,7 +939,7 @@ export declare interface Position {
 export declare interface Location {
 
     sta: Position;
-    // end: Position;
+    end: Position;
     src: string;
 }
 
@@ -858,6 +949,7 @@ export declare interface BaseToken {
     loc?: Location;
     tokens?: Token[];
     parent?: AstRuleList;
+    validSyntax?: boolean;
 }
 
 export declare interface AstComment extends BaseToken {
@@ -873,32 +965,28 @@ export declare interface AstDeclaration extends BaseToken {
     typ: EnumToken.DeclarationNodeType
 }
 
-
 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 {
 
     typ: EnumToken.InvalidRuleTokenType;
     sel: string;
-    chi: Array<AstDeclaration | AstComment | AstRuleList>;
+    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 {
 
     typ: EnumToken.KeyFrameRuleNodeType;
@@ -923,17 +1011,34 @@ 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 | AstInvalidDeclaration | AstComment | AstRuleList>;
+    optimized?: OptimizedSelector;
+    raw?: RawSelectorTokens;
+}
+
+export declare interface AstKeyframAtRule extends BaseToken {
+
+    typ: EnumToken.KeyframeAtRuleNodeType,
+    nam: string;
+    val: string;
+    chi: Array<AstKeyframeRule | AstComment>;
 }
 
 export declare interface AstRuleList extends BaseToken {
 
-    typ:  EnumToken.StyleSheetNodeType |  EnumToken.RuleNodeType |  EnumToken.AtRuleNodeType,
+    typ: EnumToken.StyleSheetNodeType | EnumToken.RuleNodeType | EnumToken.AtRuleNodeType | EnumToken.KeyframeAtRuleNodeType | EnumToken.KeyFrameRuleNodeType | EnumToken.InvalidRuleTokenType | EnumToken.InvalidAtRuleTokenType,
     chi: Array<BaseToken | AstComment>;
 }
 
 export declare interface AstRuleStyleSheet extends AstRuleList {
-    typ:  EnumToken.StyleSheetNodeType,
+    typ: EnumToken.StyleSheetNodeType,
     chi: Array<AstRuleList | AstComment>
 }
 
@@ -944,9 +1049,10 @@ export declare type AstNode =
     | AstAtRule
     | AstRule
     | AstDeclaration
+    | AstKeyframAtRule
     | AstKeyFrameRule
     | AstInvalidRule
-    | AstInvalidAtRule;
+    | AstInvalidDeclaration;
 
 /**
  * Declaration visitor handler
@@ -990,13 +1096,18 @@ export declare interface PropertyListOptions {
     computeShorthand?: boolean;
 }
 
-export declare type WalkerOption = 'ignore' | 'stop' | 'children' | 'ignore-children' | Token | null;
+declare enum FeatureWalkMode {
+    Pre = 0,
+    Post = 1
+}
+
+export declare type WalkerOption = WalkerOptionEnum | Token | null;
 /**
  * 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
+ * - 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
  */
 export declare type WalkerFilter = (node: AstNode) => WalkerOption;
 
@@ -1007,7 +1118,7 @@ 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: AstNode | Token, parent: FunctionToken | ParensToken | BinaryExpressionToken, event?: WalkerValueEvent) => WalkerOption | null;
+export declare type WalkerValueFilter = (node: AstNode | Token, parent?: FunctionToken | ParensToken | BinaryExpressionToken, event?: WalkerValueEvent) => WalkerOption | null;
 
 export declare interface WalkResult {
     node: AstNode;
@@ -1020,7 +1131,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;
 }
 
@@ -1029,18 +1140,21 @@ 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 {
@@ -1050,16 +1164,17 @@ interface MinifyOptions {
     expandNestingRules?: boolean;
     removeDuplicateDeclarations?: boolean;
     computeShorthand?: boolean;
+    computeTransform?: boolean;
     computeCalcExpression?: boolean;
     inlineCssVariables?: boolean;
     removeEmpty?: boolean;
     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;
@@ -1075,11 +1190,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 {
@@ -1096,10 +1212,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 {
@@ -1114,7 +1232,7 @@ export declare interface RenderOptions {
     removeEmpty?: boolean;
     expandNestingRules?: boolean;
     preserveLicense?: boolean;
-    sourcemap?: boolean;
+    sourcemap?: boolean | 'inline';
     indent?: string;
     newLine?: string;
     removeComments?: boolean;
@@ -1165,6 +1283,15 @@ export declare interface TransformResult extends ParseResult, RenderResult {
 export declare interface ParseTokenOptions extends ParserOptions {
 }
 
+export declare interface TokenizeResult {
+    token: string;
+    len: number;
+    hint?: EnumToken;
+    sta: Position;
+    end: Position;
+    bytesIn: number;
+}
+
 export declare interface SourceMapObject {
     version: number;
     file?: string;
@@ -1175,13 +1302,28 @@ 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;
 };
 
-declare function load(url: string, currentFile: string): Promise<string>;
+/**
+ * load file
+ * @param url
+ * @param currentFile
+ */
+declare function load(url: string, currentFile?: string): Promise<string>;
 
 /**
  * render ast node
@@ -1196,4 +1338,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

@@ -1,20 +1,26 @@
 import { EnumToken } from '../types.js';
-import { walkValues, WalkerValueEvent } from '../walk.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) {
-            for (const feature of options.features) {
-                if (feature instanceof ComputeCalcExpressionFeature) {
-                    return;
-                }
-            }
             // @ts-ignore
             options.features.push(new ComputeCalcExpressionFeature());
         }
@@ -23,7 +29,6 @@ class ComputeCalcExpressionFeature {
         if (!('chi' in ast)) {
             return;
         }
-        // @ts-ignore
         for (const node of ast.chi) {
             if (node.typ != EnumToken.DeclarationNodeType) {
                 continue;
@@ -31,15 +36,18 @@ class ComputeCalcExpressionFeature {
             const set = new Set;
             for (const { value, parent } of walkValues(node.val, node, {
                 event: WalkerValueEvent.Enter,
-                fn(node, parent, event) {
+                // @ts-ignore
+                fn(node, parent) {
                     if (parent != null &&
+                        // @ts-ignore
                         parent.typ == EnumToken.DeclarationNodeType &&
+                        // @ts-ignore
                         parent.val.length == 1 &&
                         node.typ == EnumToken.FunctionTokenType &&
                         mathFuncs.includes(node.val) &&
                         node.chi.length == 1 &&
                         node.chi[0].typ == EnumToken.IdenTokenType) {
-                        return 'ignore';
+                        return WalkerOptionEnum.Ignore;
                     }
                     if ((node.typ == EnumToken.FunctionTokenType && node.val == 'var') || (!mathFuncs.includes(parent.val) && [EnumToken.ColorTokenType, EnumToken.DeclarationNodeType, EnumToken.RuleNodeType, EnumToken.AtRuleNodeType, EnumToken.StyleSheetNodeType].includes(parent?.typ))) {
                         return null;
@@ -61,7 +69,7 @@ class ComputeCalcExpressionFeature {
                             // @ts-ignore
                             node[key] = values;
                         }
-                        return 'ignore';
+                        return WalkerOptionEnum.Ignore;
                     }
                     return null;
                 }

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

@@ -2,3 +2,4 @@ export { ComputePrefixFeature } from './prefix.js';
 export { InlineCssVariablesFeature } from './inlinecssvariables.js';
 export { ComputeShorthandFeature } from './shorthand.js';
 export { ComputeCalcExpressionFeature } from './calc.js';
+export { TransformCssFeature } from './transform.js';