@tbela99/css-parser 0.1.0 → 0.3.0

package/dist/lib/ast/types.js

@@ -1,88 +1,118 @@
-var NodeType;
-(function (NodeType) {
-    NodeType[NodeType["CommentNodeType"] = 0] = "CommentNodeType";
-    NodeType[NodeType["CDOCOMMNodeType"] = 1] = "CDOCOMMNodeType";
-    NodeType[NodeType["StyleSheetNodeType"] = 2] = "StyleSheetNodeType";
-    NodeType[NodeType["AtRuleNodeType"] = 3] = "AtRuleNodeType";
-    NodeType[NodeType["RuleNodeType"] = 4] = "RuleNodeType";
-    NodeType[NodeType["DeclarationNodeType"] = 5] = "DeclarationNodeType";
-})(NodeType || (NodeType = {}));
 var EnumToken;
 (function (EnumToken) {
     EnumToken[EnumToken["CommentTokenType"] = 0] = "CommentTokenType";
     EnumToken[EnumToken["CDOCOMMTokenType"] = 1] = "CDOCOMMTokenType";
-    EnumToken[EnumToken["LiteralTokenType"] = 2] = "LiteralTokenType";
-    EnumToken[EnumToken["IdenTokenType"] = 3] = "IdenTokenType";
-    EnumToken[EnumToken["CommaTokenType"] = 4] = "CommaTokenType";
-    EnumToken[EnumToken["ColonTokenType"] = 5] = "ColonTokenType";
-    EnumToken[EnumToken["SemiColonTokenType"] = 6] = "SemiColonTokenType";
-    EnumToken[EnumToken["NumberTokenType"] = 7] = "NumberTokenType";
-    EnumToken[EnumToken["AtRuleTokenType"] = 8] = "AtRuleTokenType";
-    EnumToken[EnumToken["PercentageTokenType"] = 9] = "PercentageTokenType";
-    EnumToken[EnumToken["FunctionTokenType"] = 10] = "FunctionTokenType";
-    EnumToken[EnumToken["UrlFunctionTokenType"] = 11] = "UrlFunctionTokenType";
-    EnumToken[EnumToken["StringTokenType"] = 12] = "StringTokenType";
-    EnumToken[EnumToken["UnclosedStringTokenType"] = 13] = "UnclosedStringTokenType";
-    EnumToken[EnumToken["DimensionTokenType"] = 14] = "DimensionTokenType";
-    EnumToken[EnumToken["LengthTokenType"] = 15] = "LengthTokenType";
-    EnumToken[EnumToken["AngleTokenType"] = 16] = "AngleTokenType";
-    EnumToken[EnumToken["TimeTokenType"] = 17] = "TimeTokenType";
-    EnumToken[EnumToken["FrequencyTokenType"] = 18] = "FrequencyTokenType";
-    EnumToken[EnumToken["ResolutionTokenType"] = 19] = "ResolutionTokenType";
-    EnumToken[EnumToken["HashTokenType"] = 20] = "HashTokenType";
-    EnumToken[EnumToken["BlockStartTokenType"] = 21] = "BlockStartTokenType";
-    EnumToken[EnumToken["BlockEndTokenType"] = 22] = "BlockEndTokenType";
-    EnumToken[EnumToken["AttrStartTokenType"] = 23] = "AttrStartTokenType";
-    EnumToken[EnumToken["AttrEndTokenType"] = 24] = "AttrEndTokenType";
-    EnumToken[EnumToken["StartParensTokenType"] = 25] = "StartParensTokenType";
-    EnumToken[EnumToken["EndParensTokenType"] = 26] = "EndParensTokenType";
-    EnumToken[EnumToken["ParensTokenType"] = 27] = "ParensTokenType";
-    EnumToken[EnumToken["WhitespaceTokenType"] = 28] = "WhitespaceTokenType";
-    EnumToken[EnumToken["IncludesTokenType"] = 29] = "IncludesTokenType";
-    EnumToken[EnumToken["DashMatchTokenType"] = 30] = "DashMatchTokenType";
-    EnumToken[EnumToken["LtTokenType"] = 31] = "LtTokenType";
-    EnumToken[EnumToken["LteTokenType"] = 32] = "LteTokenType";
-    EnumToken[EnumToken["GtTokenType"] = 33] = "GtTokenType";
-    EnumToken[EnumToken["GteTokenType"] = 34] = "GteTokenType";
-    EnumToken[EnumToken["PseudoClassTokenType"] = 35] = "PseudoClassTokenType";
-    EnumToken[EnumToken["PseudoClassFuncTokenType"] = 36] = "PseudoClassFuncTokenType";
-    EnumToken[EnumToken["DelimTokenType"] = 37] = "DelimTokenType";
-    EnumToken[EnumToken["UrlTokenTokenType"] = 38] = "UrlTokenTokenType";
-    EnumToken[EnumToken["EOFTokenType"] = 39] = "EOFTokenType";
-    EnumToken[EnumToken["ImportantTokenType"] = 40] = "ImportantTokenType";
-    EnumToken[EnumToken["ColorTokenType"] = 41] = "ColorTokenType";
-    EnumToken[EnumToken["AttrTokenType"] = 42] = "AttrTokenType";
-    EnumToken[EnumToken["BadCommentTokenType"] = 43] = "BadCommentTokenType";
-    EnumToken[EnumToken["BadCdoTokenType"] = 44] = "BadCdoTokenType";
-    EnumToken[EnumToken["BadUrlTokenType"] = 45] = "BadUrlTokenType";
-    EnumToken[EnumToken["BadStringTokenType"] = 46] = "BadStringTokenType";
-    EnumToken[EnumToken["BinaryExpressionTokenType"] = 47] = "BinaryExpressionTokenType";
-    EnumToken[EnumToken["UnaryExpressionTokenType"] = 48] = "UnaryExpressionTokenType";
+    EnumToken[EnumToken["StyleSheetNodeType"] = 2] = "StyleSheetNodeType";
+    EnumToken[EnumToken["AtRuleNodeType"] = 3] = "AtRuleNodeType";
+    EnumToken[EnumToken["RuleNodeType"] = 4] = "RuleNodeType";
+    EnumToken[EnumToken["DeclarationNodeType"] = 5] = "DeclarationNodeType";
+    EnumToken[EnumToken["LiteralTokenType"] = 6] = "LiteralTokenType";
+    EnumToken[EnumToken["IdenTokenType"] = 7] = "IdenTokenType";
+    EnumToken[EnumToken["DashedIdenTokenType"] = 8] = "DashedIdenTokenType";
+    EnumToken[EnumToken["CommaTokenType"] = 9] = "CommaTokenType";
+    EnumToken[EnumToken["ColonTokenType"] = 10] = "ColonTokenType";
+    EnumToken[EnumToken["SemiColonTokenType"] = 11] = "SemiColonTokenType";
+    EnumToken[EnumToken["NumberTokenType"] = 12] = "NumberTokenType";
+    EnumToken[EnumToken["AtRuleTokenType"] = 13] = "AtRuleTokenType";
+    EnumToken[EnumToken["PercentageTokenType"] = 14] = "PercentageTokenType";
+    EnumToken[EnumToken["FunctionTokenType"] = 15] = "FunctionTokenType";
+    EnumToken[EnumToken["TimelineFunctionTokenType"] = 16] = "TimelineFunctionTokenType";
+    EnumToken[EnumToken["TimingFunctionTokenType"] = 17] = "TimingFunctionTokenType";
+    EnumToken[EnumToken["UrlFunctionTokenType"] = 18] = "UrlFunctionTokenType";
+    EnumToken[EnumToken["ImageFunctionTokenType"] = 19] = "ImageFunctionTokenType";
+    EnumToken[EnumToken["StringTokenType"] = 20] = "StringTokenType";
+    EnumToken[EnumToken["UnclosedStringTokenType"] = 21] = "UnclosedStringTokenType";
+    EnumToken[EnumToken["DimensionTokenType"] = 22] = "DimensionTokenType";
+    EnumToken[EnumToken["LengthTokenType"] = 23] = "LengthTokenType";
+    EnumToken[EnumToken["AngleTokenType"] = 24] = "AngleTokenType";
+    EnumToken[EnumToken["TimeTokenType"] = 25] = "TimeTokenType";
+    EnumToken[EnumToken["FrequencyTokenType"] = 26] = "FrequencyTokenType";
+    EnumToken[EnumToken["ResolutionTokenType"] = 27] = "ResolutionTokenType";
+    EnumToken[EnumToken["HashTokenType"] = 28] = "HashTokenType";
+    EnumToken[EnumToken["BlockStartTokenType"] = 29] = "BlockStartTokenType";
+    EnumToken[EnumToken["BlockEndTokenType"] = 30] = "BlockEndTokenType";
+    EnumToken[EnumToken["AttrStartTokenType"] = 31] = "AttrStartTokenType";
+    EnumToken[EnumToken["AttrEndTokenType"] = 32] = "AttrEndTokenType";
+    EnumToken[EnumToken["StartParensTokenType"] = 33] = "StartParensTokenType";
+    EnumToken[EnumToken["EndParensTokenType"] = 34] = "EndParensTokenType";
+    EnumToken[EnumToken["ParensTokenType"] = 35] = "ParensTokenType";
+    EnumToken[EnumToken["WhitespaceTokenType"] = 36] = "WhitespaceTokenType";
+    EnumToken[EnumToken["IncludeMatchTokenType"] = 37] = "IncludeMatchTokenType";
+    EnumToken[EnumToken["DashMatchTokenType"] = 38] = "DashMatchTokenType";
+    EnumToken[EnumToken["LtTokenType"] = 39] = "LtTokenType";
+    EnumToken[EnumToken["LteTokenType"] = 40] = "LteTokenType";
+    EnumToken[EnumToken["GtTokenType"] = 41] = "GtTokenType";
+    EnumToken[EnumToken["GteTokenType"] = 42] = "GteTokenType";
+    EnumToken[EnumToken["PseudoClassTokenType"] = 43] = "PseudoClassTokenType";
+    EnumToken[EnumToken["PseudoClassFuncTokenType"] = 44] = "PseudoClassFuncTokenType";
+    EnumToken[EnumToken["DelimTokenType"] = 45] = "DelimTokenType";
+    EnumToken[EnumToken["UrlTokenTokenType"] = 46] = "UrlTokenTokenType";
+    EnumToken[EnumToken["EOFTokenType"] = 47] = "EOFTokenType";
+    EnumToken[EnumToken["ImportantTokenType"] = 48] = "ImportantTokenType";
+    EnumToken[EnumToken["ColorTokenType"] = 49] = "ColorTokenType";
+    EnumToken[EnumToken["AttrTokenType"] = 50] = "AttrTokenType";
+    EnumToken[EnumToken["BadCommentTokenType"] = 51] = "BadCommentTokenType";
+    EnumToken[EnumToken["BadCdoTokenType"] = 52] = "BadCdoTokenType";
+    EnumToken[EnumToken["BadUrlTokenType"] = 53] = "BadUrlTokenType";
+    EnumToken[EnumToken["BadStringTokenType"] = 54] = "BadStringTokenType";
+    EnumToken[EnumToken["BinaryExpressionTokenType"] = 55] = "BinaryExpressionTokenType";
+    EnumToken[EnumToken["UnaryExpressionTokenType"] = 56] = "UnaryExpressionTokenType";
+    EnumToken[EnumToken["FlexTokenType"] = 57] = "FlexTokenType";
     /* catch all */
-    EnumToken[EnumToken["ListToken"] = 49] = "ListToken";
+    EnumToken[EnumToken["ListToken"] = 58] = "ListToken";
     /* arithmetic tokens */
-    EnumToken[EnumToken["Add"] = 50] = "Add";
-    EnumToken[EnumToken["Mul"] = 51] = "Mul";
-    EnumToken[EnumToken["Div"] = 52] = "Div";
-    EnumToken[EnumToken["Sub"] = 53] = "Sub";
+    EnumToken[EnumToken["Add"] = 59] = "Add";
+    EnumToken[EnumToken["Mul"] = 60] = "Mul";
+    EnumToken[EnumToken["Div"] = 61] = "Div";
+    EnumToken[EnumToken["Sub"] = 62] = "Sub";
+    /* new tokens */
+    EnumToken[EnumToken["ColumnCombinatorTokenType"] = 63] = "ColumnCombinatorTokenType";
+    EnumToken[EnumToken["ContainMatchTokenType"] = 64] = "ContainMatchTokenType";
+    EnumToken[EnumToken["StartMatchTokenType"] = 65] = "StartMatchTokenType";
+    EnumToken[EnumToken["EndMatchTokenType"] = 66] = "EndMatchTokenType";
+    EnumToken[EnumToken["MatchExpressionTokenType"] = 67] = "MatchExpressionTokenType";
+    EnumToken[EnumToken["NameSpaceAttributeTokenType"] = 68] = "NameSpaceAttributeTokenType";
+    EnumToken[EnumToken["FractionTokenType"] = 69] = "FractionTokenType";
+    EnumToken[EnumToken["IdenListTokenType"] = 70] = "IdenListTokenType";
+    EnumToken[EnumToken["GridTemplateFuncTokenType"] = 71] = "GridTemplateFuncTokenType";
     /* aliases */
-    EnumToken[EnumToken["Time"] = 17] = "Time";
-    EnumToken[EnumToken["Iden"] = 3] = "Iden";
-    EnumToken[EnumToken["Hash"] = 20] = "Hash";
-    EnumToken[EnumToken["Angle"] = 16] = "Angle";
-    EnumToken[EnumToken["Color"] = 41] = "Color";
-    EnumToken[EnumToken["Comma"] = 4] = "Comma";
-    EnumToken[EnumToken["String"] = 12] = "String";
-    EnumToken[EnumToken["Length"] = 15] = "Length";
-    EnumToken[EnumToken["Number"] = 7] = "Number";
-    EnumToken[EnumToken["Perc"] = 9] = "Perc";
-    EnumToken[EnumToken["Literal"] = 2] = "Literal";
+    EnumToken[EnumToken["Time"] = 25] = "Time";
+    EnumToken[EnumToken["Iden"] = 7] = "Iden";
+    EnumToken[EnumToken["Hash"] = 28] = "Hash";
+    EnumToken[EnumToken["Flex"] = 57] = "Flex";
+    EnumToken[EnumToken["Angle"] = 24] = "Angle";
+    EnumToken[EnumToken["Color"] = 49] = "Color";
+    EnumToken[EnumToken["Comma"] = 9] = "Comma";
+    EnumToken[EnumToken["String"] = 20] = "String";
+    EnumToken[EnumToken["Length"] = 23] = "Length";
+    EnumToken[EnumToken["Number"] = 12] = "Number";
+    EnumToken[EnumToken["Perc"] = 14] = "Perc";
+    EnumToken[EnumToken["Literal"] = 6] = "Literal";
     EnumToken[EnumToken["Comment"] = 0] = "Comment";
-    EnumToken[EnumToken["UrlFunc"] = 11] = "UrlFunc";
-    EnumToken[EnumToken["Dimension"] = 14] = "Dimension";
-    EnumToken[EnumToken["Frequency"] = 18] = "Frequency";
-    EnumToken[EnumToken["Resolution"] = 19] = "Resolution";
-    EnumToken[EnumToken["Whitespace"] = 28] = "Whitespace";
+    EnumToken[EnumToken["UrlFunc"] = 18] = "UrlFunc";
+    EnumToken[EnumToken["Dimension"] = 22] = "Dimension";
+    EnumToken[EnumToken["Frequency"] = 26] = "Frequency";
+    EnumToken[EnumToken["Resolution"] = 27] = "Resolution";
+    EnumToken[EnumToken["Whitespace"] = 36] = "Whitespace";
+    EnumToken[EnumToken["IdenList"] = 70] = "IdenList";
+    EnumToken[EnumToken["DashedIden"] = 8] = "DashedIden";
+    EnumToken[EnumToken["GridTemplateFunc"] = 71] = "GridTemplateFunc";
+    EnumToken[EnumToken["ImageFunc"] = 19] = "ImageFunc";
+    EnumToken[EnumToken["CommentNodeType"] = 0] = "CommentNodeType";
+    EnumToken[EnumToken["CDOCOMMNodeType"] = 1] = "CDOCOMMNodeType";
+    EnumToken[EnumToken["TimingFunction"] = 17] = "TimingFunction";
+    EnumToken[EnumToken["TimelineFunction"] = 16] = "TimelineFunction";
 })(EnumToken || (EnumToken = {}));
