@tbela99/css-parser 0.0.1 → 0.2.0

package/dist/lib/ast/types.js

@@ -0,0 +1,101 @@
+var EnumToken;
+(function (EnumToken) {
+    EnumToken[EnumToken["CommentTokenType"] = 0] = "CommentTokenType";
+    EnumToken[EnumToken["CDOCOMMTokenType"] = 1] = "CDOCOMMTokenType";
+    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";
+    /* catch all */
+    EnumToken[EnumToken["ListToken"] = 57] = "ListToken";
+    /* arithmetic tokens */
+    EnumToken[EnumToken["Add"] = 58] = "Add";
+    EnumToken[EnumToken["Mul"] = 59] = "Mul";
+    EnumToken[EnumToken["Div"] = 60] = "Div";
+    EnumToken[EnumToken["Sub"] = 61] = "Sub";
+    /* new tokens */
+    EnumToken[EnumToken["ColumnCombinatorTokenType"] = 62] = "ColumnCombinatorTokenType";
+    EnumToken[EnumToken["ContainMatchTokenType"] = 63] = "ContainMatchTokenType";
+    EnumToken[EnumToken["StartMatchTokenType"] = 64] = "StartMatchTokenType";
+    EnumToken[EnumToken["EndMatchTokenType"] = 65] = "EndMatchTokenType";
+    EnumToken[EnumToken["MatchExpressionTokenType"] = 66] = "MatchExpressionTokenType";
+    EnumToken[EnumToken["NameSpaceAttributeTokenType"] = 67] = "NameSpaceAttributeTokenType";
+    EnumToken[EnumToken["FractionTokenType"] = 68] = "FractionTokenType";
+    /* aliases */
+    EnumToken[EnumToken["Time"] = 25] = "Time";
+    EnumToken[EnumToken["Iden"] = 7] = "Iden";
+    EnumToken[EnumToken["Hash"] = 28] = "Hash";
+    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"] = 18] = "UrlFunc";
+    EnumToken[EnumToken["Dimension"] = 22] = "Dimension";
+    EnumToken[EnumToken["Frequency"] = 26] = "Frequency";
+    EnumToken[EnumToken["Resolution"] = 27] = "Resolution";
+    EnumToken[EnumToken["Whitespace"] = 36] = "Whitespace";
+    EnumToken[EnumToken["DashedIden"] = 8] = "DashedIden";
+    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 = {}));
+
+export { EnumToken };

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

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

package/dist/lib/ast/walk.js

@@ -1,17 +1,45 @@
-function* walk(node, parent, root) {
-    yield { node, parent, root };
-    if ('chi' in node) {
-        for (const child of node.chi) {
-            yield* walk(child, node, (root ?? node));
+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
+        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);
+            }
         }
     }
 }
