@tbela99/css-parser 0.9.1 → 1.0.0

package/dist/index.d.ts

@@ -92,6 +92,7 @@ declare enum EnumToken {
     MediaFeatureOrTokenType = 90,
     PseudoPageTokenType = 91,
     PseudoElementTokenType = 92,
+    KeyframeAtRuleNodeType = 93,
     Time = 25,
     Iden = 7,
     EOF = 48,
@@ -134,6 +135,12 @@ declare function minify(ast: AstNode, options?: ParserOptions | MinifyFeatureOpt
     [key: string]: any;
 }): AstNode;
 
+declare enum WalkerOptionEnum {
+    Ignore = 0,
+    Stop = 1,
+    Children = 2,
+    IgnoreChildren = 3
+}
 declare enum WalkerValueEvent {
     Enter = 0,
     Leave = 1
@@ -152,7 +159,7 @@ declare function walk(node: AstNode, filter?: WalkerFilter): Generator<WalkResul
  * @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>;
@@ -873,7 +880,6 @@ export declare interface AstDeclaration extends BaseToken {
     typ: EnumToken.DeclarationNodeType
 }
 
-
 export declare interface AstRule extends BaseToken {
 
     typ: EnumToken.RuleNodeType;
@@ -887,7 +893,7 @@ 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 {
@@ -897,8 +903,6 @@ export declare interface AstInvalidAtRule extends BaseToken {
     chi?: Array<AstNode>;
 }
 
-
-
 export declare interface AstKeyFrameRule extends BaseToken {
 
     typ: EnumToken.KeyFrameRuleNodeType;
@@ -926,14 +930,31 @@ export declare interface AstAtRule extends BaseToken {
     chi?: Array<AstDeclaration | AstComment> | Array<AstRule | AstComment>
 }
 
+export declare interface AstKeyframeRule extends BaseToken {
+
+    typ: EnumToken.KeyFrameRuleNodeType;
+    sel: string;
+    chi: Array<AstDeclaration | 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,
     chi: Array<BaseToken | AstComment>;
 }
 
 export declare interface AstRuleStyleSheet extends AstRuleList {
-    typ:  EnumToken.StyleSheetNodeType,
+    typ: EnumToken.StyleSheetNodeType,
     chi: Array<AstRuleList | AstComment>
 }
 
@@ -944,6 +965,7 @@ export declare type AstNode =
     | AstAtRule
     | AstRule
     | AstDeclaration
+    | AstKeyframAtRule
     | AstKeyFrameRule
     | AstInvalidRule
     | AstInvalidAtRule;
@@ -990,13 +1012,13 @@ export declare interface PropertyListOptions {
     computeShorthand?: boolean;
 }
 
-export declare type WalkerOption = 'ignore' | 'stop' | 'children' | 'ignore-children' | Token | null;
+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 +1029,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;
@@ -1035,6 +1057,7 @@ export declare interface ErrorDescription {
         col: number;
     };
     error?: Error;
+    rawTokens?: TokenizeResult[];
 }
 
 interface ValidationOptions {
@@ -1050,6 +1073,7 @@ interface MinifyOptions {
     expandNestingRules?: boolean;
     removeDuplicateDeclarations?: boolean;
     computeShorthand?: boolean;
+    computeTransform?: boolean;
     computeCalcExpression?: boolean;
     inlineCssVariables?: boolean;
     removeEmpty?: boolean;
@@ -1165,6 +1189,14 @@ export declare interface TransformResult extends ParseResult, RenderResult {
 export declare interface ParseTokenOptions extends ParserOptions {
 }
 
+export declare interface TokenizeResult {
+    token: string;
+    len: number;
+    hint?: EnumToken;
+    position: Position;
+    bytesIn: number;
+}
+
 export declare interface SourceMapObject {
     version: number;
     file?: string;
@@ -1181,7 +1213,7 @@ declare function resolve(url: string, currentDirectory: string, cwd?: string): {
     relative: string;
 };
 
-declare function load(url: string, currentFile: string): Promise<string>;
+declare function load(url: string, currentFile?: string): Promise<string>;
 
 /**
  * render ast node

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

@@ -1,5 +1,5 @@
 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 { mathFuncs } from '../../syntax/syntax.js';
@@ -10,11 +10,6 @@ class ComputeCalcExpressionFeature {
     }
     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 +18,6 @@ class ComputeCalcExpressionFeature {
         if (!('chi' in ast)) {
             return;
         }
-        // @ts-ignore
         for (const node of ast.chi) {
             if (node.typ != EnumToken.DeclarationNodeType) {
                 continue;
@@ -31,15 +25,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 +58,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';

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

@@ -31,11 +31,6 @@ class InlineCssVariablesFeature {
     }
     static register(options) {
         if (options.inlineCssVariables) {
-            for (const feature of options.features) {
-                if (feature instanceof InlineCssVariablesFeature) {
-                    return;
-                }
-            }
             // @ts-ignore
             options.features.push(new InlineCssVariablesFeature());
         }

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

@@ -17,11 +17,6 @@ class ComputePrefixFeature {
     }
     static register(options) {
         if (options.removePrefix) {
-            for (const feature of options.features) {
-                if (feature instanceof ComputePrefixFeature) {
-                    return;
-                }
-            }
             // @ts-ignore
             options.features.push(new ComputePrefixFeature(options));
         }
@@ -48,9 +43,9 @@ class ComputePrefixFeature {
                     for (const { value } of walkValues(node.val)) {
                         if (value.typ == EnumToken.IdenTokenType && value.val.charAt(0) == '-' && value.val.charAt(1) != '-') {
                             // @ts-ignore
-                            const values = config.declarations[node.nam].ast.slice();
+                            const values = config.declarations[node.nam].ast?.slice?.();
                             const match = value.val.match(/^-(.*?)-(.*)$/);
-                            if (match != null) {
+                            if (values != null && match != null) {
                                 const val = matchToken({ ...value, val: match[2] }, values);
                                 if (val != null) {
                                     // @ts-ignore

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

@@ -9,15 +9,10 @@ import '../../parser/utils/config.js';
 
 class ComputeShorthandFeature {
     static get ordering() {
-        return 2;
+        return 3;
     }
     static register(options) {
         if (options.computeShorthand) {
-            for (const feature of options.features) {
-                if (feature instanceof ComputeShorthandFeature) {
-                    return;
-                }
-            }
             // @ts-ignore
             options.features.push(new ComputeShorthandFeature(options));
         }
@@ -27,18 +22,20 @@ class ComputeShorthandFeature {
         const j = ast.chi.length;
         let k = 0;
         let properties = new PropertyList(options);
+        const rules = [];
         // @ts-ignore
         for (; k < j; k++) {
             // @ts-ignore
             const node = ast.chi[k];
             if (node.typ == EnumToken.CommentNodeType || node.typ == EnumToken.DeclarationNodeType) {
                 properties.add(node);
-                continue;
             }
-            break;
+            else {
+                rules.push(node);
+            }
         }
         // @ts-ignore
-        ast.chi = [...properties].concat(ast.chi.slice(k));
+        ast.chi = [...properties, ...rules];
         return ast;
     }
 }

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

@@ -0,0 +1,60 @@
+import { EnumToken } from '../types.js';
+import { consumeWhitespace } from '../../validation/utils/whitespace.js';
+import '../minify.js';
+import '../walk.js';
+import '../../parser/parse.js';
+import { filterValues, renderToken } from '../../renderer/render.js';
+import '../../renderer/color/utils/constants.js';
+import '../../parser/utils/config.js';
+import { compute } from '../transform/compute.js';
+import { eqMatrix } from '../transform/minify.js';
+
+class TransformCssFeature {
+    static get ordering() {
+        return 4;
+    }
+    static register(options) {
+        // @ts-ignore
+        if (options.computeTransform) {
+            // @ts-ignore
+            options.features.push(new TransformCssFeature());
+        }
+    }
+    run(ast) {
+        if (!('chi' in ast)) {
+            return;
+        }
+        let i = 0;
+        let node;
+        // @ts-ignore
+        for (; i < ast.chi.length; i++) {
+            // @ts-ignore
+            node = ast.chi[i];
+            if (node.typ != EnumToken.DeclarationNodeType || !node.nam.match(/^(-[a-z]+-)?transform$/)) {
+                continue;
+            }
+            const children = node.val.slice();
+            consumeWhitespace(children);
+            let { matrix, cumulative, minified } = compute(children) ?? {};
+            if (matrix == null || cumulative == null || minified == null) {
+                return;
+            }
+            let r = [filterValues(node.val.slice())];
+            if (eqMatrix(matrix, cumulative)) {
+                r.push(cumulative);
+            }
+            if (eqMatrix(matrix, minified)) {
+                r.push(minified);
+            }
+            const l = renderToken(matrix).length;
+            node.val = r.reduce((acc, curr) => {
+                if (curr.reduce((acc, t) => acc + renderToken(t), '').length < l) {
+                    return curr;
+                }
+                return acc;
+            }, [matrix]);
+        }
+    }
+}
+
+export { TransformCssFeature };

package/dist/lib/ast/math/expression.js

@@ -39,14 +39,19 @@ function evaluate(tokens) {
         return tokens;
     }
     if (nodes.length <= 1) {
-        // @ts-ignore
-        if (nodes.length == 1 && nodes[0].typ == EnumToken.IdenTokenType && typeof Math[nodes[0].val.toUpperCase()] == 'number') {
-            return [{
-                    ...nodes[0],
-                    // @ts-ignore
-                    val: '' + Math[nodes[0].val.toUpperCase()],
-                    typ: EnumToken.NumberTokenType
-                }];
+        if (nodes.length == 1) {
+            if (nodes[0].typ == EnumToken.BinaryExpressionTokenType) {
+                return inlineExpression(nodes[0]);
+            }
+            // @ts-ignore
+            if (nodes[0].typ == EnumToken.IdenTokenType && typeof Math[nodes[0].val.toUpperCase()] == 'number') {
+                return [{
+                        ...nodes[0],
+                        // @ts-ignore
+                        val: '' + Math[nodes[0].val.toUpperCase()],
+                        typ: EnumToken.NumberTokenType
+                    }];
+            }
         }
         return nodes;
     }
@@ -167,7 +172,6 @@ function doEvaluate(l, r, op) {
     }
     // @ts-ignore
     const val = compute(v1, v2, op);
-    // typ = typeof val == 'number' ? EnumToken.NumberTokenType : EnumToken.FractionTokenType;
     const token = {
         ...(l.typ == EnumToken.NumberTokenType ? r : l),
         typ,
@@ -513,4 +517,4 @@ function factor(tokens, ops) {
     return tokens;
 }
 
-export { evaluate, evaluateFunc };
+export { evaluate, evaluateFunc, inlineExpression };

package/dist/lib/ast/math/math.js

@@ -4,9 +4,20 @@ import { reduceNumber } from '../../renderer/render.js';
 function gcd(x, y) {
     x = Math.abs(x);
     y = Math.abs(y);
+    if (x == y) {
+        return x;
+    }
     let t;
-    if (x == 0 || y == 0) {
-        return 1;
+    if (x == 0) {
+        return y;
+    }
+    if (y == 0) {
+        return x;
+    }
+    if (y > x) {
+        t = x;
+        x = y;
+        y = t;
     }
     while (y) {
         t = y;
@@ -76,6 +87,7 @@ function compute(a, b, op) {
             r2 = l1.r.val * r1.l.val;
             break;
     }
+    // @ts-ignore
     const a2 = simplify(l2, r2);
     if (a2[1] == 1) {
         return a2[0];

package/dist/lib/ast/minify.js

@@ -69,9 +69,9 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             nestingContent = options.nestingRules && ast.typ == EnumToken.RuleNodeType;
         }
         let i = 0;
-        let previous;
+        let previous = null;
         let node;
-        let nodeIndex;
+        let nodeIndex = -1;
         // @ts-ignore
         for (; i < ast.chi.length; i++) {
             // @ts-ignore
@@ -83,13 +83,50 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
             // @ts-ignore
             if (previous == node) {
                 // @ts-ignore
-                ast.chi.splice(i, 1);
-                i--;
+                ast.chi.splice(i--, 1);
                 continue;
             }
             if (node.typ == EnumToken.AtRuleNodeType && node.nam == 'font-face') {
                 continue;
             }
+            if (node.typ == EnumToken.KeyframeAtRuleNodeType) {
+                if (previous?.typ == EnumToken.KeyframeAtRuleNodeType &&
+                    node.nam == previous.nam &&
+                    node.val == previous.val) {
+                    ast.chi?.splice(nodeIndex--, 1);
+                    previous = ast?.chi?.[nodeIndex] ?? null;
+                    i = nodeIndex;
+                    continue;
+                }
+                if (node.chi.length > 0) {
+                    minify(node, options, true, errors, nestingContent, context);
+                }
+            }
+            if (node.typ == EnumToken.KeyFrameRuleNodeType) {
+                if (previous?.typ == EnumToken.KeyFrameRuleNodeType &&
+                    node.sel == previous.sel) {
+                    previous.chi.push(...node.chi);
+                    // @ts-ignore
+                    ast.chi.splice(i--, 1);
+                    continue;
+                }
+                let k;
+                for (k = 0; k < node.chi.length; k++) {
+                    if (node.chi[k].typ == EnumToken.DeclarationNodeType) {
+                        let l = node.chi[k].val.length;
+                        while (l--) {
+                            if (node.chi[k].val[l].typ == EnumToken.ImportantTokenType) {
+                                node.chi.splice(k--, 1);
+                                break;
+                            }
+                            if ([EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(node.chi[k].val[l].typ)) {
+                                continue;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
             if (node.typ == EnumToken.AtRuleNodeType) {
                 // @ts-ignore
                 if (node.nam == 'media' && ['all', '', null].includes(node.val)) {
@@ -340,6 +377,10 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
                     }
                 }
             }
+            // else if ('chi' in node) {
+            //
+            //     minify(node, options, recursive, errors, nestingContent, context);
+            // }
             if (!nestingContent &&
                 // @ts-ignore
                 previous != null &&
@@ -354,7 +395,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
         // @ts-ignore
         if (recursive && node != null && ('chi' in node)) {
             // @ts-ignore
-            if (!node.chi.some(n => n.typ == EnumToken.DeclarationNodeType)) {
+            if (node.typ == EnumToken.KeyframeAtRuleNodeType || !node.chi.some(n => n.typ == EnumToken.DeclarationNodeType)) {
                 // @ts-ignore
                 if (!(node.typ == EnumToken.AtRuleNodeType && node.nam != 'font-face')) {
                     minify(node, options, recursive, errors, nestingContent, context);