+const funcLike = [
+    EnumToken.ParensTokenType,
+    EnumToken.FunctionTokenType,
+    EnumToken.UrlFunctionTokenType,
+    EnumToken.StartParensTokenType,
+    EnumToken.ImageFunctionTokenType,
+    EnumToken.TimingFunctionTokenType,
+    EnumToken.TimingFunctionTokenType,
+    EnumToken.PseudoClassFuncTokenType,
+    EnumToken.GridTemplateFuncTokenType
+];
 
-export { EnumToken, NodeType };
+export { EnumToken, funcLike };

package/dist/lib/ast/walk.js

@@ -1,33 +1,66 @@
-function* walk(node) {
+import { EnumToken } from './types.js';
+
+function* walk(node, filter) {
     const parents = [node];
     const root = node;
     const weakMap = new WeakMap;
     while (parents.length > 0) {
         node = parents.shift();
+        let option = null;
+        if (filter != null) {
+            option = filter(node);
+            if (option === 'ignore') {
+                continue;
+            }
+            if (option === 'stop') {
+                break;
+            }
+        }
         // @ts-ignore
-        yield { node, parent: weakMap.get(node), root };
-        if ('chi' in node) {
-            for (const child of node.chi) {
+        if (option !== 'children') {
+            // @ts-ignore
+            yield { node, parent: weakMap.get(node), root };
+        }
+        if (option !== 'ignore-children' && 'chi' in node) {
+            parents.unshift(...node.chi);
+            for (const child of node.chi.slice()) {
                 weakMap.set(child, node);
             }
-            parents.unshift(...node.chi);
         }
     }
 }
-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/set.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/iterable/weakmap.js

@@ -0,0 +1,53 @@
+class IterableWeakMap {
+    #map;
+    #set;
+    constructor(iterable) {
+        this.#map = new WeakMap;
+        this.#set = new Set;
+        if (iterable) {
+            for (const [key, value] of iterable) {
+                const ref = new WeakRef(key);
+                this.#set.add(ref);
+                this.#map.set(key, value);
+            }
+        }
+    }
+    has(key) {
+        return this.#map.has(key);
+    }
+    set(key, value) {
+        if (!this.#map.has(key)) {
+            this.#set.add(new WeakRef(key));
+        }
+        this.#map.set(key, value);
+        return this;
+    }
+    get(key) {
+        return this.#map.get(key);
+    }
+    delete(key) {
+        if (this.#map.has(key)) {
+            for (const ref of this.#set) {
+                if (ref.deref() === key) {
+                    this.#set.delete(ref);
+                    break;
+                }
+            }
+            return this.#map.delete(key);
+        }
+        return false;
+    }
+    *[Symbol.iterator]() {
+        for (const ref of new Set(this.#set)) {
+            const key = ref.deref();
+            if (key == null) {
+                this.#set.delete(ref);
+                continue;
+            }
+            // @ts-ignore
+            yield [key, this.#map.get(key)];
+        }
+    }
+}
+
+export { IterableWeakMap };

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

@@ -1,6 +1,6 @@
 import { PropertySet } from './set.js';
 import '../../renderer/utils/color.js';
-import '../../ast/types.js';
+import { EnumToken } from '../../ast/types.js';
 import '../../ast/minify.js';
 import { parseString } from '../parse.js';
 import '../../renderer/sourcemap/lib/encode.js';
@@ -21,10 +21,14 @@ class PropertyList {
         this.declarations = new Map;
     }
     set(nam, value) {
-        return this.add({ typ: 5 /* NodeType.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 != 5 /* NodeType.DeclarationNodeType */ || !this.options.removeDuplicateDeclarations) {
+        if (declaration.typ != EnumToken.DeclarationNodeType || !this.options.removeDuplicateDeclarations) {
             this.declarations.set(Number(Math.random().toString().slice(2)).toString(36), declaration);
             return this;
         }

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

@@ -128,7 +128,7 @@ class PropertyMap {
                 if (values.length == 0) {
                     this.declarations = Object.entries(tokens).reduce((acc, curr) => {
                         acc.set(curr[0], {
-                            typ: 5 /* NodeType.DeclarationNodeType */,
+                            typ: EnumToken.DeclarationNodeType,
                             nam: curr[0],
                             val: curr[1].reduce((acc, curr) => {
                                 if (acc.length > 0) {
@@ -192,6 +192,69 @@ class PropertyMap {
             requiredCount = this.declarations.size;
         }
         if (!isShorthand || requiredCount < this.requiredCount) {
+            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) => {
+                        if (!cache.has(t)) {
+                            cache.set(t, renderToken(t, { minify: true }));
+                        }
+                        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 &&
+                        array[index - 1].typ == EnumToken.WhitespaceTokenType));
+                    if (declaration.val.at(-1)?.typ == EnumToken.WhitespaceTokenType) {
+                        declaration.val.pop();
+                    }
+                    return declaration;
+                };
+                const values = [...this.declarations.values()].reduce((acc, curr) => {
+                    if (curr instanceof PropertySet) {
+                        acc.push(...curr);
+                    }
+                    else {
+                        acc.push(curr);
+                    }
+                    return acc;
+                }, []);
+                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]();
+            }
             // @ts-ignore
             iterable = this.declarations.values();
         }
@@ -204,7 +267,6 @@ class PropertyMap {
             } : null;
             const tokens = {};
             // @ts-ignore
-            /* const valid: string[] =*/
             Object.entries(this.config.properties).reduce((acc, curr) => {
                 if (!this.declarations.has(curr[0])) {
                     if (curr[1].required) {
@@ -270,7 +332,7 @@ class PropertyMap {
                 iterable = this.declarations.values();
             }
             else {
-                const values = Object.entries(tokens).reduce((acc, curr) => {
+                let values = Object.entries(tokens).reduce((acc, curr) => {
                     const props = this.config.properties[curr[0]];
                     for (let i = 0; i < curr[1].length; i++) {
                         if (acc.length == i) {
@@ -285,8 +347,11 @@ 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;
                         if (curr[0] in propertiesConfig.properties) {
                             for (let v of values) {
@@ -298,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
@@ -359,7 +427,10 @@ class PropertyMap {
                     return acc;
                 }, []);
                 if (this.config.mapping != null) {
-                    const val = values.reduce((acc, curr) => acc + renderToken(curr, { removeComments: 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({
@@ -369,8 +440,16 @@ class PropertyMap {
                         });
                     }
                 }
+                // @ts-ignore
+                if (values.length == 1 &&
+                    typeof values[0].val == 'string' &&
+                    this.config.default.includes(values[0].val.toLowerCase()) &&
+                    this.config.default[0] != values[0].val.toLowerCase()) {
+                    // @ts-ignore/
+                    values = parseString(this.config.default[0]);
+                }
                 iterable = [{
-                        typ: 5 /* NodeType.DeclarationNodeType */,
+                        typ: EnumToken.DeclarationNodeType,
                         nam: this.config.shorthand,
                         val: values
                     }][Symbol.iterator]();