@tbela99/css-parser 0.3.0 → 0.4.0

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

@@ -21,7 +21,7 @@ class ComputeCalcExpressionFeature extends MinifyFeature {
     }
     run(ast) {
         if (!('chi' in ast)) {
-            return ast;
+            return;
         }
         // @ts-ignore
         for (const node of ast.chi) {
@@ -58,7 +58,6 @@ class ComputeCalcExpressionFeature extends MinifyFeature {
                 }
             }
         }
-        return ast;
     }
 }
 

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

@@ -45,7 +45,7 @@ class InlineCssVariablesFeature extends MinifyFeature {
         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) {

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

@@ -1,8 +1,8 @@
 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 { MinifyFeature } from '../utils/minifyfeature.js';
 

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

@@ -72,10 +72,41 @@ function doEvaluate(l, r, op) {
             return defaultReturn;
         }
     }
-    const typ = l.typ == EnumToken.NumberTokenType ? r.typ : l.typ;
+    else if (op == EnumToken.Mul &&
+        ![EnumToken.NumberTokenType, EnumToken.PercentageTokenType].includes(l.typ) &&
+        ![EnumToken.NumberTokenType, EnumToken.PercentageTokenType].includes(r.typ)) {
+        return defaultReturn;
+    }
+    const typ = l.typ == EnumToken.NumberTokenType ? r.typ : (r.typ == EnumToken.NumberTokenType ? l.typ : (l.typ == EnumToken.PercentageTokenType ? r.typ : l.typ));
+    // @ts-ignore
+    let v1 = typeof l.val == 'string' ? +l.val : l.val;
     // @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 };
+    let v2 = typeof r.val == 'string' ? +r.val : r.val;
+    if (op == EnumToken.Mul) {
+        if (l.typ != EnumToken.NumberTokenType && r.typ != EnumToken.NumberTokenType) {
+            if (typeof v1 == 'number' && l.typ == EnumToken.PercentageTokenType) {
+                v1 = {
+                    typ: EnumToken.FractionTokenType,
+                    l: { typ: EnumToken.NumberTokenType, val: String(v1) },
+                    r: { typ: EnumToken.NumberTokenType, val: '100' }
+                };
+            }
+            else if (typeof v2 == 'number' && r.typ == EnumToken.PercentageTokenType) {
+                v2 = {
+                    typ: EnumToken.FractionTokenType,
+                    l: { typ: EnumToken.NumberTokenType, val: String(v2) },
+                    r: { typ: EnumToken.NumberTokenType, val: '100' }
+                };
+            }
+        }
+    }
+    // @ts-ignore
+    const val = compute(v1, v2, op);
+    return {
+        ...(l.typ == EnumToken.NumberTokenType ? r : l),
+        typ,
+        val: typeof val == 'number' ? reduceNumber(val) : val
+    };
 }
 /**
  * convert BinaryExpression into an array
@@ -166,6 +197,10 @@ function factor(tokens, ops) {
         return [factorToken(tokens[0])];
     }
     for (let i = 0; i < tokens.length; i++) {
+        if (tokens[i].typ == EnumToken.ListToken) {
+            // @ts-ignore
+            tokens.splice(i, 1, ...tokens[i].chi);
+        }
         isOp = opList.includes(tokens[i].typ);
         if (isOp ||
             // @ts-ignore

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

@@ -1,7 +1,7 @@
 import { EnumToken } from '../types.js';
 import { reduceNumber } from '../../renderer/render.js';
 
-const gcd = (x, y) => {
+function gcd(x, y) {
     x = Math.abs(x);
     y = Math.abs(y);
     let t;
@@ -14,7 +14,7 @@ const gcd = (x, y) => {
         x = t;
     }
     return x;
-};
+}
 function compute(a, b, op) {
     if (typeof a == 'number' && typeof b == 'number') {
         switch (op) {

package/dist/lib/ast/minify.js

@@ -17,7 +17,6 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent, co
         context.nodes = new WeakSet;
     }
     if (context.nodes.has(ast)) {
-        // console.error('skipped', ast.typ);
         return ast;
     }
     context.nodes.add(ast);

package/dist/lib/ast/types.js

@@ -78,6 +78,7 @@ var EnumToken;
     /* aliases */
     EnumToken[EnumToken["Time"] = 25] = "Time";
     EnumToken[EnumToken["Iden"] = 7] = "Iden";
