@tbela99/css-parser 0.2.0 → 0.3.0

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

@@ -1,23 +1,22 @@
 import { EnumToken } from '../types.js';
-import { reduceNumber } from '../../renderer/render.js';
 import { walkValues } from '../walk.js';
 import { MinifyFeature } from '../utils/minifyfeature.js';
-import { compute } from './utils/math.js';
-import { IterableWeakSet } from '../../iterable/set.js';
+import { IterableWeakSet } from '../../iterable/weakset.js';
+import { evaluate } from '../math/expression.js';
 
-class ComputeCalcExpression extends MinifyFeature {
+class ComputeCalcExpressionFeature extends MinifyFeature {
     static get ordering() {
         return 1;
     }
     static register(options) {
         if (options.computeCalcExpression) {
             for (const feature of options.features) {
-                if (feature instanceof ComputeCalcExpression) {
+                if (feature instanceof ComputeCalcExpressionFeature) {
                     return;
                 }
             }
             // @ts-ignore
-            options.features.push(new ComputeCalcExpression());
+            options.features.push(new ComputeCalcExpressionFeature());
         }
     }
     run(ast) {
@@ -30,11 +29,31 @@ class ComputeCalcExpression extends MinifyFeature {
                 continue;
             }
             const set = new IterableWeakSet;
-            for (const { parent } of walkValues(node.val)) {
-                if (parent != null && parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') {
+            for (const { value, parent } of walkValues(node.val)) {
+                if (value != null && value.typ == EnumToken.FunctionTokenType && value.val == 'calc') {
                     if (!set.has(parent)) {
-                        set.add(parent);
-                        parent.chi = evaluate(parent.chi);
+                        set.add(value);
+                        value.chi = evaluate(value.chi);
+                        if (value.chi.length == 1 && value.chi[0].typ != EnumToken.BinaryExpressionTokenType) {
+                            if (parent != null) {
+                                if (parent.typ == EnumToken.BinaryExpressionTokenType) {
+                                    if (parent.l == value) {
+                                        parent.l = value.chi[0];
+                                    }
+                                    else {
+                                        parent.r = value.chi[0];
+                                    }
+                                }
+                                else {
+                                    for (let i = 0; i < parent.chi.length; i++) {
+                                        if (parent.chi[i] == value) {
+                                            parent.chi.splice(i, 1, value.chi[0]);
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }
@@ -42,184 +61,5 @@ class ComputeCalcExpression extends MinifyFeature {
         return ast;
     }
 }
-/**
- * evaluate arithmetic operation
- * @param l
- * @param r
- * @param op
- */
-function doEvaluate(l, r, op) {
-    const defaultReturn = {
-        typ: EnumToken.BinaryExpressionTokenType,
-        op,
-        l,
-        r
-    };
-    if (!isScalarToken(l) || !isScalarToken(r)) {
-        return defaultReturn;
-    }
-    if ((op == EnumToken.Add || op == EnumToken.Sub)) {
-        // @ts-ignore
-        if (l.typ != r.typ) {
-            return defaultReturn;
-        }
-    }
-    const typ = l.typ == EnumToken.NumberTokenType ? r.typ : l.typ;
-    // @ts-ignore
-    const val = compute(typeof l.val == 'string' ? +l.val : l.val, typeof r.val == 'string' ? +r.val : r.val, op);
-    return { ...(l.typ == EnumToken.NumberTokenType ? r : l), typ, val: typeof val == 'number' ? reduceNumber(val) : val };
-}
-/**
- * evaluate an array of tokens
- * @param tokens
- */
-function evaluate(tokens) {
-    const nodes = inlineExpression(evaluateExpression(buildExpression(tokens)));
-    if (nodes.length <= 1) {
-        return nodes;
-    }
-    const map = new Map;
-    let token;
-    let i;
-    for (i = 0; i < nodes.length; i++) {
-        token = nodes[i];
-        if (token.typ == EnumToken.Add) {
-            continue;
-        }
-        if (token.typ == EnumToken.Sub) {
-            if (!isScalarToken(nodes[i + 1])) {
-                token = { typ: EnumToken.ListToken, chi: [nodes[i], nodes[i + 1]] };
-            }
-            else {
-                token = doEvaluate(nodes[i + 1], { typ: EnumToken.NumberTokenType, val: '-1' }, EnumToken.Mul);
-            }
-            i++;
-        }
-        if (!map.has(token.typ)) {
-            map.set(token.typ, [token]);
-        }
-        else {
-            map.get(token.typ).push(token);
-        }
-    }
-    return [...map].reduce((acc, curr) => {
-        const token = curr[1].reduce((acc, curr) => doEvaluate(acc, curr, EnumToken.Add));
-        if (token.typ != EnumToken.BinaryExpressionTokenType) {
-            if ('val' in token && +token.val < 0) {
-                acc.push({ typ: EnumToken.Sub }, { ...token, val: String(-token.val) });
-                return acc;
-            }
-        }
-        if (acc.length > 0 && curr[0] != EnumToken.ListToken) {
-            acc.push({ typ: EnumToken.Add });
-        }
-        acc.push(token);
-        return acc;
-    }, []);
-}
-/**
- * convert BinaryExpression into an array
- * @param token
- */
-function inlineExpression(token) {
-    const result = [];
-    if (token.typ == EnumToken.ParensTokenType && token.chi.length == 1) {
-        result.push(token.chi[0]);
-    }
-    else if (token.typ == EnumToken.BinaryExpressionTokenType) {
-        if ([EnumToken.Mul, EnumToken.Div].includes(token.op)) {
-            result.push(token);
-        }
-        else {
-            result.push(...inlineExpression(token.l), { typ: token.op }, ...inlineExpression(token.r));
-        }
-    }
-    else {
-        result.push(token);
-    }
-    return result;
-}
-/**
- * evaluate expression
- * @param token
- */
-function evaluateExpression(token) {
-    if (token.typ != EnumToken.BinaryExpressionTokenType) {
-        return token;
-    }
-    if (token.r.typ == EnumToken.BinaryExpressionTokenType) {
-        token.r = evaluateExpression(token.r);
-    }
-    if (token.l.typ == EnumToken.BinaryExpressionTokenType) {
-        token.l = evaluateExpression(token.l);
-    }
-    return doEvaluate(token.l, token.r, token.op);
-}
-function isScalarToken(token) {
-    return token.typ != EnumToken.BinaryExpressionTokenType && token.typ != EnumToken.ParensTokenType && token.typ != EnumToken.FunctionTokenType;
-}
-/**
- *
- * generate binary expression tree
- * @param tokens
- */
-function buildExpression(tokens) {
-    return factor(factor(tokens.filter(t => t.typ != EnumToken.WhitespaceTokenType), ['/', '*']), ['+', '-'])[0];
-}
-function getArithmeticOperation(op) {
-    if (op == '+') {
-        return EnumToken.Add;
-    }
-    if (op == '-') {
-        return EnumToken.Sub;
-    }
-    if (op == '/') {
-        return EnumToken.Div;
-    }
-    return EnumToken.Mul;
-}
-/**
- *
- * generate binary expression tree
- * @param token
- */
-function factorToken(token) {
-    if (token.typ == EnumToken.ParensTokenType || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc')) {
-        if (token.typ == EnumToken.FunctionTokenType && token.val == 'calc') {
-            token = { ...token, typ: EnumToken.ParensTokenType };
-            // @ts-ignore
-            delete token.val;
-        }
-        return buildExpression(token.chi);
-    }
-    return token;
-}
-/**
- * generate binary expression tree
- * @param tokens
- * @param ops
- */
-function factor(tokens, ops) {
-    let isOp;
-    const opList = ops.map(x => getArithmeticOperation(x));
-    if (tokens.length == 1) {
-        return [factorToken(tokens[0])];
-    }
-    for (let i = 0; i < tokens.length; i++) {
-        isOp = opList.includes(tokens[i].typ);
-        if (isOp ||
-            // @ts-ignore
-            (tokens[i].typ == EnumToken.LiteralTokenType && ops.includes(tokens[i].val))) {
-            tokens.splice(i - 1, 3, {
-                typ: EnumToken.BinaryExpressionTokenType,
-                op: isOp ? tokens[i].typ : getArithmeticOperation(tokens[i].val),
-                l: factorToken(tokens[i - 1]),
-                r: factorToken(tokens[i + 1])
-            });
-            i--;
-        }
-    }
-    return tokens;
-}
 
-export { ComputeCalcExpression };
+export { ComputeCalcExpressionFeature };

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

@@ -1,3 +1,3 @@
-export { InlineCssVariables } from './inlinecssvariables.js';
-export { ComputeShorthand } from './shorthand.js';
-export { ComputeCalcExpression } from './calc.js';
+export { InlineCssVariablesFeature } from './inlinecssvariables.js';
+export { ComputeShorthandFeature } from './shorthand.js';
+export { ComputeCalcExpressionFeature } from './calc.js';

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

@@ -1,7 +1,7 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
 import { MinifyFeature } from '../utils/minifyfeature.js';
-import { IterableWeakSet } from '../../iterable/set.js';
+import { IterableWeakSet } from '../../iterable/weakset.js';
 
 function replace(node, variableScope) {
     for (const { value, parent: parentValue } of walkValues(node.val)) {
@@ -26,19 +26,19 @@ function replace(node, variableScope) {
         }
     }
 }
-class InlineCssVariables extends MinifyFeature {
+class InlineCssVariablesFeature extends MinifyFeature {
     static get ordering() {
         return 0;
     }
     static register(options) {
         if (options.inlineCssVariables) {
             for (const feature of options.features) {
-                if (feature instanceof InlineCssVariables) {
+                if (feature instanceof InlineCssVariablesFeature) {
                     return;
                 }
             }
             // @ts-ignore
-            options.features.push(new InlineCssVariables());
+            options.features.push(new InlineCssVariablesFeature());
         }
     }
     run(ast, options = {}, parent, context) {
@@ -127,4 +127,4 @@ class InlineCssVariables extends MinifyFeature {
     }
 }
 
-export { InlineCssVariables };
+export { InlineCssVariablesFeature };

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

@@ -4,22 +4,21 @@ import { EnumToken } from '../types.js';
 import '../minify.js';
 import '../../parser/parse.js';
 import '../../renderer/sourcemap/lib/encode.js';
-import '../../parser/declaration/map.js';
 import { MinifyFeature } from '../utils/minifyfeature.js';
 
-class ComputeShorthand extends MinifyFeature {
+class ComputeShorthandFeature extends MinifyFeature {
     static get ordering() {
         return 2;
     }
     static register(options) {
         if (options.computeShorthand) {
             for (const feature of options.features) {
-                if (feature instanceof ComputeShorthand) {
+                if (feature instanceof ComputeShorthandFeature) {
                     return;
                 }
             }
             // @ts-ignore
-            options.features.push(new ComputeShorthand());
+            options.features.push(new ComputeShorthandFeature());
         }
     }
     run(ast, options = {}, parent, context) {
@@ -43,4 +42,4 @@ class ComputeShorthand extends MinifyFeature {
     }
 }
 
-export { ComputeShorthand };
+export { ComputeShorthandFeature };

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

@@ -0,0 +1,185 @@
+import { EnumToken } from '../types.js';
+import { compute } from './math.js';
+import { reduceNumber } from '../../renderer/render.js';
+
+/**
+ * evaluate an array of tokens
+ * @param tokens
+ */
+function evaluate(tokens) {
+    const nodes = inlineExpression(evaluateExpression(buildExpression(tokens)));
+    if (nodes.length <= 1) {
+        return nodes;
+    }
+    const map = new Map;
+    let token;
+    let i;
+    for (i = 0; i < nodes.length; i++) {
+        token = nodes[i];
+        if (token.typ == EnumToken.Add) {
+            continue;
+        }
+        if (token.typ == EnumToken.Sub) {
+            if (!isScalarToken(nodes[i + 1])) {
+                token = { typ: EnumToken.ListToken, chi: [nodes[i], nodes[i + 1]] };
+            }
+            else {
+                token = doEvaluate(nodes[i + 1], { typ: EnumToken.NumberTokenType, val: '-1' }, EnumToken.Mul);
+            }
+            i++;
+        }
+        if (!map.has(token.typ)) {
+            map.set(token.typ, [token]);
+        }
+        else {
+            map.get(token.typ).push(token);
+        }
+    }
+    return [...map].reduce((acc, curr) => {
+        const token = curr[1].reduce((acc, curr) => doEvaluate(acc, curr, EnumToken.Add));
+        if (token.typ != EnumToken.BinaryExpressionTokenType) {
+            if ('val' in token && +token.val < 0) {
+                acc.push({ typ: EnumToken.Sub }, { ...token, val: String(-token.val) });
+                return acc;
+            }
+        }
+        if (acc.length > 0 && curr[0] != EnumToken.ListToken) {
+            acc.push({ typ: EnumToken.Add });
+        }
+        acc.push(token);
+        return acc;
+    }, []);
+}
+/**
+ * evaluate arithmetic operation
+ * @param l
+ * @param r
+ * @param op
+ */
+function doEvaluate(l, r, op) {
+    const defaultReturn = {
+        typ: EnumToken.BinaryExpressionTokenType,
+        op,
+        l,
+        r
+    };
+    if (!isScalarToken(l) || !isScalarToken(r)) {
+        return defaultReturn;
+    }
+    if ((op == EnumToken.Add || op == EnumToken.Sub)) {
+        // @ts-ignore
+        if (l.typ != r.typ) {
+            return defaultReturn;
+        }
+    }
+    const typ = l.typ == EnumToken.NumberTokenType ? r.typ : l.typ;
+    // @ts-ignore
+    const val = compute(typeof l.val == 'string' ? +l.val : l.val, typeof r.val == 'string' ? +r.val : r.val, op);
+    return { ...(l.typ == EnumToken.NumberTokenType ? r : l), typ, val: typeof val == 'number' ? reduceNumber(val) : val };
+}
+/**
+ * convert BinaryExpression into an array
+ * @param token
+ */
+function inlineExpression(token) {
+    const result = [];
+    if (token.typ == EnumToken.ParensTokenType && token.chi.length == 1) {
+        result.push(token.chi[0]);
+    }
+    else if (token.typ == EnumToken.BinaryExpressionTokenType) {
+        if ([EnumToken.Mul, EnumToken.Div].includes(token.op)) {
+            result.push(token);
+        }
+        else {
+            result.push(...inlineExpression(token.l), { typ: token.op }, ...inlineExpression(token.r));
+        }
+    }
+    else {
+        result.push(token);
+    }
+    return result;
+}
+/**
+ * evaluate expression
+ * @param token
+ */
+function evaluateExpression(token) {
+    if (token.typ != EnumToken.BinaryExpressionTokenType) {
+        return token;
+    }
+    if (token.r.typ == EnumToken.BinaryExpressionTokenType) {
+        token.r = evaluateExpression(token.r);
+    }
+    if (token.l.typ == EnumToken.BinaryExpressionTokenType) {
+        token.l = evaluateExpression(token.l);
+    }
+    return doEvaluate(token.l, token.r, token.op);
+}
+function isScalarToken(token) {
+    return 'unit' in token || [EnumToken.NumberTokenType, EnumToken.FractionTokenType, EnumToken.PercentageTokenType].includes(token.typ);
+}
+/**
+ *
+ * generate binary expression tree
+ * @param tokens
+ */
+function buildExpression(tokens) {
+    return factor(factor(tokens.filter(t => t.typ != EnumToken.WhitespaceTokenType), ['/', '*']), ['+', '-'])[0];
+}
+function getArithmeticOperation(op) {
+    if (op == '+') {
+        return EnumToken.Add;
+    }
+    if (op == '-') {
+        return EnumToken.Sub;
+    }
+    if (op == '/') {
+        return EnumToken.Div;
+    }
+    return EnumToken.Mul;
+}
+/**
+ *
+ * generate binary expression tree
+ * @param token
+ */
+function factorToken(token) {
+    if (token.typ == EnumToken.ParensTokenType || (token.typ == EnumToken.FunctionTokenType && token.val == 'calc')) {
+        if (token.typ == EnumToken.FunctionTokenType && token.val == 'calc') {
+            token = { ...token, typ: EnumToken.ParensTokenType };
+            // @ts-ignore
+            delete token.val;
+        }
+        return buildExpression(token.chi);
+    }
+    return token;
+}
+/**
+ * generate binary expression tree
+ * @param tokens
+ * @param ops
+ */
+function factor(tokens, ops) {
+    let isOp;
+    const opList = ops.map(x => getArithmeticOperation(x));
+    if (tokens.length == 1) {
+        return [factorToken(tokens[0])];
+    }
+    for (let i = 0; i < tokens.length; i++) {
+        isOp = opList.includes(tokens[i].typ);
+        if (isOp ||
+            // @ts-ignore
+            (tokens[i].typ == EnumToken.LiteralTokenType && ops.includes(tokens[i].val))) {
+            tokens.splice(i - 1, 3, {
+                typ: EnumToken.BinaryExpressionTokenType,
+                op: isOp ? tokens[i].typ : getArithmeticOperation(tokens[i].val),
+                l: factorToken(tokens[i - 1]),
+                r: factorToken(tokens[i + 1])
+            });
+            i--;
+        }
+    }
+    return tokens;
+}
+
+export { evaluate };

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

@@ -0,0 +1,95 @@
+import { EnumToken } from '../types.js';
+import { reduceNumber } from '../../renderer/render.js';
+
+const gcd = (x, y) => {
+    x = Math.abs(x);
+    y = Math.abs(y);
+    let t;
+    if (x == 0 || y == 0) {
+        return 1;
+    }
+    while (y) {
+        t = y;
+        y = x % y;
+        x = t;
+    }
+    return x;
+};
+function compute(a, b, op) {
+    if (typeof a == 'number' && typeof b == 'number') {
+        switch (op) {
+            case EnumToken.Add:
+                return a + b;
+            case EnumToken.Sub:
+                return a - b;
+            case EnumToken.Mul:
+                return a * b;
+            case EnumToken.Div:
+                const r = simplify(a, b);
+                if (r[1] == 1) {
+                    return r[0];
+                }
+                const result = a / b;
+                const r2 = reduceNumber(r[0]) + '/' + reduceNumber(r[1]);
+                return reduceNumber(result).length <= r2.length ? result : {
+                    typ: EnumToken.FractionTokenType,
+                    l: { typ: EnumToken.NumberTokenType, val: reduceNumber(r[0]) },
+                    r: { typ: EnumToken.NumberTokenType, val: reduceNumber(r[1]) }
+                };
+        }
+    }
+    let l1 = typeof a == 'number' ? {
+        typ: EnumToken.FractionTokenType,
+        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(a) },
+        r: { typ: EnumToken.NumberTokenType, val: '1' }
+    } : a;
+    let r1 = typeof b == 'number' ? {
+        typ: EnumToken.FractionTokenType,
+        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(b) },
+        r: { typ: EnumToken.NumberTokenType, val: '1' }
+    } : b;
+    let l2;
+    let r2;
+    switch (op) {
+        case EnumToken.Add:
+            // @ts-ignore
+            l2 = l1.l.val * r1.r.val + l1.r.val * r1.l.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.r.val;
+            break;
+        case EnumToken.Sub:
+            // @ts-ignore
+            l2 = l1.l.val * r1.r.val - l1.r.val * r1.l.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.r.val;
+            break;
+        case EnumToken.Mul:
+            // @ts-ignore
+            l2 = l1.l.val * r1.l.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.r.val;
+            break;
+        case EnumToken.Div:
+            // @ts-ignore
+            l2 = l1.l.val * r1.r.val;
+            // @ts-ignore
+            r2 = l1.r.val * r1.l.val;
+            break;
+    }
+    const a2 = simplify(l2, r2);
+    if (a2[1] == 1) {
+        return a2[0];
+    }
+    const result = a2[0] / a2[1];
+    return reduceNumber(result).length <= reduceNumber(a2[0]).length + 1 + reduceNumber(a2[1]).length ? result : {
+        typ: EnumToken.FractionTokenType,
+        l: { typ: EnumToken.NumberTokenType, val: reduceNumber(a2[0]) },
+        r: { typ: EnumToken.NumberTokenType, val: reduceNumber(a2[1]) }
+    };
+}
+function simplify(a, b) {
+    const g = gcd(a, b);
+    return g > 1 ? [a / g, b / g] : [a, b];
+}
+
+export { compute, gcd, simplify };

package/dist/lib/ast/types.js

@@ -57,25 +57,29 @@ var EnumToken;
     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"] = 57] = "ListToken";
+    EnumToken[EnumToken["ListToken"] = 58] = "ListToken";
     /* arithmetic tokens */
-    EnumToken[EnumToken["Add"] = 58] = "Add";
-    EnumToken[EnumToken["Mul"] = 59] = "Mul";
-    EnumToken[EnumToken["Div"] = 60] = "Div";
-    EnumToken[EnumToken["Sub"] = 61] = "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"] = 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";
+    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"] = 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";
@@ -90,12 +94,25 @@ var EnumToken;
     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 };
+export { EnumToken, funcLike };