@tbela99/css-parser 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -56,21 +56,26 @@ declare enum EnumToken {
     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,
+    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,
     Time = 25,
     Iden = 7,
+    EOF = 47,
     Hash = 28,
+    Flex = 57,
     Angle = 24,
     Color = 49,
     Comma = 9,
@@ -85,7 +90,9 @@ declare enum EnumToken {
     Frequency = 26,
     Resolution = 27,
     Whitespace = 36,
+    IdenList = 70,
     DashedIden = 8,
+    GridTemplateFunc = 71,
     ImageFunc = 19,
     CommentNodeType = 0,
     CDOCOMMNodeType = 1,
@@ -98,7 +105,7 @@ declare function minify(ast: AstNode, options?: ParserOptions | MinifyOptions, r
 }): AstNode;
 
 declare function walk(node: AstNode, filter?: WalkerFilter): Generator<WalkResult>;
-declare function walkValues(values: Token[]): Generator<WalkAttributesResult>;
+declare function walkValues(values: Token[], root?: AstNode | null, filter?: WalkerValueFilter): Generator<WalkAttributesResult>;
 
 declare function expand(ast: AstNode): AstNode;
 
@@ -123,12 +130,19 @@ export declare interface LiteralToken extends BaseToken {
     val: string;
 }
 
+
 export declare interface IdentToken extends BaseToken {
 
     typ: EnumToken.IdenTokenType,
     val: string;
 }
 
+export declare interface IdentListToken extends BaseToken {
+
+    typ: EnumToken.IdenListTokenType,
+    val: string;
+}
+
 export declare interface DashedIdentToken extends BaseToken {
 
     typ: EnumToken.DashedIdenTokenType,
@@ -168,6 +182,12 @@ export declare interface PercentageToken extends BaseToken {
     val: string | FractionToken;
 }
 
+export declare interface FlexToken extends BaseToken {
+
+    typ: EnumToken.FlexTokenType,
+    val: string | FractionToken;
+}
+
 export declare interface FunctionToken extends BaseToken {
 
     typ: EnumToken.FunctionTokenType,
@@ -175,6 +195,13 @@ export declare interface FunctionToken extends BaseToken {
     chi: Token[];
 }
 
+export declare interface GridTemplateFuncToken extends BaseToken {
+
+    typ: EnumToken.GridTemplateFuncTokenType,
+    val: string;
+    chi: Token[];
+}
+
 export declare interface FunctionURLToken extends BaseToken {
 
     typ: EnumToken.UrlFunctionTokenType,
@@ -195,6 +222,7 @@ export declare interface TimingFunctionToken extends BaseToken {
     val: string;
     chi: Token[];
 }
+
 export declare interface TimelineFunctionToken extends BaseToken {
 
     typ: EnumToken.TimelineFunctionTokenType;
@@ -430,12 +458,18 @@ export declare interface ImportantToken extends BaseToken {
     typ: EnumToken.ImportantTokenType;
 }
 
+export declare type ColorKind = 'lit' | 'hex' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'hwb' | 'device-cmyk' | 'oklab' | 'oklch' | 'lab' | 'lch' | 'color';
+
+// export declare type HueInterpolationMethod = 'shorter' | 'longer' | 'increasing' | 'decreasing';
+
 export declare interface ColorToken extends BaseToken {
 
     typ: EnumToken.ColorTokenType;
     val: string;
-    kin: 'lit' | 'hex' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'hwb' | 'device-cmyk';
+    kin: ColorKind;
     chi?: Token[];
+    /* calculated */
+    cal?: 'rel' | 'mix';
 }
 
 export declare interface AttrToken extends BaseToken {
@@ -517,11 +551,13 @@ export declare type UnaryExpressionNode =
     | AngleToken
     | FrequencyToken;
 
-export declare type BinaryExpressionNode = NumberToken | DimensionToken | PercentageToken | FractionToken |
+export declare type BinaryExpressionNode = NumberToken | DimensionToken | PercentageToken | FlexToken | FractionToken |
     AngleToken | LengthToken | FrequencyToken | BinaryExpressionToken | FunctionToken | ParensToken;
+
 export declare type Token =
     LiteralToken
     | IdentToken
+    | IdentListToken
     | DashedIdentToken
     | CommaToken
     | ColonToken
@@ -530,11 +566,13 @@ export declare type Token =
     NumberToken
     | AtRuleToken
     | PercentageToken
+    | FlexToken
     | FunctionURLToken
     | FunctionImageToken
     | TimingFunctionToken
     | TimelineFunctionToken
     | FunctionToken
+    | GridTemplateFuncToken
     | DimensionToken
     | LengthToken
     |
@@ -674,21 +712,21 @@ export declare type AstNode =
 /**
  * Declaration visitor handler
  */
-export declare type DeclarationVisitorHandler = (node: AstDeclaration) => AstDeclaration | AstDeclaration[] | null;
+export declare type DeclarationVisitorHandler = (node: AstDeclaration) => AstDeclaration | AstDeclaration[] | null | Promise<AstDeclaration | AstDeclaration[] | null>;
 /**
  * Rule visitor handler
  */
-export declare type RuleVisitorHandler = (node: AstRule$1) => AstRule$1 | AstRule$1[] | null;
+export declare type RuleVisitorHandler = (node: AstRule$1) => AstRule$1 | AstRule$1[] | null | Promise<AstRule$1 | AstRule$1[] | null>;
 
 /**
  * AtRule visitor handler
  */
-export declare type AtRuleVisitorHandler = (node: AstAtRule$1) => AstAtRule$1 | AstAtRule$1[] | null;
+export declare type AtRuleVisitorHandler = (node: AstAtRule$1) => AstAtRule$1 | AstAtRule$1[] | null | Promise<AstAtRule$1 | AstAtRule$1[] | null>;
 
 /**
  * Value visitor handler
  */
-export declare type ValueVisitorHandler = (node: Token) => Token | Token[] | null;
+export declare type ValueVisitorHandler = (node: Token) => Token | Token[] | null | Promise<Token | Token[] | null>;
 
 
 export declare interface VisitorNodeMap {
@@ -701,7 +739,7 @@ export declare interface VisitorNodeMap {
 
 export declare type WalkerOption = 'ignore' | 'stop' | 'children' | 'ignore-children' | null;
 /**
- * return value:
+ * returned value:
  * - 'ignore': ignore this node and its children
  * - 'stop': stop walking the tree
  * - 'children': walk the children and ignore the node itself
@@ -709,6 +747,15 @@ export declare type WalkerOption = 'ignore' | 'stop' | 'children' | 'ignore-chil
  */
 export declare type WalkerFilter = (node: AstNode) => WalkerOption;
 
+/**
+ * returned value:
+ * - 'ignore': ignore this node and its children
+ * - 'stop': stop walking the tree
+ * - 'children': walk the children and ignore the node itself
+ * - 'ignore-children': walk the node and ignore children
+ */
+export declare type WalkerValueFilter = (node: Token) => WalkerOption;
+
 export declare interface WalkResult {
     node: AstNode;
     parent?: AstRuleList;
@@ -717,7 +764,8 @@ export declare interface WalkResult {
 
 export declare interface WalkAttributesResult {
     value: Token;
-    parent: FunctionToken | ParensToken | null;
+    root?: AstNode;
+    parent: FunctionToken | ParensToken | BinaryExpressionToken | null;
 }
 
 export declare interface ErrorDescription {
@@ -756,6 +804,7 @@ export declare interface ParserOptions extends PropertyListOptions {
     resolveUrls?: boolean;
     resolveImport?: boolean;
     cwd?: string;
+    parseColor?: boolean;
     removeDuplicateDeclarations?: boolean;
     computeShorthand?: boolean;
     inlineCssVariables?: boolean;
@@ -789,7 +838,7 @@ export declare interface RenderOptions {
     indent?: string;
     newLine?: string;
     removeComments?: boolean;
-    colorConvert?: boolean;
+    convertColor?: boolean;
     output?: string;
     cwd?: string;
     load?: (url: string, currentUrl: string) => Promise<string>;
@@ -834,7 +883,6 @@ export declare interface TransformResult extends ParseResult, RenderResult {
 }
 
 export declare interface ParseTokenOptions extends ParserOptions {
-    parseColor?: boolean;
 }
 
 export declare interface SourceMapObject {

package/dist/lib/ast/expand.js

@@ -1,9 +1,9 @@
 import { splitRule, combinators } from './minify.js';
 import { parseString } from '../parser/parse.js';
 import { renderToken } from '../renderer/render.js';
-import '../renderer/utils/color.js';
 import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
+import '../renderer/color/utils/constants.js';
 
 function expand(ast) {
     //

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

@@ -1,28 +1,27 @@
 import { EnumToken } from '../types.js';
-import { reduceNumber } from '../../renderer/render.js';
 import { walkValues } from '../walk.js';
 import { MinifyFeature } from '../utils/minifyfeature.js';
-import { compute } from './utils/math.js';
-import { IterableWeakSet } from '../../iterable/set.js';
+import { IterableWeakSet } from '../../iterable/weakset.js';
+import { evaluate } from '../math/expression.js';
 
-class ComputeCalcExpression extends MinifyFeature {
+class ComputeCalcExpressionFeature extends MinifyFeature {
     static get ordering() {
         return 1;
     }
     static register(options) {
         if (options.computeCalcExpression) {
             for (const feature of options.features) {
-                if (feature instanceof ComputeCalcExpression) {
+                if (feature instanceof ComputeCalcExpressionFeature) {
                     return;
                 }
             }
             // @ts-ignore
-            options.features.push(new ComputeCalcExpression());
+            options.features.push(new ComputeCalcExpressionFeature());
         }
     }
     run(ast) {
         if (!('chi' in ast)) {
-            return ast;
+            return;
         }
         // @ts-ignore
         for (const node of ast.chi) {
@@ -30,196 +29,36 @@ class ComputeCalcExpression extends MinifyFeature {
                 continue;
             }
             const set = new IterableWeakSet;
-            for (const { parent } of walkValues(node.val)) {
-                if (parent != null && parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') {
+            for (const { value, parent } of walkValues(node.val)) {
+                if (value != null && value.typ == EnumToken.FunctionTokenType && value.val == 'calc') {
                     if (!set.has(parent)) {
-                        set.add(parent);
-                        parent.chi = evaluate(parent.chi);
+                        set.add(value);
+                        value.chi = evaluate(value.chi);
+                        if (value.chi.length == 1 && value.chi[0].typ != EnumToken.BinaryExpressionTokenType) {
+                            if (parent != null) {
+                                if (parent.typ == EnumToken.BinaryExpressionTokenType) {
+                                    if (parent.l == value) {
+                                        parent.l = value.chi[0];
+                                    }
+                                    else {
+                                        parent.r = value.chi[0];
+                                    }
+                                }
+                                else {
+                                    for (let i = 0; i < parent.chi.length; i++) {
+                                        if (parent.chi[i] == value) {
+                                            parent.chi.splice(i, 1, value.chi[0]);
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }
         }
-        return ast;
     }
 }
-/**
- * evaluate arithmetic operation
- * @param l
- * @param r
- * @param op
- */
-function doEvaluate(l, r, op) {
-    const defaultReturn = {
-        typ: EnumToken.BinaryExpressionTokenType,
-        op,
-        l,
-        r
-    };
-    if (!isScalarToken(l) || !isScalarToken(r)) {
-        return defaultReturn;
-    }
-    if ((op == EnumToken.Add || op == EnumToken.Sub)) {
-        // @ts-ignore
-        if (l.typ != r.typ) {
-            return defaultReturn;
-        }
-    }
-    const typ = l.typ == EnumToken.NumberTokenType ? r.typ : l.typ;
-    // @ts-ignore
-    const val = compute(typeof l.val == 'string' ? +l.val : l.val, typeof r.val == 'string' ? +r.val : r.val, op);
-    return { ...(l.typ == EnumToken.NumberTokenType ? r : l), typ, val: typeof val == 'number' ? reduceNumber(val) : val };
-}
-/**
- * evaluate an array of tokens
- * @param tokens
- */
-function evaluate(tokens) {
-    const nodes = inlineExpression(evaluateExpression(buildExpression(tokens)));
-    if (nodes.length <= 1) {
-        return nodes;
-    }
-    const map = new Map;
-    let token;
-    let i;
-    for (i = 0; i < nodes.length; i++) {
-        token = nodes[i];
-        if (token.typ == EnumToken.Add) {
-            continue;
-        }
-        if (token.typ == EnumToken.Sub) {
-            if (!isScalarToken(nodes[i + 1])) {
-                token = { typ: EnumToken.ListToken, chi: [nodes[i], nodes[i + 1]] };
-            }
-            else {
-                token = doEvaluate(nodes[i + 1], { typ: EnumToken.NumberTokenType, val: '-1' }, EnumToken.Mul);
-            }
-            i++;
-        }
-        if (!map.has(token.typ)) {
-            map.set(token.typ, [token]);
-        }
-        else {
-            map.get(token.typ).push(token);
-        }
-    }
-    return [...map].reduce((acc, curr) => {
-        const token = curr[1].reduce((acc, curr) => doEvaluate(acc, curr, EnumToken.Add));
-        if (token.typ != EnumToken.BinaryExpressionTokenType) {
-            if ('val' in token && +token.val < 0) {
-                acc.push({ typ: EnumToken.Sub }, { ...token, val: String(-token.val) });
-                return acc;
-            }
-        }
-        if (acc.length > 0 && curr[0] != EnumToken.ListToken) {
-            acc.push({ typ: EnumToken.Add });
-        }
-        acc.push(token);
-        return acc;
-    }, []);
-}
-/**
- * convert BinaryExpression into an array
- * @param token
- */
-function inlineExpression(token) {
-    const result = [];
-    if (token.typ == EnumToken.ParensTokenType && token.chi.length == 1) {
-        result.push(token.chi[0]);
-    }
-    else if (token.typ == EnumToken.BinaryExpressionTokenType) {
-        if ([EnumToken.Mul, EnumToken.Div].includes(token.op)) {
-            result.push(token);
-        }
-        else {
-            result.push(...inlineExpression(token.l), { typ: token.op }, ...inlineExpression(token.r));
-        }
-    }
-    else {
-        result.push(token);
-    }
-    return result;
-}
-/**
- * evaluate expression
- * @param token
- */
-function evaluateExpression(token) {
-    if (token.typ != EnumToken.BinaryExpressionTokenType) {
-        return token;
-    }
-    if (token.r.typ == EnumToken.BinaryExpressionTokenType) {
-        token.r = evaluateExpression(token.r);
-    }
-    if (token.l.typ == EnumToken.BinaryExpressionTokenType) {
-        token.l = evaluateExpression(token.l);
-    }
-    return doEvaluate(token.l, token.r, token.op);
-}
-function isScalarToken(token) {
-    return token.typ != EnumToken.BinaryExpressionTokenType && token.typ != EnumToken.ParensTokenType && token.typ != EnumToken.FunctionTokenType;
-}
-/**
- *
- * generate binary expression tree
- * @param tokens
- */
-function buildExpression(tokens) {
-    return factor(factor(tokens.filter(t => t.typ != EnumToken.WhitespaceTokenType), ['/', '*']), ['+', '-'])[0];
-}
-function getArithmeticOperation(op) {
-    if (op == '+') {
-        return EnumToken.Add;
-    }
-    if (op == '-') {
-        return EnumToken.Sub;
-    }
-    if (op == '/') {
-        return EnumToken.Div;
-    }
-    return EnumToken.Mul;
-}
-/**
- *
- * generate binary expression tree
- * @param token
- */
-function factorToken(token) {
-    if (token.typ == EnumToken.ParensTokenType || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc')) {
-        if (token.typ == EnumToken.FunctionTokenType && token.val == 'calc') {
-            token = { ...token, typ: EnumToken.ParensTokenType };
-            // @ts-ignore
-            delete token.val;
-        }
-        return buildExpression(token.chi);
-    }
-    return token;
-}
-/**
- * generate binary expression tree
- * @param tokens
- * @param ops
- */
-function factor(tokens, ops) {
-    let isOp;
-    const opList = ops.map(x => getArithmeticOperation(x));
-    if (tokens.length == 1) {
-        return [factorToken(tokens[0])];
-    }
-    for (let i = 0; i < tokens.length; i++) {
-        isOp = opList.includes(tokens[i].typ);
-        if (isOp ||
-            // @ts-ignore
-            (tokens[i].typ == EnumToken.LiteralTokenType && ops.includes(tokens[i].val))) {
-            tokens.splice(i - 1, 3, {
-                typ: EnumToken.BinaryExpressionTokenType,
-                op: isOp ? tokens[i].typ : getArithmeticOperation(tokens[i].val),
-                l: factorToken(tokens[i - 1]),
-                r: factorToken(tokens[i + 1])
-            });
-            i--;
-        }
-    }
-    return tokens;
-}
 
-export { ComputeCalcExpression };
+export { ComputeCalcExpressionFeature };

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

@@ -1,3 +1,3 @@
-export { InlineCssVariables } from './inlinecssvariables.js';
-export { ComputeShorthand } from './shorthand.js';
-export { ComputeCalcExpression } from './calc.js';
+export { InlineCssVariablesFeature } from './inlinecssvariables.js';
+export { ComputeShorthandFeature } from './shorthand.js';
+export { ComputeCalcExpressionFeature } from './calc.js';

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

@@ -1,7 +1,7 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
 import { MinifyFeature } from '../utils/minifyfeature.js';
-import { IterableWeakSet } from '../../iterable/set.js';
+import { IterableWeakSet } from '../../iterable/weakset.js';
 
 function replace(node, variableScope) {
     for (const { value, parent: parentValue } of walkValues(node.val)) {
@@ -26,26 +26,26 @@ function replace(node, variableScope) {
         }
     }
 }
-class InlineCssVariables extends MinifyFeature {
+class InlineCssVariablesFeature extends MinifyFeature {
     static get ordering() {
         return 0;
     }
     static register(options) {
         if (options.inlineCssVariables) {
             for (const feature of options.features) {
-                if (feature instanceof InlineCssVariables) {
+                if (feature instanceof InlineCssVariablesFeature) {
                     return;
                 }
             }
             // @ts-ignore
-            options.features.push(new InlineCssVariables());
+            options.features.push(new InlineCssVariablesFeature());
         }
     }
     run(ast, options = {}, parent, context) {
         if (!('variableScope' in context)) {
             context.variableScope = new Map;
         }
-        const isRoot = parent.typ == EnumToken.StyleSheetNodeType && ast.typ == EnumToken.RuleNodeType && ast.sel == ':root';
+        const isRoot = parent.typ == EnumToken.StyleSheetNodeType && ast.typ == EnumToken.RuleNodeType && [':root', 'html'].includes(ast.sel);
         const variableScope = context.variableScope;
         // @ts-ignore
         for (const node of ast.chi) {
@@ -127,4 +127,4 @@ class InlineCssVariables extends MinifyFeature {
     }
 }
 
-export { InlineCssVariables };
+export { InlineCssVariablesFeature };

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

@@ -1,25 +1,24 @@
 import { PropertyList } from '../../parser/declaration/list.js';
-import '../../renderer/utils/color.js';
 import { EnumToken } from '../types.js';
 import '../minify.js';
 import '../../parser/parse.js';
+import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
-import '../../parser/declaration/map.js';
 import { MinifyFeature } from '../utils/minifyfeature.js';
 
-class ComputeShorthand extends MinifyFeature {
+class ComputeShorthandFeature extends MinifyFeature {
     static get ordering() {
         return 2;
     }
     static register(options) {
         if (options.computeShorthand) {
             for (const feature of options.features) {
-                if (feature instanceof ComputeShorthand) {
+                if (feature instanceof ComputeShorthandFeature) {
                     return;
                 }
             }
             // @ts-ignore
-            options.features.push(new ComputeShorthand());
+            options.features.push(new ComputeShorthandFeature());
         }
     }
     run(ast, options = {}, parent, context) {
@@ -43,4 +42,4 @@ class ComputeShorthand extends MinifyFeature {
     }
 }
 
-export { ComputeShorthand };
+export { ComputeShorthandFeature };