-function* walkValues(values, parent) {
-    for (const value of values) {
+function* walkValues(values) {
+    const stack = values.slice();
+    const weakMap = new WeakMap;
+    let value;
+    while (stack.length > 0) {
+        value = stack.shift();
         // @ts-ignore
-        yield { value, parent };
+        yield { value, parent: weakMap.get(value) };
         if ('chi' in value) {
-            yield* walkValues(value.chi, value);
+            for (const child of value.chi) {
+                weakMap.set(child, value);
+            }
+            stack.unshift(...value.chi);
         }
     }
 }

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/parser/declaration/list.js

@@ -1,23 +1,37 @@
 import { PropertySet } from './set.js';
 import '../../renderer/utils/color.js';
-import { PropertyMap } from './map.js';
+import { EnumToken } from '../../ast/types.js';
+import '../../ast/minify.js';
 import { parseString } from '../parse.js';
+import '../../renderer/sourcemap/lib/encode.js';
 import { getConfig } from '../utils/config.js';
+import { PropertyMap } from './map.js';
 
 const config = getConfig();
 class PropertyList {
+    options = { removeDuplicateDeclarations: true, computeShorthand: true };
     declarations;
-    constructor() {
+    constructor(options = {}) {
+        for (const key of Object.keys(this.options)) {
+            if (key in options) {
+                // @ts-ignore
+                this.options[key] = options[key];
+            }
+        }
         this.declarations = new Map;
     }
     set(nam, value) {
-        return this.add({ typ: 'Declaration', 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 != 'Declaration') {
+        if (declaration.typ != EnumToken.DeclarationNodeType || !this.options.removeDuplicateDeclarations) {
             this.declarations.set(Number(Math.random().toString().slice(2)).toString(36), declaration);
             return this;
         }
+        if (!this.options.computeShorthand) {
+            this.declarations.set(declaration.nam, declaration);
+            return this;
+        }
         let propertyName = declaration.nam;
         let shortHandType;
         let shorthand;

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

@@ -1,11 +1,15 @@
 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 { getConfig } from '../utils/config.js';
 import { matchType } from '../utils/type.js';
-import { parseString } from '../parse.js';
 import { PropertySet } from './set.js';
+import { IterableWeakMap } from '../../iterable/weakmap.js';
 
+const cache = new IterableWeakMap();
 const propertiesConfig = getConfig();
 class PropertyMap {
     config;
@@ -28,21 +32,23 @@ class PropertyMap {
             this.declarations.set(declaration.nam, declaration);
         }
         else {
-            const separator = this.config.separator;
+            const separator = this.config.separator != null ? {
+                ...this.config.separator,
+                typ: EnumToken[this.config.separator.typ]
+            } : null;
             // expand shorthand
             if (declaration.nam != this.config.shorthand && this.declarations.has(this.config.shorthand)) {
                 const tokens = {};
                 const values = [];
                 // @ts-ignore
                 this.declarations.get(this.config.shorthand).val.slice().reduce((acc, curr) => {
+                    // @ts-ignore
                     if (separator != null && separator.typ == curr.typ && eq(separator, curr)) {
                         acc.push([]);
                         return acc;
                     }
-                    // else {
                     // @ts-ignore
                     acc.at(-1).push(curr);
-                    // }
                     return acc;
                 }, [[]]).
                     // @ts-ignore
@@ -51,7 +57,7 @@ class PropertyMap {
                         // let current: number = 0;
                         const props = this.config.properties[property];
                         for (let i = 0; i < acc.length; i++) {
-                            if (acc[i].typ == 'Comment' || acc[i].typ == 'Whitespace') {
+                            if (acc[i].typ == EnumToken.CommentTokenType || acc[i].typ == EnumToken.WhitespaceTokenType) {
                                 acc.splice(i, 1);
                                 i--;
                                 continue;
@@ -67,18 +73,20 @@ class PropertyMap {
                                 else {
                                     if (current == tokens[property].length) {
                                         tokens[property].push([acc[i]]);
-                                        // tokens[property][current].push();
                                     }
                                     else {
-                                        tokens[property][current].push({ typ: 'Whitespace' }, acc[i]);
+                                        tokens[property][current].push({ typ: EnumToken.WhitespaceTokenType }, acc[i]);
                                     }
                                 }
                                 acc.splice(i, 1);
                                 i--;
                                 // @ts-ignore
-                                if ('prefix' in props && acc[i]?.typ == props.prefix.typ) {
-                                    // @ts-ignore
-                                    if (eq(acc[i], this.config.properties[property].prefix)) {
+                                if ('prefix' in props && acc[i]?.typ == EnumToken[props.prefix.typ]) {
+                                    if (eq(acc[i], {
+                                        ...this.config.properties[property].prefix,
+                                        // @ts-ignore
+                                        typ: EnumToken[props.prefix.typ]
+                                    })) {
                                         acc.splice(i, 1);
                                         i--;
                                     }
@@ -111,7 +119,7 @@ class PropertyMap {
                                     tokens[property][current].push(...defaults);
                                 }
                                 else {
-                                    tokens[property][current].push({ typ: 'Whitespace' }, ...defaults);
+                                    tokens[property][current].push({ typ: EnumToken.WhitespaceTokenType }, ...defaults);
                                 }
                             }
                         }
@@ -122,7 +130,7 @@ class PropertyMap {
                 if (values.length == 0) {
                     this.declarations = Object.entries(tokens).reduce((acc, curr) => {
                         acc.set(curr[0], {
-                            typ: 'Declaration',
+                            typ: EnumToken.DeclarationNodeType,
                             nam: curr[0],
                             val: curr[1].reduce((acc, curr) => {
                                 if (acc.length > 0) {
@@ -186,16 +194,56 @@ class PropertyMap {
             requiredCount = this.declarations.size;
         }
         if (!isShorthand || requiredCount < this.requiredCount) {
+            if (isShorthand && this.declarations.has(this.config.shorthand)) {
+                // console.debug(...this.declarations.values());
+                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 }));
+                        }
+                        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;
+                }, []);
+                const filtered = values.map(removeDefaults).filter((x) => x.val.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])
+                    });
+                }
+                return (filtered.length > 0 ? filtered : values)[Symbol.iterator]();
+            }
             // @ts-ignore
             iterable = this.declarations.values();
         }
         else {
             let count = 0;
             let match;
-            const separator = this.config.separator;
+            const separator = this.config.separator != null ? {
+                ...this.config.separator,
+                typ: EnumToken[this.config.separator.typ]
+            } : 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) {
@@ -216,14 +264,18 @@ class PropertyMap {
                             }
                             continue;
                         }
-                        if (val.typ == 'Whitespace' || val.typ == 'Comment') {
+                        if (val.typ == EnumToken.WhitespaceTokenType || val.typ == EnumToken.CommentTokenType) {
                             continue;
                         }
-                        if (props.multiple && props.separator != null && props.separator.typ == val.typ && eq(props.separator, val)) {
+                        // @ts-ignore
+                        if (props.multiple && props.separator != null && EnumToken[props.separator.typ] == val.typ && eq({
+                            ...props.separator,
+                            typ: EnumToken[props.separator.typ]
+                        }, val)) {
                             continue;
                         }
                         // @ts-ignore
-                        match = val.typ == 'Comment' || matchType(val, curr[1]);
+                        match = val.typ == EnumToken.CommentTokenType || matchType(val, curr[1]);
                         if (isShorthand) {
                             isShorthand = match;
                         }
@@ -252,12 +304,12 @@ class PropertyMap {
                 return entry[1].required && !(entry[0] in tokens);
             }) ||
                 // @ts-ignore
-                !Object.values(tokens).every(v => v.filter(t => t.typ != 'Comment').length == count)) {
+                !Object.values(tokens).every(v => v.filter(t => t.typ != EnumToken.CommentTokenType).length == count)) {
                 // @ts-ignore
                 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) {
@@ -265,7 +317,7 @@ class PropertyMap {
                         }
                         let values = curr[1][i].reduce((acc, curr) => {
                             if (acc.length > 0) {
-                                acc.push({ typ: 'Whitespace' });
+                                acc.push({ typ: EnumToken.WhitespaceTokenType });
                             }
                             acc.push(curr);
                             return acc;
@@ -274,11 +326,12 @@ class PropertyMap {
                         if (props.default.includes(curr[1][i].reduce((acc, curr) => acc + renderToken(curr) + ' ', '').trimEnd())) {
                             continue;
                         }
+                        // remove default values
                         let doFilterDefault = true;
                         if (curr[0] in propertiesConfig.properties) {
                             for (let v of values) {
-                                if (!['Whitespace', 'Comment', 'Iden'].includes(v.typ)
-                                    || (v.typ == 'Iden' && !this.config.properties[curr[0]].default.includes(v.val))) {
+                                if (![EnumToken.WhitespaceTokenType, EnumToken.CommentTokenType, EnumToken.IdenTokenType].includes(v.typ)
+                                    || (v.typ == EnumToken.IdenTokenType && !this.config.properties[curr[0]].default.includes(v.val))) {
                                     doFilterDefault = false;
                                     break;
                                 }
@@ -286,10 +339,10 @@ class PropertyMap {
                         }
                         // remove default values
                         values = values.filter((val) => {
-                            if (val.typ == 'Whitespace' || val.typ == 'Comment') {
+                            if (val.typ == EnumToken.WhitespaceTokenType || val.typ == EnumToken.CommentTokenType) {
                                 return false;
                             }
-                            return !doFilterDefault || !(val.typ == 'Iden' && props.default.includes(val.val));
+                            return !doFilterDefault || !(val.typ == EnumToken.IdenTokenType && props.default.includes(val.val));
                         });
                         if (values.length > 0) {
                             if ('mapping' in props) {
@@ -298,7 +351,7 @@ class PropertyMap {
                                     let i = values.length;
                                     while (i--) {
                                         // @ts-ignore
-                                        if (values[i].typ == 'Iden' && values[i].val in props.mapping) {
+                                        if (values[i].typ == EnumToken.IdenTokenType && values[i].val in props.mapping) {
                                             // @ts-ignore
                                             values.splice(i, 1, ...parseString(props.mapping[values[i].val]));
                                         }
@@ -307,15 +360,20 @@ class PropertyMap {
                             }
                             if ('prefix' in props) {
                                 // @ts-ignore
-                                acc[i].push({ ...props.prefix });
+                                acc[i].push({ ...props.prefix, typ: EnumToken[props.prefix.typ] });
                             }
                             else if (acc[i].length > 0) {
-                                acc[i].push({ typ: 'Whitespace' });
+                                acc[i].push({ typ: EnumToken.WhitespaceTokenType });
                             }
                             acc[i].push(...values.reduce((acc, curr) => {
                                 if (acc.length > 0) {
                                     // @ts-ignore
-                                    acc.push({ ...(props.separator ?? { typ: 'Whitespace' }) });
+                                    acc.push({
+                                        ...((props.separator && {
+                                            ...props.separator,
+                                            typ: EnumToken[props.separator.typ]
+                                        }) ?? { typ: EnumToken.WhitespaceTokenType })
+                                    });
                                 }
                                 // @ts-ignore
                                 acc.push(curr);
@@ -331,7 +389,7 @@ class PropertyMap {
                     if (curr.length == 0 && this.config.default.length > 0) {
                         curr.push(...parseString(this.config.default[0]).reduce((acc, curr) => {
                             if (acc.length > 0) {
-                                acc.push({ typ: 'Whitespace' });
+                                acc.push({ typ: EnumToken.WhitespaceTokenType });
                             }
                             acc.push(curr);
                             return acc;
@@ -341,15 +399,26 @@ 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;
-                        // @ts-ignore
-                        values.push({ typ: ['"', "'"].includes(val.charAt(0)) ? 'String' : 'Iden', val: this.config.mapping[val] });
+                        values.push({
+                            typ: ['"', "'"].includes(val.charAt(0)) ? EnumToken.StringTokenType : EnumToken.IdenTokenType,
+                            // @ts-ignore
+                            val: this.config.mapping[val]
+                        });
                     }
                 }
+                // @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: 'Declaration',
+                        typ: EnumToken.DeclarationNodeType,
                         nam: this.config.shorthand,
                         val: values
                     }][Symbol.iterator]();