@tbela99/css-parser 0.0.1 → 0.1.0

package/dist/lib/ast/types.js

@@ -0,0 +1,88 @@
+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";
+    /* catch all */
+    EnumToken[EnumToken["ListToken"] = 49] = "ListToken";
+    /* arithmetic tokens */
+    EnumToken[EnumToken["Add"] = 50] = "Add";
+    EnumToken[EnumToken["Mul"] = 51] = "Mul";
+    EnumToken[EnumToken["Div"] = 52] = "Div";
+    EnumToken[EnumToken["Sub"] = 53] = "Sub";
+    /* 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["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 = {}));
+
+export { EnumToken, NodeType };

package/dist/lib/ast/utiles/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,32 @@
-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) {
+    const parents = [node];
+    const root = node;
+    const weakMap = new WeakMap;
+    while (parents.length > 0) {
+        node = parents.shift();
+        // @ts-ignore
+        yield { node, parent: weakMap.get(node), root };
+        if ('chi' in node) {
+            for (const child of node.chi) {
+                weakMap.set(child, node);
+            }
+            parents.unshift(...node.chi);
         }
     }
 }
-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/parser/declaration/list.js

@@ -1,23 +1,37 @@
 import { PropertySet } from './set.js';
 import '../../renderer/utils/color.js';
-import { PropertyMap } from './map.js';
+import '../../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: 5 /* NodeType.DeclarationNodeType */, nam, val: Array.isArray(value) ? value : parseString(String(value)) });
     }
     add(declaration) {
-        if (declaration.typ != 'Declaration') {
+        if (declaration.typ != 5 /* NodeType.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,9 +1,11 @@
 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';
 
 const propertiesConfig = getConfig();
@@ -28,21 +30,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 +55,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 +71,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 +117,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 +128,7 @@ class PropertyMap {
                 if (values.length == 0) {
                     this.declarations = Object.entries(tokens).reduce((acc, curr) => {
                         acc.set(curr[0], {
-                            typ: 'Declaration',
+                            typ: 5 /* NodeType.DeclarationNodeType */,
                             nam: curr[0],
                             val: curr[1].reduce((acc, curr) => {
                                 if (acc.length > 0) {
@@ -192,7 +198,10 @@ class PropertyMap {
         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[] =*/
@@ -216,14 +225,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,7 +265,7 @@ 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();
             }
@@ -265,7 +278,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;
@@ -277,8 +290,8 @@ class PropertyMap {
                         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 +299,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 +311,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 +320,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 +349,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;
@@ -344,12 +362,15 @@ class PropertyMap {
                     const val = values.reduce((acc, curr) => acc + renderToken(curr, { removeComments: 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]
+                        });
                     }
                 }
                 iterable = [{
-                        typ: 'Declaration',
+                        typ: 5 /* NodeType.DeclarationNodeType */,
                         nam: this.config.shorthand,
                         val: values
                     }][Symbol.iterator]();

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

@@ -1,5 +1,10 @@
 import { eq } from '../utils/eq.js';
 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/sourcemap/lib/encode.js';
 
 class PropertySet {
     config;
@@ -20,7 +25,8 @@ class PropertySet {
                 const tokens = [];
                 // @ts-ignore
                 for (let token of this.declarations.get(this.config.shorthand).val) {
-                    if (this.config.types.includes(token.typ) || (token.typ == 'Number' && token.val == '0' &&
+                    // @ts-ignore
+                    if (this.config.types.some(t => token.typ == EnumToken[t]) || (token.typ == EnumToken.NumberTokenType && token.val == '0' &&
                         (this.config.types.includes('Length') ||
                             this.config.types.includes('Angle') ||
                             this.config.types.includes('Dimension')))) {
@@ -31,15 +37,15 @@ class PropertySet {
                         tokens[current].push(token);
                         continue;
                     }
-                    if (token.typ != 'Whitespace' && token.typ != 'Comment') {
-                        if (token.typ == 'Iden' && this.config.keywords.includes(token.val)) {
+                    if (token.typ != EnumToken.WhitespaceTokenType && token.typ != EnumToken.CommentTokenType) {
+                        if (token.typ == EnumToken.IdenTokenType && this.config.keywords.includes(token.val)) {
                             if (tokens.length == 0) {
                                 tokens.push([]);
                                 current++;
                             }
                             tokens[current].push(token);
                         }
-                        if (token.typ == 'Literal' && token.val == this.config.separator) {
+                        if (token.typ == EnumToken.LiteralTokenType && token.val == this.config.separator) {
                             tokens.push([]);
                             current++;
                             continue;
@@ -54,7 +60,7 @@ class PropertySet {
                         this.config.properties.forEach((property, index) => {
                             if (!this.declarations.has(property)) {
                                 this.declarations.set(property, {
-                                    typ: 'Declaration',
+                                    typ: 5 /* NodeType.DeclarationNodeType */,
                                     nam: property,
                                     val: []
                                 });
@@ -71,7 +77,7 @@ class PropertySet {
                             // @ts-ignore
                             const val = this.declarations.get(property).val;
                             if (val.length > 0) {
-                                val.push({ typ: 'Whitespace' });
+                                val.push({ typ: EnumToken.WhitespaceTokenType });
                             }
                             val.push({ ...values[index] });
                         });
@@ -102,7 +108,7 @@ class PropertySet {
                 let index = 0;
                 // @ts-ignore
                 for (const token of this.declarations.get(property).val) {
-                    if (token.typ == 'Whitespace') {
+                    if (token.typ == EnumToken.WhitespaceTokenType) {
                         continue;
                     }
                     if (values.length == index) {
@@ -118,8 +124,8 @@ class PropertySet {
                     const t = value[i];
                     const k = value[i == 1 ? 0 : i % 2];
                     if (t.val == k.val && t.val == '0') {
-                        if ((t.typ == 'Number' && isLength(k)) ||
-                            (k.typ == 'Number' && isLength(t)) ||
+                        if ((t.typ == EnumToken.NumberTokenType && isLength(k)) ||
+                            (k.typ == EnumToken.NumberTokenType && isLength(t)) ||
                             (isLength(k) || isLength(t))) {
                             value.splice(i, 1);
                             continue;
@@ -133,19 +139,19 @@ class PropertySet {
                 }
             }
             iterator = [{
-                    typ: 'Declaration',
+                    typ: 5 /* NodeType.DeclarationNodeType */,
                     nam: this.config.shorthand,
                     val: values.reduce((acc, curr) => {
                         if (curr.length > 1) {
                             const k = curr.length * 2 - 1;
                             let i = 1;
                             while (i < k) {
-                                curr.splice(i, 0, { typ: 'Whitespace' });
+                                curr.splice(i, 0, { typ: EnumToken.WhitespaceTokenType });
                                 i += 2;
                             }
                         }
                         if (acc.length > 0) {
-                            acc.push({ typ: 'Literal', val: this.config.separator });
+                            acc.push({ typ: EnumToken.LiteralTokenType, val: this.config.separator });
                         }
                         acc.push(...curr);
                         return acc;