+    EnumToken[EnumToken["EOF"] = 47] = "EOF";
     EnumToken[EnumToken["Hash"] = 28] = "Hash";
     EnumToken[EnumToken["Flex"] = 57] = "Flex";
     EnumToken[EnumToken["Angle"] = 24] = "Angle";

package/dist/lib/ast/utils/minifyfeature.js

@@ -1,7 +1,8 @@
 class MinifyFeature {
-    static get ordering() { return 10000; }
-    register(options) { }
-    run(ast, options = {}, parent, context) {
+    static get ordering() {
+        return 10000;
+    }
+    register(options) {
     }
 }
 

package/dist/lib/parser/declaration/list.js

@@ -1,8 +1,8 @@
 import { PropertySet } from './set.js';
-import '../../renderer/utils/color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { parseString } from '../parse.js';
+import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 import { getConfig } from '../utils/config.js';
 import { PropertyMap } from './map.js';

package/dist/lib/parser/declaration/map.js

@@ -1,9 +1,9 @@
 import { eq } from '../utils/eq.js';
 import { renderToken } from '../../renderer/render.js';
-import '../../renderer/utils/color.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { parseString } from '../parse.js';
+import '../../renderer/color/utils/constants.js';
 import { getConfig } from '../utils/config.js';
 import { matchType } from '../utils/type.js';
 import { PropertySet } from './set.js';
@@ -22,12 +22,10 @@ class PropertyMap {
         this.pattern = config.pattern.split(/\s/);
     }
     add(declaration) {
-        for (const val of declaration.val) {
-            Object.defineProperty(val, 'propertyName', { enumerable: false, writable: true, value: declaration.nam });
-        }
         if (declaration.nam == this.config.shorthand) {
             this.declarations = new Map;
             this.declarations.set(declaration.nam, declaration);
+            this.matchTypes(declaration);
         }
         else {
             const separator = this.config.separator != null ? {
@@ -165,6 +163,55 @@ class PropertyMap {
         }
         return this;
     }
+    matchTypes(declaration) {
+        const patterns = this.pattern.slice();
+        const values = [...declaration.val];
+        let i;
+        let j;
+        const map = new Map;
+        for (i = 0; i < patterns.length; i++) {
+            for (j = 0; j < values.length; j++) {
+                if (!map.has(patterns[i])) {
+                    // @ts-ignore
+                    map.set(patterns[i], this.config.properties?.[patterns[i]]?.constraints?.mapping?.max ?? 1);
+                }
+                let count = map.get(patterns[i]);
+                if (count > 0 && matchType(values[j], this.config.properties[patterns[i]])) {
+                    Object.defineProperty(values[j], 'propertyName', {
+                        enumerable: false,
+                        writable: true,
+                        value: patterns[i]
+                    });
+                    map.set(patterns[i], --count);
+                    values.splice(j--, 1);
+                }
+            }
+        }
+        if (this.config.set != null) {
+            for (const [key, val] of Object.entries(this.config.set)) {
+                if (map.has(key)) {
+                    for (const v of val) {
+                        // missing
+                        if (map.get(v) == 1) {
+                            let i = declaration.val.length;
+                            while (i--) {
+                                // @ts-ignore
+                                if (declaration.val[i].propertyName == key) {
+                                    const val = { ...declaration.val[i] };
+                                    Object.defineProperty(val, 'propertyName', {
+                                        enumerable: false,
+                                        writable: true,
+                                        value: v
+                                    });
+                                    declaration.val.splice(i, 0, val, { typ: EnumToken.WhitespaceTokenType });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
     [Symbol.iterator]() {
         let iterable;
         let requiredCount = 0;
@@ -195,34 +242,60 @@ class PropertyMap {
             if (isShorthand && this.declarations.has(this.config.shorthand)) {
                 const cache = new Map();
                 const removeDefaults = (declaration) => {
-                    let config = this.config.shorthand == declaration.nam ? this.config : this.config.properties[declaration.nam];
-                    if (config == null && declaration.nam in propertiesConfig.properties) {
-                        // @ts-ignore
-                        const shorthand = propertiesConfig.properties[declaration.nam].shorthand;
-                        // @ts-ignore
-                        config = propertiesConfig.properties[shorthand];
-                    }
-                    declaration.val = declaration.val.map((t) => {
+                    let i;
+                    let t;
+                    let map = new Map();
+                    let value = [];
+                    let values = [];
+                    // @ts-ignore
+                    let typ = (EnumToken[this.config.separator?.typ] ?? EnumToken.CommaTokenType);
+                    let separator = this.config.separator ? renderToken(this.config.separator) : ',';
+                    this.matchTypes(declaration);
+                    values.push(value);
+                    for (i = 0; i < declaration.val.length; i++) {
+                        t = declaration.val[i];
                         if (!cache.has(t)) {
                             cache.set(t, renderToken(t, { minify: true }));
                         }
-                        const value = cache.get(t);
+                        if (t.typ == typ && separator == cache.get(t)) {
+                            this.removeDefaults(map, value);
+                            value = [];
+                            values.push(value);
+                            map.clear();
+                            continue;
+                        }
+                        value.push(t);
                         // @ts-ignore
-                        if (config?.mapping?.[value] != null) {
+                        if ('propertyName' in t) {
                             // @ts-ignore
-                            t = parseString(config.mapping[value])[0];
-                            cache.set(t, renderToken(t, { minify: true }));
+                            if (!map.has(t.propertyName)) {
+                                // @ts-ignore
+                                map.set(t.propertyName, { t: [t], value: [cache.get(t)] });
+                            }
+                            else {
+                                // @ts-ignore
+                                const v = map.get(t.propertyName);
+                                v.t.push(t);
+                                v.value.push(cache.get(t));
+                            }
+                        }
+                    }
+                    this.removeDefaults(map, value);
+                    declaration.val = values.reduce((acc, curr) => {
+                        for (const cr of curr) {
+                            if (cr.typ == EnumToken.WhitespaceTokenType && acc.at(-1)?.typ == cr.typ) {
+                                continue;
+                            }
+                            acc.push(cr);
                         }
-                        return t;
-                    }).filter((val) => {
-                        return !config?.default?.includes(cache.get(val));
-                    })
-                        .filter((val, index, array) => !(index > 0 &&
-                        val.typ == EnumToken.WhitespaceTokenType &&
-                        array[index - 1].typ == EnumToken.WhitespaceTokenType));
-                    if (declaration.val.at(-1)?.typ == EnumToken.WhitespaceTokenType) {
+                        return acc;
+                    }, []);
+                    while (declaration.val.at(-1)?.typ == EnumToken.WhitespaceTokenType) {
                         declaration.val.pop();
                     }
+                    while (declaration.val.at(0)?.typ == EnumToken.WhitespaceTokenType) {
+                        declaration.val.shift();
+                    }
                     return declaration;
                 };
                 const values = [...this.declarations.values()].reduce((acc, curr) => {
@@ -322,12 +395,12 @@ class PropertyMap {
                 return acc;
             }, []);
             count++;
-            if (!isShorthand || Object.entries(this.config.properties).some(entry => {
+            if (!isShorthand || Object.entries(this.config.properties).some((entry) => {
                 // missing required property
                 return entry[1].required && !(entry[0] in tokens);
             }) ||
                 // @ts-ignore
-                !Object.values(tokens).every(v => v.filter(t => t.typ != EnumToken.CommentTokenType).length == count)) {
+                !Object.values(tokens).every((v) => v.filter((t) => t.typ != EnumToken.CommentTokenType).length == count)) {
                 // @ts-ignore
                 iterable = this.declarations.values();
             }
@@ -482,6 +555,36 @@ class PropertyMap {
             }
         };
     }
+    removeDefaults(map, value) {
+        for (const [key, val] of map) {
+            const config = this.config.properties[key];
+            if (config == null) {
+                continue;
+            }
+            const v = val.value.join(' ');
+            if (config.default.includes(v) || (value.length == 1 && this.config.default.includes(v))) {
+                for (const token of value) {
+                    if (val.t.includes(token)) {
+                        let index = value.indexOf(token);
+                        value.splice(index, 1);
+                        if (config.prefix != null) {
+                            while (index-- > 0) {
+                                if (value[index].typ == EnumToken.WhitespaceTokenType) {
+                                    continue;
+                                }
+                                if (value[index].typ == EnumToken[config.prefix.typ] &&
+                                    // @ts-ignore
+                                    value[index].val == config.prefix.val) {
+                                    value.splice(index, 1);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
 }
 
 export { PropertyMap };

package/dist/lib/parser/declaration/set.js

@@ -3,7 +3,7 @@ import { isLength } from '../utils/syntax.js';
 import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import '../parse.js';
-import '../../renderer/utils/color.js';
+import '../../renderer/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 function dedup(values) {