@tbela99/css-parser 0.2.0 → 0.3.0

package/dist/lib/ast/walk.js

@@ -1,3 +1,5 @@
+import { EnumToken } from './types.js';
+
 function* walk(node, filter) {
     const parents = [node];
     const root = node;
@@ -27,20 +29,38 @@ function* walk(node, filter) {
         }
     }
 }
-function* walkValues(values) {
+function* walkValues(values, root = null, filter) {
     const stack = values.slice();
     const weakMap = new WeakMap;
     let value;
     while (stack.length > 0) {
         value = stack.shift();
+        let option = null;
+        if (filter != null) {
+            option = filter(value);
+            if (option === 'ignore') {
+                continue;
+            }
+            if (option === 'stop') {
+                break;
+            }
+        }
         // @ts-ignore
-        yield { value, parent: weakMap.get(value) };
-        if ('chi' in value) {
-            for (const child of value.chi) {
+        if (option !== 'children') {
+            // @ts-ignore
+            yield { value, parent: weakMap.get(value), root };
+        }
+        if (option !== 'ignore-children' && 'chi' in value) {
+            for (const child of value.chi.slice()) {
                 weakMap.set(child, value);
             }
             stack.unshift(...value.chi);
         }
+        else if (value.typ == EnumToken.BinaryExpressionTokenType) {
+            weakMap.set(value.l, value);
+            weakMap.set(value.r, value);
+            stack.unshift(value.l, value.r);
+        }
     }
 }
 

package/dist/lib/fs/resolve.js

@@ -35,13 +35,14 @@ function splitPath(result) {
             parts[parts.length - 1] += chr;
         }
     }
-    let k = parts.length;
-    while (k--) {
+    let k = -1;
+    while (++k < parts.length) {
         if (parts[k] == '.') {
-            parts.splice(k, 1);
+            parts.splice(k--, 1);
         }
         else if (parts[k] == '..') {
             parts.splice(k - 1, 2);
+            k -= 2;
         }
     }
     return { parts, i };

package/dist/lib/iterable/weakset.js

@@ -0,0 +1,48 @@
+class IterableWeakSet {
+    #weakset = new WeakSet;
+    #set = new Set;
+    constructor(iterable) {
+        if (iterable) {
+            for (const value of iterable) {
+                const ref = new WeakRef(value);
+                this.#weakset.add(value);
+                this.#set.add(ref);
+            }
+        }
+    }
+    has(value) {
+        return this.#weakset.has(value);
+    }
+    delete(value) {
+        if (this.#weakset.has(value)) {
+            for (const ref of this.#set) {
+                if (ref.deref() === value) {
+                    this.#set.delete(ref);
+                    break;
+                }
+            }
+            return this.#weakset.delete(value);
+        }
+        return false;
+    }
+    add(value) {
+        if (!this.#weakset.has(value)) {
+            this.#weakset.add(value);
+            this.#set.add(new WeakRef(value));
+        }
+        return this;
+    }
+    *[Symbol.iterator]() {
+        for (const ref of new Set(this.#set)) {
+            const key = ref.deref();
+            if (key != null) {
+                yield key;
+            }
+            else {
+                this.#set.delete(ref);
+            }
+        }
+    }
+}
+
+export { IterableWeakSet };

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

@@ -21,7 +21,11 @@ class PropertyList {
         this.declarations = new Map;
     }
     set(nam, value) {
-        return this.add({ typ: EnumToken.DeclarationNodeType, nam, val: Array.isArray(value) ? value : parseString(String(value)) });
+        return this.add({
+            typ: EnumToken.DeclarationNodeType,
+            nam,
+            val: Array.isArray(value) ? value : parseString(String(value))
+        });
     }
     add(declaration) {
         if (declaration.typ != EnumToken.DeclarationNodeType || !this.options.removeDuplicateDeclarations) {

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

@@ -7,9 +7,7 @@ import { parseString } from '../parse.js';
 import { getConfig } from '../utils/config.js';
 import { matchType } from '../utils/type.js';
 import { PropertySet } from './set.js';
-import { IterableWeakMap } from '../../iterable/weakmap.js';
 
-const cache = new IterableWeakMap();
 const propertiesConfig = getConfig();
 class PropertyMap {
     config;
@@ -195,15 +193,29 @@ class PropertyMap {
         }
         if (!isShorthand || requiredCount < this.requiredCount) {
             if (isShorthand && this.declarations.has(this.config.shorthand)) {
-                // console.debug(...this.declarations.values());
+                const cache = new Map();
                 const removeDefaults = (declaration) => {
-                    // const dec: AstDeclaration = {...declaration};
-                    const config = this.config.shorthand == declaration.nam ? this.config : this.config.properties[declaration.nam];
-                    declaration.val = declaration.val.filter((val) => {
-                        if (!cache.has(val)) {
-                            cache.set(val, renderToken(val, { minify: true }));
+                    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) => {
+                        if (!cache.has(t)) {
+                            cache.set(t, renderToken(t, { minify: true }));
                         }
-                        return !config.default.includes(cache.get(val));
+                        const value = cache.get(t);
+                        // @ts-ignore
+                        if (config?.mapping?.[value] != null) {
+                            // @ts-ignore
+                            t = parseString(config.mapping[value])[0];
+                            cache.set(t, renderToken(t, { minify: true }));
+                        }
+                        return t;
+                    }).filter((val) => {
+                        return !config?.default?.includes(cache.get(val));
                     })
                         .filter((val, index, array) => !(index > 0 &&
                         val.typ == EnumToken.WhitespaceTokenType &&
@@ -222,13 +234,24 @@ class PropertyMap {
                     }
                     return acc;
                 }, []);
-                const filtered = values.map(removeDefaults).filter((x) => x.val.length > 0);
+                let isImportant = false;
+                const filtered = values.map(removeDefaults).filter((x) => x.val.filter((t) => {
+                    if (t.typ == EnumToken.ImportantTokenType) {
+                        isImportant = true;
+                    }
+                    return ![EnumToken.WhitespaceTokenType, EnumToken.ImportantTokenType].includes(t.typ);
+                }).length > 0);
                 if (filtered.length == 0 && this.config.default.length > 0) {
                     filtered.push({
                         typ: EnumToken.DeclarationNodeType,
                         nam: this.config.shorthand,
                         val: parseString(this.config.default[0])
                     });
+                    if (isImportant) {
+                        filtered[0].val.push({
+                            typ: EnumToken.ImportantTokenType
+                        });
+                    }
                 }
                 return (filtered.length > 0 ? filtered : values)[Symbol.iterator]();
             }
@@ -324,7 +347,9 @@ class PropertyMap {
                         }, []);
                         // @todo remove renderToken call
                         if (props.default.includes(curr[1][i].reduce((acc, curr) => acc + renderToken(curr) + ' ', '').trimEnd())) {
-                            continue;
+                            if (!this.config.properties[curr[0]].required) {
+                                continue;
+                            }
                         }
                         // remove default values
                         let doFilterDefault = true;
@@ -338,12 +363,15 @@ class PropertyMap {
                             }
                         }
                         // remove default values
-                        values = values.filter((val) => {
+                        const filtered = values.filter((val) => {
                             if (val.typ == EnumToken.WhitespaceTokenType || val.typ == EnumToken.CommentTokenType) {
                                 return false;
                             }
                             return !doFilterDefault || !(val.typ == EnumToken.IdenTokenType && props.default.includes(val.val));
                         });
+                        if (filtered.length > 0 || !(this.requiredCount == requiredCount && this.config.properties[curr[0]].required)) {
+                            values = filtered;
+                        }
                         if (values.length > 0) {
                             if ('mapping' in props) {
                                 // @ts-ignore
@@ -399,7 +427,10 @@ class PropertyMap {
                     return acc;
                 }, []);
                 if (this.config.mapping != null) {
-                    const val = values.reduce((acc, curr) => acc + renderToken(curr, { removeComments: true, minify: true }), '');
+                    const val = values.reduce((acc, curr) => acc + renderToken(curr, {
+                        removeComments: true,
+                        minify: true
+                    }), '');
                     if (val in this.config.mapping) {
                         values.length = 0;
                         values.push({

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

@@ -6,6 +6,29 @@ import '../parse.js';
 import '../../renderer/utils/color.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
+function dedup(values) {
+    for (const value of values) {
+        let i = value.length;
+        while (i-- > 1) {
+            const t = value[i];
+            const k = value[i == 1 ? 0 : i % 2];
+            if (t.val == k.val && t.val == '0') {
+                if ((t.typ == EnumToken.NumberTokenType && isLength(k)) ||
+                    (k.typ == EnumToken.NumberTokenType && isLength(t)) ||
+                    (isLength(k) || isLength(t))) {
+                    value.splice(i, 1);
+                    continue;
+                }
+            }
+            if (eq(t, k)) {
+                value.splice(i, 1);
+                continue;
+            }
+            break;
+        }
+    }
+    return values;
+}
 class PropertySet {
     config;
     declarations;
@@ -100,7 +123,23 @@ class PropertySet {
         let iterator;
         const declarations = this.declarations;
         if (declarations.size < this.config.properties.length) {
-            iterator = declarations.values();
+            const values = [...declarations.values()];
+            if (this.isShortHand()) {
+                const val = values[0].val.reduce((acc, curr) => {
+                    if (![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(curr.typ)) {
+                        acc.push(curr);
+                    }
+                    return acc;
+                }, []);
+                values[0].val = val.reduce((acc, curr) => {
+                    if (acc.length > 0) {
+                        acc.push({ typ: EnumToken.WhitespaceTokenType });
+                    }
+                    acc.push(curr);
+                    return acc;
+                }, []);
+            }
+            return values[Symbol.iterator]();
         }
         else {
             const values = [];
@@ -118,26 +157,7 @@ class PropertySet {
                     index++;
                 }
             });
-            for (const value of values) {
-                let i = value.length;
-                while (i-- > 1) {
-                    const t = value[i];
-                    const k = value[i == 1 ? 0 : i % 2];
-                    if (t.val == k.val && t.val == '0') {
-                        if ((t.typ == EnumToken.NumberTokenType && isLength(k)) ||
-                            (k.typ == EnumToken.NumberTokenType && isLength(t)) ||
-                            (isLength(k) || isLength(t))) {
-                            value.splice(i, 1);
-                            continue;
-                        }
-                    }
-                    if (eq(t, k)) {
-                        value.splice(i, 1);
-                        continue;
-                    }
-                    break;
-                }
-            }
+            dedup(values);
             iterator = [{
                     typ: EnumToken.DeclarationNodeType,
                     nam: this.config.shorthand,

package/dist/lib/parser/parse.js

@@ -1,24 +1,15 @@
-import { isPseudo, isAtKeyword, isFunction, isNumber, isDimension, parseDimension, isPercentage, isIdent, isHexColor, isHash, isIdentStart, isColor } from './utils/syntax.js';
-import { EnumToken } from '../ast/types.js';
+import { isPseudo, isAtKeyword, isFunction, isNumber, isPercentage, isFlex, isDimension, parseDimension, isIdent, isHexColor, isHash, isIdentStart, isColor } from './utils/syntax.js';
+import { EnumToken, funcLike } from '../ast/types.js';
 import { minify, combinators } from '../ast/minify.js';
 import { walkValues, walk } from '../ast/walk.js';
 import { expand } from '../ast/expand.js';
+import { parseDeclaration } from './utils/declaration.js';
 import { renderToken } from '../renderer/render.js';
 import { COLORS_NAMES } from '../renderer/utils/color.js';
 import { tokenize } from './tokenize.js';
 
 const urlTokenMatcher = /^(["']?)[a-zA-Z0-9_/.-][a-zA-Z0-9_/:.#?-]+(\1)$/;
 const trimWhiteSpace = [EnumToken.CommentTokenType, EnumToken.GtTokenType, EnumToken.GteTokenType, EnumToken.LtTokenType, EnumToken.LteTokenType, EnumToken.ColumnCombinatorTokenType];
-const funcLike = [
-    EnumToken.ParensTokenType,
-    EnumToken.FunctionTokenType,
-    EnumToken.UrlFunctionTokenType,
-    EnumToken.StartParensTokenType,
-    EnumToken.ImageFunctionTokenType,
-    EnumToken.PseudoClassFuncTokenType,
-    EnumToken.TimingFunctionTokenType,
-    EnumToken.TimingFunctionTokenType
-];
 const BadTokensTypes = [
     EnumToken.BadCommentTokenType,
     EnumToken.BadCdoTokenType,
@@ -37,6 +28,7 @@ async function doParse(iterator, options = {}) {
             src: '',
             sourcemap: false,
             minify: true,
+            parseColor: true,
             nestingRules: false,
             resolveImport: false,
             resolveUrls: false,
@@ -312,7 +304,7 @@ async function doParse(iterator, options = {}) {
                         if (tokens[i].typ == EnumToken.ColonTokenType) {
                             name = tokens.slice(0, i);
                             value = parseTokens(tokens.slice(i + 1), {
-                                parseColor: true,
+                                parseColor: options.parseColor,
                                 src: options.src,
                                 resolveUrls: options.resolveUrls,
                                 resolve: options.resolve,
@@ -351,19 +343,11 @@ async function doParse(iterator, options = {}) {
                         // @ts-ignore
                         val: value
                     };
-                    while (node.val[0]?.typ == EnumToken.WhitespaceTokenType) {
-                        node.val.shift();
-                    }
-                    if (node.val.length == 0) {
-                        errors.push({
-                            action: 'drop',
-                            message: 'doParse: invalid declaration',
-                            location: { src, ...position }
-                        });
-                        return null;
+                    const result = parseDeclaration(node, errors, src, position);
+                    if (result != null) {
+                        // @ts-ignore
+                        context.chi.push(node);
                     }
-                    // @ts-ignore
-                    context.chi.push(node);
                     return null;
                 }
             }
@@ -620,15 +604,21 @@ function getTokenType(val, hint) {
             val
         };
     }
-    if (isDimension(val)) {
-        return parseDimension(val);
-    }
     if (isPercentage(val)) {
         return {
             typ: EnumToken.PercentageTokenType,
             val: val.slice(0, -1)
         };
     }
+    if (isFlex(val)) {
+        return {
+            typ: EnumToken.FlexTokenType,
+            val: val.slice(0, -2)
+        };
+    }
+    if (isDimension(val)) {
+        return parseDimension(val);
+    }
     const v = val.toLowerCase();
     if (v == 'currentcolor' || val == 'transparent' || v in COLORS_NAMES) {
         return {
@@ -728,15 +718,6 @@ function parseTokens(tokens, options = {}) {
                 // @ts-ignore
                 parseTokens(t.chi, t.typ);
             }
-            // @ts-ignore
-            // t.chi.forEach(val => {
-            //     if (val.typ == EnumToken.StringTokenType) {
-            //         const slice = val.val.slice(1, -1);
-            //         if ((slice.charAt(0) != '-' || (slice.charAt(0) == '-' && isIdentStart(slice.charCodeAt(1)))) && isIdent(slice)) {
-            //             Object.assign(val, {typ: EnumToken.IdenTokenType, val: slice});
-            //         }
-            //     }
-            // });
             let m = t.chi.length;
             let val;
             for (m = 0; m < t.chi.length; m++) {
@@ -871,6 +852,11 @@ function parseTokens(tokens, options = {}) {
                 // @ts-ignore
                 t.chi.pop();
             }
+            // @ts-ignore
+            if (t.chi.length > 0) {
+                // @ts-ignore
+                parseTokens(t.chi, options);
+            }
             if (t.typ == EnumToken.FunctionTokenType && t.val == 'calc') {
                 for (const { value, parent } of walkValues(t.chi)) {
                     if (value.typ == EnumToken.WhitespaceTokenType) {
@@ -893,35 +879,25 @@ function parseTokens(tokens, options = {}) {
                     }
                 }
             }
+            else if (t.typ == EnumToken.FunctionTokenType && ['minmax', 'fit-content', 'repeat'].includes(t.val)) {
+                // @ts-ignore
+                t.typ = EnumToken.GridTemplateFuncTokenType;
+            }
             else if (t.typ == EnumToken.StartParensTokenType) {
                 // @ts-ignore
                 t.typ = EnumToken.ParensTokenType;
             }
             // @ts-ignore
             if (options.parseColor && t.typ == EnumToken.FunctionTokenType && isColor(t)) {
-                // if (isColor) {
                 // @ts-ignore
                 t.typ = EnumToken.ColorTokenType;
                 // @ts-ignore
                 t.kin = t.val;
-                // @ts-ignore
-                let m = t.chi.length;
-                while (m-- > 0) {
+                if (t.chi[0].typ == EnumToken.IdenTokenType && t.chi[0].val == 'from') {
                     // @ts-ignore
-                    if ([EnumToken.LiteralTokenType].concat(trimWhiteSpace).includes(t.chi[m].typ)) {
-                        // @ts-ignore
-                        if (t.chi[m + 1]?.typ == EnumToken.WhitespaceTokenType) {
-                            // @ts-ignore
-                            t.chi.splice(m + 1, 1);
-                        }
-                        // @ts-ignore
-                        if (t.chi[m - 1]?.typ == EnumToken.WhitespaceTokenType) {
-                            // @ts-ignore
-                            t.chi.splice(m - 1, 1);
-                            m--;
-                        }
-                    }
+                    t.cal = 'rel';
                 }
+                t.chi = t.chi.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommaTokenType, EnumToken.CommentTokenType].includes(t.typ));
                 continue;
             }
             if (t.typ == EnumToken.UrlFunctionTokenType) {
@@ -946,8 +922,6 @@ function parseTokens(tokens, options = {}) {
             }
             // @ts-ignore
             if (t.chi.length > 0) {
-                // @ts-ignore
-                parseTokens(t.chi, options);
                 if (t.typ == EnumToken.PseudoClassFuncTokenType && t.val == ':is' && options.minify) {
                     //
                     const count = t.chi.filter(t => t.typ != EnumToken.CommentTokenType).length;

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

@@ -0,0 +1,67 @@
+import { EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
+import { walkValues } from '../../ast/walk.js';
+import '../parse.js';
+import { isWhiteSpace } from './syntax.js';
+import '../../renderer/utils/color.js';
+import '../../renderer/sourcemap/lib/encode.js';
+
+function parseDeclaration(node, errors, src, position) {
+    while (node.val[0]?.typ == EnumToken.WhitespaceTokenType) {
+        node.val.shift();
+    }
+    if (node.val.filter((t) => ![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ)).length == 0) {
+        errors.push({
+            action: 'drop',
+            message: 'doParse: invalid declaration',
+            location: { src, ...position }
+        });
+        return null;
+    }
+    for (const { value: val, parent } of walkValues(node.val, node)) {
+        if (val.typ == EnumToken.AttrTokenType && val.chi.every((t) => [EnumToken.IdenTokenType, EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType].includes(t.typ))) {
+            // @ts-ignore
+            val.typ = EnumToken.IdenListTokenType;
+        }
+        else if (val.typ == EnumToken.StringTokenType && (node.nam == 'grid' || node.nam == 'grid-template-areas' || node.nam == 'grid-template-rows' || node.nam == 'grid-template-columns')) {
+            val.val = val.val.at(0) + parseGridTemplate(val.val.slice(1, -1)) + val.val.at(-1);
+            // @ts-ignore
+            const array = parent?.chi ?? node.val;
+            const index = array.indexOf(val);
+            if (index > 0 && array[index - 1].typ == EnumToken.WhitespaceTokenType) {
+                array.splice(index - 1, 1);
+            }
+        }
+    }
+    return node;
+}
+function parseGridTemplate(template) {
+    let result = '';
+    let buffer = '';
+    for (let i = 0; i < template.length; i++) {
+        const char = template[i];
+        if (isWhiteSpace(char.codePointAt(0))) {
+            while (i + 1 < template.length && isWhiteSpace(template[i + 1].codePointAt(0))) {
+                i++;
+            }
+            result += buffer + ' ';
+            buffer = '';
+        }
+        else if (char == '.') {
+            while (i + 1 < template.length && template[i + 1] == '.') {
+                i++;
+            }
+            if (isWhiteSpace((result.at(-1)?.codePointAt(0)))) {
+                result = result.slice(0, -1);
+            }
+            result += buffer + char;
+            buffer = '';
+        }
+        else {
+            buffer += char;
+        }
+    }
+    return buffer.length > 0 ? result + buffer : result;
+}
+
+export { parseDeclaration };

package/dist/lib/parser/utils/syntax.js

@@ -37,10 +37,37 @@ function isColor(token) {
         // named color
         return token.val.toLowerCase() in COLORS_NAMES;
     }
+    let isLegacySyntax = false;
     if (token.typ == EnumToken.FunctionTokenType && token.chi.length > 0 && colorsFunc.includes(token.val)) {
+        const keywords = ['from', 'none'];
+        if (['rgb', 'hsl', 'hwb'].includes(token.val)) {
+            keywords.push('a', ...token.val.split(''));
+        }
+        // console.debug(JSON.stringify({token}, null, 1));
         // @ts-ignore
         for (const v of token.chi) {
-            if (![EnumToken.NumberTokenType, EnumToken.AngleTokenType, EnumToken.PercentageTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType, EnumToken.LiteralTokenType].includes(v.typ)) {
+            // console.debug(JSON.stringify({v}, null, 1));
+            if (v.typ == EnumToken.CommaTokenType) {
+                isLegacySyntax = true;
+            }
+            if (v.typ == EnumToken.IdenTokenType) {
+                if (!(keywords.includes(v.val) || v.val.toLowerCase() in COLORS_NAMES)) {
+                    return false;
+                }
+                if (keywords.includes(v.val)) {
+                    if (isLegacySyntax) {
+                        return false;
+                    }
+                    if (v.val == 'from' && ['rgba', 'hsla'].includes(token.val)) {
+                        return false;
+                    }
+                }
+                continue;
+            }
+            if (v.typ == EnumToken.FunctionTokenType && (v.val == 'calc' || colorsFunc.includes(v.val))) {
+                continue;
+            }
+            if (![EnumToken.ColorTokenType, EnumToken.IdenTokenType, EnumToken.NumberTokenType, EnumToken.AngleTokenType, EnumToken.PercentageTokenType, EnumToken.CommaTokenType, EnumToken.WhitespaceTokenType, EnumToken.LiteralTokenType].includes(v.typ)) {
                 return false;
             }
         }
@@ -200,6 +227,9 @@ function isDimension(name) {
 function isPercentage(name) {
     return name.endsWith('%') && isNumber(name.slice(0, -1));
 }
+function isFlex(name) {
+    return name.endsWith('fr') && isNumber(name.slice(0, -2));
+}
 function parseDimension(name) {
     let index = name.length;
     while (index--) {
@@ -267,4 +297,4 @@ function isWhiteSpace(codepoint) {
         codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
 }
 
-export { isAngle, isAtKeyword, isColor, isDigit, isDimension, isFrequency, isFunction, isHash, isHexColor, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, parseDimension };
+export { isAngle, isAtKeyword, isColor, isDigit, isDimension, isFlex, isFrequency, isFunction, isHash, isHexColor, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, parseDimension };